summaryrefslogtreecommitdiff
path: root/exercises
diff options
context:
space:
mode:
Diffstat (limited to 'exercises')
-rw-r--r--exercises/026_hello2.zig11
-rw-r--r--exercises/034_quiz4.zig6
-rw-r--r--exercises/106_files.zig33
-rw-r--r--exercises/107_files2.zig22
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.
generated by cgit v1.2.3 (git 2.51.0) at 2026-06-30 14:26:59 +0000