From cae0fbe0b2ae1d24769d322e4a2b6c46ca3d97d7 Mon Sep 17 00:00:00 2001
From: Dave Gauer <dave@ratfactor.com>
Date: Mon, 26 Apr 2021 20:01:54 -0400
Subject: add ex073 comptime 8

---
 build.zig                           |  4 +++
 exercises/073_comptime8.zig         | 65 +++++++++++++++++++++++++++++++++++++
 patches/patches/073_comptime8.patch |  8 +++++
 3 files changed, 77 insertions(+)
 create mode 100644 exercises/073_comptime8.zig
 create mode 100644 patches/patches/073_comptime8.patch

diff --git a/build.zig b/build.zig
index eafcfef..9581e17 100644
--- a/build.zig
+++ b/build.zig
@@ -366,6 +366,10 @@ const exercises = [_]Exercise{
         .main_file = "072_comptime7.zig",
         .output = "26",
     },
+    .{
+        .main_file = "073_comptime8.zig",
+        .output = "My llama value is 25.",
+    },
 };
 
 /// Check the zig version to make sure it can compile the examples properly.
diff --git a/exercises/073_comptime8.zig b/exercises/073_comptime8.zig
new file mode 100644
index 0000000..6828f55
--- /dev/null
+++ b/exercises/073_comptime8.zig
@@ -0,0 +1,65 @@
+//
+// As a matter of fact, you can put 'comptime' in front of any
+// expression to force it to be run at compile time.
+//
+// Execute a function:
+//
+//     comptime llama();
+//
+// Get a value:
+//
+//     bar = comptime baz();
+//
+// Execute a whole block:
+//
+//     comptime {
+//         bar = baz + biff();
+//         llama(bar);
+//     }
+//
+// Get a value from a block:
+//
+//     var llama = comptime bar: {
+//         const baz = biff() + bonk();
+//         break :bar baz;
+//     }
+//
+const print = @import("std").debug.print;
+
+const llama_count = 5;
+const llamas = [llama_count]u32{ 5, 10, 15, 20, 25 };
+
+pub fn main() void {
+    // We meant to fetch the last llama. Please fix this simple
+    // mistake so the assertion no longer fails.
+    const my_llama = getLlama(5);
+
+    print("My llama value is {}.\n", .{my_llama});
+}
+
+fn getLlama(i: usize) u32 {
+    // We've put a guard assert() at the top of this function to
+    // prevent mistakes. The 'comptime' keyword here means that
+    // the mistake will be caught when we compile!
+    //
+    // Without 'comptime', this would still work, but the
+    // assertion would fail at runtime with a PANIC, and that's
+    // not as nice.
+    //
+    // Unfortunately, we're going to get an error right now
+    // because the 'i' parameter needs to be guaranteed to be
+    // known at compile time. What can you do with the 'i'
+    // parameter above to make this so?
+    comptime assert(i < llama_count);
+
+    return llamas[i];
+}
+
+// Fun fact: this assert() function is identical to
+// std.debug.assert() from the Zig Standard Library. 
+fn assert(ok: bool) void {
+    if (!ok) unreachable;
+}
+//
+// Bonus fun fact: I accidentally replaced all instances of 'foo'
+// with 'llama' in this exercise and I have no regrets!
diff --git a/patches/patches/073_comptime8.patch b/patches/patches/073_comptime8.patch
new file mode 100644
index 0000000..5b50edb
--- /dev/null
+++ b/patches/patches/073_comptime8.patch
@@ -0,0 +1,8 @@
+35c35
+<     const my_llama = getLlama(5);
+---
+>     const my_llama = getLlama(4);
+40c40
+< fn getLlama(i: usize) u32 {
+---
+> fn getLlama(comptime i: usize) u32 {
-- 
cgit v1.2.3-ZIG