Merge pull request 'Fix zig 0.15.0-dev.1149+4e6a04929 build errors' (#283) from zawupf/ziglings-exercises:zig-0.15 into main

Reviewed-on: https://codeberg.org/ziglings/exercises/pulls/283

.gitea/issue_template.md

@@ -0,0 +1,5 @@
+Ziglings is a progressive learning series — each exercise builds on previous ones.
+Before opening an issue, please ensure you've followed the path and read the instructions carefully.
+
+Respectful and constructive feedback is always welcome.
+

README.md

@@ -45,7 +45,7 @@ Verify the installation and build number of `zig` like so:
 
 ```
 $ zig version
-0.14.0-dev.xxxx+xxxxxxxxx
+0.15.0-dev.xxxx+xxxxxxxxx
 ```
 
 Clone this repository with Git:
@@ -73,8 +73,8 @@ the appropriate tag.
 The Zig language is under very active development. In order to be
 current, Ziglings tracks **development** builds of the Zig
 compiler rather than versioned **release** builds. The last
-stable release was `0.13.0`, but Ziglings needs a dev build with
-pre-release version "0.14.0" and a build number at least as high
+stable release was `0.14.1`, but Ziglings needs a dev build with
+pre-release version "0.15.0" and a build number at least as high
 as that shown in the example version check above.
 
 It is likely that you'll download a build which is _greater_ than
@@ -87,7 +87,8 @@ that if you update one, you may need to also update the other.
 
 ### Version Changes
 
-Version-0.14.0-dev.1573
+Version-0.15.0-dev.1092
+* *2025-07-22* zig 0.15.0-dev.1092 - various changes due to new I/O API, see [#24488](https://github.com/ziglang/zig/pull/24488)
 * *2024-09-16* zig 0.14.0-dev.1573 - introduction of labeled switch, see [#21257](https://github.com/ziglang/zig/pull/21257)
 * *2024-09-02* zig 0.14.0-dev.1409 - several changes in std.builtin, see [#21225](https://github.com/ziglang/zig/pull/21225)
 * *2024-08-04* zig 0.14.0-dev.1224 - several changes in build system, see [#21115](https://github.com/ziglang/zig/pull/21115)
@@ -233,6 +234,7 @@ Zig Core Language
 * [X] Interfaces
 * [X] Bit manipulation
 * [X] Working with C
+* [ ] Opaque types (anyopaque)
 * [X] Threading
 * [x] Labeled switch
 * [x] Vector operations (SIMD)

build.zig

@@ -15,7 +15,7 @@ const print = std.debug.print;
 //     1) Getting Started
 //     2) Version Changes
 comptime {
-    const required_zig = "0.14.0-dev.1573";
+    const required_zig = "0.15.0-dev.1092";
     const current_zig = builtin.zig_version;
     const min_zig = std.SemanticVersion.parse(required_zig) catch unreachable;
     if (current_zig.order(min_zig) == .lt) {
@@ -126,19 +126,18 @@ pub fn build(b: *Build) !void {
     if (!validate_exercises()) std.process.exit(2);
 
     use_color_escapes = false;
-    if (std.io.getStdErr().supportsAnsiEscapeCodes()) {
+    if (std.fs.File.stderr().supportsAnsiEscapeCodes()) {
         use_color_escapes = true;
     } else if (builtin.os.tag == .windows) {
         const w32 = struct {
-            const WINAPI = std.os.windows.WINAPI;
             const DWORD = std.os.windows.DWORD;
             const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004;
             const STD_ERROR_HANDLE: DWORD = @bitCast(@as(i32, -12));
-            extern "kernel32" fn GetStdHandle(id: DWORD) callconv(WINAPI) ?*anyopaque;
-            extern "kernel32" fn GetConsoleMode(console: ?*anyopaque, out_mode: *DWORD) callconv(WINAPI) u32;
-            extern "kernel32" fn SetConsoleMode(console: ?*anyopaque, mode: DWORD) callconv(WINAPI) u32;
+            const GetStdHandle = std.os.windows.kernel32.GetStdHandle;
+            const GetConsoleMode = std.os.windows.kernel32.GetConsoleMode;
+            const SetConsoleMode = std.os.windows.kernel32.SetConsoleMode;
         };
-        const handle = w32.GetStdHandle(w32.STD_ERROR_HANDLE);
+        const handle = w32.GetStdHandle(w32.STD_ERROR_HANDLE).?;
         var mode: w32.DWORD = 0;
         if (w32.GetConsoleMode(handle, &mode) != 0) {
             mode |= w32.ENABLE_VIRTUAL_TERMINAL_PROCESSING;
@@ -200,7 +199,7 @@ pub fn build(b: *Build) !void {
 
     if (rand) |_| {
         // Random build mode: verifies one random exercise.
-        // like for 'exno' but chooses a random exersise number.
+        // like for 'exno' but chooses a random exercise number.
         print("work in progress: check a random exercise\n", .{});
 
         var prng = std.Random.DefaultPrng.init(blk: {
@@ -1064,7 +1063,7 @@ const exercises = [_]Exercise{
     .{
         .main_file = "082_anonymous_structs3.zig",
         .output =
-        \\"0"(bool):true "1"(bool):false "2"(i32):42 "3"(f32):3.141592e0
+        \\"0"(bool):true "1"(bool):false "2"(i32):42 "3"(f32):3.141592
         ,
         .hint = "This one is a challenge! But you have everything you need.",
     },
@@ -1146,7 +1145,7 @@ const exercises = [_]Exercise{
     },
     .{
         .main_file = "097_bit_manipulation.zig",
-        .output = "x = 0; y = 1",
+        .output = "x = 1011; y = 1101",
     },
     .{
         .main_file = "098_bit_manipulation2.zig",

exercises/026_hello2.zig

@@ -16,12 +16,12 @@ const std = @import("std");
 //
 pub fn main() !void {
     // We get a Writer for Standard Out so we can print() to it.
-    const stdout = std.io.getStdOut().writer();
+    var stdout = std.fs.File.stdout().writer(&.{});
 
     // Unlike std.debug.print(), the Standard Out writer can fail
     // with an error. We don't care _what_ the error is, we want
     // to be able to pass it up as a return value of main().
     //
     // We just learned of a single statement which can accomplish this.
-    stdout.print("Hello world!\n", .{});
+    stdout.interface.print("Hello world!\n", .{});
 }

exercises/033_iferror.zig

@@ -17,7 +17,7 @@
 //
 //     if (foo) |value| {
 //         ...
-//     } else |err| switch(err) {
+//     } else |err| switch (err) {
 //         ...
 //     }
 //

exercises/034_quiz4.zig

@@ -10,11 +10,11 @@ const std = @import("std");
 const NumError = error{IllegalNumber};
 
 pub fn main() void {
-    const stdout = std.io.getStdOut().writer();
+    var stdout = std.fs.File.stdout().writer(&.{});
 
     const my_num: u32 = getNumber();
 
-    try stdout.print("my_num={}\n", .{my_num});
+    try stdout.interface.print("my_num={}\n", .{my_num});
 }
 
 // This function is obviously weird and non-functional. But you will not be changing it for this quiz.

exercises/050_no_value.zig

@@ -43,7 +43,7 @@
 //
 //       "void" is a _type_, not a value. It is the most popular of the
 //       Zero Bit Types (those types which take up absolutely no space
-//       and have only a semantic value. When compiled to executable
+//       and have only a semantic value). When compiled to executable
 //       code, zero bit types generate no code at all. The above example
 //       shows a variable foo of type void which is assigned the value
 //       of an empty expression. It's much more common to see void as

exercises/065_builtins2.zig

@@ -99,11 +99,15 @@ pub fn main() void {
     // 'fields' is a slice of StructFields. Here's the declaration:
     //
     //     pub const StructField = struct {
-    //         name: []const u8,
+    //         name: [:0]const u8,
     //         type: type,
-    //         default_value: anytype,
+    //         default_value_ptr: ?*const anyopaque,
     //         is_comptime: bool,
     //         alignment: comptime_int,
+    //
+    //         defaultValue() ?sf.type  // Function that loads the
+    //                                  // field's default value from
+    //                                  // `default_value_ptr`
     //     };
     //
     // Please complete these 'if' statements so that the field

exercises/071_comptime6.zig

@@ -7,7 +7,7 @@
 // doing this work.
 //
 // An 'inline for' is performed at compile time, allowing you to
-// programatically loop through a series of items in situations
+// programmatically loop through a series of items in situations
 // like those mentioned above where a regular runtime 'for' loop
 // wouldn't be allowed:
 //

exercises/080_anonymous_structs.zig

@@ -19,12 +19,12 @@
 //     const MyBar = Bar();  // store the struct type
 //     const bar = Bar() {}; // create instance of the struct
 //
-// * The value of @typeName(Bar()) is "Bar()".
-// * The value of @typeName(MyBar) is "Bar()".
-// * The value of @typeName(@TypeOf(bar)) is "Bar()".
+// * The value of @typeName(Bar()) is "<filename>.Bar()".
+// * The value of @typeName(MyBar) is "<filename>.Bar()".
+// * The value of @typeName(@TypeOf(bar)) is "<filename>.Bar()".
 //
 // You can also have completely anonymous structs. The value
-// of @typeName(struct {}) is "struct:<position in source>".
+// of @typeName(struct {}) is "<filename>.<function>__struct_<nnn>".
 //
 const print = @import("std").debug.print;
 

exercises/082_anonymous_structs3.zig

@@ -95,13 +95,15 @@ fn printTuple(tuple: anytype) void {
         //     Each 'field' in this loop is one of these:
         //
         //         pub const StructField = struct {
-        //             name: []const u8,
+        //             name: [:0]const u8,
         //             type: type,
-        //             default_value: anytype,
+        //             default_value_ptr: ?*const anyopaque,
         //             is_comptime: bool,
         //             alignment: comptime_int,
         //         };
         //
+        //     Note we will learn about 'anyopaque' type later
+        //
         //     You'll need this builtin:
         //
         //         @field(lhs: anytype, comptime field_name: []const u8)

exercises/097_bit_manipulation.zig

@@ -71,9 +71,9 @@ const print = std.debug.print;
 
 pub fn main() !void {
 
-    // As in the example above, we use 1 and 0 as values for x and y
-    var x: u8 = 1;
-    var y: u8 = 0;
+    // Let us use 1101 and 1011 as values for x and y
+    var x: u8 = 0b1101;
+    var y: u8 = 0b1011;
 
     // Now we swap the values of the two variables by doing xor on them
     x ^= y;
@@ -82,7 +82,7 @@ pub fn main() !void {
     // What must be written here?
     ???;
 
-    print("x = {d}; y = {d}\n", .{ x, y });
+    print("x = {b}; y = {b}\n", .{ x, y });
 }
 
 // This variable swap takes advantage of the fact that the value resulting

exercises/098_bit_manipulation2.zig

@@ -32,7 +32,7 @@ const print = std.debug.print;
 
 pub fn main() !void {
     // let's check the pangram
-    print("Is this a pangram? {?}!\n", .{isPangram("The quick brown fox jumps over the lazy dog.")});
+    print("Is this a pangram? {}!\n", .{isPangram("The quick brown fox jumps over the lazy dog.")});
 }
 
 fn isPangram(str: []const u8) bool {
@@ -45,7 +45,7 @@ fn isPangram(str: []const u8) bool {
     // loop about all characters in the string
     for (str) |c| {
         // if the character is an alphabetical character
-        if (ascii.isASCII(c) and ascii.isAlphabetic(c)) {
+        if (ascii.isAscii(c) and ascii.isAlphabetic(c)) {
             // then we set the bit at the position
             //
             // to do this, we use a little trick:

exercises/099_formatting.zig

@@ -60,7 +60,7 @@
 // variety of formatting instructions. It's basically a tiny
 // language of its own. Here's a numeric example:
 //
-//     print("Catch-{x:0>4}.", .{twenty_two});
+//     print("Catch-0x{x:0>4}.", .{twenty_two});
 //
 // This formatting instruction outputs a hexadecimal number with
 // leading zeros:

exercises/104_threading.zig

@@ -106,7 +106,7 @@ pub fn main() !void {
 
         // After the threads have been started,
         // they run in parallel and we can still do some work in between.
-        std.time.sleep(1500 * std.time.ns_per_ms);
+        std.Thread.sleep(1500 * std.time.ns_per_ms);
         std.debug.print("Some weird stuff, after starting the threads.\n", .{});
     }
     // After we have left the closed area, we wait until
@@ -117,12 +117,12 @@ 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 {
-    std.time.sleep(200 * num * std.time.ns_per_ms);
+    std.Thread.sleep(200 * num * std.time.ns_per_ms);
     std.debug.print("thread {d}: {s}\n", .{ num, "started." });
 
     // This timer simulates the work of the thread.
     const work_time = 3 * ((5 - num % 3) - 2);
-    std.time.sleep(work_time * std.time.ns_per_s);
+    std.Thread.sleep(work_time * std.time.ns_per_s);
 
     std.debug.print("thread {d}: {s}\n", .{ num, "finished." });
 }

exercises/105_threading2.zig

@@ -21,9 +21,9 @@
 // There were the Scottish mathematician Gregory and the German
 // mathematician Leibniz, and even a few hundred years earlier the Indian
 // mathematician Madhava. All of them independently developed the same
-// formula, which was published by Leibnitz in 1682 in the journal
+// formula, which was published by Leibniz in 1682 in the journal
 // "Acta Eruditorum".
-// This is why this method has become known as the "Leibnitz series",
+// This is why this method has become known as the "Leibniz series",
 // although the other names are also often used today.
 // We will not go into the formula and its derivation in detail, but
 // will deal with the series straight away:
@@ -50,7 +50,7 @@
 // enough for us for now, because we want to understand the principle and
 // nothing more, right?
 //
-// As we have already discovered, the Leibnitz series is a series with a
+// As we have already discovered, the Leibniz series is a series with a
 // fixed distance of 2 between the individual partial values. This makes
 // it easy to apply a simple loop to it, because if we start with n = 1
 // (which is not necessarily useful now) we always have to add 2 in each

exercises/107_files2.zig

@@ -12,7 +12,7 @@
 // Alright, bud, lean in close. Here's the game plan.
 //    - First, we open the {project_root}/output/ directory
 //    - Secondly, we open file `zigling.txt` in that directory
-//    - Then, we initalize an array of characters with all letter 'A', and print it
+//    - Then, we initialize an array of characters with all letter 'A', and print it
 //    - After that, we read the content of the file into the array
 //    - Finally, we print out the content we just read
 
@@ -30,9 +30,9 @@ pub fn main() !void {
     const file = try output_dir.openFile("zigling.txt", .{});
     defer file.close();
 
-    // initalize an array of u8 with all letter 'A'
+    // initialize an array of u8 with all letter 'A'
     // we need to pick the size of the array, 64 seems like a good number
-    // fix the initalization below
+    // fix the initialization below
     var content = ['A']*64;
     // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`
     std.debug.print("{s}\n", .{content});

exercises/108_labeled_switch.zig

@@ -19,12 +19,12 @@
 //              }
 //              break;
 //          }
-//      std.debug.print("This statement cannot be reached\n", .{});
+//          std.debug.print("This statement cannot be reached\n", .{});
 //      }
 //
-// By combining all we've learned so far, we can now proceed with a labeled switch
+// By combining all we've learned so far, we can now proceed with a labeled switch.
 //
-// A labeled switch is some extra syntatic sugar, which comes with all sorts of
+// A labeled switch is some extra syntactic sugar, which comes with all sorts of
 // candy (performance benefits). Don't believe me? Directly to source https://github.com/ziglang/zig/pull/21367
 //
 // Here is the previous excerpt implemented as a labeled switch instead:

exercises/110_quiz9.zig

@@ -161,7 +161,7 @@ pub fn main() !void {
 // In order to output a 1, the logic of an XOR operation requires that the
 // two input bits are of different values. Therefore, 0 ^ 1 and 1 ^ 0 will
 // both yield a 1 but 0 ^ 0 and 1 ^ 1 will output 0. XOR's unique behavior
-// of outputing a 0 when both inputs are 1s is what makes it different from
+// of outputting a 0 when both inputs are 1s is what makes it different from
 // the OR operator; it also gives us the ability to toggle bits by putting
 // 1s into our bitmask.
 //
@@ -247,7 +247,7 @@ pub fn main() !void {
 // PORTB = PORTB & 0b1011;
 // print("PORTB: {b:0>4}\n", .{PORTB}); // output -> 1010
 //
-// - 0s clear bits when used in conjuction with a bitwise AND.
+// - 0s clear bits when used in conjunction with a bitwise AND.
 // - 1s do nothing, thus preserving the original bits.
 //
 // -AND op- ---expanded---

patches/patches/026_hello2.patch

@@ -1,9 +1,9 @@
---- exercises/026_hello2.zig	2023-10-03 22:15:22.122241138 +0200
-+++ answers/026_hello2.zig	2023-10-05 20:04:06.959431737 +0200
+--- exercises/026_hello2.zig	2025-07-22 09:55:51.337832401 +0200
++++ answers/026_hello2.zig	2025-07-22 10:00:11.233348058 +0200
 @@ -23,5 +23,5 @@
      // to be able to pass it up as a return value of main().
      //
      // We just learned of a single statement which can accomplish this.
--    stdout.print("Hello world!\n", .{});
-+    try stdout.print("Hello world!\n", .{});
+-    stdout.interface.print("Hello world!\n", .{});
++    try stdout.interface.print("Hello world!\n", .{});
  }

patches/patches/034_quiz4.patch

@@ -1,15 +1,15 @@
---- exercises/034_quiz4.zig	2023-10-03 22:15:22.122241138 +0200
-+++ answers/034_quiz4.zig	2023-10-05 20:04:06.996099091 +0200
+--- exercises/034_quiz4.zig	2025-07-22 09:55:51.337832401 +0200
++++ answers/034_quiz4.zig	2025-07-22 10:05:08.320323184 +0200
 @@ -9,10 +9,10 @@
  
  const NumError = error{IllegalNumber};
  
 -pub fn main() void {
 +pub fn main() !void {
-     const stdout = std.io.getStdOut().writer();
+     var stdout = std.fs.File.stdout().writer(&.{});
  
 -    const my_num: u32 = getNumber();
 +    const my_num: u32 = try getNumber();
  
-     try stdout.print("my_num={}\n", .{my_num});
+     try stdout.interface.print("my_num={}\n", .{my_num});
  }

patches/patches/065_builtins2.patch

@@ -1,5 +1,5 @@
---- exercises/065_builtins2.zig	2024-11-02 16:58:30.607829441 +0100
-+++ answers/065_builtins2.zig	2024-11-02 16:58:33.821220588 +0100
+--- exercises/065_builtins2.zig	2025-06-17 13:58:07.857258167 +0200
++++ answers/065_builtins2.zig	2025-06-17 13:56:36.630415938 +0200
 @@ -58,7 +58,7 @@
      // Oops! We cannot leave the 'me' and 'myself' fields
      // undefined. Please set them here:
@@ -18,7 +18,7 @@
  
      // Now we print a pithy statement about Narcissus.
      print("A {s} loves all {s}es. ", .{
-@@ -109,15 +109,15 @@
+@@ -113,15 +113,15 @@
      // Please complete these 'if' statements so that the field
      // name will not be printed if the field is of type 'void'
      // (which is a zero-bit type that takes up no space at all!):

patches/patches/082_anonymous_structs3.patch

@@ -1,5 +1,5 @@
---- exercises/082_anonymous_structs3.zig	2024-09-07 19:13:58.210327580 +0200
-+++ answers/082_anonymous_structs3.zig	2024-09-07 19:21:20.972733477 +0200
+--- exercises/082_anonymous_structs3.zig	2025-03-14 16:41:17.892873287 +0200
++++ answers/082_anonymous_structs3.zig	2025-03-14 16:40:56.043829543 +0200
 @@ -82,14 +82,14 @@
      //         @typeInfo(Circle).@"struct".fields
      //
@@ -17,7 +17,7 @@
          // 3. Print the field's name, type, and value.
          //
          //     Each 'field' in this loop is one of these:
-@@ -117,9 +117,9 @@
+@@ -119,9 +119,9 @@
          //
          // The first field should print as: "0"(bool):true
          print("\"{s}\"({any}):{any} ", .{

patches/patches/084_async.patch

@@ -1,11 +0,0 @@
---- exercises/084_async.zig	2023-10-03 22:15:22.125574535 +0200
-+++ answers/084_async.zig	2023-10-05 20:04:07.219436606 +0200
-@@ -48,7 +48,7 @@
- pub fn main() void {
-     // Additional Hint: you can assign things to '_' when you
-     // don't intend to do anything with them.
--    foo();
-+    _ = async foo();
- }
- 
- fn foo() void {

patches/patches/085_async2.patch

@@ -1,10 +0,0 @@
---- exercises/085_async2.zig	2023-10-03 22:15:22.125574535 +0200
-+++ answers/085_async2.zig	2023-10-05 20:04:07.226103397 +0200
-@@ -19,6 +19,7 @@
- 
- pub fn main() void {
-     var foo_frame = async foo();
-+    resume foo_frame;
- }
- 
- fn foo() void {

patches/patches/086_async3.patch

@@ -1,16 +0,0 @@
---- exercises/086_async3.zig	2023-10-03 22:15:22.125574535 +0200
-+++ answers/086_async3.zig	2023-10-05 20:04:07.229436793 +0200
-@@ -13,7 +13,12 @@
-     const n = 5;
-     var foo_frame = async foo(n);
- 
--    ???
-+    // Silly solution. You can also use a loop.
-+    resume foo_frame;
-+    resume foo_frame;
-+    resume foo_frame;
-+    resume foo_frame;
-+    resume foo_frame;
- 
-     print("\n", .{});
- }

patches/patches/087_async4.patch

@@ -1,21 +0,0 @@
---- exercises/087_async4.zig	2023-10-03 22:15:22.125574535 +0200
-+++ answers/087_async4.zig	2023-10-05 20:04:07.236103584 +0200
-@@ -16,7 +16,7 @@
- 
-     while (global_counter <= 5) {
-         print("{} ", .{global_counter});
--        ???
-+        resume foo_frame;
-     }
- 
-     print("\n", .{});
-@@ -24,7 +24,7 @@
- 
- fn foo() void {
-     while (true) {
--        ???
--        ???
-+        global_counter += 1;
-+        suspend {}
-     }
- }

patches/patches/088_async5.patch

@@ -1,11 +0,0 @@
---- exercises/088_async5.zig	2023-10-03 22:15:22.125574535 +0200
-+++ answers/088_async5.zig	2023-10-05 20:04:07.239436980 +0200
-@@ -36,7 +36,7 @@
- pub fn main() void {
-     var myframe = async getPageTitle("http://example.com");
- 
--    var value = ???
-+    var value = await myframe;
- 
-     print("{s}\n", .{value});
- }

patches/patches/089_async6.patch

@@ -1,13 +0,0 @@
---- exercises/089_async6.zig	2023-10-03 22:15:22.125574535 +0200
-+++ answers/089_async6.zig	2023-10-05 20:04:07.242770376 +0200
-@@ -41,8 +41,8 @@
-     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;
-+    var com_title = await com_frame;
-+    var org_title = await org_frame;
- 
-     print(".com: {s}, .org: {s}.\n", .{ com_title, org_title });
- }

patches/patches/090_async7.patch

@@ -1,11 +0,0 @@
---- exercises/090_async7.zig	2023-10-03 22:15:22.125574535 +0200
-+++ answers/090_async7.zig	2023-10-05 20:04:07.249437167 +0200
-@@ -29,7 +29,7 @@
-     // 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);
-+    var my_beef = nosuspend getBeef(0);
- 
-     print("beef? {X}!\n", .{my_beef});
- }

patches/patches/091_async8.patch

@@ -1,26 +0,0 @@
---- exercises/091_async8.zig	2023-10-03 22:15:22.125574535 +0200
-+++ answers/091_async8.zig	2023-10-05 20:04:07.252770563 +0200
-@@ -17,7 +17,7 @@
- 
-     var frame = async suspendable();
- 
--    print("X", .{});
-+    print("D", .{});
- 
-     resume frame;
- 
-@@ -25,11 +25,11 @@
- }
- 
- fn suspendable() void {
--    print("X", .{});
-+    print("B", .{});
- 
-     suspend {
--        print("X", .{});
-+        print("C", .{});
-     }
- 
--    print("X", .{});
-+    print("E", .{});
- }

patches/patches/097_bit_manipulation.patch

@@ -1,5 +1,5 @@
---- exercises/097_bit_manipulation.zig	2023-10-03 22:15:22.125574535 +0200
-+++ answers/097_bit_manipulation.zig	2023-10-05 20:04:07.282771124 +0200
+--- 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;
  
@@ -7,5 +7,5 @@
 -    ???;
 +    x ^= y;
  
-     print("x = {d}; y = {d}\n", .{ x, y });
+     print("x = {b}; y = {b}\n", .{ x, y });
  }

patches/patches/106_files.patch

@@ -1,63 +1,16 @@
---- exercises/106_files.zig	2024-11-09 20:33:07.455580904 +0100
-+++ answers/106_files.zig	2024-11-09 20:33:30.394785215 +0100
-@@ -1,22 +1,22 @@
- //
- // Until now, we've only been printing our output in the console,
--// which is good enough for fighting aliens and hermit bookkeeping.
-+// which is good enough for fighting alien and hermit bookkeeping.
- //
--// However, many other tasks require some interaction with the file system,
-+// However, many other task require some interaction with the file system,
- // which is the underlying structure for organizing files on your computer.
- //
--// The file system provides a hierarchical structure for storing files
--// by organizing them into directories, which hold files and other directories,
--// thus creating a tree structure that can be navigated.
-+// The File System provide a hierarchical structure for storing files
-+// by organizing files into directories, which hold files and other directories,
-+// thus creating a tree structure for navigating.
- //
--// Fortunately, the Zig Standard Library provides a simple API for interacting
--// with the file system, see the detail documentation here:
-+// Fortunately, the Zig Standard Library provide a simple api for interacting
-+// with the file system, see the detail documentation here
- //
- // https://ziglang.org/documentation/master/std/#std.fs
- //
--// In this exercise, we'll try to:
--//   - create a new directory,
--//   - open a file in the directory,
-+// In this exercise, we'll try to
-+//   - create a new directory
-+//   - open a file in the directory
- //   - write to the file.
- //
- // import std as always
-@@ -27,42 +27,42 @@
-     const cwd: std.fs.Dir = std.fs.cwd();
- 
-     // then we'll try to make a new directory /output/
--    // to store our output files.
-+    // to put our output files.
-     cwd.makeDir("output") catch |e| switch (e) {
--        // there is a chance you might want to run this
-+        // there are chance you might want to run this
-         // program more than once and the path might already
--        // have been created, so we'll have to handle this error
-+        // been created, so we'll have to handle this error
+--- exercises/106_files.zig	2025-03-13 15:26:59.532367792 +0200
++++ answers/106_files.zig	2025-03-14 22:04:52.243435159 +0200
+@@ -35,7 +35,7 @@
          // by doing nothing
          //
          // we want to catch error.PathAlreadyExists and do nothing
 -        ??? => {},
--        // if there's any other unexpected error we just propagate it through
 +        error.PathAlreadyExists => {},
-+        // if is any other unexpected error we just propagate it through
+         // if there's any other unexpected error we just propagate it through
          else => return e,
      };
- 
-     // then we'll try to open our freshly created directory
--    // wait a minute...
-+    // wait a minute
+@@ -44,7 +44,7 @@
+     // wait a minute...
      // opening a directory might fail!
      // what should we do here?
 -    var output_dir: std.fs.Dir = cwd.openDir("output", .{});
@@ -65,36 +18,12 @@
      defer output_dir.close();
  
      // we try to open the file `zigling.txt`,
--    // and propagate any error up
-+    // and propagate the error up if there are any errors
-     const file: std.fs.File = try output_dir.createFile("zigling.txt", .{});
-     // it is a good habit to close a file after you are done with it
-     // so that other programs can read it and prevent data corruption
+@@ -55,7 +55,7 @@
      // but here we are not yet done writing to the file
--    // if only there were a keyword in Zig that
--    // allowed you to "defer" code execution to the end of the scope...
+     // if only there were a keyword in Zig that
+     // allowed you to "defer" code execution to the end of the scope...
 -    file.close();
-+    // if only there were a keyword in zig that
-+    // allows you "defer" code execute to the end of scope...
 +    defer file.close();
  
--    // you are not allowed to move these two lines above the file closing line!
-+    // !you are not allowed to switch these two lines above the file closing line!
+     // you are not allowed to move these two lines above the file closing line!
      const byte_written = try file.write("It's zigling time!");
-     std.debug.print("Successfully wrote {d} bytes.\n", .{byte_written});
- }
- // to check if you actually write to the file, you can either,
--// 1. open the file in your text editor, or
-+// 1. open the file on your text editor, or
- // 2. print the content of the file in the console with the following command
- //    >> cat ./output/zigling.txt
- //
-@@ -86,7 +86,7 @@
- //
- // Question:
- //   - what should you do if you want to also read the file after opening it?
--//   - go to the documentation of the struct `std.fs.Dir` here:
-+//   - go to documentation of the struct `std.fs.Dir` here
- //     https://ziglang.org/documentation/master/std/#std.fs.Dir
- //       - can you find a function for opening a file? how about deleting a file?
- //       - what kind of options can you use with those functions?

patches/patches/107_files2.patch

@@ -1,55 +1,23 @@
---- exercises/107_files2.zig	2024-06-17 10:11:53.651439869 +0200
-+++ answers/107_files2.zig	2024-06-17 10:21:50.700671057 +0200
-@@ -4,17 +4,17 @@
- //    - create a file {project_root}/output/zigling.txt
- //      with content `It's zigling time!`(18 byte total)
- //
--// Now there's no point in writing to a file if we don't read from it, am I right?
--// Let's write a program to read the content of the file that we just created.
-+// Now there no point in writing to a file if we don't read from it am I right?
-+// let's write a program to read the content of the file that we just created.
- //
- // I am assuming that you've created the appropriate files for this to work.
- //
--// Alright, bud, lean in close. Here's the game plan.
-+// Alright, bud, lean in close here's the game plan.
- //    - First, we open the {project_root}/output/ directory
- //    - Secondly, we open file `zigling.txt` in that directory
--//    - Then, we initalize an array of characters with all letter 'A', and print it
--//    - After that, we read the content of the file into the array
--//    - Finally, we print out the content we just read
-+//    - then, we initalize an array of characters with all letter 'A', and print it
-+//    - After that, we read the content of the file to the array
-+//    - Finally, we print out the read content
- 
- const std = @import("std");
- 
-@@ -30,23 +30,23 @@
-     const file = try output_dir.openFile("zigling.txt", .{});
-     defer file.close();
- 
--    // initalize an array of u8 with all letter 'A'
--    // we need to pick the size of the array, 64 seems like a good number
-+    // initalize an array of u8 with all letter 'A'.
-+    // we need to pick the size of the array, 64 seems like a good number.
-     // fix the initalization below
+--- exercises/107_files2.zig	2025-03-13 15:26:59.532367792 +0200
++++ answers/107_files2.zig	2025-03-14 22:08:35.167953736 +0200
+@@ -33,7 +33,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
+     // fix the initialization below
 -    var content = ['A']*64;
 +    var content = [_]u8{'A'} ** 64;
      // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`
      std.debug.print("{s}\n", .{content});
  
-     // okay, seems like a threat of violence is not the answer in this case
--    // can you go here to find a way to read the content?
-+    // can you go here to find a way to read the content ?
+@@ -41,12 +41,12 @@
+     // can you go here to find a way to read the content?
      // https://ziglang.org/documentation/master/std/#std.fs.File
      // hint: you might find two answers that are both valid in this case
 -    const bytes_read = zig_read_the_file_or_i_will_fight_you(&content);
 +    const bytes_read = try file.read(&content);
  
--    // Woah, too screamy. I know you're excited for zigling time but tone it down a bit.
--    // Can you print only what we read from the file?
-+    // Woah, too screamy, I know you're excited for zigling time but tone it down a bit
-+    // Can you print only what we read from the file ?
+     // Woah, too screamy. I know you're excited for zigling time but tone it down a bit.
+     // Can you print only what we read from the file?
      std.debug.print("Successfully Read {d} bytes: {s}\n", .{
          bytes_read,
 -        content, // change this line only

test/tests.zig

@@ -161,7 +161,7 @@ const CheckNamedStep = struct {
         );
         defer stderr_file.close();
 
-        const stderr = stderr_file.reader();
+        var stderr = stderr_file.readerStreaming(&.{});
         {
             // Skip the logo.
             const nlines = mem.count(u8, root.logo, "\n");
@@ -169,10 +169,10 @@ const CheckNamedStep = struct {
 
             var lineno: usize = 0;
             while (lineno < nlines) : (lineno += 1) {
-                _ = try readLine(stderr, &buf);
+                _ = try readLine(&stderr, &buf);
             }
         }
-        try check_output(step, ex, stderr);
+        try check_output(step, ex, &stderr);
     }
 };
 
@@ -213,7 +213,7 @@ const CheckStep = struct {
         );
         defer stderr_file.close();
 
-        const stderr = stderr_file.reader();
+        var stderr = stderr_file.readerStreaming(&.{});
         for (exercises) |ex| {
             if (ex.number() == 1) {
                 // Skip the logo.
@@ -222,15 +222,15 @@ const CheckStep = struct {
 
                 var lineno: usize = 0;
                 while (lineno < nlines) : (lineno += 1) {
-                    _ = try readLine(stderr, &buf);
+                    _ = try readLine(&stderr, &buf);
                 }
             }
-            try check_output(step, ex, stderr);
+            try check_output(step, ex, &stderr);
         }
     }
 };
 
-fn check_output(step: *Step, exercise: Exercise, reader: Reader) !void {
+fn check_output(step: *Step, exercise: Exercise, reader: *Reader) !void {
     const b = step.owner;
 
     var buf: [1024]u8 = undefined;
@@ -297,12 +297,9 @@ fn check(
     }
 }
 
-fn readLine(reader: fs.File.Reader, buf: []u8) !?[]const u8 {
-    if (try reader.readUntilDelimiterOrEof(buf, '\n')) |line| {
-        return mem.trimRight(u8, line, " \r\n");
-    }
-
-    return null;
+fn readLine(reader: *fs.File.Reader, buf: []u8) !?[]const u8 {
+    try reader.interface.readSliceAll(buf);
+    return mem.trimRight(u8, buf, " \r\n");
 }
 
 /// Fails with a custom error message.
@@ -405,7 +402,8 @@ fn heal(allocator: Allocator, exercises: []const Exercise, work_path: []const u8
 /// difference that returns an error when the temp path cannot be created.
 pub fn makeTempPath(b: *Build) ![]const u8 {
     const rand_int = std.crypto.random.int(u64);
-    const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ Build.hex64(rand_int);
+    const rand_hex64 = std.fmt.hex(rand_int);
+    const tmp_dir_sub_path = "tmp" ++ fs.path.sep_str ++ rand_hex64;
     const path = b.cache_root.join(b.allocator, &.{tmp_dir_sub_path}) catch
         @panic("OOM");
     try b.cache_root.handle.makePath(tmp_dir_sub_path);