From 17a22adce10e016489feb243587f0bf80cdd2f76 Mon Sep 17 00:00:00 2001
From: Dave Gauer <dave@ratfactor.com>
Date: Sun, 18 Apr 2021 18:05:36 -0400
Subject: [PATCH] add ex068 comptime 3

---
 build.zig                           |   4 ++
 exercises/068_comptime3.zig         | 108 ++++++++++++++++++++++++++++
 patches/patches/068_comptime3.patch |   8 +++
 3 files changed, 120 insertions(+)
 create mode 100644 exercises/068_comptime3.zig
 create mode 100644 patches/patches/068_comptime3.patch

diff --git a/build.zig b/build.zig
index 410da75..fe80a3e 100644
--- a/build.zig
+++ b/build.zig
@@ -340,6 +340,10 @@ const exercises = [_]Exercise{
         .main_file = "067_comptime2.zig",
         .output = "A BB CCC DDDD",
     },
+    .{
+        .main_file = "068_comptime3.zig",
+        .output = "Minnow (1:32, 4 x 2)\nShark (1:16, 8 x 5)\nWhale (1:1, 143 x 95)\n",
+    },
 };
 
 /// Check the zig version to make sure it can compile the examples properly.
diff --git a/exercises/068_comptime3.zig b/exercises/068_comptime3.zig
new file mode 100644
index 0000000..ebe6c8f
--- /dev/null
+++ b/exercises/068_comptime3.zig
@@ -0,0 +1,108 @@
+//
+// You can also put 'comptime' before a function parameter to
+// enforce that the argument passed to the function must be known
+// at compile time. We've actually been using a function like
+// this the entire time, std.debug.print():
+//
+//     fn print(comptime fmt: []const u8, args: anytype) void
+//
+// Notice that the format string parameter 'fmt' is marked as
+// 'comptime'.  One of the neat benefits of this is that the
+// format string can be checked for errors at compile time rather
+// than crashing at runtime.
+//
+// (The actual formatting is done by std.fmt.format() and it
+// contains a complete format string parser that runs entirely at
+// compile time!)
+//
+const print = @import("std").debug.print;
+
+// This struct is the model of a model boat. We can transform it
+// to any scale we would like: 1:2 is half-size, 1:32 is
+// thirty-two times smaller than the real thing, and so forth.
+const Schooner = struct {
+    name: []const u8,
+    scale: u32 = 1,
+    hull_length: u32 = 143,
+    bowsprit_length: u32 = 34,
+    mainmast_height: u32 = 95,
+
+    fn scaleMe(self: *Schooner, comptime scale: u32) void {
+        var my_scale = scale;
+
+        // We did something neat here: we've anticipated the
+        // possibility of accidentally attempting to create a
+        // scale of 1:0. Rather than having this result in a
+        // divide-by-zero error at runtime, we've turned this
+        // into a compile error.
+        //
+        // This is probably the correct solution most of the
+        // time. But our model boat model program is very casual
+        // and we just want it to "do what I mean" and keep
+        // working.
+        //
+        // Please change this so that it sets a 0 scale to 1
+        // instead.
+        if (my_scale == 0) @compileError("Scale 1:0 is not valid!");
+
+        self.scale = my_scale;
+        self.hull_length /= my_scale;
+        self.bowsprit_length /= my_scale;
+        self.mainmast_height /= my_scale;
+    }
+
+    fn printMe(self: Schooner) void {
+        print("{s} (1:{}, {} x {})\n", .{
+            self.name,
+            self.scale,
+            self.hull_length,
+            self.mainmast_height,
+        });
+    }
+};
+
+pub fn main() void  {
+    var whale = Schooner {.name = "Whale"};
+    var shark = Schooner {.name = "Shark"};
+    var minnow = Schooner {.name = "Minnow"};
+
+    // Hey, we can't just pass this runtime variable as an
+    // argument to the scaleMe() method. What would let us do
+    // that?
+    var scale: u32 = undefined;
+
+    scale = 32; // 1:32 scale
+
+    minnow.scaleMe(scale);
+    minnow.printMe();
+
+    scale -= 16; // 1:16 scale
+
+    shark.scaleMe(scale);
+    shark.printMe();
+
+    scale -= 16; // 1:0 scale (oops, but DON'T FIX THIS!)
+
+    whale.scaleMe(scale);
+    whale.printMe();
+}
+//
+// Going deeper:
+//
+// What would happen if you DID attempt to build a model in the
+// scale of 1:0?
+//
+//    A) You're already done!
+//    B) You would suffer a mental divide-by-zero error.
+//    C) You would construct a singularity and destroy the
+//       planet.
+//
+// And how about a model in the scale of 0:1?
+//
+//    A) You're already done!
+//    B) You'd arrange nothing carefully into the form of the
+//       original nothing but infinitely larger.
+//    C) You would construct a singularity and destroy the
+//       planet.
+//
+// Answers can be found on the back of the Ziglings packaging.
diff --git a/patches/patches/068_comptime3.patch b/patches/patches/068_comptime3.patch
new file mode 100644
index 0000000..985f0e6
--- /dev/null
+++ b/patches/patches/068_comptime3.patch
@@ -0,0 +1,8 @@
+46c46
+<         if (my_scale == 0) @compileError("Scale 1:0 is not valid!");
+---
+>         if (my_scale == 0) my_scale = 1; //@compileError("Scale 1:0 is not valid!");
+72c72
+<     var scale: u32 = undefined;
+---
+>     comptime var scale: u32 = undefined;