Merge branch 'main' into i69

.gitignore

@@ -2,3 +2,4 @@
 /zig-out/
 /answers/
 /patches/healed/
+/output/

.woodpecker/eowyn.yml

@@ -7,6 +7,6 @@ steps:
     when:
       events:
         - push
-        - pull-requests
+        - pull-requests		
-        - cron
+        - cron		
       cron: "Daily"

build.zig

@@ -1121,6 +1121,17 @@ const exercises = [_]Exercise{
         .main_file = "105_threading2.zig",
         .output = "PI ≈ 3.14159265",
     },
+    .{
+        .main_file = "106_files.zig",
+        .output = "Successfully wrote 18 bytes.",
+    },
+    .{
+        .main_file = "107_files2.zig",
+        .output =
+        \\AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+        \\Successfully Read 18 byte: It's zigling time!
+        ,
+    },
     .{
         .main_file = "999_the_end.zig",
         .output =

exercises/105_threading2.zig

@@ -1,5 +1,5 @@
 //
-// Now that we are familiar with the principles of multithreading, we
+// Now that we are familiar with the principles of multi threading, we
 // boldly venture into a practical example from mathematics.
 // We will determine the circle number PI with sufficient accuracy.
 //

exercises/106_files.zig

@@ -0,0 +1,92 @@
+//
+// Until now, we've only been printing our output in the console,
+// which is good enough for fighting alien and hermit bookkeeping.
+//
+// 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 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, 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
+//   - write to the file.
+//
+// import std as always
+const std = @import("std");
+
+pub fn main() !void {
+    // first we get the current working directory
+    const cwd: std.fs.Dir = std.fs.cwd();
+
+    // then we'll try to make a new directory /output/
+    // to put our output files.
+    cwd.makeDir("output") catch |e| switch (e) {
+        // there are chance you might want to run this
+        // program more than once and the path might already
+        // been created, so we'll have to handle this error
+        // by doing nothing
+        //
+        // we want to catch error.PathAlreadyExists and do nothing
+        ??? => {},
+        // if is 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
+    // opening a directory might fail!
+    // what should we do here?
+    var output_dir: std.fs.Dir = cwd.openDir("output", .{});
+    defer output_dir.close();
+
+    // we try to open the file `zigling.txt`,
+    // 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
+    // so that other program can read it and prevent data corruption
+    // but here we are not yet done writing to the file
+    // if only there are a keyword in zig that
+    // allow you "defer" code execute to the end of scope...
+    file.close();
+
+    // !you are not allow to switch this two lines to before 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 on your text editor, or
+// 2. print the content of the file in the console with command
+//    >> cat ./output/zigling.txt
+//
+//
+// More on Creating files
+//
+// notice in:
+// ... try output_dir.createFile("zigling.txt", .{});
+//                                              ^^^
+//                 we passed this anonymous struct to the function call
+//
+// this is the struct `CreateFlag` with default fields
+// {
+//      read: bool = false,
+//      truncate: bool = true,
+//      exclusive: bool = false,
+//      lock: Lock = .none,
+//      lock_nonblocking: bool = false,
+//      mode: Mode = default_mode
+// }
+//
+// Question:
+//   - what should you do if you want to also read the file after opening it?
+//   - 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 option can you uses with those function?

exercises/107_files2.zig

@@ -0,0 +1,52 @@
+//
+// Prerequisite :
+//    - exercise/106_files.zig, or
+//    - create a file {project_root}/output/zigling.txt
+//      with content `It's zigling time!`(18 byte total)
+//
+// Now there no point in writing to a file if we don't read from it am I right?
+// let's wrote a program to read the content of the file that we just created.
+//
+// I am assuming you've created the appropriate files for this to work.
+//
+// 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 character with all letter 'A', and print it
+//    - Afte that, we read the content of the file to the array
+//    - Finally, we print out the read content
+
+const std = @import("std");
+
+pub fn main() !void {
+    // Get the current working directory
+    const cwd = std.fs.cwd();
+
+    // try to open ./output assuming you did your 106_files exercise
+    var output_dir = try cwd.openDir("output", .{});
+    defer output_dir.close();
+
+    // try to open the file
+    const file = try output_dir.openFile("zigling.txt", .{});
+    defer file.close();
+
+    // initalize an array of u8 with all letter 'A'.
+    // we need to pick a size of the array, 64 seems like a good number.
+    // fix the initalization below
+    var content = ['A']*64;
+    // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`
+    std.debug.print("{s}\n", .{content});
+
+    // okay, seem like 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 answer that are both vaild in this case
+    const byte_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
+    // Can you print only what we read from the file ?
+    std.debug.print("Successfully Read {d} byte: {s}\n", .{
+        byte_read,
+        content, // change this line only
+    });
+}

patches/patches/106_files.patch

@@ -0,0 +1,29 @@
+--- exercises/106_files.zig	2024-03-27 16:52:05.660910200 +0800
++++ answers/106_files.zig	2024-03-27 16:52:09.649422200 +0800
+@@ -35,7 +35,7 @@
+         // by doing nothing
+         //
+         // we want to catch error.PathAlreadyExists and do nothing
+-        ??? => {},
++        error.PathAlreadyExists => {},
+         // if is any other unexpected error we just propagate it through
+         else => return e,
+     };
+@@ -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", .{});
++    var output_dir: std.fs.Dir = try cwd.openDir("output", .{});
+     defer output_dir.close();
+ 
+     // we try to open the file `zigling.txt`,
+@@ -55,7 +55,7 @@
+     // but here we are not yet done writing to the file
+     // if only there are a keyword in zig that
+     // allow you "defer" code execute to the end of scope...
+-    file.close();
++    defer file.close();
+ 
+     // !you are not allow to switch this two lines to before file closing line!
+     const byte_written = try file.write("It's zigling time!");

patches/patches/107_files2.patch

@@ -0,0 +1,26 @@
+--- exercises/107_files2.zig	2024-03-27 16:51:56.199719600 +0800
++++ answers/107_files2.zig	2024-03-27 16:52:01.650935300 +0800
+@@ -33,7 +33,7 @@
+     // initalize an array of u8 with all letter 'A'.
+     // we need to pick a size of the array, 64 seems like a good number.
+     // fix the initalization below
+-    var content = ['A']*64;
++    var content = [_]u8{'A'} ** 64;
+     // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`
+     std.debug.print("{s}\n", .{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 answer that are both vaild in this case
+-    const byte_read = zig_read_the_file_or_i_will_fight_you(&content);
++    const byte_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 ?
+     std.debug.print("Successfully Read {d} byte: {s}\n", .{
+         byte_read,
+-        content, // change this line only
++        content[0..byte_read], // change this line only
+     });
+ }