diff --git a/README.md b/README.md
index 8d90e03..35eadd4 100644
--- a/README.md
+++ b/README.md
@@ -193,7 +193,7 @@ Zig Core Language
* [x] Sentinel termination
* [x] Quoted identifiers @""
* [x] Anonymous structs/tuples/lists
-* [ ] Async I/O
+* [x] Async I/O
* [X] Interfaces
* [X] Bit manipulation
* [X] Working with C
diff --git a/build.zig b/build.zig
index d7cc153..9209848 100644
--- a/build.zig
+++ b/build.zig
@@ -75,6 +75,8 @@ pub const Exercise = struct {
/// Hint to the user, why this has been skipped
skip_hint: ?[]const u8 = null,
+ timestamp: bool = false,
+
/// Returns the name of the main file with .zig stripped.
pub fn name(self: Exercise) []const u8 {
return std.fs.path.stem(self.main_file);
@@ -434,12 +436,40 @@ const ZiglingStep = struct {
else
result.stderr;
- // Validate the output.
// NOTE: exercise.output can never contain a CR character.
// See https://ziglang.org/documentation/master/#Source-Encoding.
const output = trimLines(b.allocator, raw_output) catch @panic("OOM");
- const exercise_output = self.exercise.output;
- if (!std.mem.eql(u8, output, self.exercise.output)) {
+
+ // Validate the output.
+ var exercise_output = self.exercise.output;
+
+ // Insert timestamp for exercise 85
+ if (self.exercise.timestamp) {
+
+ // Compare timestamp from exercise with now, diff < 5 seconds is valid
+ var ts_buf: [20]u8 = undefined;
+ const ts_slice = output[14..24];
+ const ts_value = try std.fmt.parseInt(i64, ts_slice, 10);
+ const ts_build = std.Io.Timestamp.now(io, .real).toSeconds();
+ const ts_diff = @abs(ts_build - ts_value);
+ const timestamp = std.fmt.bufPrint(&ts_buf, "{}", .{if (ts_diff < 5) ts_value else ts_build}) catch unreachable;
+
+ // Insert timestamp into check string
+ var buf: [100]u8 = undefined;
+ const prefix_len = 14;
+ const placeholder_len = 11;
+
+ @memcpy(buf[0..prefix_len], exercise_output[0..prefix_len]);
+ @memcpy(buf[prefix_len..][0..timestamp.len], timestamp);
+ const suffix = exercise_output[prefix_len + placeholder_len ..];
+ const suffix_dest_start = prefix_len + timestamp.len;
+ @memcpy(buf[suffix_dest_start..][0..suffix.len], suffix);
+
+ const total_len = prefix_len + timestamp.len + suffix.len;
+ exercise_output = buf[0..total_len];
+ }
+
+ if (!std.mem.eql(u8, output, exercise_output)) {
const red = red_bold_text;
const reset = reset_text;
@@ -698,7 +728,7 @@ const exercises = [_]Exercise{
\\most part, you'll be taking directions from the Zig
\\compiler itself.)
\\
- ,
+ , // pay attention to the comma
},
.{
.main_file = "002_std.zig",
@@ -730,7 +760,7 @@ const exercises = [_]Exercise{
\\Ziggy played guitar
\\Jamming good with Andrew Kelley
\\And the Spiders from Mars
- ,
+ , // pay attention to the comma
.hint = "Please fix the lyrics!",
},
.{
@@ -867,7 +897,7 @@ const exercises = [_]Exercise{
\\ Green
\\ Blue
\\
- ,
+ , // pay attention to the comma
.hint = "I'm feeling blue about this.",
},
.{
@@ -879,7 +909,7 @@ const exercises = [_]Exercise{
.output =
\\Character 1 - G:20 H:100 XP:10
\\Character 2 - G:10 H:100 XP:20
- ,
+ , // pay attention to the comma
},
.{
.main_file = "039_pointers.zig",
@@ -903,7 +933,7 @@ const exercises = [_]Exercise{
.output =
\\Wizard (G:10 H:100 XP:20)
\\ Mentor: Wizard (G:10000 H:100 XP:2340)
- ,
+ , // pay attention to the comma
},
.{
.main_file = "044_quiz5.zig",
@@ -947,7 +977,7 @@ const exercises = [_]Exercise{
.output =
\\Hand1: A 4 K 8
\\Hand2: 5 2 Q J
- ,
+ , // pay attention to the comma
},
.{
.main_file = "053_slices2.zig",
@@ -1043,7 +1073,10 @@ const exercises = [_]Exercise{
.main_file = "073_comptime8.zig",
.output = "My llama value is 25.",
},
- .{ .main_file = "074_comptime9.zig", .output = "My llama value is 2.", .skip = false, .skip_hint = "This is actually correct as it is. :-)" },
+ .{
+ .main_file = "074_comptime9.zig",
+ .output = "My llama value is 2.",
+ },
.{
.main_file = "075_quiz8.zig",
.output = "Archer's Point--2->Bridge--1->Dogwood Grove--3->Cottage--2->East Pond--1->Fox Pond",
@@ -1078,103 +1111,128 @@ const exercises = [_]Exercise{
.main_file = "082_anonymous_structs3.zig",
.output =
\\"0"(bool):true "1"(bool):false "2"(i32):42 "3"(f32):3.141592
- ,
+ , // pay attention to the comma
.hint = "This one is a challenge! But you have everything you need.",
},
.{
.main_file = "083_anonymous_lists.zig",
.output = "I say hello!",
},
+ .{
+ .main_file = "084_interfaces.zig",
+ .output =
+ \\=== Doctor Zoraptera's Insect Report ===
+ \\Ant is alive.
+ \\Bee visited 17 flowers.
+ \\Grasshopper hopped 32 meters.
+ , // pay attention to the comma
+ },
// Skipped because of https://github.com/ratfactor/ziglings/issues/163
// direct link: https://github.com/ziglang/zig/issues/6025
.{
- .main_file = "084_async.zig",
- .output = "foo() A",
- .hint = "Read the facts. Use the facts.",
- .skip = true,
- .skip_hint = "async has not been implemented in the current compiler version.",
+ .main_file = "085_async.zig",
+ .output = "Current time: s since epoch",
+ .timestamp = true,
},
.{
- .main_file = "085_async2.zig",
- .output = "Hello async!",
- .skip = true,
- .skip_hint = "async has not been implemented in the current compiler version.",
+ .main_file = "086_async2.zig",
+ .output = "Computing... The answer is: 42",
},
.{
- .main_file = "086_async3.zig",
- .output = "5 4 3 2 1",
- .skip = true,
- .skip_hint = "async has not been implemented in the current compiler version.",
- },
- .{
- .main_file = "087_async4.zig",
- .output = "1 2 3 4 5",
- .skip = true,
- .skip_hint = "async has not been implemented in the current compiler version.",
- },
- .{
- .main_file = "088_async5.zig",
- .output = "Example Title.",
- .skip = true,
- .skip_hint = "async has not been implemented in the current compiler version.",
- },
- .{
- .main_file = "089_async6.zig",
- .output = ".com: Example Title, .org: Example Title.",
- .skip = true,
- .skip_hint = "async has not been implemented in the current compiler version.",
- },
- .{
- .main_file = "090_async7.zig",
- .output = "beef? BEEF!",
- .skip = true,
- .skip_hint = "async has not been implemented in the current compiler version.",
- },
- .{
- .main_file = "091_async8.zig",
- .output = "ABCDEF",
- .skip = true,
- .skip_hint = "async has not been implemented in the current compiler version.",
- },
-
- .{
- .main_file = "092_interfaces.zig",
+ .main_file = "087_async3.zig",
.output =
- \\Daily Insect Report:
- \\Ant is alive.
- \\Bee visited 17 flowers.
- \\Grasshopper hopped 32 meters.
- ,
+ \\1 + 2 = 3
+ \\6 * 7 = 42
+ \\Total: 45
+ , // pay attention to the comma
},
.{
- .main_file = "093_hello_c.zig",
+ .main_file = "088_async4.zig",
+ .output =
+ \\Task 1 done.
+ \\Task 2 done.
+ \\Task 3 done.
+ \\All tasks finished!
+ , // pay attention to the comma
+ },
+ .{
+ .main_file = "089_async5.zig",
+ .output =
+ \\Starting long computation...
+ \\Canceling slow task...
+ \\Task was canceled, cleaning up.
+ \\Task returned: 0
+ , // pay attention to the comma
+ },
+ .{
+ .main_file = "090_async6.zig",
+ .output = "Hare: I'm fast!",
+ },
+ .{
+ .main_file = "091_async7.zig",
+ .output = "Counter: 400",
+ },
+ .{
+ .main_file = "092_async8.zig",
+ .output = "Sum of 1..10 = 55",
+ },
+ .{
+ .main_file = "093_async9.zig",
+ .output =
+ \\Computing concurrently!
+ \\Main continues...
+ \\Main done waiting.
+ \\Result: 123
+ , // pay attention to the comma
+ },
+ .{
+ .main_file = "094_async10.zig",
+ .output =
+ \\Starting critical section...
+ \\Critical section completed safely.
+ \\Task result: All data saved.
+ , // pay attention to the comma
+ },
+ .{
+ .main_file = "095_quiz_async.zig",
+ .output =
+ \\=== Doctor Zoraptera's Garden Report ===
+ \\Temperature : 23C
+ \\Humidity : 63%
+ \\Wind : 13 km/h
+ \\Readings : 9
+ \\Bee-friendly conditions! Expect high pollination.
+ , // pay attention to the comma
+ },
+ .{
+ .main_file = "096_hello_c.zig",
.output = "Hello C from Zig! - C result is 17 chars written.",
.link_libc = true,
},
.{
- .main_file = "094_c_math.zig",
+ .main_file = "097_c_math.zig",
.output = "The normalized angle of 765.2 degrees is 45.2 degrees.",
.link_libc = true,
},
.{
- .main_file = "095_for3.zig",
+ .main_file = "098_for3.zig",
.output = "1 2 4 7 8 11 13 14 16 17 19\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15",
},
.{
- .main_file = "096_memory_allocation.zig",
+ .main_file = "099_memory_allocation.zig",
.output = "Running Average: 0.30 0.25 0.20 0.18 0.22",
},
.{
- .main_file = "097_bit_manipulation.zig",
+ .main_file = "100_bit_manipulation.zig",
.output = "x = 1011; y = 1101",
},
.{
- .main_file = "098_bit_manipulation2.zig",
+ .main_file = "101_bit_manipulation2.zig",
.output = "Is this a pangram? true!",
},
.{
- .main_file = "099_formatting.zig",
+ .main_file = "102_formatting.zig",
.output =
\\
\\ X | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
@@ -1211,25 +1269,25 @@ const exercises = [_]Exercise{
,
},
.{
- .main_file = "100_for4.zig",
+ .main_file = "103_for4.zig",
.output = "Arrays match!",
},
.{
- .main_file = "101_for5.zig",
+ .main_file = "104_for5.zig",
.output =
\\1. Wizard (Gold: 25, XP: 40)
\\2. Bard (Gold: 11, XP: 17)
\\3. Bard (Gold: 5, XP: 55)
\\4. Warrior (Gold: 7392, XP: 21)
- ,
+ , // pay attention to the comma
},
.{
- .main_file = "102_testing.zig",
+ .main_file = "105_testing.zig",
.output = "",
.kind = .@"test",
},
.{
- .main_file = "103_tokenization.zig",
+ .main_file = "106_tokenization.zig",
.output =
\\My
\\name
@@ -1247,10 +1305,10 @@ const exercises = [_]Exercise{
\\and
\\despair
\\This little poem has 15 words!
- ,
+ , // pay attention to the comma
},
.{
- .main_file = "104_threading.zig",
+ .main_file = "107_threading.zig",
.output =
\\Starting work...
\\thread 1: started.
@@ -1261,35 +1319,35 @@ const exercises = [_]Exercise{
\\thread 1: finished.
\\thread 3: finished.
\\Zig is cool!
- ,
+ , // pay attention to the comma
},
.{
- .main_file = "105_threading2.zig",
+ .main_file = "108_threading2.zig",
.output = "PI ≈ 3.14159265",
},
.{
- .main_file = "106_files.zig",
+ .main_file = "109_files.zig",
.output = "Successfully wrote 18 bytes.",
},
.{
- .main_file = "107_files2.zig",
+ .main_file = "110_files2.zig",
.output =
\\AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
\\Successfully Read 18 bytes: It's zigling time!
- ,
+ , // pay attention to the comma
},
.{
- .main_file = "108_labeled_switch.zig",
+ .main_file = "111_labeled_switch.zig",
.output = "The pull request has been merged.",
},
.{
- .main_file = "109_vectors.zig",
+ .main_file = "112_vectors.zig",
.output =
\\Max difference (old fn): 0.014
\\Max difference (new fn): 0.014
- ,
+ , // pay attention to the comma
},
- .{ .main_file = "110_quiz9.zig", .output =
+ .{ .main_file = "113_quiz9.zig", .output =
\\Toggle pins with XOR on PORTB
\\-----------------------------
\\ 1100 // (initial state of PORTB)
@@ -1321,11 +1379,11 @@ const exercises = [_]Exercise{
\\= 0110
},
.{
- .main_file = "111_packed.zig",
+ .main_file = "114_packed.zig",
.output = "",
},
.{
- .main_file = "112_packed2.zig",
+ .main_file = "115_packed2.zig",
.output = "",
},
.{
@@ -1334,6 +1392,6 @@ const exercises = [_]Exercise{
\\
\\This is the end for now!
\\We hope you had fun and were able to learn a lot, so visit us again when the next exercises are available.
- ,
+ , // pay attention to the comma
},
};
diff --git a/exercises/084_async.zig b/exercises/084_async.zig
deleted file mode 100644
index 56c9969..0000000
--- a/exercises/084_async.zig
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// Six Facts:
-//
-// 1. The memory space allocated to your program for the
-// invocation of a function and all of its data is called a
-// "stack frame".
-//
-// 2. The 'return' keyword "pops" the current function
-// invocation's frame off of the stack (it is no longer needed)
-// and returns control to the place where the function was
-// called.
-//
-// fn foo() void {
-// return; // Pop the frame and return control
-// }
-//
-// 3. Like 'return', the 'suspend' keyword returns control to the
-// place where the function was called BUT the function
-// invocation's frame remains so that it can regain control again
-// at a later time. Functions which do this are "async"
-// functions.
-//
-// fn fooThatSuspends() void {
-// suspend {} // return control, but leave the frame alone
-// }
-//
-// 4. To call any function in async context and get a reference
-// to its frame for later use, use the 'async' keyword:
-//
-// var foo_frame = async fooThatSuspends();
-//
-// 5. If you call an async function without the 'async' keyword,
-// the function FROM WHICH you called the async function itself
-// becomes async! In this example, the bar() function is now
-// async because it calls fooThatSuspends(), which is async.
-//
-// fn bar() void {
-// fooThatSuspends();
-// }
-//
-// 6. The main() function cannot be async!
-//
-// Given facts 3 and 4, how do we fix this program (broken by facts
-// 5 and 6)?
-//
-const print = @import("std").debug.print;
-
-pub fn main() void {
- // Additional Hint: you can assign things to '_' when you
- // don't intend to do anything with them.
- foo();
-}
-
-fn foo() void {
- print("foo() A\n", .{});
- suspend {}
- print("foo() B\n", .{});
-}
diff --git a/exercises/092_interfaces.zig b/exercises/084_interfaces.zig
similarity index 98%
rename from exercises/092_interfaces.zig
rename to exercises/084_interfaces.zig
index 7775dd5..fd61ead 100644
--- a/exercises/092_interfaces.zig
+++ b/exercises/084_interfaces.zig
@@ -102,7 +102,7 @@ pub fn main() !void {
Insect{ .grasshopper = Grasshopper{ .distance_hopped = 32 } },
};
- std.debug.print("Daily Insect Report:\n", .{});
+ std.debug.print("=== Doctor Zoraptera's Insect Report ===\n", .{});
for (my_insects) |insect| {
// Almost done! We want to print() each insect with a
// single method call here.
diff --git a/exercises/085_async.zig b/exercises/085_async.zig
new file mode 100644
index 0000000..1d885a5
--- /dev/null
+++ b/exercises/085_async.zig
@@ -0,0 +1,49 @@
+//
+// In previous versions of Zig, async/await used special keywords
+// like 'suspend', 'resume', and 'async' that operated on stackframes
+// directly. Those keywords no longer exist!
+//
+// Zig 0.16 replaced them with a unified I/O interface: std.Io.
+// This interface uses a VTable pattern - a struct of function pointers -
+// to abstract over different concurrency backends:
+//
+// * Threaded - thread-pool based I/O
+// * Evented - chooses the best event-loop backend for your OS:
+// * Uring on Linux (io_uring)
+// * Kqueue on BSD/macOS
+// * Dispatch on macOS (Grand Central Dispatch)
+//
+// The Io struct itself is tiny:
+//
+// const Io = struct {
+// userdata: ?*anyopaque, // opaque state of the backend
+// vtable: *const VTable, // table of function pointers
+// };
+//
+// Your code receives an Io value and calls methods on it.
+// The backend is chosen at initialization time - your code doesn't
+// need to know which one it is!
+//
+// In Zig 0.16, main() receives a std.process.Init struct to opt
+// into I/O and concurrency support:
+//
+// pub fn main(init: std.process.Init) !void {
+// const io = init.io;
+// // ... use io ...
+// }
+//
+// Let's start simple. Fix the main function to extract the Io
+// interface from init, then use it to get the current time.
+//
+const std = @import("std");
+
+pub fn main(init: std.process.Init) !void {
+ const io = init.???;
+
+ // Get the current wall-clock time using the Io interface.
+ // Hint: Timestamp.now() takes an Io and a Clock type (.real = wall clock).
+ const timestamp = std.Io.Timestamp.now(io, .real);
+
+ // Print the timestamp in seconds since the Unix epoch.
+ std.debug.print("Current time: {}s since epoch\n", .{timestamp.toSeconds()});
+}
diff --git a/exercises/085_async2.zig b/exercises/085_async2.zig
deleted file mode 100644
index 036aefa..0000000
--- a/exercises/085_async2.zig
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// So, 'suspend' returns control to the place from which it was
-// called (the "call site"). How do we give control back to the
-// suspended function?
-//
-// For that, we have a new keyword called 'resume' which takes an
-// async function invocation's frame and returns control to it.
-//
-// fn fooThatSuspends() void {
-// suspend {}
-// }
-//
-// var foo_frame = async fooThatSuspends();
-// resume foo_frame;
-//
-// See if you can make this program print "Hello async!".
-//
-const print = @import("std").debug.print;
-
-pub fn main() void {
- var foo_frame = async foo();
-}
-
-fn foo() void {
- print("Hello ", .{});
- suspend {}
- print("async!\n", .{});
-}
diff --git a/exercises/086_async2.zig b/exercises/086_async2.zig
new file mode 100644
index 0000000..cf376e2
--- /dev/null
+++ b/exercises/086_async2.zig
@@ -0,0 +1,54 @@
+//
+// 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 });
+// 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.
+//
+// IMPORTANT: Every Future MUST be either .await()ed or .cancel()ed.
+// Failing to do so leaks resources! A safe pattern is:
+//
+// 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.
+ var future = io.async(computeAnswer, .{ 6, 7 });
+ defer _ = future.cancel(io); // always clean up!
+
+ print("Computing... ", .{});
+
+ // Now collect the result. What method on Future gives us
+ // the value, blocking until it's ready?
+ const answer = future.???(io);
+
+ print("The answer is: {}\n", .{answer});
+}
+
+fn computeAnswer(a: u32, b: u32) u32 {
+ return a * b;
+}
diff --git a/exercises/086_async3.zig b/exercises/086_async3.zig
deleted file mode 100644
index c8f1113..0000000
--- a/exercises/086_async3.zig
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-// Because they can suspend and resume, async Zig functions are
-// an example of a more general programming concept called
-// "coroutines". One of the neat things about Zig async functions
-// is that they retain their state as they are suspended and
-// resumed.
-//
-// See if you can make this program print "5 4 3 2 1".
-//
-const print = @import("std").debug.print;
-
-pub fn main() void {
- const n = 5;
- var foo_frame = async foo(n);
-
- ???
-
- print("\n", .{});
-}
-
-fn foo(countdown: u32) void {
- var current = countdown;
-
- while (current > 0) {
- print("{} ", .{current});
- current -= 1;
- suspend {}
- }
-}
diff --git a/exercises/087_async3.zig b/exercises/087_async3.zig
new file mode 100644
index 0000000..d10052c
--- /dev/null
+++ b/exercises/087_async3.zig
@@ -0,0 +1,49 @@
+//
+// The real power of async shows when you launch MULTIPLE tasks!
+//
+// With io.async(), you can start several operations, then await
+// them all. The Io backend may run them concurrently:
+//
+// var f1 = io.async(taskA, .{});
+// defer _ = f1.cancel(io);
+// var f2 = io.async(taskB, .{});
+// defer _ = f2.cancel(io);
+// const a = f1.await(io);
+// const b = f2.await(io);
+//
+// Notice the defer pattern: each async call is immediately
+// followed by a defer cancel. This ensures cleanup even if
+// we return early or hit an error before reaching await.
+// Since await/cancel are idempotent, the defer is harmless
+// if we've already awaited.
+//
+// Fix this program to launch both tasks and collect their results.
+//
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn main(init: std.process.Init) !void {
+ const io = init.io;
+
+ // Launch both tasks asynchronously.
+ var future_a = io.async(slowAdd, .{ 1, 2 });
+ defer _ = future_a.cancel(io);
+ var future_b = ???(slowMul, .{ 6, 7 });
+ defer _ = future_b.cancel(io);
+
+ // Await both results.
+ const sum = future_a.await(io);
+ const product = future_b.await(io);
+
+ print("{} + {} = {}\n", .{ 1, 2, sum });
+ print("{} * {} = {}\n", .{ 6, 7, product });
+ print("Total: {}\n", .{sum + product});
+}
+
+fn slowAdd(a: u32, b: u32) u32 {
+ return a + b;
+}
+
+fn slowMul(a: u32, b: u32) u32 {
+ return a * b;
+}
diff --git a/exercises/087_async4.zig b/exercises/087_async4.zig
deleted file mode 100644
index bb9c9ec..0000000
--- a/exercises/087_async4.zig
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// It has probably not escaped your attention that we are no
-// longer capturing a return value from foo() because the 'async'
-// keyword returns the frame instead.
-//
-// One way to solve this is to use a global variable.
-//
-// See if you can make this program print "1 2 3 4 5".
-//
-const print = @import("std").debug.print;
-
-var global_counter: i32 = 0;
-
-pub fn main() void {
- var foo_frame = async foo();
-
- while (global_counter <= 5) {
- print("{} ", .{global_counter});
- ???
- }
-
- print("\n", .{});
-}
-
-fn foo() void {
- while (true) {
- ???
- ???
- }
-}
diff --git a/exercises/088_async4.zig b/exercises/088_async4.zig
new file mode 100644
index 0000000..8298ca1
--- /dev/null
+++ b/exercises/088_async4.zig
@@ -0,0 +1,50 @@
+//
+// When you have many tasks that don't return individual values,
+// use a Group! A Group is an unordered set of tasks that can
+// only be awaited or canceled as a whole:
+//
+// var group: std.Io.Group = .init;
+// group.async(io, myTask, .{arg1});
+// group.async(io, myTask, .{arg2});
+// try group.await(io); // blocks until ALL tasks finish
+//
+// Important rules:
+// * The return type of functions spawned in a group must be
+// coercible to Cancelable!void (i.e. void, or error{Canceled}!void).
+// * Once you call group.async(), you MUST eventually call
+// group.await() or group.cancel() to release resources.
+// * group.cancel() requests cancellation on ALL members,
+// then blocks until they all finish.
+//
+// Unlike Future, Group tasks don't return values to the caller.
+// They're ideal for parallel work that communicates through
+// shared state or side effects (like printing).
+//
+// Fix this program to await all tasks in the group.
+//
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn main(init: std.process.Init) !void {
+ const io = init.io;
+
+ var group: std.Io.Group = .init;
+
+ // Spawn 3 tasks in any order. Each sleeps for (id * 1) seconds
+ // before printing, so the output order is deterministic.
+ group.async(io, doWork, .{ io, 1 });
+ group.async(io, doWork, .{ io, 3 });
+ group.async(io, doWork, .{ io, 2 });
+
+ // Wait for all tasks to finish.
+ // What Group method blocks until all tasks complete?
+ try group.???(io);
+
+ print("All tasks finished!\n", .{});
+}
+
+fn doWork(io: std.Io, id: u32) void {
+ // Sleep ensures deterministic output order.
+ io.sleep(std.Io.Duration.fromSeconds(id), .awake) catch return;
+ print("Task {} done.\n", .{id});
+}
diff --git a/exercises/088_async5.zig b/exercises/088_async5.zig
deleted file mode 100644
index 759a920..0000000
--- a/exercises/088_async5.zig
+++ /dev/null
@@ -1,48 +0,0 @@
-//
-// Sure, we can solve our async value problem with a global
-// variable. But this hardly seems like an ideal solution.
-//
-// So how do we REALLY get return values from async functions?
-//
-// The 'await' keyword waits for an async function to complete
-// and then captures its return value.
-//
-// fn foo() u32 {
-// return 5;
-// }
-//
-// var foo_frame = async foo(); // invoke and get frame
-// var value = await foo_frame; // await result using frame
-//
-// The above example is just a silly way to call foo() and get 5
-// back. But if foo() did something more interesting such as wait
-// for a network response to get that 5, our code would pause
-// until the value was ready.
-//
-// As you can see, async/await basically splits a function call
-// into two parts:
-//
-// 1. Invoke the function ('async')
-// 2. Getting the return value ('await')
-//
-// Also notice that a 'suspend' keyword does NOT need to exist in
-// a function to be called in an async context.
-//
-// Please use 'await' to get the string returned by
-// getPageTitle().
-//
-const print = @import("std").debug.print;
-
-pub fn main() void {
- var myframe = async getPageTitle("http://example.com");
-
- var value = ???
-
- print("{s}\n", .{value});
-}
-
-fn getPageTitle(url: []const u8) []const u8 {
- // Please PRETEND this is actually making a network request.
- _ = url;
- return "Example Title.";
-}
diff --git a/exercises/089_async5.zig b/exercises/089_async5.zig
new file mode 100644
index 0000000..0c00c1f
--- /dev/null
+++ b/exercises/089_async5.zig
@@ -0,0 +1,67 @@
+//
+// One of the most important features of the new Io system is
+// structured cancellation!
+//
+// Every Future has a .cancel() method that:
+// 1. Requests the task to stop (via error.Canceled at the
+// next "cancellation point")
+// 2. BLOCKS until the task actually finishes
+// 3. Returns whatever result the task produced
+//
+// A "cancellation point" is any Io function that can return
+// error.Canceled - most commonly io.sleep():
+//
+// fn myTask(io: std.Io) u32 {
+// io.sleep(...) catch |err| switch (err) {
+// error.Canceled => return 0, // error handle
+// };
+// return 42;
+// }
+//
+// This is fundamentally different from killing a thread -
+// the task gets a chance to clean up and return a value!
+//
+// Remember: both .await() and .cancel() block and return the
+// result. The only difference is that .cancel() also sends
+// the cancellation request. And both are idempotent — calling
+// either one again just returns the same result.
+//
+// Fix this program: the slow task would take 10 seconds,
+// but we cancel it after 1 second. The task should detect
+// the cancellation and return early.
+//
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn main(init: std.process.Init) !void {
+ const io = init.io;
+
+ var future = io.async(slowTask, .{io});
+ defer _ = future.cancel(io); // safety net
+
+ // Wait 1 second, then cancel instead of waiting the full 10.
+ io.sleep(std.Io.Duration.fromSeconds(1), .awake) catch {};
+
+ print("Canceling slow task...\n", .{});
+
+ // We don't want to wait 10 seconds!
+ // Which Future method requests cancellation AND returns the result?
+ const result = future.???(io);
+
+ print("Task returned: {}\n", .{result});
+}
+
+fn slowTask(io: std.Io) u32 {
+ print("Starting long computation...\n", .{});
+
+ // Try to sleep for 10 seconds - but we might get canceled!
+ io.sleep(std.Io.Duration.fromSeconds(10), .awake) catch |err| switch (err) {
+ error.Canceled => {
+ print("Task was canceled, cleaning up.\n", .{});
+ return 0;
+ },
+ };
+
+ print("Task completed normally.\n", .{});
+ return 42;
+}
diff --git a/exercises/089_async6.zig b/exercises/089_async6.zig
deleted file mode 100644
index 8bf50e9..0000000
--- a/exercises/089_async6.zig
+++ /dev/null
@@ -1,54 +0,0 @@
-//
-// The power and purpose of async/await becomes more apparent
-// when we do multiple things concurrently. Foo and Bar do not
-// depend on each other and can happen at the same time, but End
-// requires that they both be finished.
-//
-// +---------+
-// | Start |
-// +---------+
-// / \
-// / \
-// +---------+ +---------+
-// | Foo | | Bar |
-// +---------+ +---------+
-// \ /
-// \ /
-// +---------+
-// | End |
-// +---------+
-//
-// We can express this in Zig like so:
-//
-// fn foo() u32 { ... }
-// fn bar() u32 { ... }
-//
-// // Start
-//
-// var foo_frame = async foo();
-// var bar_frame = async bar();
-//
-// var foo_value = await foo_frame;
-// var bar_value = await bar_frame;
-//
-// // End
-//
-// Please await TWO page titles!
-//
-const print = @import("std").debug.print;
-
-pub fn main() void {
- var com_frame = async getPageTitle("http://example.com");
- var org_frame = async getPageTitle("http://example.org");
-
- var com_title = com_frame;
- var org_title = org_frame;
-
- print(".com: {s}, .org: {s}.\n", .{ com_title, org_title });
-}
-
-fn getPageTitle(url: []const u8) []const u8 {
- // Please PRETEND this is actually making a network request.
- _ = url;
- return "Example Title";
-}
diff --git a/exercises/090_async6.zig b/exercises/090_async6.zig
new file mode 100644
index 0000000..16fb75f
--- /dev/null
+++ b/exercises/090_async6.zig
@@ -0,0 +1,76 @@
+//
+// Sometimes you want to race multiple tasks and act on whichever
+// finishes first. That's what Select is for!
+//
+// Select is like a Group, but lets you receive individual results
+// as tasks complete — one at a time:
+//
+// const Race = std.Io.Select(union(enum) {
+// fast: u32,
+// slow: u32,
+// });
+//
+// var buffer: [2]Race.Union = undefined;
+// var sel = Race.init(io, &buffer);
+//
+// sel.async(.fast, fastFn, .{io});
+// sel.async(.slow, slowFn, .{io});
+//
+// const winner = try sel.await(); // returns first completed
+// switch (winner) {
+// .fast => |val| ...,
+// .slow => |val| ...,
+// }
+// sel.cancelDiscard(); // cancel remaining, discard results
+//
+// As with all async primitives: tasks spawned in a Select MUST
+// be cleaned up. Use sel.cancel() to get remaining results one
+// by one (for resource cleanup), or sel.cancelDiscard() if you
+// don't need them.
+//
+// The buffer must be large enough for all tasks that might
+// complete before you call cancelDiscard().
+//
+// Fix this program to receive the winner of the race.
+//
+const std = @import("std");
+const print = std.debug.print;
+
+const RaceResult = std.Io.Select(union(enum) {
+ hare: []const u8,
+ tortoise: []const u8,
+});
+
+pub fn main(init: std.process.Init) !void {
+ const io = init.io;
+
+ var buffer: [2]RaceResult.Union = undefined;
+ var sel = RaceResult.init(io, &buffer);
+
+ sel.async(.hare, runHare, .{io});
+ sel.async(.tortoise, runTortoise, .{io});
+
+ // Wait for the first finisher.
+ // What Select method returns the first completed result?
+ const winner = try sel.???();
+
+ switch (winner) {
+ .hare => |msg| print("Hare: {s}\n", .{msg}),
+ .tortoise => |msg| print("Tortoise: {s}\n", .{msg}),
+ }
+
+ // Clean up the loser — we don't need their result.
+ sel.cancelDiscard();
+}
+
+fn runHare(io: std.Io) []const u8 {
+ // The hare is fast — only 1 second!
+ io.sleep(std.Io.Duration.fromSeconds(1), .awake) catch return "I got canceled!";
+ return "I'm fast!";
+}
+
+fn runTortoise(io: std.Io) []const u8 {
+ // The tortoise is slow — 10 seconds.
+ io.sleep(std.Io.Duration.fromSeconds(10), .awake) catch return "I got canceled!";
+ return "Slow and steady...";
+}
diff --git a/exercises/090_async7.zig b/exercises/090_async7.zig
deleted file mode 100644
index 2da3a4a..0000000
--- a/exercises/090_async7.zig
+++ /dev/null
@@ -1,87 +0,0 @@
-//
-// Remember how a function with 'suspend' is async and calling an
-// async function without the 'async' keyword makes the CALLING
-// function async?
-//
-// fn fooThatMightSuspend(maybe: bool) void {
-// if (maybe) suspend {}
-// }
-//
-// fn bar() void {
-// fooThatMightSuspend(true); // Now bar() is async!
-// }
-//
-// But if you KNOW the function won't suspend, you can make a
-// promise to the compiler with the 'nosuspend' keyword:
-//
-// fn bar() void {
-// nosuspend fooThatMightSuspend(false);
-// }
-//
-// If the function does suspend and YOUR PROMISE TO THE COMPILER
-// IS BROKEN, the program will panic at runtime, which is
-// probably better than you deserve, you oathbreaker! >:-(
-//
-const print = @import("std").debug.print;
-
-pub fn main() void {
-
- // The main() function can not be async. But we know
- // getBeef() will not suspend with this particular
- // invocation. Please make this okay:
- var my_beef = getBeef(0);
-
- print("beef? {X}!\n", .{my_beef});
-}
-
-fn getBeef(input: u32) u32 {
- if (input == 0xDEAD) {
- suspend {}
- }
-
- return 0xBEEF;
-}
-//
-// Going Deeper Into...
-// ...uNdeFiNEd beHAVi0r!
-//
-// We haven't discussed it yet, but runtime "safety" features
-// require some extra instructions in your compiled program.
-// Most of the time, you're going to want to keep these in.
-//
-// But in some programs, when data integrity is less important
-// than raw speed (some games, for example), you can compile
-// without these safety features.
-//
-// Instead of a safe panic when something goes wrong, your
-// program will now exhibit Undefined Behavior (UB), which simply
-// means that the Zig language does not (cannot) define what will
-// happen. The best case is that it will crash, but in the worst
-// case, it will continue to run with the wrong results and
-// corrupt your data or expose you to security risks.
-//
-// This program is a great way to explore UB. Once you get it
-// working, try calling the getBeef() function with the value
-// 0xDEAD so that it will invoke the 'suspend' keyword:
-//
-// getBeef(0xDEAD)
-//
-// Now when you run the program, it will panic and give you a
-// nice stack trace to help debug the problem.
-//
-// zig run exercises/090_async7.zig
-// thread 328 panic: async function called...
-// ...
-//
-// But see what happens when you turn off safety checks by using
-// ReleaseFast mode:
-//
-// zig run -O ReleaseFast exercises/090_async7.zig
-// beef? 0!
-//
-// This is the wrong result. On your computer, you may get a
-// different answer or it might crash! What exactly will happen
-// is UNDEFINED. Your computer is now like a wild animal,
-// reacting to bits and bytes of raw memory with the base
-// instincts of the CPU. It is both terrifying and exhilarating.
-//
diff --git a/exercises/091_async7.zig b/exercises/091_async7.zig
new file mode 100644
index 0000000..bfe6ffd
--- /dev/null
+++ b/exercises/091_async7.zig
@@ -0,0 +1,57 @@
+//
+// When multiple async tasks access shared data, you need
+// synchronization! Io provides a Mutex for this:
+//
+// var mutex: std.Io.Mutex = .init;
+//
+// // In a task:
+// try mutex.lock(io); // blocks until lock is acquired
+// defer mutex.unlock();
+// // ... critical section: safe to modify shared data ...
+//
+// Without the mutex, concurrent tasks could read and write the
+// same memory simultaneously, causing a data race — the result
+// would be unpredictable.
+//
+// mutex.lock() is a cancellation point — it can return
+// error.Canceled. There's also tryLock() which returns
+// immediately (true if acquired, false if not).
+//
+// Fix this program so the counter is correctly synchronized.
+// Without the fix, the final count would be unpredictable.
+// With it, four tasks incrementing 100 times each = 400.
+//
+const std = @import("std");
+const print = std.debug.print;
+
+const SharedState = struct {
+ counter: u32 = 0,
+ mutex: std.Io.Mutex = .init,
+};
+
+pub fn main(init: std.process.Init) !void {
+ const io = init.io;
+ var state = SharedState{};
+
+ var group: std.Io.Group = .init;
+
+ group.async(io, increment, .{ io, &state, 100 });
+ group.async(io, increment, .{ io, &state, 100 });
+ group.async(io, increment, .{ io, &state, 100 });
+ group.async(io, increment, .{ io, &state, 100 });
+
+ try group.await(io);
+
+ print("Counter: {}\n", .{state.counter});
+}
+
+fn increment(io: std.Io, state: *SharedState, times: u32) void {
+ for (0..times) |_| {
+ // Acquire the lock before modifying shared state.
+ // What Mutex method blocks until the lock is acquired?
+ state.mutex.??? catch return;
+ defer state.mutex.unlock(); // <-- what's missing here?
+
+ state.counter += 1;
+ }
+}
diff --git a/exercises/091_async8.zig b/exercises/091_async8.zig
deleted file mode 100644
index cd9c975..0000000
--- a/exercises/091_async8.zig
+++ /dev/null
@@ -1,35 +0,0 @@
-//
-// You have doubtless noticed that 'suspend' requires a block
-// expression like so:
-//
-// suspend {}
-//
-// The suspend block executes when a function suspends. To get
-// sense for when this happens, please make the following
-// program print the string
-//
-// "ABCDEF"
-//
-const print = @import("std").debug.print;
-
-pub fn main() void {
- print("A", .{});
-
- var frame = async suspendable();
-
- print("X", .{});
-
- resume frame;
-
- print("F", .{});
-}
-
-fn suspendable() void {
- print("X", .{});
-
- suspend {
- print("X", .{});
- }
-
- print("X", .{});
-}
diff --git a/exercises/092_async8.zig b/exercises/092_async8.zig
new file mode 100644
index 0000000..10921c3
--- /dev/null
+++ b/exercises/092_async8.zig
@@ -0,0 +1,62 @@
+//
+// Tasks often need to communicate! Io provides Queue for this —
+// a bounded, thread-safe channel for passing data between tasks:
+//
+// var backing: [16]u32 = undefined;
+// var queue: std.Io.Queue(u32) = .init(&backing);
+//
+// // Producer task:
+// try queue.putOne(io, value); // blocks if queue is full
+//
+// // Consumer task:
+// const val = try queue.getOne(io); // blocks if queue is empty
+//
+// When the producer is done, it calls queue.close(io) to signal
+// that no more data is coming. After that, getOne() will return
+// error.Closed once the queue is drained.
+//
+// This is the classic producer/consumer pattern — one task
+// generates work, another processes it, and the queue handles
+// all the synchronization automatically.
+//
+// Fix this program: the producer sends numbers 1..10, the
+// consumer sums them up. The expected sum is 55.
+//
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn main(init: std.process.Init) !void {
+ const io = init.io;
+
+ var backing: [4]u32 = undefined;
+ var queue: std.Io.Queue(u32) = .init(&backing);
+
+ var group: std.Io.Group = .init;
+
+ group.async(io, producer, .{ io, &queue });
+ group.async(io, consumer, .{ io, &queue });
+
+ try group.await(io);
+}
+
+fn producer(io: std.Io, queue: *std.Io.Queue(u32)) void {
+ // Send numbers 1 through 10 into the queue.
+ for (1..11) |i| {
+ // What Queue method sends a single element, blocking if full?
+ queue.???(io, @intCast(i)) catch return;
+ }
+ // Signal that we're done sending.
+ queue.close(io);
+}
+
+fn consumer(io: std.Io, queue: *std.Io.Queue(u32)) void {
+ var sum: u32 = 0;
+ while (true) {
+ const value = queue.getOne(io) catch |err| switch (err) {
+ error.Closed => break,
+ error.Canceled => return,
+ };
+ sum += value;
+ }
+ print("Sum of 1..10 = {}\n", .{sum});
+}
diff --git a/exercises/093_async9.zig b/exercises/093_async9.zig
new file mode 100644
index 0000000..4a41544
--- /dev/null
+++ b/exercises/093_async9.zig
@@ -0,0 +1,69 @@
+//
+// We've been using io.async() to launch tasks. But there's a
+// stronger variant: io.concurrent().
+//
+// The difference:
+//
+// io.async():
+// * The function MAY run on a separate unit of concurrency,
+// or it may run immediately on the caller (synchronously).
+// * Never fails — if no concurrency is available, it just
+// runs the function right away.
+// * More portable, works with all Io backends.
+//
+// io.concurrent():
+// * GUARANTEES a separate unit of concurrency.
+// * Can fail with error.ConcurrencyUnavailable if resources
+// are exhausted or the backend doesn't support it.
+// * Use when you NEED the task to run independently of the
+// caller.
+//
+// What is a "unit of concurrency"? That depends on the backend!
+// The Threaded backend uses OS threads. But the Evented backends
+// (Uring, Kqueue, Dispatch) use M:N green threads / fibers,
+// which can provide concurrency even on a SINGLE OS thread.
+// Your code doesn't need to know the difference.
+//
+// Because concurrent() can fail, you must handle the error:
+//
+// var future = try io.concurrent(myFn, .{args});
+// defer _ = future.cancel(io);
+// const result = future.await(io);
+//
+// Notice the 'try' — that's the key difference in usage!
+//
+// Fix this program to launch the computation concurrently.
+//
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn main(init: std.process.Init) !void {
+ const io = init.io;
+
+ // Launch with a guaranteed separate unit of concurrency.
+ // Which Io method guarantees this?
+ // (Hint: unlike io.async, this one can fail!)
+ var future = try io.???(compute, .{io});
+ defer _ = future.cancel(io);
+
+ // Note: All breaks in this excercise (using sleep)
+ // are only necessary for a deterministic result.
+ io.sleep(std.Io.Duration.fromMilliseconds(100), .awake) catch {};
+
+ print("Main continues...\n", .{});
+
+ // Wait 1 second for the output order.
+ io.sleep(std.Io.Duration.fromMilliseconds(200), .awake) catch {};
+
+ print("Main done waiting.\n", .{});
+
+ const result = future.await(io);
+ print("Result: {}\n", .{result});
+}
+
+fn compute(io: std.Io) u32 {
+ print("Computing concurrently!\n", .{});
+ // Simulate some work.
+ io.sleep(std.Io.Duration.fromMilliseconds(400), .awake) catch return 0;
+ return 123;
+}
diff --git a/exercises/094_async10.zig b/exercises/094_async10.zig
new file mode 100644
index 0000000..c561d37
--- /dev/null
+++ b/exercises/094_async10.zig
@@ -0,0 +1,68 @@
+//
+// In exercise 089, we learned that cancellation happens at
+// "cancellation points" — any Io function that can return
+// error.Canceled.
+//
+// But sometimes a task has a critical section that MUST NOT
+// be interrupted — for example, writing a consistent state
+// to disk, or completing a transaction.
+//
+// Io provides CancelProtection for this:
+//
+// const old = io.swapCancelProtection(.blocked);
+// defer _ = io.swapCancelProtection(old);
+
+// // In this block, NO Io function will return error.Canceled.
+// // The cancel request is held until protection is restored.
+//
+// There are two states:
+// .unblocked — normal: cancellation points can fire (default)
+// .blocked — protected: error.Canceled is never returned
+//
+// There's also io.checkCancel() — a pure cancellation point
+// that does nothing except return error.Canceled if a cancel
+// request is pending. Useful in long CPU-bound loops.
+//
+// And io.recancel() — re-arms a consumed cancel request so
+// the NEXT cancellation point will fire again.
+//
+// Fix this program so the critical section completes even
+// when the task is canceled.
+//
+const std = @import("std");
+const print = std.debug.print;
+
+pub fn main(init: std.process.Init) !void {
+ const io = init.io;
+
+ var future = io.async(importantTask, .{io});
+ defer _ = future.cancel(io);
+
+ // Give the task time to start and enter its critical section.
+ io.sleep(std.Io.Duration.fromMilliseconds(200), .awake) catch {};
+
+ // Cancel while the task is in its protected section.
+ const result = future.cancel(io);
+ print("Task result: {s}\n", .{result});
+}
+
+fn importantTask(io: std.Io) []const u8 {
+ print("Starting critical section...\n", .{});
+
+ // Protect this section from cancellation.
+ // What method swaps the cancel protection state?
+ const old = io.???(.blocked);
+ defer _ = io.???(old);
+
+ // This sleep will NOT return error.Canceled even though
+ // we get canceled during it — protection is active!
+ io.sleep(std.Io.Duration.fromMilliseconds(300), .awake) catch |err| switch (err) {
+ error.Canceled => {
+ // This should never happen while protected!
+ return "ERROR: canceled during critical section!";
+ },
+ };
+
+ print("Critical section completed safely.\n", .{});
+ return "All data saved.";
+}
diff --git a/exercises/095_quiz_async.zig b/exercises/095_quiz_async.zig
new file mode 100644
index 0000000..b116fc9
--- /dev/null
+++ b/exercises/095_quiz_async.zig
@@ -0,0 +1,188 @@
+//
+// Quiz Time — Async I/O!
+//
+// Doctor Zoraptera's insect simulation is going well, but she
+// realized that her virtual garden needs weather data! Insects
+// behave differently depending on temperature, humidity, and
+// wind conditions.
+//
+// She has set up three weather sensors around the garden that
+// measure conditions in parallel and report their readings
+// through a shared data channel. A collector task gathers the
+// readings, and after all sensors have reported, a garden
+// report is printed.
+//
+// But Doctor Z rushed through the code (she was being chased
+// by a grasshopper) and left several bugs. Can you fix them?
+//
+// Here's what the program should do:
+// 1. Three sensor tasks send exactly 3 readings each through
+// a Queue
+// 2. A collector task receives readings concurrently,
+// protected by a Mutex
+// 3. After all sensors finish, the queue is closed
+// 4. The final report is written in a cancel-protected section
+//
+// *************************************************************
+// * A NOTE ABOUT THIS EXERCISE *
+// * *
+// * This quiz uses concepts from exercises 085-094. *
+// * There are 6 bugs to fix — look for the ???s! *
+// * *
+// *************************************************************
+//
+const std = @import("std");
+const print = std.debug.print;
+
+const SensorType = enum { thermometer, hygrometer, anemometer };
+
+const Reading = struct {
+ sensor_type: SensorType,
+ value: i32,
+};
+
+const GardenWeather = struct {
+ temperature: i32 = 0,
+ humidity: i32 = 0,
+ wind: i32 = 0,
+ readings_count: u32 = 0,
+ mutex: std.Io.Mutex = .init,
+
+ fn addReading(self: *GardenWeather, io: std.Io, reading: Reading) void {
+ // Bug 1: The collector needs to lock before modifying
+ // shared state. What Mutex method acquires the lock?
+ self.mutex.???(io) catch return;
+ defer self.mutex.unlock(io);
+
+ switch (reading.sensor_type) {
+ .thermometer => self.temperature = reading.value,
+ .hygrometer => self.humidity = reading.value,
+ .anemometer => self.wind = reading.value,
+ }
+ self.readings_count += 1;
+ }
+};
+
+pub fn main(init: std.process.Init) !void {
+ const io = init.io;
+
+ var weather = GardenWeather{};
+
+ var reading_buf: [8]Reading = undefined;
+ var queue: std.Io.Queue(Reading) = .init(&reading_buf);
+
+ // The collector must run concurrently so it can process
+ // readings while the sensors are still sending.
+ // Start it FIRST to ensure its concurrency unit is reserved.
+ //
+ // Bug 2: The collector needs guaranteed concurrency.
+ // What method ensures a separate unit of concurrency?
+ // (Don't forget: it can fail!)
+ var collector_future = try io.???(collector, .{ io, &queue, &weather });
+ defer _ = collector_future.cancel(io);
+
+ // Sensor group: the sensors can use async — they just need
+ // to run, and async is more portable.
+ var sensors: std.Io.Group = .init;
+
+ sensors.async(io, sensor, .{ io, &queue, .thermometer, 20 });
+ sensors.async(io, sensor, .{ io, &queue, .hygrometer, 60 });
+ sensors.async(io, sensor, .{ io, &queue, .anemometer, 10 });
+
+ // Bug 3: Wait for ALL sensors to finish sending their readings.
+ // What Group method blocks until all tasks complete?
+ try sensors.???(io);
+
+ // All sensors done — close the queue so the collector knows
+ // there's no more data coming.
+ queue.close(io);
+
+ // Wait for the collector to drain the remaining queue.
+ _ = collector_future.await(io);
+ // _ = collector_future.???(io);
+
+ // Now write the garden report. This is critical — it must
+ // NOT be interrupted, even if something tries to cancel us!
+ //
+ // Bug 5: Protect this section from cancellation.
+ // What Io method swaps the cancel protection state?
+ const old_protection = io.???(.blocked);
+ defer _ = io.???(old_protection);
+
+ printGardenReport(&weather);
+}
+
+fn sensor(
+ io: std.Io,
+ queue: *std.Io.Queue(Reading),
+ sensor_type: SensorType,
+ base_value: i32,
+) void {
+ // Each sensor takes exactly 3 measurements.
+ for (1..4) |i| {
+ io.sleep(std.Io.Duration.fromMilliseconds(100), .awake) catch return;
+
+ const reading = Reading{
+ .sensor_type = sensor_type,
+ .value = base_value + @as(i32, @intCast(i)),
+ };
+
+ // Bug 6: Send the reading into the queue.
+ // What Queue method sends a single element?
+ queue.???(io, reading) catch return;
+ }
+}
+
+fn collector(
+ io: std.Io,
+ queue: *std.Io.Queue(Reading),
+ weather: *GardenWeather,
+) void {
+ while (true) {
+ const reading = queue.getOne(io) catch |err| switch (err) {
+ error.Closed => break,
+ error.Canceled => return,
+ };
+ weather.addReading(io, reading);
+ }
+}
+
+fn printGardenReport(weather: *GardenWeather) void {
+ print("=== Doctor Zoraptera's Garden Report ===\n", .{});
+ print("Temperature : {}C\n", .{weather.temperature});
+ print("Humidity : {}%\n", .{weather.humidity});
+ print("Wind : {} km/h\n", .{weather.wind});
+ print("Readings : {}\n", .{weather.readings_count});
+
+ if (weather.temperature > 20 and weather.wind < 15) {
+ print("Bee-friendly conditions! Expect high pollination.\n", .{});
+ } else {
+ print("Grasshoppers will be grumpy today.\n", .{});
+ }
+}
+
+// Further reading for the curious:
+//
+// This quiz covered the main async I/O primitives:
+// io.async() - launch a task (may run inline)
+// io.concurrent() - guaranteed unit of concurrency
+// Future.await/cancel - collect or cancel a single task
+// Group.async/await/cancel - manage fire-and-forget tasks
+// Select.async/await - race tasks, act on first completion
+// Queue - bounded channel between tasks
+// Mutex - protect shared state
+// CancelProtection - shield critical sections
+//
+// There are more synchronization primitives we didn't cover:
+// Condition - wait for a condition to become true
+// RwLock - multiple readers OR one writer
+// Semaphore - limit concurrent access to a resource
+// Futex - low-level wait/wake on a memory address
+// Batch - submit multiple I/O operations at once
+//
+// The key insight: all of these work through the Io VTable,
+// so your code is portable across backends — whether Threaded
+// (OS thread pool), or Evented (M:N green threads / fibers
+// that can provide concurrency even on a single OS thread).
+//
+// Doctor Zoraptera approves.
diff --git a/exercises/093_hello_c.zig b/exercises/096_hello_c.zig
similarity index 100%
rename from exercises/093_hello_c.zig
rename to exercises/096_hello_c.zig
diff --git a/exercises/094_c_math.zig b/exercises/097_c_math.zig
similarity index 100%
rename from exercises/094_c_math.zig
rename to exercises/097_c_math.zig
diff --git a/exercises/095_for3.zig b/exercises/098_for3.zig
similarity index 100%
rename from exercises/095_for3.zig
rename to exercises/098_for3.zig
diff --git a/exercises/096_memory_allocation.zig b/exercises/099_memory_allocation.zig
similarity index 100%
rename from exercises/096_memory_allocation.zig
rename to exercises/099_memory_allocation.zig
diff --git a/exercises/097_bit_manipulation.zig b/exercises/100_bit_manipulation.zig
similarity index 100%
rename from exercises/097_bit_manipulation.zig
rename to exercises/100_bit_manipulation.zig
diff --git a/exercises/098_bit_manipulation2.zig b/exercises/101_bit_manipulation2.zig
similarity index 100%
rename from exercises/098_bit_manipulation2.zig
rename to exercises/101_bit_manipulation2.zig
diff --git a/exercises/099_formatting.zig b/exercises/102_formatting.zig
similarity index 100%
rename from exercises/099_formatting.zig
rename to exercises/102_formatting.zig
diff --git a/exercises/100_for4.zig b/exercises/103_for4.zig
similarity index 100%
rename from exercises/100_for4.zig
rename to exercises/103_for4.zig
diff --git a/exercises/101_for5.zig b/exercises/104_for5.zig
similarity index 100%
rename from exercises/101_for5.zig
rename to exercises/104_for5.zig
diff --git a/exercises/102_testing.zig b/exercises/105_testing.zig
similarity index 100%
rename from exercises/102_testing.zig
rename to exercises/105_testing.zig
diff --git a/exercises/103_tokenization.zig b/exercises/106_tokenization.zig
similarity index 100%
rename from exercises/103_tokenization.zig
rename to exercises/106_tokenization.zig
diff --git a/exercises/104_threading.zig b/exercises/107_threading.zig
similarity index 78%
rename from exercises/104_threading.zig
rename to exercises/107_threading.zig
index 2b0e6f7..3c3fa21 100644
--- a/exercises/104_threading.zig
+++ b/exercises/107_threading.zig
@@ -1,31 +1,22 @@
//
-// Whenever there is a lot to calculate, the question arises as to how
-// tasks can be carried out simultaneously. We have already learned about
-// one possibility, namely asynchronous processes, in Exercises 84-91.
+// In Exercises 84-91, we learned about Zig's Io interface for
+// concurrent execution: io.async(), Group, Select, and Futures.
+// Under the hood, the Threaded backend manages a pool of real
+// OS threads for you - including scheduling, cancellation, and
+// resource cleanup.
//
-// However, the computing power of the processor is only distributed to
-// the started and running tasks, which always reaches its limits when
-// pure computing power is called up.
+// But sometimes you need direct control over threads:
+// * Long-lived dedicated workers
+// * Specific stack sizes or thread counts
+// * Code that doesn't have an Io interface available
+// * Fine-grained synchronization patterns
//
-// For example, in blockchains based on proof of work, the miners have
-// to find a nonce for a certain character string so that the first m bits
-// in the hash of the character string and the nonce are zeros.
-// As the miner who can solve the task first receives the reward, everyone
-// tries to complete the calculations as quickly as possible.
+// That's where std.Thread comes in. It gives you a raw OS thread
+// that you spawn, manage, and join yourself. No pool, no Futures,
+// no automatic cancellation - but full control.
//
-// This is where multithreading comes into play, where tasks are actually
-// distributed across several cores of the CPU or GPU, which then really
-// means a multiplication of performance.
-//
-// The following diagram roughly illustrates the difference between the
-// various types of process execution.
-// The 'Overall Time' column is intended to illustrate how the time is
-// affected if, instead of one core as in synchronous and asynchronous
-// processing, a second core now helps to complete the work in multithreading.
-//
-// In the ideal case shown, execution takes only half the time compared
-// to the synchronous single thread. And even asynchronous processing
-// is only slightly faster in comparison.
+// The following diagram roughly illustrates the difference between
+// the various types of process execution:
//
//
// Synchronous Asynchronous
@@ -108,7 +99,7 @@ pub fn main() !void {
// they run in parallel and we can still do some work in between.
var io_instance: std.Io.Threaded = .init_single_threaded;
const io = io_instance.io();
- try io.sleep(std.Io.Duration.fromSeconds(4), .awake);
+ try io.sleep(std.Io.Duration.fromMilliseconds(400), .awake);
std.debug.print("Some weird stuff, after starting the threads.\n", .{});
}
// After we have left the closed area, we wait until
@@ -118,17 +109,17 @@ pub fn main() !void {
// This function is started with every thread that we set up.
// In our example, we pass the number of the thread as a parameter.
-fn thread_function(num: usize) !void {
+fn thread_function(id: usize) !void {
var io_instance: std.Io.Threaded = .init_single_threaded;
const io = io_instance.io();
- try io.sleep(std.Io.Duration.fromSeconds(1 * @as(isize, @intCast(num))), .awake);
- std.debug.print("thread {d}: {s}\n", .{ num, "started." });
+ try io.sleep(std.Io.Duration.fromMilliseconds(100 * @as(isize, @intCast(id))), .awake);
+ std.debug.print("thread {d}: {s}\n", .{ id, "started." });
// This timer simulates the work of the thread.
- const work_time = 3 * ((5 - num % 3) - 2);
- try io.sleep(std.Io.Duration.fromSeconds(@intCast(work_time)), .awake);
+ const work_time = 300 * ((5 - id % 3) - 2);
+ try io.sleep(std.Io.Duration.fromMilliseconds(@intCast(work_time)), .awake);
- std.debug.print("thread {d}: {s}\n", .{ num, "finished." });
+ std.debug.print("thread {d}: {s}\n", .{ id, "finished." });
}
// This is the easiest way to run threads in parallel.
// In general, however, more management effort is required,
diff --git a/exercises/105_threading2.zig b/exercises/108_threading2.zig
similarity index 100%
rename from exercises/105_threading2.zig
rename to exercises/108_threading2.zig
diff --git a/exercises/106_files.zig b/exercises/109_files.zig
similarity index 100%
rename from exercises/106_files.zig
rename to exercises/109_files.zig
diff --git a/exercises/107_files2.zig b/exercises/110_files2.zig
similarity index 100%
rename from exercises/107_files2.zig
rename to exercises/110_files2.zig
diff --git a/exercises/108_labeled_switch.zig b/exercises/111_labeled_switch.zig
similarity index 100%
rename from exercises/108_labeled_switch.zig
rename to exercises/111_labeled_switch.zig
diff --git a/exercises/109_vectors.zig b/exercises/112_vectors.zig
similarity index 100%
rename from exercises/109_vectors.zig
rename to exercises/112_vectors.zig
diff --git a/exercises/110_quiz9.zig b/exercises/113_quiz9.zig
similarity index 100%
rename from exercises/110_quiz9.zig
rename to exercises/113_quiz9.zig
diff --git a/exercises/111_packed.zig b/exercises/114_packed.zig
similarity index 100%
rename from exercises/111_packed.zig
rename to exercises/114_packed.zig
diff --git a/exercises/112_packed2.zig b/exercises/115_packed2.zig
similarity index 100%
rename from exercises/112_packed2.zig
rename to exercises/115_packed2.zig
diff --git a/patches/patches/084_async.patch b/patches/patches/084_async.patch
new file mode 100644
index 0000000..2c97f0e
--- /dev/null
+++ b/patches/patches/084_async.patch
@@ -0,0 +1,11 @@
+--- exercises/084_async.zig 2026-04-01 20:40:08.904999609 +0200
++++ answers/084_async.zig 2026-04-01 20:40:05.641933231 +0200
+@@ -37,7 +37,7 @@
+ const std = @import("std");
+
+ pub fn main(init: std.process.Init) !void {
+- const io = init.???;
++ const io = init.io;
+
+ // Get the current wall-clock time using the Io interface.
+ // Hint: Timestamp.now() takes an Io and a Clock type (.real = wall clock).
diff --git a/patches/patches/092_interfaces.patch b/patches/patches/084_interfaces.patch
similarity index 62%
rename from patches/patches/092_interfaces.patch
rename to patches/patches/084_interfaces.patch
index 36d8784..d3a45fd 100644
--- a/patches/patches/092_interfaces.patch
+++ b/patches/patches/084_interfaces.patch
@@ -1,5 +1,5 @@
---- exercises/092_interfaces.zig 2023-10-03 22:15:22.125574535 +0200
-+++ answers/092_interfaces.zig 2023-10-05 20:04:07.259437354 +0200
+--- exercises/084_interfaces.zig 2026-04-03 19:24:51.764327692 +0200
++++ answers/084_interfaces.zig 2026-04-03 19:27:31.552579474 +0200
@@ -106,7 +106,7 @@
for (my_insects) |insect| {
// Almost done! We want to print() each insect with a
diff --git a/patches/patches/085_async.patch b/patches/patches/085_async.patch
new file mode 100644
index 0000000..108eae1
--- /dev/null
+++ b/patches/patches/085_async.patch
@@ -0,0 +1,11 @@
+--- exercises/085_async.zig 2026-04-04 16:01:01.509555724 +0200
++++ answers/085_async.zig 2026-04-04 16:00:58.541495688 +0200
+@@ -38,7 +38,7 @@
+ const std = @import("std");
+
+ pub fn main(init: std.process.Init) !void {
+- const io = init.???;
++ const io = init.io;
+
+ // Get the current wall-clock time using the Io interface.
+ // Hint: Timestamp.now() takes an Io and a Clock type (.real = wall clock).
diff --git a/patches/patches/086_async2.patch b/patches/patches/086_async2.patch
new file mode 100644
index 0000000..1738089
--- /dev/null
+++ b/patches/patches/086_async2.patch
@@ -0,0 +1,11 @@
+--- 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 until it's ready?
+- const answer = future.???(io);
++ const answer = future.await(io);
+
+ print("The answer is: {}\n", .{answer});
+ }
diff --git a/patches/patches/087_async3.patch b/patches/patches/087_async3.patch
new file mode 100644
index 0000000..91ba9af
--- /dev/null
+++ b/patches/patches/087_async3.patch
@@ -0,0 +1,11 @@
+--- exercises/087_async3.zig 2026-04-05 16:12:48.317265515 +0200
++++ answers/087_async3.zig 2026-04-05 16:12:52.269343030 +0200
+@@ -28,7 +28,7 @@
+ // Launch both tasks asynchronously.
+ var future_a = io.async(slowAdd, .{ 1, 2 });
+ defer _ = future_a.cancel(io);
+- var future_b = ???(slowMul, .{ 6, 7 });
++ var future_b = io.async(slowMul, .{ 6, 7 });
+ defer _ = future_b.cancel(io);
+
+ // Await both results.
diff --git a/patches/patches/088_async4.patch b/patches/patches/088_async4.patch
new file mode 100644
index 0000000..6cf549f
--- /dev/null
+++ b/patches/patches/088_async4.patch
@@ -0,0 +1,11 @@
+--- exercises/088_async4.zig 2026-04-06 12:22:06.643385622 +0200
++++ answers/088_async4.zig 2026-04-06 12:22:11.820491035 +0200
+@@ -38,7 +38,7 @@
+
+ // Wait for all tasks to finish.
+ // What Group method blocks until all tasks complete?
+- try group.???(io);
++ try group.await(io);
+
+ print("All tasks finished!\n", .{});
+ }
diff --git a/patches/patches/089_async5.patch b/patches/patches/089_async5.patch
new file mode 100644
index 0000000..3cea4e9
--- /dev/null
+++ b/patches/patches/089_async5.patch
@@ -0,0 +1,11 @@
+--- exercises/089_async5.zig 2026-04-06 14:38:54.443726849 +0200
++++ answers/089_async5.zig 2026-04-06 14:38:39.945438309 +0200
+@@ -46,7 +46,7 @@
+
+ // We don't want to wait 10 seconds!
+ // Which Future method requests cancellation AND returns the result?
+- const result = future.???(io);
++ const result = future.cancel(io);
+
+ print("Task returned: {}\n", .{result});
+ }
diff --git a/patches/patches/090_async6.patch b/patches/patches/090_async6.patch
new file mode 100644
index 0000000..6289708
--- /dev/null
+++ b/patches/patches/090_async6.patch
@@ -0,0 +1,11 @@
+--- exercises/090_async6.zig 2026-04-06 18:49:37.232023422 +0200
++++ answers/090_async6.zig 2026-04-06 18:49:22.189720687 +0200
+@@ -52,7 +52,7 @@
+
+ // Wait for the first finisher.
+ // What Select method returns the first completed result?
+- const winner = try sel.???();
++ const winner = try sel.await();
+
+ switch (winner) {
+ .hare => |msg| print("Hare: {s}\n", .{msg}),
diff --git a/patches/patches/091_async7.patch b/patches/patches/091_async7.patch
new file mode 100644
index 0000000..b4bab9b
--- /dev/null
+++ b/patches/patches/091_async7.patch
@@ -0,0 +1,13 @@
+--- exercises/091_async7.zig 2026-04-02 10:50:08.142508099 +0200
++++ answers/091_async7.zig 2026-04-02 10:49:59.629341593 +0200
+@@ -49,8 +49,8 @@
+ for (0..times) |_| {
+ // Acquire the lock before modifying shared state.
+ // What Mutex method blocks until the lock is acquired?
+- state.mutex.??? catch return;
+- defer state.mutex.unlock(); // <-- what's missing here?
++ state.mutex.lock(io) catch return;
++ defer state.mutex.unlock(io);
+
+ state.counter += 1;
+ }
diff --git a/patches/patches/092_async8.patch b/patches/patches/092_async8.patch
new file mode 100644
index 0000000..0ec9116
--- /dev/null
+++ b/patches/patches/092_async8.patch
@@ -0,0 +1,11 @@
+--- exercises/092_async8.zig 2026-04-02 10:49:27.925721496 +0200
++++ answers/092_async8.zig 2026-04-02 10:49:31.694795212 +0200
+@@ -43,7 +43,7 @@
+ // Send numbers 1 through 10 into the queue.
+ for (1..11) |i| {
+ // What Queue method sends a single element, blocking if full?
+- queue.???(io, @intCast(i)) catch return;
++ queue.putOne(io, @intCast(i)) catch return;
+ }
+ // Signal that we're done sending.
+ queue.close(io);
diff --git a/patches/patches/093_async9.patch b/patches/patches/093_async9.patch
new file mode 100644
index 0000000..ebdfce2
--- /dev/null
+++ b/patches/patches/093_async9.patch
@@ -0,0 +1,11 @@
+--- exercises/093_async9.zig 2026-04-06 19:26:11.388025362 +0200
++++ answers/093_async9.zig 2026-04-06 19:18:36.242931688 +0200
+@@ -43,7 +43,7 @@
+ // Launch with a guaranteed separate unit of concurrency.
+ // Which Io method guarantees this?
+ // (Hint: unlike io.async, this one can fail!)
+- var future = try io.???(compute, .{io});
++ var future = try io.concurrent(compute, .{io});
+ defer _ = future.cancel(io);
+
+ // Note: All breaks in this excercise (using sleep)
diff --git a/patches/patches/094_async10.patch b/patches/patches/094_async10.patch
new file mode 100644
index 0000000..e721485
--- /dev/null
+++ b/patches/patches/094_async10.patch
@@ -0,0 +1,13 @@
+--- exercises/094_async10.zig 2026-04-06 19:36:59.873966580 +0200
++++ answers/094_async10.zig 2026-04-06 19:37:12.416216872 +0200
+@@ -51,8 +51,8 @@
+
+ // Protect this section from cancellation.
+ // What method swaps the cancel protection state?
+- const old = io.???(.blocked);
+- defer _ = io.???(old);
++ const old = io.swapCancelProtection(.blocked);
++ defer _ = io.swapCancelProtection(old);
+
+ // This sleep will NOT return error.Canceled even though
+ // we get canceled during it — protection is active!
diff --git a/patches/patches/095_quiz_async.patch b/patches/patches/095_quiz_async.patch
new file mode 100644
index 0000000..e3d2a79
--- /dev/null
+++ b/patches/patches/095_quiz_async.patch
@@ -0,0 +1,56 @@
+--- exercises/095_quiz_async.zig 2026-04-06 19:55:17.111817364 +0200
++++ answers/095_quiz_async.zig 2026-04-06 19:56:16.063974543 +0200
+@@ -51,7 +51,7 @@
+ fn addReading(self: *GardenWeather, io: std.Io, reading: Reading) void {
+ // Bug 1: The collector needs to lock before modifying
+ // shared state. What Mutex method acquires the lock?
+- self.mutex.???(io) catch return;
++ self.mutex.lock(io) catch return;
+ defer self.mutex.unlock(io);
+
+ switch (reading.sensor_type) {
+@@ -78,7 +78,7 @@
+ // Bug 2: The collector needs guaranteed concurrency.
+ // What method ensures a separate unit of concurrency?
+ // (Don't forget: it can fail!)
+- var collector_future = try io.???(collector, .{ io, &queue, &weather });
++ var collector_future = try io.concurrent(collector, .{ io, &queue, &weather });
+ defer _ = collector_future.cancel(io);
+
+ // Sensor group: the sensors can use async — they just need
+@@ -91,7 +91,7 @@
+
+ // Bug 3: Wait for ALL sensors to finish sending their readings.
+ // What Group method blocks until all tasks complete?
+- try sensors.???(io);
++ try sensors.await(io);
+
+ // All sensors done — close the queue so the collector knows
+ // there's no more data coming.
+@@ -99,15 +99,14 @@
+
+ // Wait for the collector to drain the remaining queue.
+ _ = collector_future.await(io);
+- // _ = collector_future.???(io);
+
+ // Now write the garden report. This is critical — it must
+ // NOT be interrupted, even if something tries to cancel us!
+ //
+ // Bug 5: Protect this section from cancellation.
+ // What Io method swaps the cancel protection state?
+- const old_protection = io.???(.blocked);
+- defer _ = io.???(old_protection);
++ const old_protection = io.swapCancelProtection(.blocked);
++ defer _ = io.swapCancelProtection(old_protection);
+
+ printGardenReport(&weather);
+ }
+@@ -129,7 +128,7 @@
+
+ // Bug 6: Send the reading into the queue.
+ // What Queue method sends a single element?
+- queue.???(io, reading) catch return;
++ queue.putOne(io, reading) catch return;
+ }
+ }
+
diff --git a/patches/patches/093_hello_c.patch b/patches/patches/096_hello_c.patch
similarity index 73%
rename from patches/patches/093_hello_c.patch
rename to patches/patches/096_hello_c.patch
index fe1f853..f5fe06f 100644
--- a/patches/patches/093_hello_c.patch
+++ b/patches/patches/096_hello_c.patch
@@ -1,5 +1,5 @@
---- exercises/093_hello_c.zig 2023-10-03 22:15:22.125574535 +0200
-+++ answers/093_hello_c.zig 2023-10-05 20:04:07.262770750 +0200
+--- exercises/096_hello_c.zig 2025-08-15 15:17:57.839348063 +0200
++++ answers/096_hello_c.zig 2026-04-03 13:09:26.195163128 +0200
@@ -54,7 +54,7 @@
//
// In this exercise we use 'write' to output 17 chars,
diff --git a/patches/patches/097_bit_manipulation.patch b/patches/patches/097_bit_manipulation.patch
deleted file mode 100644
index 19ba876..0000000
--- a/patches/patches/097_bit_manipulation.patch
+++ /dev/null
@@ -1,11 +0,0 @@
---- exercises/097_bit_manipulation.zig 2025-05-12 21:25:03.395385743 +0200
-+++ answers/097_bit_manipulation.zig 2025-05-12 21:22:57.472986976 +0200
-@@ -80,7 +80,7 @@
- y ^= x;
-
- // What must be written here?
-- ???;
-+ x ^= y;
-
- print("x = {b}; y = {b}\n", .{ x, y });
- }
diff --git a/patches/patches/094_c_math.patch b/patches/patches/097_c_math.patch
similarity index 52%
rename from patches/patches/094_c_math.patch
rename to patches/patches/097_c_math.patch
index f8c7620..917fe6b 100644
--- a/patches/patches/094_c_math.patch
+++ b/patches/patches/097_c_math.patch
@@ -1,5 +1,5 @@
---- exercises/094_c_math.zig 2024-02-28 12:50:35.789939935 +0100
-+++ answers/094_c_math.zig 2024-02-28 12:53:57.910309471 +0100
+--- exercises/097_c_math.zig 2025-08-15 15:17:57.839348063 +0200
++++ answers/097_c_math.zig 2026-04-03 13:09:32.059278502 +0200
@@ -26,7 +26,7 @@
const c = @cImport({
diff --git a/patches/patches/095_for3.patch b/patches/patches/098_for3.patch
similarity index 80%
rename from patches/patches/095_for3.patch
rename to patches/patches/098_for3.patch
index a158b31..c280bc6 100644
--- a/patches/patches/095_for3.patch
+++ b/patches/patches/098_for3.patch
@@ -1,5 +1,5 @@
---- exercises/095_for3.zig 2026-02-27 19:33:59
-+++ answers/095_for3.zig 2026-02-27 19:33:38
+--- exercises/098_for3.zig 2026-03-20 19:23:48.873150100 +0100
++++ answers/098_for3.zig 2026-04-03 13:09:39.916433087 +0200
@@ -56,7 +56,7 @@
// I want to print every number between 1 and 20 that is NOT
diff --git a/patches/patches/096_memory_allocation.patch b/patches/patches/099_memory_allocation.patch
similarity index 64%
rename from patches/patches/096_memory_allocation.patch
rename to patches/patches/099_memory_allocation.patch
index c26eeeb..d83a0ae 100644
--- a/patches/patches/096_memory_allocation.patch
+++ b/patches/patches/099_memory_allocation.patch
@@ -1,5 +1,5 @@
---- exercises/096_memory_allocation.zig 2023-11-21 14:55:33.805678390 +0100
-+++ answers/096_memory_allocation.zig 2023-11-21 14:56:00.236163484 +0100
+--- exercises/099_memory_allocation.zig 2025-08-15 15:17:57.839348063 +0200
++++ answers/099_memory_allocation.zig 2026-04-03 13:09:47.403580391 +0200
@@ -64,7 +64,7 @@
const allocator = arena.allocator();
diff --git a/patches/patches/100_bit_manipulation.patch b/patches/patches/100_bit_manipulation.patch
new file mode 100644
index 0000000..f70cc41
--- /dev/null
+++ b/patches/patches/100_bit_manipulation.patch
@@ -0,0 +1,11 @@
+--- exercises/100_bit_manipulation.zig 2025-08-15 15:17:57.839348063 +0200
++++ answers/100_bit_manipulation.zig 2026-04-02 10:51:15.795831343 +0200
+@@ -80,7 +80,7 @@
+ y ^= x;
+
+ // What must be written here?
+- ???;
++ x ^= y;
+
+ print("x = {b}; y = {b}\n", .{ x, y });
+ }
diff --git a/patches/patches/098_bit_manipulation2.patch b/patches/patches/101_bit_manipulation2.patch
similarity index 55%
rename from patches/patches/098_bit_manipulation2.patch
rename to patches/patches/101_bit_manipulation2.patch
index 5354a7b..5179272 100644
--- a/patches/patches/098_bit_manipulation2.patch
+++ b/patches/patches/101_bit_manipulation2.patch
@@ -1,5 +1,5 @@
---- exercises/098_bit_manipulation2.zig 2023-10-03 22:15:22.125574535 +0200
-+++ answers/098_bit_manipulation2.zig 2023-10-05 20:04:07.286104520 +0200
+--- exercises/101_bit_manipulation2.zig 2025-08-15 15:17:57.839348063 +0200
++++ answers/101_bit_manipulation2.zig 2026-04-02 10:51:15.797831382 +0200
@@ -60,5 +60,5 @@
// and if so, we know the given string is a pangram
//
diff --git a/patches/patches/099_formatting.patch b/patches/patches/102_formatting.patch
similarity index 71%
rename from patches/patches/099_formatting.patch
rename to patches/patches/102_formatting.patch
index a56b556..dba8aef 100644
--- a/patches/patches/099_formatting.patch
+++ b/patches/patches/102_formatting.patch
@@ -1,5 +1,5 @@
---- exercises/099_formatting.zig 2024-11-07 21:45:10.459123650 +0100
-+++ answers/099_formatting.zig 2024-11-07 21:43:55.154345991 +0100
+--- exercises/102_formatting.zig 2026-03-20 19:23:48.873150100 +0100
++++ answers/102_formatting.zig 2026-04-02 10:51:15.799831421 +0200
@@ -131,7 +131,7 @@
for (0..size) |b| {
// What formatting is needed here to make our columns
diff --git a/patches/patches/100_for4.patch b/patches/patches/103_for4.patch
similarity index 71%
rename from patches/patches/100_for4.patch
rename to patches/patches/103_for4.patch
index ad73e9a..7a7e161 100644
--- a/patches/patches/100_for4.patch
+++ b/patches/patches/103_for4.patch
@@ -1,5 +1,5 @@
---- exercises/100_for4.zig 2023-10-03 22:15:22.125574535 +0200
-+++ answers/100_for4.zig 2023-10-05 20:04:07.296104707 +0200
+--- exercises/103_for4.zig 2025-08-15 15:17:57.839348063 +0200
++++ answers/103_for4.zig 2026-04-02 10:51:15.801831460 +0200
@@ -39,7 +39,7 @@
const hex_nums = [_]u8{ 0xb, 0x2a, 0x77 };
const dec_nums = [_]u8{ 11, 42, 119 };
diff --git a/patches/patches/101_for5.patch b/patches/patches/104_for5.patch
similarity index 72%
rename from patches/patches/101_for5.patch
rename to patches/patches/104_for5.patch
index 00f19df..ef77013 100644
--- a/patches/patches/101_for5.patch
+++ b/patches/patches/104_for5.patch
@@ -1,5 +1,5 @@
---- exercises/101_for5.zig 2023-10-03 22:15:22.125574535 +0200
-+++ answers/101_for5.zig 2023-10-05 20:04:07.299438103 +0200
+--- exercises/104_for5.zig 2025-08-15 15:17:57.839348063 +0200
++++ answers/104_for5.zig 2026-04-02 10:51:15.803831499 +0200
@@ -51,7 +51,7 @@
// We would like to number our list starting with 1, not 0.
diff --git a/patches/patches/102_testing.patch b/patches/patches/105_testing.patch
similarity index 81%
rename from patches/patches/102_testing.patch
rename to patches/patches/105_testing.patch
index 6d18bf6..069b72b 100644
--- a/patches/patches/102_testing.patch
+++ b/patches/patches/105_testing.patch
@@ -1,5 +1,5 @@
---- exercises/102_testing.zig 2025-10-24 12:54:56
-+++ answers/102_testing.zig 2025-10-24 12:56:33
+--- exercises/105_testing.zig 2026-03-20 19:23:48.873150100 +0100
++++ answers/105_testing.zig 2026-04-02 10:51:15.805831538 +0200
@@ -71,7 +71,7 @@
// The corresponding test is not much different from the previous one. Except
// that it contains an error that you need to correct.
diff --git a/patches/patches/103_tokenization.patch b/patches/patches/106_tokenization.patch
similarity index 64%
rename from patches/patches/103_tokenization.patch
rename to patches/patches/106_tokenization.patch
index 941ca3b..4792df6 100644
--- a/patches/patches/103_tokenization.patch
+++ b/patches/patches/106_tokenization.patch
@@ -1,5 +1,5 @@
---- exercises/103_tokenization.zig 2026-02-27 19:25:11
-+++ answers/103_tokenization.zig 2026-02-27 19:26:04
+--- exercises/106_tokenization.zig 2026-03-20 19:23:48.873150100 +0100
++++ answers/106_tokenization.zig 2026-04-02 10:51:15.807831578 +0200
@@ -134,7 +134,7 @@
;
diff --git a/patches/patches/104_threading.patch b/patches/patches/107_threading.patch
similarity index 79%
rename from patches/patches/104_threading.patch
rename to patches/patches/107_threading.patch
index eda25fd..3f65ef4 100644
--- a/patches/patches/104_threading.patch
+++ b/patches/patches/107_threading.patch
@@ -1,6 +1,6 @@
---- exercises/104_threading.zig 2025-11-28 14:17:31.552529679 +0100
-+++ answers/104_threading.zig 2025-11-28 14:15:36.823931851 +0100
-@@ -97,12 +97,12 @@
+--- exercises/107_threading.zig 2026-04-01 23:31:10.073198955 +0200
++++ answers/107_threading.zig 2026-04-02 10:51:15.809831617 +0200
+@@ -88,12 +88,12 @@
defer handle.join();
// Second thread
diff --git a/patches/patches/105_threading2.patch b/patches/patches/108_threading2.patch
similarity index 73%
rename from patches/patches/105_threading2.patch
rename to patches/patches/108_threading2.patch
index dfa5613..d71f254 100644
--- a/patches/patches/105_threading2.patch
+++ b/patches/patches/108_threading2.patch
@@ -1,5 +1,5 @@
---- exercises/105_threading2.zig 2024-03-23 16:35:14.754540802 +0100
-+++ answers/105_threading2.zig 2024-03-23 16:38:00.577539733 +0100
+--- exercises/108_threading2.zig 2025-08-15 15:17:57.839348063 +0200
++++ answers/108_threading2.zig 2026-04-02 10:51:15.811831656 +0200
@@ -81,8 +81,8 @@
defer handle1.join();
diff --git a/patches/patches/106_files.patch b/patches/patches/109_files.patch
similarity index 84%
rename from patches/patches/106_files.patch
rename to patches/patches/109_files.patch
index 27bcb56..ac59d70 100644
--- a/patches/patches/106_files.patch
+++ b/patches/patches/109_files.patch
@@ -1,5 +1,5 @@
---- exercises/106_files.zig 2026-01-09 22:41:19.373872684 +0100
-+++ answers/106_files.zig 2026-01-09 22:41:44.518372910 +0100
+--- exercises/109_files.zig 2026-03-20 19:23:48.874150121 +0100
++++ answers/109_files.zig 2026-04-02 10:51:15.813831695 +0200
@@ -41,7 +41,7 @@
// by doing nothing
//
diff --git a/patches/patches/107_files2.patch b/patches/patches/110_files2.patch
similarity index 89%
rename from patches/patches/107_files2.patch
rename to patches/patches/110_files2.patch
index 6820742..64dc193 100644
--- a/patches/patches/107_files2.patch
+++ b/patches/patches/110_files2.patch
@@ -1,5 +1,5 @@
---- exercises/107_files2.zig 2026-01-09 22:43:15.211177186 +0100
-+++ answers/107_files2.zig 2026-01-09 22:42:48.943654602 +0100
+--- exercises/110_files2.zig 2026-03-20 19:23:48.874150121 +0100
++++ answers/110_files2.zig 2026-04-02 10:51:15.815831734 +0200
@@ -39,7 +39,7 @@
// initialize an array of u8 with all letter 'A'
// we need to pick the size of the array, 64 seems like a good number
diff --git a/patches/patches/108_labeled_switch.patch b/patches/patches/111_labeled_switch.patch
similarity index 83%
rename from patches/patches/108_labeled_switch.patch
rename to patches/patches/111_labeled_switch.patch
index fa9dd67..0fb872d 100644
--- a/patches/patches/108_labeled_switch.patch
+++ b/patches/patches/111_labeled_switch.patch
@@ -1,6 +1,6 @@
---- exercises/108_labeled_switch.zig 2024-09-20 12:09:24.370066539 +0200
-+++ answers/108_labeled_switch.zig 2024-09-20 12:09:06.499711739 +0200
-@@ -65,13 +65,13 @@
+--- exercises/111_labeled_switch.zig 2025-08-15 15:17:57.840348083 +0200
++++ answers/111_labeled_switch.zig 2026-04-02 10:51:15.817831773 +0200
+@@ -67,13 +67,13 @@
// how would you fix it?
pr: switch (PullRequestState.Draft) {
PullRequestState.Draft => continue :pr PullRequestState.InReview,
diff --git a/patches/patches/109_vectors.patch b/patches/patches/112_vectors.patch
similarity index 70%
rename from patches/patches/109_vectors.patch
rename to patches/patches/112_vectors.patch
index bf18cc0..5bf684b 100644
--- a/patches/patches/109_vectors.patch
+++ b/patches/patches/112_vectors.patch
@@ -1,5 +1,5 @@
---- exercises/109_vectors.zig 2024-11-07 14:57:09.673383618 +0100
-+++ answers/109_vectors.zig 2024-11-07 14:22:59.069150138 +0100
+--- exercises/112_vectors.zig 2025-08-15 15:17:57.840348083 +0200
++++ answers/112_vectors.zig 2026-04-02 10:51:15.819831812 +0200
@@ -121,8 +121,8 @@
const Vec4 = @Vector(4, f32);
diff --git a/patches/patches/110_quiz9.patch b/patches/patches/113_quiz9.patch
similarity index 87%
rename from patches/patches/110_quiz9.patch
rename to patches/patches/113_quiz9.patch
index 9d9b864..03bd572 100644
--- a/patches/patches/110_quiz9.patch
+++ b/patches/patches/113_quiz9.patch
@@ -1,6 +1,6 @@
---- exercises/110_quiz9.zig 2025-02-08 13:19:48.522641785 -0800
-+++ answers/110_quiz9.zig 2025-02-10 17:42:04.525004335 -0800
-@@ -108,7 +108,7 @@
+--- exercises/113_quiz9.zig 2025-08-15 15:17:57.840348083 +0200
++++ answers/113_quiz9.zig 2026-04-02 10:51:15.821831851 +0200
+@@ -84,7 +84,7 @@
PORTB = 0b1100;
print(" {b:0>4} // (initial state of PORTB)\n", .{PORTB});
print("^ {b:0>4} // (bitmask)\n", .{0b0101});
@@ -9,7 +9,7 @@
checkAnswer(0b1001, PORTB);
newline();
-@@ -116,7 +116,7 @@
+@@ -92,7 +92,7 @@
PORTB = 0b1100;
print(" {b:0>4} // (initial state of PORTB)\n", .{PORTB});
print("^ {b:0>4} // (bitmask)\n", .{0b0011});
@@ -18,7 +18,7 @@
checkAnswer(0b1111, PORTB);
newline();
-@@ -170,7 +170,7 @@
+@@ -103,7 +103,7 @@
PORTB = 0b1001; // reset PORTB
print(" {b:0>4} // (initial state of PORTB)\n", .{PORTB});
print("| {b:0>4} // (bitmask)\n", .{0b0100});
@@ -27,7 +27,7 @@
checkAnswer(0b1101, PORTB);
newline();
-@@ -178,7 +178,7 @@
+@@ -111,7 +111,7 @@
PORTB = 0b1001; // reset PORTB
print(" {b:0>4} // (reset state)\n", .{PORTB});
print("| {b:0>4} // (bitmask)\n", .{0b0100});
@@ -36,7 +36,7 @@
checkAnswer(0b1101, PORTB);
newline();
-@@ -269,7 +269,7 @@
+@@ -122,7 +122,7 @@
PORTB = 0b1110; // reset PORTB
print(" {b:0>4} // (initial state of PORTB)\n", .{PORTB});
print("& {b:0>4} // (bitmask)\n", .{0b1011});
@@ -45,7 +45,7 @@
checkAnswer(0b1010, PORTB);
newline();
-@@ -277,7 +277,7 @@
+@@ -130,7 +130,7 @@
PORTB = 0b0111; // reset PORTB
print(" {b:0>4} // (reset state)\n", .{PORTB});
print("& {b:0>4} // (bitmask)\n", .{0b1110});
diff --git a/patches/patches/111_packed.patch b/patches/patches/114_packed.patch
similarity index 91%
rename from patches/patches/111_packed.patch
rename to patches/patches/114_packed.patch
index d38ac68..3c79f18 100644
--- a/patches/patches/111_packed.patch
+++ b/patches/patches/114_packed.patch
@@ -1,5 +1,5 @@
---- exercises/111_packed.zig 2026-03-13 11:18:44
-+++ answers/111_packed.zig 2026-03-13 11:18:57
+--- exercises/114_packed.zig 2026-03-20 19:23:48.874150121 +0100
++++ answers/114_packed.zig 2026-04-02 10:51:15.824831910 +0200
@@ -41,7 +41,7 @@
const PackedStruct = packed struct {
diff --git a/patches/patches/112_packed2.patch b/patches/patches/115_packed2.patch
similarity index 87%
rename from patches/patches/112_packed2.patch
rename to patches/patches/115_packed2.patch
index 9b01eb3..81c32ab 100644
--- a/patches/patches/112_packed2.patch
+++ b/patches/patches/115_packed2.patch
@@ -1,5 +1,5 @@
---- exercises/112_packed2.zig 2026-03-13 11:14:08
-+++ answers/112_packed2.zig 2026-03-13 11:14:16
+--- exercises/115_packed2.zig 2026-03-20 19:23:48.874150121 +0100
++++ answers/115_packed2.zig 2026-04-02 10:51:15.826831949 +0200
@@ -13,9 +13,9 @@
const s: S = .{ .a = true, .b = -1 };
switch (s) {