@shd101wyy/yo 0.1.26 → 0.1.27

package/std/fmt/writer.yo

@@ -11,154 +11,132 @@
 //!   .write_byte(u8(33));
 //! s := w.to_string();  // "hello world!"
 //! ```
-
-{ String } :: import "../string";
-{ ArrayList } :: import "../collections/array_list";
-{ rune } :: import "../string/rune";
-{ snprintf } :: import "../libc/stdio";
-
+{ String } :: import("../string");
+{ ArrayList } :: import("../collections/array_list");
+{ rune } :: import("../string/rune");
+{ snprintf } :: import("../libc/stdio");
 /// Text alignment for padded output.
 Alignment :: enum(Left, Right, Center);
-export Alignment;
-
+export(Alignment);
 /// Chainable string builder backed by `ArrayList(u8)`.
 /// Useful for constructing formatted strings without intermediate allocations.
 Writer :: object(
   buf : ArrayList(u8)
 );
-
-impl(Writer,
+impl(
+  Writer,
   /// Create a new empty Writer.
   new : (fn() -> Self)(
-    Self(buf: ArrayList(u8).new())
+    Self(buf : ArrayList(u8).new())
   ),
-
   /// Create a Writer pre-allocated with the given byte capacity.
-  with_capacity : (fn(cap: usize) -> Self)(
-    Self(buf: ArrayList(u8).with_capacity(cap))
+  with_capacity : (fn(cap : usize) -> Self)(
+    Self(buf : ArrayList(u8).with_capacity(cap))
   ),
-
   /// Append a `str` literal (byte slice) to the Writer.
-  write_str : (fn(self: Self, s: str) -> Self)({
+  write_str : (fn(self : Self, s : str) -> Self)({
     i := usize(0);
-    while (i < s.len()),
-          (i = (i + usize(1))),
-    {
+    while(i < s.len(), i = (i + usize(1)), {
       self.buf.push(s.bytes(i));
-    };
+    });
     self
   }),
-
   /// Append a String (owned UTF-8) to the Writer.
-  write_string : (fn(self: Self, s: String) -> Self)({
+  write_string : (fn(self : Self, s : String) -> Self)({
     bytes := s.as_bytes();
     i := usize(0);
-    while (i < bytes.len()),
-          (i = (i + usize(1))),
-    {
+    while(i < bytes.len(), i = (i + usize(1)), {
       self.buf.push(bytes.get(i).unwrap());
-    };
+    });
     self
   }),
-
   /// Append a single byte to the Writer.
-  write_byte : (fn(self: Self, b: u8) -> Self)({
+  write_byte : (fn(self : Self, b : u8) -> Self)({
     self.buf.push(b);
     self
   }),
-
   /// Append an ArrayList(u8) of bytes to the Writer.
-  write_bytes : (fn(self: Self, data: ArrayList(u8)) -> Self)({
+  write_bytes : (fn(self : Self, data : ArrayList(u8)) -> Self)({
     i := usize(0);
-    while (i < data.len()),
-          (i = (i + usize(1))),
-    {
+    while(i < data.len(), i = (i + usize(1)), {
       self.buf.push(data.get(i).unwrap());
-    };
+    });
     self
   }),
-
   /// Append a Unicode code point encoded as UTF-8.
-  write_rune : (fn(self: Self, r: rune) -> Self)({
+  write_rune : (fn(self : Self, r : rune) -> Self)({
     v := u32(r.char);
     cond(
       (v < u32(0x80)) => {
         self.buf.push(u8(v));
       },
       (v < u32(0x800)) => {
-        self.buf.push(u8((u32(0xC0) | (v >> u32(6)))));
-        self.buf.push(u8((u32(0x80) | (v & u32(0x3F)))));
+        self.buf.push(u8(u32(0xC0) | (v >> u32(6))));
+        self.buf.push(u8(u32(0x80) | (v & u32(0x3F))));
       },
       (v < u32(0x10000)) => {
-        self.buf.push(u8((u32(0xE0) | (v >> u32(12)))));
-        self.buf.push(u8((u32(0x80) | ((v >> u32(6)) & u32(0x3F)))));
-        self.buf.push(u8((u32(0x80) | (v & u32(0x3F)))));
+        self.buf.push(u8(u32(0xE0) | (v >> u32(12))));
+        self.buf.push(u8(u32(0x80) | ((v >> u32(6)) & u32(0x3F))));
+        self.buf.push(u8(u32(0x80) | (v & u32(0x3F))));
       },
       true => {
-        self.buf.push(u8((u32(0xF0) | (v >> u32(18)))));
-        self.buf.push(u8((u32(0x80) | ((v >> u32(12)) & u32(0x3F)))));
-        self.buf.push(u8((u32(0x80) | ((v >> u32(6)) & u32(0x3F)))));
-        self.buf.push(u8((u32(0x80) | (v & u32(0x3F)))));
+        self.buf.push(u8(u32(0xF0) | (v >> u32(18))));
+        self.buf.push(u8(u32(0x80) | ((v >> u32(12)) & u32(0x3F))));
+        self.buf.push(u8(u32(0x80) | ((v >> u32(6)) & u32(0x3F))));
+        self.buf.push(u8(u32(0x80) | (v & u32(0x3F))));
       }
     );
     self
   }),
-
   /// Append a signed 64-bit integer in decimal.
-  write_i64 : (fn(self: Self, n: i64) -> Self)({
+  write_i64 : (fn(self : Self, n : i64) -> Self)({
     buf := Array(u8, usize(24)).fill(u8(0));
     buf_ptr := &(buf(usize(0)));
     snprintf(*(char)(buf_ptr), usize(24), "%lld", n);
     s := String.from_cstr(buf_ptr).unwrap();
     self.write_string(s)
   }),
-
   /// Append an unsigned 64-bit integer in decimal.
-  write_u64 : (fn(self: Self, n: u64) -> Self)({
+  write_u64 : (fn(self : Self, n : u64) -> Self)({
     buf := Array(u8, usize(24)).fill(u8(0));
     buf_ptr := &(buf(usize(0)));
     snprintf(*(char)(buf_ptr), usize(24), "%llu", n);
     s := String.from_cstr(buf_ptr).unwrap();
     self.write_string(s)
   }),
-
   /// Append a 64-bit float with the given number of decimal places.
-  write_f64 : (fn(self: Self, n: f64, precision: i32) -> Self)({
+  write_f64 : (fn(self : Self, n : f64, precision : i32) -> Self)({
     buf := Array(u8, usize(64)).fill(u8(0));
     buf_ptr := &(buf(usize(0)));
     snprintf(*(char)(buf_ptr), usize(64), "%.*f", precision, n);
     s := String.from_cstr(buf_ptr).unwrap();
     self.write_string(s)
   }),
-
   /// Append a bool as "true" or "false".
-  write_bool : (fn(self: Self, b: bool) -> Self)(
+  write_bool : (fn(self : Self, b : bool) -> Self)(
     cond(
       b => self.write_str("true"),
       true => self.write_str("false")
     )
   ),
-
   /// Append an unsigned 64-bit integer in lowercase hexadecimal.
-  write_hex : (fn(self: Self, n: u64) -> Self)({
+  write_hex : (fn(self : Self, n : u64) -> Self)({
     buf := Array(u8, usize(20)).fill(u8(0));
     buf_ptr := &(buf(usize(0)));
     snprintf(*(char)(buf_ptr), usize(20), "%llx", n);
     s := String.from_cstr(buf_ptr).unwrap();
     self.write_string(s)
   }),
-
   /// Append an unsigned 64-bit integer in octal.
-  write_octal : (fn(self: Self, n: u64) -> Self)({
+  write_octal : (fn(self : Self, n : u64) -> Self)({
     buf := Array(u8, usize(24)).fill(u8(0));
     buf_ptr := &(buf(usize(0)));
     snprintf(*(char)(buf_ptr), usize(24), "%llo", n);
     s := String.from_cstr(buf_ptr).unwrap();
     self.write_string(s)
   }),
-
   /// Append an unsigned 64-bit integer in binary (no stdlib support — manual).
-  write_binary : (fn(self: Self, n: u64) -> Self)({
+  write_binary : (fn(self : Self, n : u64) -> Self)({
     cond(
       (n == u64(0)) => {
         self.buf.push(u8(48)); // '0'
@@ -167,74 +145,67 @@ impl(Writer,
         // Collect bits into a temporary ArrayList in reverse order
         bits := ArrayList(u8).new();
         v := n;
-        while (v > u64(0)),
-              (v = (v >> u64(1))),
-        {
-          bit := u8(((v & u64(1)) + u64(0)));
-          bits.push((bit + u8(48))); // '0' or '1'
-        };
+        while(v > u64(0), v = (v >> u64(1)), {
+          bit := u8((v & u64(1)) + u64(0));
+          bits.push(bit + u8(48)); // '0' or '1'
+        });
         // Push in reverse order (most significant first)
         i := bits.len();
-        while (i > usize(0)),
-              (i = (i - usize(1))),
-        {
-          self.buf.push(bits.get((i - usize(1))).unwrap());
-        };
+        while(i > usize(0), i = (i - usize(1)), {
+          self.buf.push(bits.get(i - usize(1)).unwrap());
+        });
       }
     );
     self
   }),
-
   /// Append a str padded to width using the given pad rune and alignment.
-  write_padded : (fn(self: Self, s: str, width: usize, pad: rune, align: Alignment) -> Self)({
+  write_padded : (fn(self : Self, s : str, width : usize, pad : rune, align : Alignment) -> Self)({
     len := s.len();
     cond(
       (len >= width) => self.write_str(s),
       true => {
         padding := (width - len);
-        match(align,
+        match(
+          align,
           .Left => {
             self.write_str(s);
             i := usize(0);
-            while (i < padding), (i = (i + usize(1))), {
+            while(i < padding, i = (i + usize(1)), {
               self.write_rune(pad);
-            };
+            });
           },
           .Right => {
             i := usize(0);
-            while (i < padding), (i = (i + usize(1))), {
+            while(i < padding, i = (i + usize(1)), {
               self.write_rune(pad);
-            };
+            });
             self.write_str(s);
           },
           .Center => {
             left_pad := (padding / usize(2));
             right_pad := (padding - left_pad);
             i := usize(0);
-            while (i < left_pad), (i = (i + usize(1))), {
+            while(i < left_pad, i = (i + usize(1)), {
               self.write_rune(pad);
-            };
+            });
             self.write_str(s);
             j := usize(0);
-            while (j < right_pad), (j = (j + usize(1))), {
+            while(j < right_pad, j = (j + usize(1)), {
               self.write_rune(pad);
-            };
+            });
           }
         );
         self
       }
     )
   }),
-
   /// Consume the Writer and return an owned String.
-  to_string : (fn(self: Self) -> String)(
+  to_string : (fn(self : Self) -> String)(
     String.from_bytes(self.buf)
   ),
-
   /// Return the current byte length of the buffer.
-  len : (fn(self: Self) -> usize)(
+  len : (fn(self : Self) -> usize)(
     self.buf.len()
   )
 );
-
-export Writer;
+export(Writer);

package/std/fs/dir.yo

@@ -20,28 +20,21 @@
 //!   io.await(remove_dir(Path.new(`/tmp/yo_test`)));
 //! });
 //! ```
-
-{ GlobalAllocator } :: import "../allocator";
+{ GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
-{ ArrayList } :: import "../collections/array_list";
-open import "../string";
-{ Path } :: import "../path";
-{ IOError } :: import "../sys/errors";
-{ Error, AnyError, Exception } :: import "../error";
-{ EEXIST, ENOENT } :: import "../libc/errno";
-IO_dir :: import "../sys/dir";
-IO_file :: import "../sys/file";
-{ platform, Platform } :: import "../process";
-{
-  AT_FDCWD, AT_REMOVEDIR, O_RDONLY, O_DIRECTORY,
-  DEFAULT_DIR_MODE,
-  DT_REG, DT_DIR, DT_LNK
-} :: import "../sys/constants";
-
+{ ArrayList } :: import("../collections/array_list");
+open(import("../string"));
+{ Path } :: import("../path");
+{ IOError } :: import("../sys/errors");
+{ Error, AnyError, Exception } :: import("../error");
+{ EEXIST, ENOENT } :: import("../libc/errno");
+IO_dir :: import("../sys/dir");
+IO_file :: import("../sys/file");
+{ platform, Platform } :: import("../process");
+{ AT_FDCWD, AT_REMOVEDIR, O_RDONLY, O_DIRECTORY, DEFAULT_DIR_MODE, DT_REG, DT_DIR, DT_LNK } :: import("../sys/constants");
 // ============================================================================
 // FileType enum
 // ============================================================================
-
 /// The type of a file system entry.
 FileType :: enum(
   /// A regular file.
@@ -53,47 +46,39 @@ FileType :: enum(
   /// An unknown or unsupported file type.
   Other
 );
-
-export FileType;
-
+export(FileType);
 // ============================================================================
 // DirEntry
 // ============================================================================
-
 /// A directory entry containing the entry name, file type, and inode number.
 DirEntry :: struct(
-  name      : String,
+  name : String,
   file_type : FileType,
-  ino       : u64
+  ino : u64
 );
-
-export DirEntry;
-
+export(DirEntry);
 // ============================================================================
 // Directory operations
 // ============================================================================
-
 /// Create a directory at the given path.
-create_dir :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+create_dir :: (fn(path : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   io.async((using(io, exn)) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     result := io.await(IO_dir.mkdir(AT_FDCWD, cstr, i32(DEFAULT_DIR_MODE)));
     cond(
-      (result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - result))),
+      (result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - result))),
       true => ()
     )
   })
 );
-
 /// Create a directory (`str` path variant).
-create_dir_str :: (fn(path: str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+create_dir_str :: (fn(path : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   create_dir(Path.new(String.from(path)))
 );
-
 /// Create a directory and all missing parent directories.
 /// Does not error if the directory already exists.
-create_dir_all :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+create_dir_all :: (fn(path : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   io.async((using(io, exn)) => {
     path_s := path.to_string();
     cstr_bytes := path_s.to_cstr();
@@ -121,14 +106,19 @@ create_dir_all :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Excep
                     first := bytes.get(usize(0)).unwrap();
                     second := bytes.get(usize(1)).unwrap();
                     is_drive_root := ((((first >= u8(65)) && (first <= u8(90))) || ((first >= u8(97)) && (first <= u8(122)))) && (second == u8(58)));
-                    cond(is_drive_root => { i = usize(3); }, true => ());
+                    cond(
+                      is_drive_root => {
+                        i = usize(3);
+                      },
+                      true => ()
+                    );
                   },
                   true => ()
                 );
               },
               true => ()
             );
-            while runtime((i < bytes.len())), {
+            while(runtime(i < bytes.len()), {
               b := bytes.get(i).unwrap();
               cond(
                 ((b == u8(47)) || (b == u8(92))) => {
@@ -140,7 +130,7 @@ create_dir_all :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Excep
                   // Ignore EEXIST errors
                   cond(
                     ((r < i32(0)) && ((i32(0) - r) != i32(EEXIST))) => {
-                      exn.throw(dyn IOError.from_errno((i32(0) - r)));
+                      exn.throw(dyn(IOError.from_errno(i32(0) - r)));
                     },
                     true => ()
                   );
@@ -148,7 +138,7 @@ create_dir_all :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Excep
                 true => ()
               );
               i = (i + usize(1));
-            };
+            });
             // Create the final directory
             final_result := io.await(IO_dir.mkdir(AT_FDCWD, cstr, i32(DEFAULT_DIR_MODE)));
             cond(
@@ -157,59 +147,51 @@ create_dir_all :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Excep
                 final_errno := (i32(0) - final_result);
                 cond(
                   (final_errno == i32(EEXIST)) => (),
-                  true => exn.throw(dyn IOError.from_errno(final_errno))
+                  true => exn.throw(dyn(IOError.from_errno(final_errno)))
                 )
               }
             )
           },
-          true => exn.throw(dyn IOError.from_errno(errno))
+          true => exn.throw(dyn(IOError.from_errno(errno)))
         )
       }
     )
   })
 );
-
 /// Create a directory and all missing parents (`str` path variant).
-create_dir_all_str :: (fn(path: str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+create_dir_all_str :: (fn(path : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   create_dir_all(Path.new(String.from(path)))
 );
-
 /// Remove an empty directory. Throws if the directory is not empty.
-remove_dir :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+remove_dir :: (fn(path : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   io.async((using(io, exn)) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     result := io.await(IO_dir.unlink(AT_FDCWD, cstr, AT_REMOVEDIR));
     cond(
-      (result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - result))),
+      (result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - result))),
       true => ()
     )
   })
 );
-
-remove_dir_str :: (fn(path: str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+remove_dir_str :: (fn(path : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   remove_dir(Path.new(String.from(path)))
 );
-
 /// Remove a file at the given path.
-remove_file :: (fn(path: Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+remove_file :: (fn(path : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   io.async((using(io, exn)) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     result := io.await(IO_dir.unlink(AT_FDCWD, cstr, i32(0)));
     cond(
-      (result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - result))),
+      (result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - result))),
       true => ()
     )
   })
 );
-
-remove_file_str :: (fn(path: str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))
-  remove_file(Path.new(String.from(path)))
-;
-
+remove_file_str :: (fn(path : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(remove_file(Path.new(String.from(path))));
 /// Rename or move a file or directory from `from` to `to`.
-rename :: (fn(from: Path, to: Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+rename :: (fn(from : Path, to : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   io.async((using(io, exn)) => {
     from_cstr_bytes := from.to_string().to_cstr();
     from_cstr := from_cstr_bytes.ptr().unwrap();
@@ -217,18 +199,14 @@ rename :: (fn(from: Path, to: Path, using(io : IO)) -> Impl(Future(unit, IO, Exc
     to_cstr := to_cstr_bytes.ptr().unwrap();
     result := io.await(IO_dir.rename(AT_FDCWD, from_cstr, AT_FDCWD, to_cstr));
     cond(
-      (result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - result))),
+      (result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - result))),
       true => ()
     )
   })
 );
-
-rename_str :: (fn(from: str, to: str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))
-  rename(Path.new(String.from(from)), Path.new(String.from(to)))
-;
-
+rename_str :: (fn(from : str, to : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(rename(Path.new(String.from(from)), Path.new(String.from(to))));
 /// Create a hard link from `src` to `dst`.
-hard_link :: (fn(src: Path, dst: Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+hard_link :: (fn(src : Path, dst : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   io.async((using(io, exn)) => {
     src_cstr_bytes := src.to_string().to_cstr();
     src_cstr := src_cstr_bytes.ptr().unwrap();
@@ -236,18 +214,14 @@ hard_link :: (fn(src: Path, dst: Path, using(io : IO)) -> Impl(Future(unit, IO,
     dst_cstr := dst_cstr_bytes.ptr().unwrap();
     result := io.await(IO_dir.link(AT_FDCWD, src_cstr, AT_FDCWD, dst_cstr, i32(0)));
     cond(
-      (result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - result))),
+      (result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - result))),
       true => ()
     )
   })
 );
-
-hard_link_str :: (fn(src: str, dst: str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))
-  hard_link(Path.new(String.from(src)), Path.new(String.from(dst)))
-;
-
+hard_link_str :: (fn(src : str, dst : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(hard_link(Path.new(String.from(src)), Path.new(String.from(dst))));
 /// Create a symbolic link at `dst` pointing to `src`.
-symlink :: (fn(src: Path, dst: Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
+symlink :: (fn(src : Path, dst : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
   io.async((using(io, exn)) => {
     src_cstr_bytes := src.to_string().to_cstr();
     src_cstr := src_cstr_bytes.ptr().unwrap();
@@ -255,48 +229,45 @@ symlink :: (fn(src: Path, dst: Path, using(io : IO)) -> Impl(Future(unit, IO, Ex
     dst_cstr := dst_cstr_bytes.ptr().unwrap();
     result := io.await(IO_dir.symlink(src_cstr, AT_FDCWD, dst_cstr));
     cond(
-      (result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - result))),
+      (result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - result))),
       true => ()
     )
   })
 );
-
-symlink_str :: (fn(src: str, dst: str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))
-  symlink(Path.new(String.from(src)), Path.new(String.from(dst)))
-;
-
+symlink_str :: (fn(src : str, dst : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(symlink(Path.new(String.from(src)), Path.new(String.from(dst))));
 // ============================================================================
 // Directory listing
 // ============================================================================
-
 /// Read all entries from a directory, returning an `ArrayList(DirEntry)`.
 /// Skips the `.` and `..` entries.
-read_dir :: (fn(path: Path, using(io : IO)) -> Impl(Future(ArrayList(DirEntry), IO, Exception)))(
+read_dir :: (fn(path : Path, using(io : IO)) -> Impl(Future(ArrayList(DirEntry), IO, Exception)))(
   io.async((using(io, exn)) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     // Open the directory
-    fd_result := io.await(IO_file.openat(AT_FDCWD, cstr, (O_RDONLY | O_DIRECTORY), i32(0)));
+    fd_result := io.await(IO_file.openat(AT_FDCWD, cstr, O_RDONLY | O_DIRECTORY, i32(0)));
     cond(
-      (fd_result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - fd_result))),
+      (fd_result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - fd_result))),
       true => ()
     );
     fd := fd_result;
     entries := ArrayList(DirEntry).new();
     buf_size := u32(4096);
     buf := *(u8)(malloc(usize(buf_size)).unwrap());
-    while runtime(true), {
+    while(runtime(true), {
       n := io.await(IO_dir.getdents(fd, buf, buf_size));
       cond(
         (n < i32(0)) => {
           free(.Some(*(void)(buf)));
           io.await(IO_file.close(fd));
-          exn.throw(dyn IOError.from_errno((i32(0) - n)));
+          exn.throw(dyn(IOError.from_errno(i32(0) - n)));
+        },
+        (n == i32(0)) => {
+          break;
         },
-        (n == i32(0)) => { break; },
         true => {
           offset := usize(0);
-          while runtime((offset < usize(n))), {
+          while(runtime(offset < usize(n)), {
             entry_ptr := (buf &+ offset);
             name_ptr := IO_dir.dirent_name(entry_ptr);
             name := String.from_cstr(name_ptr).unwrap();
@@ -311,31 +282,41 @@ read_dir :: (fn(path: Path, using(io : IO)) -> Impl(Future(ArrayList(DirEntry),
                   (dt == DT_LNK) => FileType.Symlink,
                   true => FileType.Other
                 );
-                entries.push(DirEntry(
-                  name: name,
-                  file_type: ft,
-                  ino: IO_dir.dirent_ino(entry_ptr)
-                ));
+                entries.push(
+                  DirEntry(
+                    name : name,
+                    file_type : ft,
+                    ino : IO_dir.dirent_ino(entry_ptr)
+                  )
+                );
               }
             );
             offset = (offset + usize(IO_dir.dirent_reclen(entry_ptr)));
-          };
+          });
         }
       );
-    };
+    });
     free(.Some(*(void)(buf)));
     io.await(IO_file.close(fd));
     entries
   })
 );
-
-read_dir_str :: (fn(path: str, using(io : IO)) -> Impl(Future(ArrayList(DirEntry), IO, Exception)))
-  read_dir(Path.new(String.from(path)))
-;
-
-export
-  create_dir, create_dir_str, create_dir_all, create_dir_all_str,
-  remove_dir, remove_dir_str, remove_file, remove_file_str,
-  rename, rename_str, hard_link, hard_link_str, symlink, symlink_str,
-  read_dir, read_dir_str
-;
+read_dir_str :: (fn(path : str, using(io : IO)) -> Impl(Future(ArrayList(DirEntry), IO, Exception)))(read_dir(Path.new(String.from(path))));
+export(
+  create_dir,
+  create_dir_str,
+  create_dir_all,
+  create_dir_all_str,
+  remove_dir,
+  remove_dir_str,
+  remove_file,
+  remove_file_str,
+  rename,
+  rename_str,
+  hard_link,
+  hard_link_str,
+  symlink,
+  symlink_str,
+  read_dir,
+  read_dir_str
+);