@shd101wyy/yo 0.1.22 → 0.1.24

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "main": "./out/cjs/index.cjs",
   "module": "./out/esm/index.mjs",
   "types": "./out/types/src/index.d.ts",

package/std/build.yo

@@ -201,7 +201,7 @@ impl(Step,
     __yo_build_add_import(self.name, entry.name, entry.module.name, entry.module._dep);
   }),
   /// Add a list of module imports to this step.
-  add_import_list : (fn(comptime(self) : Self, comptime(entries) : ComptimeList(ImportEntry)) -> comptime(unit))({
+  add_import_list : (fn(comptime(self) : Self, comptime(entries) : ComptimeList(ImportEntry)) -> comptime(unit))(
     cond(
       (entries.len() == usize(0)) => (),
       true => {
@@ -209,7 +209,7 @@ impl(Step,
         recur(self, entries.cdr())
       }
     )
-  }),
+  ),
   /// Add extra C compiler flags to this step.
   add_c_flags : (fn(comptime(self) : Self, comptime(flags) : comptime_string) -> comptime(unit))({
     __yo_build_add_cflags(self.name, flags);

package/std/collections/array_list.yo

@@ -696,6 +696,32 @@ impl(forall(T : Type), where(T <: Ord(T)), ArrayList(T),
   })
 );
 
+/// Equality for ArrayList — two lists are equal if they have the same length
+/// and every pair of elements at corresponding indices is equal.
+impl(forall(T : Type), where(T <: Eq(T)), ArrayList(T), Eq(ArrayList(T))(
+  (==) : (fn(lhs: Self, rhs: Self) -> bool)({
+    n := lhs.len();
+    cond(
+      ((!(n == rhs.len()))) => false,
+      true => {
+        (i : usize) = usize(0);
+        (equal : bool) = true;
+        while runtime(((i < n) && equal)), {
+          match(lhs.get(i),
+            .Some(a) => match(rhs.get(i),
+              .Some(b) => { equal = (a == b); },
+              .None    => { equal = false; }
+            ),
+            .None => { equal = false; }
+          );
+          i = (i + usize(1));
+        };
+        equal
+      }
+    )
+  })
+));
+
 /// Clone implementation for ArrayList — deep-clones each element.
 impl(forall(T : Type), where(T <: Clone), ArrayList(T), Clone(
   clone : (fn(self: *(Self)) -> Self)(

package/std/{env/index.yo → env.yo}

@@ -4,11 +4,11 @@
 //! Mirrors the layout of Rust's `std::env`. Platform/architecture detection
 //! and child-process spawning live in `std/process`.
 
-open import "../collections/array_list";
-open import "../string";
-open import "../path";
-{ platform, Platform } :: import "../process";
-{ GlobalAllocator } :: import "../allocator";
+open import "./collections/array_list";
+open import "./string";
+open import "./path";
+{ platform, Platform } :: import "./process";
+{ GlobalAllocator } :: import "./allocator";
 { malloc, free } :: GlobalAllocator;
 
 // === Low-level C interface ===
@@ -63,7 +63,7 @@ export args;
 
 /// Environment variable access and manipulation.
 env :: impl {
-  { getenv, setenv } :: import "../libc/stdlib";
+  { getenv, setenv } :: import "./libc/stdlib";
 
   /// Get the value of an environment variable by name.
   /// Returns `.None` if the variable is not set.
@@ -85,7 +85,7 @@ env :: impl {
 
     result := cond(
       (platform == Platform.Windows) => {
-        { _putenv_s } :: import "../libc/windows";
+        { _putenv_s } :: import "./libc/windows";
 
         cond(
           overwrite =>
@@ -119,7 +119,7 @@ export env;
 cwd :: (fn() -> Result(Path, String))(
   cond(
     (platform == Platform.Windows) => {
-      { GetCurrentDirectoryW, WideCharToMultiByte, CP_UTF8, WCHAR, DWORD } :: import "../libc/windows";
+      { GetCurrentDirectoryW, WideCharToMultiByte, CP_UTF8, WCHAR, DWORD } :: import "./libc/windows";
 
       required_size := GetCurrentDirectoryW(ulong(0), .None);
       cond(
@@ -187,7 +187,7 @@ cwd :: (fn() -> Result(Path, String))(
       )
     },
     true => {
-      { getcwd } :: import "../libc/unistd";
+      { getcwd } :: import "./libc/unistd";
 
       buf_size := usize(4096);
       buf := *(char)(malloc(buf_size).unwrap());
@@ -215,7 +215,7 @@ export cwd;
 chdir :: (fn(path: Path) -> Result(unit, String))(
   cond(
     (platform == Platform.Windows) => {
-      { SetCurrentDirectoryA, BOOL } :: import "../libc/windows";
+      { SetCurrentDirectoryA, BOOL } :: import "./libc/windows";
 
       path_str := path.to_string();
       path_cstr := path_str.to_cstr().ptr().unwrap();
@@ -227,7 +227,7 @@ chdir :: (fn(path: Path) -> Result(unit, String))(
       )
     },
     true => {
-      { chdir : unix_chdir } :: import "../libc/unistd";
+      { chdir : unix_chdir } :: import "./libc/unistd";
 
       path_str := path.to_string();
       path_cstr := path_str.to_cstr().ptr().unwrap();

package/std/{glob/index.yo → glob.yo}

@@ -1,7 +1,7 @@
 //! Glob pattern matching for file paths.
 
-open import "../string";
-{ ArrayList } :: import "../collections/array_list";
+open import "./string";
+{ ArrayList } :: import "./collections/array_list";
 
 // Recursive byte-level glob pattern matching
 _glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usize) -> bool)({

package/std/imm/map.yo

@@ -249,7 +249,7 @@ _copy_pairs :: (fn(
   };
 });
 
-_coll_with_pair :: (fn(comptime(K) : Type, comptime(V) : Type, coll: MapCollision(K, V), k: K, v: V, where(K <: (Eq(K), Hash, Send), V <: Send)) -> MapCollision(K, V))({
+_coll_with_pair :: (fn(comptime(K) : Type, comptime(V) : Type, coll: MapCollision(K, V), k: K, v: V, where(K <: (Eq(K), Hash, Send), V <: Send)) -> MapCollision(K, V))(
   match(_coll_find_key(K, V, coll, k),
     .Some(idx) => {
       new_ptr := _alloc_pairs(K, V, coll._pairs_len);
@@ -265,9 +265,9 @@ _coll_with_pair :: (fn(comptime(K) : Type, comptime(V) : Type, coll: MapCollisio
       return MapCollision(K, V)(hash: coll.hash, _pairs_ptr: new_ptr, _pairs_len: new_len);
     }
   )
-});
+);
 
-_coll_without_key :: (fn(comptime(K) : Type, comptime(V) : Type, coll: MapCollision(K, V), k: K, where(K <: (Eq(K), Hash, Send), V <: Send)) -> Option(MapCollision(K, V)))({
+_coll_without_key :: (fn(comptime(K) : Type, comptime(V) : Type, coll: MapCollision(K, V), k: K, where(K <: (Eq(K), Hash, Send), V <: Send)) -> Option(MapCollision(K, V)))(
   match(_coll_find_key(K, V, coll, k),
     .Some(idx) => {
       if((coll._pairs_len <= usize(2)), {
@@ -286,7 +286,7 @@ _coll_without_key :: (fn(comptime(K) : Type, comptime(V) : Type, coll: MapCollis
     },
     .None => .Some(coll)
   )
-});
+);
 
 // -- Core HAMT algorithms --
 
@@ -311,7 +311,7 @@ _make_branch :: (fn(
   frag1 := _fragment(hash1, shift);
   frag2 := _fragment(hash2, shift);
   if((frag1 == frag2), {
-    child := _make_branch(K, V, (shift + BITS), node1, hash1, node2, hash2);
+    child := recur(K, V, (shift + BITS), node1, hash1, node2, hash2);
     ptr := _alloc_map_children(K, V, u8(1));
     consume((*(MapNode(K, V))(ptr)).* = child);
     return .Branch(MapBranch(K, V)(
@@ -382,7 +382,7 @@ _node_insert :: (fn(
       if(_branch_has_child(K, V, branch, bit), {
         idx := _branch_index_for(K, V, branch, bit);
         child := _branch_child_at(K, V, branch, idx);
-        result := _node_insert(K, V, child, (shift + BITS), hash, k, v);
+        result := recur(K, V, child, (shift + BITS), hash, k, v);
         return InsertResult(K, V)(
           node: .Branch(_branch_replace_child(K, V, branch, bit, result.node)),
           added: result.added
@@ -433,7 +433,7 @@ _node_get :: (fn(
         return .None;
       });
       idx := _branch_index_for(K, V, branch, bit);
-      return _node_get(K, V, _branch_child_at(K, V, branch, idx), (shift + BITS), hash, k);
+      return recur(K, V, _branch_child_at(K, V, branch, idx), (shift + BITS), hash, k);
     },
     .Collision(coll) => {
       if((coll.hash != hash), {
@@ -479,7 +479,7 @@ _node_remove :: (fn(
       });
       idx := _branch_index_for(K, V, branch, bit);
       child := _branch_child_at(K, V, branch, idx);
-      sub := _node_remove(K, V, child, (shift + BITS), hash, k);
+      sub := recur(K, V, child, (shift + BITS), hash, k);
       if(!(sub.removed), {
         return RemoveResult(K, V)(node: .Some(node), removed: false);
       });
@@ -560,7 +560,7 @@ _merge_from_node :: (fn(
       (result : Map(K, V)) = acc;
       i := u8(0);
       while (i < branch._children_len), (i = (i + u8(1))), {
-        result = _merge_from_node(K, V, result, _branch_child_at(K, V, branch, i));
+        result = recur(K, V, result, _branch_child_at(K, V, branch, i));
       };
       result
     },
@@ -589,7 +589,7 @@ _collect_keys :: (fn(
       (result : List(K)) = acc;
       i := u8(0);
       while (i < branch._children_len), (i = (i + u8(1))), {
-        result = _collect_keys(K, V, _branch_child_at(K, V, branch, i), result);
+        result = recur(K, V, _branch_child_at(K, V, branch, i), result);
       };
       result
     },
@@ -617,7 +617,7 @@ _collect_values :: (fn(
       (result : List(V)) = acc;
       i := u8(0);
       while (i < branch._children_len), (i = (i + u8(1))), {
-        result = _collect_values(K, V, _branch_child_at(K, V, branch, i), result);
+        result = recur(K, V, _branch_child_at(K, V, branch, i), result);
       };
       result
     },
@@ -645,7 +645,7 @@ _collect_entries :: (fn(
       (result : List(Pair(K, V))) = acc;
       i := u8(0);
       while (i < branch._children_len), (i = (i + u8(1))), {
-        result = _collect_entries(K, V, _branch_child_at(K, V, branch, i), result);
+        result = recur(K, V, _branch_child_at(K, V, branch, i), result);
       };
       result
     },
@@ -675,7 +675,7 @@ _map_values_node :: (fn(
       new_children := *(MapNode(K, U))(new_ptr);
       i := u8(0);
       while (i < branch._children_len), (i = (i + u8(1))), {
-        consume((new_children &+ usize(i)).* = _map_values_node(K, V, U, _branch_child_at(K, V, branch, i), f));
+        consume((new_children &+ usize(i)).* = recur(K, V, U, _branch_child_at(K, V, branch, i), f));
       };
       .Branch(MapBranch(K, U)(
         bitmap: branch.bitmap,
@@ -716,7 +716,7 @@ _filter_from_node :: (fn(
       (result : Map(K, V)) = acc;
       i := u8(0);
       while (i < branch._children_len), (i = (i + u8(1))), {
-        result = _filter_from_node(K, V, result, _branch_child_at(K, V, branch, i), f);
+        result = recur(K, V, result, _branch_child_at(K, V, branch, i), f);
       };
       result
     },
@@ -750,7 +750,7 @@ _all_entries_match :: (fn(
       i := u8(0);
       (ok : bool) = true;
       while ((i < branch._children_len) && ok), (i = (i + u8(1))), {
-        if(!(_all_entries_match(K, V, _branch_child_at(K, V, branch, i), target)), {
+        if(!(recur(K, V, _branch_child_at(K, V, branch, i), target)), {
           ok = false;
         });
       };

package/std/imm/sorted_map.yo

@@ -202,12 +202,12 @@ _node_insert :: (fn(
       (n : RBNode(K, V)) = cond(
         (key < h._key) =>
           _new_node(K, V, h._key, h._value, h._color,
-            .Some(_node_insert(K, V, h._left, key, value)), h._right),
+            .Some(recur(K, V, h._left, key, value)), h._right),
         (key == h._key) =>
           _new_node(K, V, h._key, value, h._color, h._left, h._right),
         true =>
           _new_node(K, V, h._key, h._value, h._color,
-            h._left, .Some(_node_insert(K, V, h._right, key, value)))
+            h._left, .Some(recur(K, V, h._right, key, value)))
       );
       _fixup(K, V, n)
     }
@@ -225,9 +225,9 @@ _node_get :: (fn(
   match(node,
     .None => .None,
     .Some(h) => cond(
-      (key < h._key) => _node_get(K, V, h._left, key),
+      (key < h._key) => recur(K, V, h._left, key),
       (key == h._key) => .Some(h._value),
-      true => _node_get(K, V, h._right, key)
+      true => recur(K, V, h._right, key)
     )
   )
 );
@@ -243,9 +243,9 @@ _node_contains :: (fn(
   match(node,
     .None => false,
     .Some(h) => cond(
-      (key < h._key) => _node_contains(K, V, h._left, key),
+      (key < h._key) => recur(K, V, h._left, key),
       (key == h._key) => true,
-      true => _node_contains(K, V, h._right, key)
+      true => recur(K, V, h._right, key)
     )
   )
 );
@@ -305,7 +305,7 @@ _node_min :: (fn(
   where(K <: (Eq(K), Ord(K), Send), V <: Send)
 ) -> RBNode(K, V))(
   match(h._left,
-    .Some(l) => _node_min(K, V, l),
+    .Some(l) => recur(K, V, l),
     .None => h
   )
 );
@@ -325,7 +325,7 @@ _delete_min :: (fn(
         node = _move_red_left(K, V, node);
       });
       new_left := match(node._left,
-        .Some(nl) => _delete_min(K, V, nl),
+        .Some(nl) => recur(K, V, nl),
         .None => (Option(RBNode(K, V)).None)
       );
       .Some(_fixup(K, V,
@@ -361,7 +361,7 @@ _node_remove :: (fn(
         node = _move_red_left(K, V, node);
       });
       new_left := match(node._left,
-        .Some(nl) => _node_remove(K, V, nl, key),
+        .Some(nl) => recur(K, V, nl, key),
         .None => (Option(RBNode(K, V)).None)
       );
       node = _new_node(K, V, node._key, node._value, node._color, new_left, node._right);
@@ -410,7 +410,7 @@ _node_remove :: (fn(
     }, {
       // Go right
       new_right := match(node._right,
-        .Some(r) => _node_remove(K, V, r, key),
+        .Some(r) => recur(K, V, r, key),
         .None => (Option(RBNode(K, V)).None)
       );
       node = _new_node(K, V, node._key, node._value, node._color, node._left, new_right);
@@ -435,9 +435,9 @@ _collect_keys :: (fn(
   match(node,
     .None => acc,
     .Some(h) => {
-      right_acc := _collect_keys(K, V, h._right, acc);
+      right_acc := recur(K, V, h._right, acc);
       with_key := right_acc.prepend(h._key);
-      _collect_keys(K, V, h._left, with_key)
+      recur(K, V, h._left, with_key)
     }
   )
 );
@@ -453,9 +453,9 @@ _collect_values :: (fn(
   match(node,
     .None => acc,
     .Some(h) => {
-      right_acc := _collect_values(K, V, h._right, acc);
+      right_acc := recur(K, V, h._right, acc);
       with_val := right_acc.prepend(h._value);
-      _collect_values(K, V, h._left, with_val)
+      recur(K, V, h._left, with_val)
     }
   )
 );

package/std/imm/string.yo

@@ -15,12 +15,12 @@ _min :: (fn(a: usize, b: usize) -> usize)(
   cond((a < b) => a, true => b)
 );
 
-_alloc_bytes :: (fn(n: usize) -> *(u8))({
+_alloc_bytes :: (fn(n: usize) -> *(u8))(
   match(malloc(n),
     .Some(p) => *(u8)(p),
     .None => panic("imm.String: allocation failed")
   )
-});
+);
 
 /// Immutable, thread-safe UTF-8 string.
 ///
@@ -424,7 +424,7 @@ impl(String,
   }),
 
   /// Replace the first occurrence of `search` with `replacement`.
-  replace : (fn(self: Self, search: Self, replacement: Self) -> Self)({
+  replace : (fn(self: Self, search: Self, replacement: Self) -> Self)(
     match(self.index_of(search, usize(0)),
       .None => { return self; },
       .Some(idx) => {
@@ -434,7 +434,7 @@ impl(String,
         return tmp.concat(after);
       }
     )
-  }),
+  ),
 
   /// Replace all occurrences of `search` with `replacement`.
   replace_all : (fn(self: Self, search: Self, replacement: Self) -> Self)({

package/std/{log/index.yo → log.yo}

@@ -1,8 +1,8 @@
 //! Structured logging with configurable level and output destination.
 
-open import "../string";
-{ ToString } :: import "../fmt";
-{ fwrite, stdout, stderr, FILE } :: import "../libc/stdio";
+open import "./string";
+{ ToString } :: import "./fmt";
+{ fwrite, stdout, stderr, FILE } :: import "./libc/stdio";
 
 /// Log severity level.
 Level :: enum(Trace, Debug, Info, Warn, Error);

package/std/prelude.yo

@@ -31,7 +31,7 @@ extern "Yo",
   __yo_return_self : (fn(forall(T: Type), self: T) -> T),
   __yo_noop : (fn(forall(T : Type))-> T),
   __yo_as : (fn(forall(_Self: Type), self: _Self, comptime(Target): Type) -> Target),
-  
+
   // Arithmetic Operators
   /// +
   __yo_op_add : (fn(forall(T : Type), x : T, y : T) -> T),
@@ -45,7 +45,7 @@ extern "Yo",
   __yo_op_mod : (fn(forall(T : Type), x : T, y : T) -> T),
   /// -
   __yo_op_neg : (fn(forall(T : Type), x : T) -> T),
-  
+
   // Relational Operators
   /// ==
   __yo_op_eq : (fn(forall(T : Type), x : T, y : T) -> bool),
@@ -641,7 +641,7 @@ ComptimeEq ::
       ((lhs, rhs) ->
         not(Self.(==)(lhs, rhs))
       ),
-    
+
     where(Self <: Comptime)
   )
 ;
@@ -3377,7 +3377,6 @@ impl(long, Clone(
 _long :: long;
 export long : _long;
 
-
 /// ulong
 impl(ulong, Send());
 impl(ulong, Acyclic());
@@ -3946,7 +3945,6 @@ assert :: (fn(flag : bool, (msg : str) ?= "Assertion failed.") -> unit)
 ;
 export assert;
 
-
 /// ComptimeList
 impl(forall(T : Type), ComptimeList(T), Comptime());
 impl(forall(T : Type), ComptimeList(T), Acyclic());
@@ -3961,7 +3959,7 @@ impl(forall(T : Type), where(T <: Comptime), ComptimeList(T),
 
   first : car,
   rest : cdr,
-  
+
   append : (fn(comptime(self): Self, comptime(another): Self) -> comptime(Self))(
     __yo_comptime_list_append(self, another)
   ),
@@ -4627,7 +4625,6 @@ export
   (?*)
 ;
 
-
 /// DeriveContext — context passed to derive rule functions (needs Option).
 /// Used by the `derive` macro to generate trait implementations.
 DeriveContext :: struct(
@@ -4789,13 +4786,13 @@ __derive_eq :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(t
           )
         ))
       },
-      true => {
+      true => 
         ctx.make_impl(quote(
           Eq(...#(trait_params))(
             (==) : ((lhs, rhs) -> true)
           )
         ))
-      }
+
     )
   }
 );
@@ -4884,13 +4881,13 @@ __derive_clone :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptim
           )
         ))
       },
-      true => {
+      true => 
         ctx.make_impl(quote(
           Clone(
             clone : ((self) -> self.*)
           )
         ))
-      }
+
     )
   }
 );
@@ -4905,13 +4902,13 @@ __derive_hash :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime
         fields :: Type.get_struct_fields(T);
         fc :: fields.len();
         cond(
-          (fc == 0) => {
+          (fc == 0) => 
             ctx.make_impl(quote(
               Hash(
                 (hash) : ((self) -> u64(0))
               )
             ))
-          },
+          ,
           true => {
             hash_stmts :: __yo_comptime_fold_range(fc, "",
               (fn(comptime(a) : comptime_string, comptime(fi) : usize) -> comptime(comptime_string))(
@@ -4986,13 +4983,13 @@ __derive_hash :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime
           )
         ))
       },
-      true => {
+      true => 
         ctx.make_impl(quote(
           Hash(
             (hash) : ((self) -> u64(0))
           )
         ))
-      }
+
     )
   }
 );
@@ -5035,7 +5032,7 @@ __derive_ord_struct_body :: (fn(comptime(T) : Type, comptime(op) : comptime_stri
 
 // Helper: generate lexicographic comparison for enum variant bindings
 __derive_ord_variant_body :: (fn(comptime(v) : VariantInfo, comptime(op) : comptime_string) -> comptime(comptime_string))(
-  {
+
     cond(
       (v.fields.len() == 1) => {
         fname :: v.fields.get(0).name;
@@ -5062,7 +5059,7 @@ __derive_ord_variant_body :: (fn(comptime(v) : VariantInfo, comptime(op) : compt
         __s3("cond(\n        ", branches, "\n      )")
       }
     )
-  }
+
 );
 
 __derive_ord :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(trait_params) : ComptimeList(Expr)) -> comptime(Expr))(
@@ -5073,7 +5070,7 @@ __derive_ord :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(
         fields :: Type.get_struct_fields(T);
         fc :: fields.len();
         cond(
-          (fc == 0) => {
+          (fc == 0) => 
             ctx.make_impl(quote(
               Ord(...#(trait_params))(
                 (<) : ((lhs, rhs) -> false),
@@ -5082,7 +5079,7 @@ __derive_ord :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(
                 (>=) : ((lhs, rhs) -> true)
               )
             ))
-          },
+          ,
           true => {
             lt_body :: __derive_ord_struct_body(T, "<");
             le_body :: __derive_ord_struct_body(T, "<=");
@@ -5168,7 +5165,7 @@ __derive_ord :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(
           )
         ))
       },
-      true => {
+      true => 
         ctx.make_impl(quote(
           Ord(...#(trait_params))(
             (<) : ((lhs, rhs) -> false),
@@ -5177,13 +5174,12 @@ __derive_ord :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(
             (>=) : ((lhs, rhs) -> true)
           )
         ))
-      }
+
     )
   }
 );
 derive_rule(Ord, __derive_ord);
 
-
 /// Result — a value that is either success (`Ok`) or failure (`Err`).
 ///
 /// `Result(OkType, ErrorType)` has two variants:
@@ -5491,7 +5487,6 @@ impl(forall(T : Type), Iso(T),
   )
 );
 
-
 (^) :: (fn(quote(v) : Expr) -> unquote(Expr))({
   temp :: cond(
     v.is_atom() => v, 

package/std/process/command.yo

@@ -163,7 +163,7 @@ _spawn_with_fds :: (fn(
   stdout_fd: i32,
   stderr_fd: i32,
   using(io : IO, exn : Exception)
-) -> Impl(Future(i32, IO, Exception)))({
+) -> Impl(Future(i32, IO, Exception)))(
   io.async((using(io, exn)) => {
     storage := _build_cstr_storage(self);
     argc := storage.len();
@@ -197,11 +197,11 @@ _spawn_with_fds :: (fn(
 
     IOError.check(pid)
   })
-});
+);
 
 // Read all available bytes from `fd` into a freshly returned ArrayList(u8)
 // until EOF (read returns 0).
-_drain_fd :: (fn(fd: i32, using(io : IO, exn : Exception)) -> Impl(Future(ArrayList(u8), IO, Exception)))({
+_drain_fd :: (fn(fd: i32, using(io : IO, exn : Exception)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
   io.async((using(io, exn)) => {
     buf_size := usize(4096);
     buf := *(u8)(malloc(buf_size).unwrap());
@@ -226,7 +226,7 @@ _drain_fd :: (fn(fd: i32, using(io : IO, exn : Exception)) -> Impl(Future(ArrayL
     free(.Some(*(void)(buf)));
     out
   })
-});
+);
 
 // ============================================================================
 // Public Command methods (status / output)
@@ -235,18 +235,18 @@ _drain_fd :: (fn(fd: i32, using(io : IO, exn : Exception)) -> Impl(Future(ArrayL
 impl(Command,
   /// Spawn the child with stdio inherited from the parent, wait for it to
   /// exit, and return its `ExitStatus`.
-  status : (fn(self: *(Self), using(io : IO)) -> Impl(Future(ExitStatus, IO, Exception)))({
+  status : (fn(self: *(Self), using(io : IO)) -> Impl(Future(ExitStatus, IO, Exception)))(
     io.async((using(io, exn)) => {
       pid := io.await(_spawn_with_fds(self, i32(-1), i32(-1), i32(-1)));
       raw := io.await(IO_process.waitpid(pid, i32(0)));
       IOError.check(raw);
       ExitStatus(raw: raw)
     })
-  }),
+  ),
 
   /// Spawn the child with stdout and stderr captured through pipes. Waits for
   /// the child to exit and returns the exit status plus the captured bytes.
-  output : (fn(self: *(Self), using(io : IO)) -> Impl(Future(Output, IO, Exception)))({
+  output : (fn(self: *(Self), using(io : IO)) -> Impl(Future(Output, IO, Exception)))(
     io.async((using(io, exn)) => {
       // Create stdout and stderr pipes.
       out_fd_buf := MaybeUninit(Array(i32, usize(2))).new();
@@ -295,7 +295,7 @@ impl(Command,
         stderr: stderr_buf
       )
     })
-  })
+  )
 );
 
 export