support iterating over maps

src/value.zig

@@ -95,7 +95,24 @@ pub const Value = union(Type) {
                         .str = str[iter.index - cp_len .. iter.index],
                     };
                 },
-                .map => {},
+                .map => |*map| {
+                    if (iter.index == map.entries.items.len) {
+                        res.* = &Value.None;
+                        return;
+                    }
+
+                    if (res.* == null)
+                        res.* = try vm.gc.alloc();
+                    if (iter.index == 0) {
+                        res.*.?.* = .{ .tuple = try vm.gc.gpa.alloc(*Value, 2) };
+                    }
+                    const e = &map.entries.items[iter.index];
+                    const t = res.*.?.tuple;
+                    // removing `const` on `Map` causes dependency loop??
+                    t[0] = @intToPtr(*Value, @ptrToInt(e.key));
+                    t[1] = e.value;
+                    iter.index += 1;
+                },
                 .range => @panic("TODO: range iterator"),
                 else => unreachable,
             }
@@ -123,7 +140,7 @@ pub const Value = union(Type) {
         switch (value.*) {
             .int, .num, .none, .bool, .native, .tagged, .err, .range, .iterator => {},
             .tuple => |t| allocator.free(t),
-                // I really, really hate `deinit` taking a mutable pointer.
+            // I really, really hate `deinit` taking a mutable pointer.
             .map => |*m| m.deinit(allocator),
             .list => |*l| l.deinit(allocator),
             .str => {

tests/behavior.zig

@@ -1,3 +1,16 @@
+test "map iterator" {
+    expectOutput(
+        \\const map = {1: 2, 3: 4, 5: 6}
+        \\let sum = 0
+        \\for (let (k, v) in map)
+        \\    sum += k
+        \\    sum *= v
+        \\return sum
+    ,
+        \\150
+    );
+}
+
 test "list comprehension" {
     expectOutput(
         \\return for (const c in "hello") c