some junk

comptime_vars.zig

@@ -0,0 +1,21 @@
+const std = @import("std");
+const expect = std.testing.expect;
+
+test "comptime vars" {
+    var x: i32 = 1;
+    comptime var y: i32 = 1;
+
+    x += 1;
+    y += 1;
+
+    expect(x == 2);
+    expect(y == 2);
+
+    if (y != 2) {
+        // this compile error never triggers. y is a comptime variable, which
+        // makes `y != 2` knowable at comptime (would we call this a comptime
+        // expression?). the "if" statement is statically evaluated. I don't
+        // get it.
+        @compileError("wrong y value");
+    }
+}

float_foo.zig

@@ -0,0 +1,12 @@
+const std = @import("std");
+const builtin = std.builtin;
+const big = @as(f64, 1 << 40);
+
+export fn foo_strict(x: f64) f64 {
+    return x + big - big;
+}
+
+export fn foo_optimized(x: f64) f64 {
+    @setFloatMode(.Optimized);
+    return x + big - big;
+}

namespaced_global.zig

@@ -4,7 +4,6 @@ const expect = std.testing.expect;
 test "namespaced global variable" {
     expect(foo() == 1235);
     expect(foo() == 1236);
-    expect(boffin() == 1237);
 }
 
 fn foo() i32 {
@@ -14,8 +13,3 @@ fn foo() i32 {
     S.x += 1;
     return S.x;
 }
-
-fn boffin() i32 {
-    S.x += 1;
-    return S.x;
-}

pwd.zig

@@ -0,0 +1,15 @@
+const std = @import("std");
+const os = std.os;
+const print = std.debug.print;
+
+pub fn main() !void {
+    var buf: [256]u8 = undefined;
+    var fba = std.heap.FixedBufferAllocator.init(&buf);
+    var allocator = &fba.allocator;
+
+    const cwd = try allocator.alloc(u8, 256);
+    defer allocator.free(cwd);
+
+    const z = try os.getcwd(cwd);
+    print("{}\n", .{z});
+}