Merge pull request 'Integrate file system I/O with the std.Io interface' (#339) from std_Io into main

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

4 files changed, 47 insertions, 25 deletions

diff --git a/exercises/026_hello2.zig b/exercises/026_hello2.zig
index 582dba9..7daa9e2 100644
--- a/exercises/026_hello2.zig
+++ b/exercises/026_hello2.zig
@@ -5,6 +5,9 @@
 //
 const std = @import("std");
 
+// Instance for input/output operations, we'll learn how to create them later.
+const io = std.Options.debug_io;
+
 // Take note that this main() definition now returns "!void" rather
 // than just "void". Since there's no specific error type, this means
 // that Zig will infer the error type. This is appropriate in the case
@@ -15,13 +18,15 @@ const std = @import("std");
 // https://ziglang.org/documentation/master/#Inferred-Error-Sets
 //
 pub fn main() !void {
-    // We get a Writer for Standard Out so we can print() to it.
-    var stdout = std.fs.File.stdout().writer(&.{});
+    // We get a Writer for Standard Out...
+    var stdout_writer = std.Io.File.stdout().writer(io, &.{});
+    // ...and extract its interface so we can print() to it.
+    const stdout = &stdout_writer.interface;
 
     // 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.interface.print("Hello world!\n", .{});
+    stdout.print("Hello world!\n", .{});
 }
diff --git a/exercises/034_quiz4.zig b/exercises/034_quiz4.zig
index 8704397..28f2291 100644
--- a/exercises/034_quiz4.zig
+++ b/exercises/034_quiz4.zig
@@ -6,15 +6,17 @@
 //     my_num=42
 //
 const std = @import("std");
+const io = std.Options.debug_io;
 
 const NumError = error{IllegalNumber};
 
 pub fn main() void {
-    var stdout = std.fs.File.stdout().writer(&.{});
+    var stdout_writer = std.Io.File.stdout().writer(io, &.{});
+    const stdout = &stdout_writer.interface;
 
     const my_num: u32 = getNumber();
 
-    try stdout.interface.print("my_num={}\n", .{my_num});
+    try stdout.print("my_num={}\n", .{my_num});
 }
 
 // This function is obviously weird and non-functional. But you will not be changing it for this quiz.
diff --git a/exercises/106_files.zig b/exercises/106_files.zig
index b38bc72..ee8c6a9 100644
--- a/exercises/106_files.zig
+++ b/exercises/106_files.zig
@@ -12,23 +12,27 @@
 // Fortunately, the Zig Standard Library provides a simple API for interacting
 // with the file system, see the detail documentation here:
 //
-// https://ziglang.org/documentation/master/std/#std.fs
+// https://ziglang.org/documentation/master/std/#std.Io
 //
 // 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
+// Note: For simplicity, we write byte-by-byte without buffering.
+// In real applications, you'd typically use a buffer for better
+// performance. We'll learn about buffered I/O in a later exercise.
+//
 const std = @import("std");
+const io = std.Options.debug_io;
 
 pub fn main() !void {
     // first we get the current working directory
-    const cwd: std.fs.Dir = std.fs.cwd();
+    const cwd: std.Io.Dir = std.Io.Dir.cwd();
 
     // then we'll try to make a new directory /output/
     // to store our output files.
-    cwd.makeDir("output") catch |e| switch (e) {
+    cwd.createDir(io, "output", .default_dir) catch |e| switch (e) {
         // there is a 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
@@ -44,21 +48,24 @@ pub fn main() !void {
     // wait a minute...
     // opening a directory might fail!
     // what should we do here?
-    var output_dir: std.fs.Dir = cwd.openDir("output", .{});
-    defer output_dir.close();
+    var output_dir: std.Io.Dir = try cwd.openDir(io, "output", .{});
+    defer output_dir.close(io);
 
     // we try to open the file `zigling.txt`,
     // and propagate any error up
-    const file: std.fs.File = try output_dir.createFile("zigling.txt", .{});
+    const file: std.Io.File = try output_dir.createFile(io, "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
     // 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...
-    file.close();
+    file.close(io);
+
+    // you are not allowed to move these lines above the file closing line!
+    var file_writer = file.writer(io, &.{});
+    const writer = &file_writer.interface;
 
-    // you are not allowed to move these two lines above the file closing line!
-    const byte_written = try file.write("It's zigling time!");
+    const byte_written = try writer.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,
@@ -71,8 +78,8 @@ pub fn main() !void {
 // More on Creating files
 //
 // notice in:
-// ... try output_dir.createFile("zigling.txt", .{});
-//                                              ^^^
+// ... try output_dir.createFile(io, "zigling.txt", .{});
+//                                                  ^^^
 //                 we passed this anonymous struct to the function call
 //
 // this is the struct `CreateFlag` with default fields
@@ -87,7 +94,7 @@ pub fn main() !void {
 //
 // 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 the documentation of the struct `std.Io.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?
diff --git a/exercises/107_files2.zig b/exercises/107_files2.zig
index 9b94101..a11c46a 100644
--- a/exercises/107_files2.zig
+++ b/exercises/107_files2.zig
@@ -15,20 +15,25 @@
 //    - 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
+//
+// Note: For simplicity, we read byte-by-byte without buffering.
+// In real applications, you'd typically use a buffer for better
+// performance. We'll learn about buffered I/O in a later exercise.
 
 const std = @import("std");
+const io = std.Options.debug_io;
 
 pub fn main() !void {
     // Get the current working directory
-    const cwd = std.fs.cwd();
+    const cwd = std.Io.Dir.cwd();
 
     // try to open ./output assuming you did your 106_files exercise
-    var output_dir = try cwd.openDir("output", .{});
-    defer output_dir.close();
+    var output_dir = try cwd.openDir(io, "output", .{});
+    defer output_dir.close(io);
 
     // try to open the file
-    const file = try output_dir.openFile("zigling.txt", .{});
-    defer file.close();
+    const file = try output_dir.openFile(io, "zigling.txt", .{});
+    defer file.close(io);
 
     // initialize an array of u8 with all letter 'A'
     // we need to pick the size of the array, 64 seems like a good number
@@ -37,10 +42,13 @@ pub fn main() !void {
     // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`
     std.debug.print("{s}\n", .{content});
 
+    var file_reader = file.reader(io, &.{});
+    const reader = &file_reader.interface;
+
     // 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?
-    // https://ziglang.org/documentation/master/std/#std.fs.File
-    // hint: you might find two answers that are both valid in this case
+    // https://ziglang.org/documentation/master/std/#std.Io.Reader
+    // hint: look for a method that reads into a slice
     const bytes_read = zig_read_the_file_or_i_will_fight_you(&content);
 
     // Woah, too screamy. I know you're excited for zigling time but tone it down a bit.