add ex069 comptime 4

README.md

@@ -41,7 +41,7 @@ Verify the installation and build number of `zig` like so:
 
 ```bash
 $ zig version
-0.8.0-dev.1065+xxxxxxxxx
+0.8.0-dev.1983+xxxxxxxxx
 ```
 
 Clone this repository with Git:
@@ -71,6 +71,11 @@ Once you have a build of the Zig compiler that works with Ziglings, they'll
 continue to work together. But keep in mind that if you update one, you may
 need to also update the other.
 
+### Version Changes
+
+* 2021-04-21 0.8.0-dev.1983 - std.fmt.format() 'any' format string
+* 2021-02-12 0.8.0-dev.1065 - std.fmt.format() 's' (string) format string
+
 ## Advanced Usage
 
 It can be handy to check just a single exercise or _start_ from a single

build.zig

@@ -344,6 +344,10 @@ const exercises = [_]Exercise{
         .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",
     },
+    .{
+        .main_file = "069_comptime4.zig",
+        .output = "s1={ 1, 2, 3 }, s2={ 1, 2, 3, 4, 5 }, s3={ 1, 2, 3, 4, 5, 6, 7 }",
+    },
 };
 
 /// Check the zig version to make sure it can compile the examples properly.
@@ -353,7 +357,10 @@ fn checkVersion() bool {
         return false;
     }
 
-    const needed_version = std.SemanticVersion.parse("0.8.0-dev.1065") catch unreachable;
+    // When changing this version, be sure to also update README.md in two places:
+    //     1) Getting Started
+    //     2) Version Changes
+    const needed_version = std.SemanticVersion.parse("0.8.0-dev.1983") catch unreachable;
     const version = std.builtin.zig_version;
     const order = version.order(needed_version);
     return order != .lt;

exercises/069_comptime4.zig

@@ -0,0 +1,54 @@
+//
+// One of the more common uses of 'comptime' function parameters is
+// passing a type to a function:
+//
+//     fn foo(comptime MyType: type) { ... }
+//
+// In fact, types are ONLY available at compile time, so the
+// 'comptime' keyword is required here.
+//
+// Please take a moment put on the wizard hat which has been
+// provided for you. We're about to use this ability to implement
+// a generic function.
+//
+const print = @import("std").debug.print;
+
+pub fn main() void  {
+    // Here we declare arrays of three different types and sizes
+    // at compile time from a function call. Neat!
+    const s1 = makeSequence(u8, 3);  // creates a [3]u8
+    const s2 = makeSequence(u32, 5); // creates a [5]u32
+    const s3 = makeSequence(i64, 7); // creates a [7]i64
+
+    print("s1={any}, s2={any}, s3={any}\n", .{s1, s2, s3});
+}
+
+// This function is pretty wild because it executes at runtime
+// and is part of the final compiled program. The function is
+// compiled with unchanging data sizes and types.
+//
+// And yet it ALSO allows for different sizes and types. This
+// seems paradoxical. How could both things be true?
+//
+// To accomplish this, the Zig compiler actually generates a
+// separate copy of the function for every size/type combination!
+// So in this case, three different functions will be generated
+// for you, each with machine code that handles that specific
+// data size and type.
+//
+// Please fix this function so that the 'size' parameter:
+//
+//     1) Is guaranteed to be known at compile time.
+//     2) Sets the size of the array of type T (which is the
+//        sequence we're creating and returning).
+//
+fn makeSequence(comptime T: type, ??? size: usize) [???]T {
+    var sequence: [???]T = undefined;
+    var i: usize = 0;
+
+    while (i < size) : (i += 1) {
+        sequence[i] = @intCast(T, i) + 1;
+    }
+    
+    return sequence;
+}

patches/patches/069_comptime4.patch

@@ -0,0 +1,6 @@
+45,46c45,46
+< fn makeSequence(comptime T: type, ??? size: usize) [???]T {
+<     var sequence: [???]T = undefined;
+---
+> fn makeSequence(comptime T: type, comptime size: usize) [size]T {
+>     var sequence: [size]T = undefined;