From 1c6487c1e79cbe0d59a39b483af8ec44b59c586e Mon Sep 17 00:00:00 2001 From: Chris Boesch Date: Fri, 3 Apr 2026 18:11:00 +0200 Subject: added async-io quiz --- exercises/086_async2.zig | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) create mode 100644 exercises/086_async2.zig (limited to 'exercises/086_async2.zig') diff --git a/exercises/086_async2.zig b/exercises/086_async2.zig new file mode 100644 index 0000000..1f1c4c8 --- /dev/null +++ b/exercises/086_async2.zig @@ -0,0 +1,48 @@ +// +// Now that we know how to get an Io value, let's use it for +// asynchronous execution! +// +// io.async() launches a function and returns a Future. The result +// won't necessarily be available until you call .await() on it: +// +// var future = io.async(someFunction, .{ arg1, arg2 }); +// // ... do other work here ... +// const result = future.await(io); +// +// The function *may* run immediately or on another thread - +// your code doesn't need to care! That's the beauty of the +// Io abstraction. (In the Threaded backend, if no thread is +// available, the function runs synchronously right away and +// .await() just returns the already-computed result.) +// +// io.async() returns a Future(T) where T is the return type +// of the function you passed in. Future has two key methods: +// +// .await(io) - block until the result is ready, return it +// .cancel(io) - request cancellation, then return the result +// +// Fix this program so that computeAnswer runs asynchronously +// and its result is properly awaited. +// +const std = @import("std"); + +pub fn main(init: std.process.Init) !void { + const io = init.io; + + // Launch computeAnswer asynchronously. + // io.async() takes a function and a tuple of its arguments. + var future = io.async(computeAnswer, .{ 6, 7 }); + + // Meanwhile, print something to show we're not blocked. + std.debug.print("Computing... ", .{}); + + // Now collect the result. What method on Future gives us + // the value, blocking if it isn't ready yet? + const answer = future.???(io); + + std.debug.print("The answer is: {}\n", .{answer}); +} + +fn computeAnswer(a: u32, b: u32) u32 { + return a * b; +} -- cgit v1.2.3 From 2acf19277544ded4f56b525240be856094085009 Mon Sep 17 00:00:00 2001 From: Chris Boesch Date: Sun, 5 Apr 2026 12:42:42 +0200 Subject: improvements for async-io --- exercises/086_async2.zig | 32 +++++++++++++++++++------------- patches/patches/086_async2.patch | 10 +++++----- 2 files changed, 24 insertions(+), 18 deletions(-) (limited to 'exercises/086_async2.zig') diff --git a/exercises/086_async2.zig b/exercises/086_async2.zig index 1f1c4c8..cf376e2 100644 --- a/exercises/086_async2.zig +++ b/exercises/086_async2.zig @@ -6,41 +6,47 @@ // won't necessarily be available until you call .await() on it: // // var future = io.async(someFunction, .{ arg1, arg2 }); -// // ... do other work here ... // const result = future.await(io); // // The function *may* run immediately or on another thread - // your code doesn't need to care! That's the beauty of the -// Io abstraction. (In the Threaded backend, if no thread is -// available, the function runs synchronously right away and -// .await() just returns the already-computed result.) +// Io abstraction. // -// io.async() returns a Future(T) where T is the return type -// of the function you passed in. Future has two key methods: +// IMPORTANT: Every Future MUST be either .await()ed or .cancel()ed. +// Failing to do so leaks resources! A safe pattern is: // -// .await(io) - block until the result is ready, return it -// .cancel(io) - request cancellation, then return the result +// var future = io.async(myFn, .{}); +// defer _ = future.cancel(io); // safety net +// // ... later, if we want the result: +// const result = future.await(io); +// // (await after cancel is fine — it just returns the result) +// +// Both .await() and .cancel() block until the task finishes and +// return the result. The difference is that .cancel() also +// requests the task to stop at its next cancellation point. +// Calling either one more than once is safe — subsequent calls +// just return a copy of the result. // // Fix this program so that computeAnswer runs asynchronously // and its result is properly awaited. // const std = @import("std"); +const print = std.debug.print; pub fn main(init: std.process.Init) !void { const io = init.io; // Launch computeAnswer asynchronously. - // io.async() takes a function and a tuple of its arguments. var future = io.async(computeAnswer, .{ 6, 7 }); + defer _ = future.cancel(io); // always clean up! - // Meanwhile, print something to show we're not blocked. - std.debug.print("Computing... ", .{}); + print("Computing... ", .{}); // Now collect the result. What method on Future gives us - // the value, blocking if it isn't ready yet? + // the value, blocking until it's ready? const answer = future.???(io); - std.debug.print("The answer is: {}\n", .{answer}); + print("The answer is: {}\n", .{answer}); } fn computeAnswer(a: u32, b: u32) u32 { diff --git a/patches/patches/086_async2.patch b/patches/patches/086_async2.patch index 9a672a6..1738089 100644 --- a/patches/patches/086_async2.patch +++ b/patches/patches/086_async2.patch @@ -1,11 +1,11 @@ ---- exercises/086_async2.zig 2026-04-03 19:42:15.274532915 +0200 -+++ answers/086_async2.zig 2026-04-03 21:30:18.180019206 +0200 -@@ -38,7 +38,7 @@ +--- exercises/086_async2.zig 2026-04-05 12:41:11.350626443 +0200 ++++ answers/086_async2.zig 2026-04-05 12:42:00.879791167 +0200 +@@ -44,7 +44,7 @@ // Now collect the result. What method on Future gives us - // the value, blocking if it isn't ready yet? + // the value, blocking until it's ready? - const answer = future.???(io); + const answer = future.await(io); - std.debug.print("The answer is: {}\n", .{answer}); + print("The answer is: {}\n", .{answer}); } -- cgit v1.2.3