@shd101wyy/yo 0.1.28 → 0.1.29

package/std/fs/file.yo

@@ -8,22 +8,16 @@
 //! ```rust
 //! { File, read_string, write_file, OpenMode } :: import "std/fs/file";
 //!
-//! main :: (fn(using(io : IO)) -> unit)({
-//!   given(exn) := Exception(
-//!     throw : (fn(forall(T : Type), error: AnyError) -> T)(
-//!       { println(error); panic("Exception found."); }
-//!     )
-//!   );
-//!
+//! main :: (fn(io : IO, exn : Exception) -> unit)({
 //!   // Write a file
-//!   io.await(write_file(Path.new(`test.txt`), `hello world`));
+//!   io.await(write_file(Path.new(`test.txt`), `hello world`, io), { io, exn });
 //!
 //!   // Read it back
-//!   content := io.await(read_string(Path.new(`test.txt`)));
+//!   content := io.await(read_string(Path.new(`test.txt`), io), { io, exn });
 //!   println(content);
 //!
 //!   // Open with OpenMode
-//!   f := io.await(File.open(Path.new(`test.txt`), .Read));
+//!   f := io.await(File.open(Path.new(`test.txt`), .Read, io), { io, exn });
 //! });
 //! ```
 { GlobalAllocator } :: import("../allocator");
@@ -33,7 +27,7 @@ open(import("../string"));
 open(import("../fmt"));
 { Path } :: import("../path");
 { IOError } :: import("../sys/errors");
-{ Error, AnyError, Exception } :: import("../error");
+{ Error, AnyError, Exception, IOErr } :: import("../error");
 { Metadata } :: import("./metadata");
 _metadata_mod :: import("./metadata");
 { Statx } :: import("../sys/statx");
@@ -57,18 +51,18 @@ File :: object(
 impl(
   File,
   /// Open a file at `path` with the given mode and custom permissions.
-  open_with : (fn(path : Path, mode : OpenMode, perm : FilePermission, using(io : IO)) -> Impl(Future(File, IO, Exception)))({
+  open_with : (fn(path : Path, mode : OpenMode, perm : FilePermission, io : IO) -> Impl(Future(File, IOErr)))({
     flags := _open_mode_to_flags(mode);
     file_mode := cond(
       _open_mode_needs_perm(mode) => i32(perm.mode),
       true => i32(0)
     );
-    io.async((using(io, exn)) => {
+    io.async((e) => {
       path_str := path.to_string();
       cstr_bytes := path_str.to_cstr();
       cstr := cstr_bytes.ptr().unwrap();
-      result := io.await(IO_file.openat(AT_FDCWD, cstr, flags, file_mode));
-      fd := IOError.check(result);
+      result := e.io.await(IO_file.openat(AT_FDCWD, cstr, flags, file_mode), e.io);
+      fd := IOError.check(result, e.exn);
       File(
         _fd : fd,
         _path : path,
@@ -77,78 +71,78 @@ impl(
     })
   }),
   /// Open a file from a `str` path with the given mode and custom permissions.
-  open_with_str : (fn(path : str, mode : OpenMode, perm : FilePermission, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
-    File.open_with(Path.new(String.from(path)), mode, perm)
+  open_with_str : (fn(path : str, mode : OpenMode, perm : FilePermission, io : IO) -> Impl(Future(File, IOErr)))(
+    File.open_with(Path.new(String.from(path)), mode, perm, io)
   ),
   /// Open a file from a C string path with the given mode and custom permissions.
-  open_with_cstr : (fn(path : *(u8), mode : OpenMode, perm : FilePermission, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
-    File.open_with(Path.from_cstr(path), mode, perm)
+  open_with_cstr : (fn(path : *(u8), mode : OpenMode, perm : FilePermission, io : IO) -> Impl(Future(File, IOErr)))(
+    File.open_with(Path.from_cstr(path), mode, perm, io)
   ),
   /// Open a file at `path` with the given mode and default permissions (0o644).
-  open : (fn(path : Path, mode : OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
-    File.open_with(path, mode, FilePermission.default())
+  open : (fn(path : Path, mode : OpenMode, io : IO) -> Impl(Future(File, IOErr)))(
+    File.open_with(path, mode, FilePermission.default(), io)
   ),
   /// Open a file from a `str` path with the given mode and default permissions.
-  open_str : (fn(path : str, mode : OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
-    File.open(Path.new(String.from(path)), mode)
+  open_str : (fn(path : str, mode : OpenMode, io : IO) -> Impl(Future(File, IOErr)))(
+    File.open(Path.new(String.from(path)), mode, io)
   ),
   /// Open a file from a C string path with the given mode and default permissions.
-  open_cstr : (fn(path : *(u8), mode : OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
-    File.open(Path.from_cstr(path), mode)
+  open_cstr : (fn(path : *(u8), mode : OpenMode, io : IO) -> Impl(Future(File, IOErr)))(
+    File.open(Path.from_cstr(path), mode, io)
   ),
   /// Read up to `size` bytes into the buffer `buf`.
   /// Returns the number of bytes actually read.
-  read : (fn(self : Self, buf : *(u8), size : u32, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  read : (fn(self : Self, buf : *(u8), size : u32, io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
-    io.async((using(io, exn)) => {
-      result := io.await(IO_file.read(fd, buf, size, u64(0)));
-      IOError.check(result)
+    io.async((e) => {
+      result := e.io.await(IO_file.read(fd, buf, size, u64(0)), e.io);
+      IOError.check(result, e.exn)
     })
   }),
   /// Write a `String` to the file.
   /// Returns the number of bytes written.
-  write_string : (fn(self : Self, data : String, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  write_string : (fn(self : Self, data : String, io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
-    io.async((using(io, exn)) => {
+    io.async((e) => {
       data_bytes := data.as_bytes();
       cond(
         (data_bytes.len() == usize(0)) => i32(0),
         true => {
-          result := io.await(IO_file.write(fd, data_bytes.ptr().unwrap(), u32(data_bytes.len()), u64(0)));
-          IOError.check(result)
+          result := e.io.await(IO_file.write(fd, data_bytes.ptr().unwrap(), u32(data_bytes.len()), u64(0)), e.io);
+          IOError.check(result, e.exn)
         }
       )
     })
   }),
   /// Write bytes from an `ArrayList(u8)` to the file.
   /// Returns the number of bytes written.
-  write_bytes : (fn(self : Self, data : ArrayList(u8), using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  write_bytes : (fn(self : Self, data : ArrayList(u8), io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
     io.async(
-      (using(io, exn)) =>
+      (e) =>
         cond(
           (data.len() == usize(0)) => i32(0),
           true => {
-            result := io.await(IO_file.write(fd, data.ptr().unwrap(), u32(data.len()), u64(0)));
-            IOError.check(result)
+            result := e.io.await(IO_file.write(fd, data.ptr().unwrap(), u32(data.len()), u64(0)), e.io);
+            IOError.check(result, e.exn)
           }
         )
     )
   }),
   /// Read the entire file contents into an `ArrayList(u8)`.
-  read_bytes : (fn(self : Self, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))({
+  read_bytes : (fn(self : Self, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))({
     fd := self._fd;
-    io.async((using(io, exn)) => {
+    io.async((e) => {
       buf_size := usize(4096);
       buf := *(u8)(malloc(buf_size).unwrap());
       result := ArrayList(u8).new();
       offset := u64(0);
       while(runtime(true), {
-        n := io.await(IO_file.read(fd, buf, u32(buf_size), offset));
+        n := e.io.await(IO_file.read(fd, buf, u32(buf_size), offset), e.io);
         cond(
           (n < i32(0)) => {
             free(.Some(*(void)(buf)));
-            exn.throw(dyn(IOError.from_errno(i32(0) - n)));
+            e.exn.throw(dyn(IOError.from_errno(i32(0) - n)));
           },
           (n == i32(0)) => break,
           true => {
@@ -166,25 +160,25 @@ impl(
     })
   }),
   /// Read the entire file contents into a `String`.
-  read_string : (fn(self : Self, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
-    io.async((using(io, exn)) => {
-      bytes := io.await(self.read_bytes());
+  read_string : (fn(self : Self, io : IO) -> Impl(Future(String, IOErr)))(
+    io.async((e) => {
+      bytes := e.io.await(self.read_bytes(io), e);
       String.from_bytes(bytes)
     })
   ),
   /// Flush (fsync) file data to disk.
-  flush : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  flush : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
     fd := self._fd;
-    io.async((using(io, exn)) => {
-      result := io.await(IO_file.fsync(fd));
+    io.async((e) => {
+      result := e.io.await(IO_file.fsync(fd), e.io);
       cond(
-        (result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - result))),
+        (result < i32(0)) => e.exn.throw(dyn(IOError.from_errno(i32(0) - result))),
         true => ()
       )
     })
   }),
   /// Seek to a position relative to `from`. Returns the new absolute byte offset.
-  seek : (fn(self : Self, offset : i64, from : SeekFrom, using(exn : Exception)) -> i64)({
+  seek : (fn(self : Self, offset : i64, from : SeekFrom, exn : Exception) -> i64)({
     result := IO_seek.lseek(self._fd, offset, _seek_from_to_whence(from));
     cond(
       (result < i64(0)) => exn.throw(dyn(IOError.from_errno(i32(i64(0) - result)))),
@@ -200,17 +194,17 @@ impl(
     IO_file.file_size(self._fd)
   ),
   /// Close the file descriptor. Safe to call multiple times.
-  close : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  close : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
     fd := self._fd;
     io.async(
-      (using(io, exn)) =>
+      (e) =>
         cond(
           self._is_closed => (),
           true => {
-            result := io.await(IO_file.close(fd));
+            result := e.io.await(IO_file.close(fd), e.io);
             self._is_closed = true;
             cond(
-              (result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - result))),
+              (result < i32(0)) => e.exn.throw(dyn(IOError.from_errno(i32(0) - result))),
               true => ()
             )
           }
@@ -226,8 +220,8 @@ impl(
     self._path
   ),
   /// Get file metadata (size, permissions, timestamps).
-  metadata : (fn(self : Self, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))(
-    _metadata_mod.metadata(self._path)
+  metadata : (fn(self : Self, io : IO) -> Impl(Future(Metadata, IOErr)))(
+    _metadata_mod.metadata(self._path, io)
   )
 );
 impl(
@@ -249,74 +243,74 @@ export(File, OpenMode, FilePermission, SeekFrom);
 // Convenience functions
 // ============================================================================
 /// Read an entire file into a `String`.
-read_string :: (fn(path : Path, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
-  io.async((using(io, exn)) => {
-    file := io.await(File.open(path,.Read));
-    content := io.await(file.read_string());
-    io.await(file.close());
+read_string :: (fn(path : Path, io : IO) -> Impl(Future(String, IOErr)))(
+  io.async((e) => {
+    file := e.io.await(File.open(path,.Read, io), e);
+    content := e.io.await(file.read_string(io), e);
+    e.io.await(file.close(io), e);
     return(content);
   })
 );
 /// Read an entire file into a `String` (`str` path variant).
-read_string_str :: (fn(path : str, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
-  read_string(Path.new(String.from(path)))
+read_string_str :: (fn(path : str, io : IO) -> Impl(Future(String, IOErr)))(
+  read_string(Path.new(String.from(path)), io)
 );
 /// Read an entire file into a `String` (C string path variant).
-read_string_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(String, IO, Exception)))(
-  read_string(Path.from_cstr(path))
+read_string_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(String, IOErr)))(
+  read_string(Path.from_cstr(path), io)
 );
 /// Read an entire file into a byte list (`ArrayList(u8)`).
-read_file :: (fn(path : Path, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
-  io.async((using(io, exn)) => {
-    file := io.await(File.open(path,.Read));
-    content := io.await(file.read_bytes());
-    io.await(file.close());
+read_file :: (fn(path : Path, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))(
+  io.async((e) => {
+    file := e.io.await(File.open(path,.Read, io), e);
+    content := e.io.await(file.read_bytes(io), e);
+    e.io.await(file.close(io), e);
     return(content);
   })
 );
 /// Read an entire file into bytes (`str` path variant).
-read_file_str :: (fn(path : str, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
-  read_file(Path.new(String.from(path)))
+read_file_str :: (fn(path : str, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))(
+  read_file(Path.new(String.from(path)), io)
 );
 /// Read an entire file into bytes (C string path variant).
-read_file_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
-  read_file(Path.from_cstr(path))
+read_file_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(ArrayList(u8), IOErr)))(
+  read_file(Path.from_cstr(path), io)
 );
 /// Write a `String` to a file, creating or truncating it.
-write_file :: (fn(path : Path, data : String, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  io.async((using(io, exn)) => {
-    file := io.await(File.open(path,.Write));
-    io.await(file.write_string(data));
-    io.await(file.close());
+write_file :: (fn(path : Path, data : String, io : IO) -> Impl(Future(unit, IOErr)))(
+  io.async((e) => {
+    file := e.io.await(File.open(path,.Write, io), e);
+    e.io.await(file.write_string(data, io), e);
+    e.io.await(file.close(io), e);
   })
 );
 /// Write a `str` to a file, creating or truncating it (`str` path variant).
-write_file_str :: (fn(path : str, data : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  write_file(Path.new(String.from(path)), String.from(data))
+write_file_str :: (fn(path : str, data : str, io : IO) -> Impl(Future(unit, IOErr)))(
+  write_file(Path.new(String.from(path)), String.from(data), io)
 );
 /// Write a `str` to a file, creating or truncating it (C string path variant).
-write_file_cstr :: (fn(path : *(u8), data : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  write_file(Path.from_cstr(path), String.from(data))
+write_file_cstr :: (fn(path : *(u8), data : str, io : IO) -> Impl(Future(unit, IOErr)))(
+  write_file(Path.from_cstr(path), String.from(data), io)
 );
 /// Write bytes to a file, creating or truncating it.
-write_bytes :: (fn(path : Path, data : ArrayList(u8), using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  io.async((using(io, exn)) => {
-    file := io.await(File.open(path,.Write));
-    io.await(file.write_bytes(data));
-    io.await(file.close());
+write_bytes :: (fn(path : Path, data : ArrayList(u8), io : IO) -> Impl(Future(unit, IOErr)))(
+  io.async((e) => {
+    file := e.io.await(File.open(path,.Write, io), e);
+    e.io.await(file.write_bytes(data, io), e);
+    e.io.await(file.close(io), e);
   })
 );
 /// Append a `String` to a file, creating it if it does not exist.
-append_file :: (fn(path : Path, data : String, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  io.async((using(io, exn)) => {
-    file := io.await(File.open(path,.Append));
-    io.await(file.write_string(data));
-    io.await(file.close());
+append_file :: (fn(path : Path, data : String, io : IO) -> Impl(Future(unit, IOErr)))(
+  io.async((e) => {
+    file := e.io.await(File.open(path,.Append, io), e);
+    e.io.await(file.write_string(data, io), e);
+    e.io.await(file.close(io), e);
   })
 );
 /// Append a `str` to a file (`str` path variant).
-append_file_str :: (fn(path : str, data : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  append_file(Path.new(String.from(path)), String.from(data))
+append_file_str :: (fn(path : str, data : str, io : IO) -> Impl(Future(unit, IOErr)))(
+  append_file(Path.new(String.from(path)), String.from(data), io)
 );
 extern(
   "Yo",
@@ -324,34 +318,34 @@ extern(
 );
 /// Check if a path exists. Returns `false` for any error including file not found.
 /// Does not use the `Exception` effect.
-exists :: (fn(path : Path, using(io : IO)) -> Impl(Future(bool, IO)))(
-  io.async((using(io : IO)) => {
+exists :: (fn(path : Path, io : IO) -> Impl(Future(bool, IO)))(
+  io.async((io) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     buf_size := __yo_statx_buf_size();
     buf := *(u8)(malloc(buf_size).unwrap());
-    result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, buf));
+    result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, buf), io);
     free(.Some(*(void)(buf)));
     result >= i32(0)
   })
 );
 /// Check if a path exists (`str` path variant).
-exists_str :: (fn(path : str, using(io : IO)) -> Impl(Future(bool, IO)))(
-  exists(Path.new(String.from(path)), using(io))
+exists_str :: (fn(path : str, io : IO) -> Impl(Future(bool, IO)))(
+  exists(Path.new(String.from(path)), io)
 );
 /// Check if a path exists (C string path variant).
-exists_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(bool, IO)))(
-  exists(Path.from_cstr(path), using(io))
+exists_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(bool, IO)))(
+  exists(Path.from_cstr(path), io)
 );
 /// Check if a path is a regular file. Returns `false` for any error.
-is_file :: (fn(path : Path, using(io : IO)) -> Impl(Future(bool, IO)))(
-  io.async((using(io : IO)) => {
+is_file :: (fn(path : Path, io : IO) -> Impl(Future(bool, IO)))(
+  io.async((io) => {
     path_str := path.to_string();
     cstr_bytes := path_str.to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     buf_size := __yo_statx_buf_size();
     buf := *(u8)(malloc(buf_size).unwrap());
-    result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, buf));
+    result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, buf), io);
     r := cond(
       (result < i32(0)) => false,
       true => {
@@ -364,22 +358,22 @@ is_file :: (fn(path : Path, using(io : IO)) -> Impl(Future(bool, IO)))(
   })
 );
 /// Check if a path is a regular file (`str` path variant).
-is_file_str :: (fn(path : str, using(io : IO)) -> Impl(Future(bool, IO)))(
-  is_file(Path.new(String.from(path)), using(io))
+is_file_str :: (fn(path : str, io : IO) -> Impl(Future(bool, IO)))(
+  is_file(Path.new(String.from(path)), io)
 );
 /// Check if a path is a regular file (C string path variant).
-is_file_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(bool, IO)))(
-  is_file(Path.from_cstr(path), using(io))
+is_file_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(bool, IO)))(
+  is_file(Path.from_cstr(path), io)
 );
 /// Check if a path is a directory. Returns `false` for any error.
-is_dir :: (fn(path : Path, using(io : IO)) -> Impl(Future(bool, IO)))(
-  io.async((using(io : IO)) => {
+is_dir :: (fn(path : Path, io : IO) -> Impl(Future(bool, IO)))(
+  io.async((io) => {
     path_str := path.to_string();
     cstr_bytes := path_str.to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     buf_size := __yo_statx_buf_size();
     buf := *(u8)(malloc(buf_size).unwrap());
-    result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, buf));
+    result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, buf), io);
     r := cond(
       (result < i32(0)) => false,
       true => {
@@ -392,33 +386,33 @@ is_dir :: (fn(path : Path, using(io : IO)) -> Impl(Future(bool, IO)))(
   })
 );
 /// Check if a path is a directory (`str` path variant).
-is_dir_str :: (fn(path : str, using(io : IO)) -> Impl(Future(bool, IO)))(
-  is_dir(Path.new(String.from(path)), using(io))
+is_dir_str :: (fn(path : str, io : IO) -> Impl(Future(bool, IO)))(
+  is_dir(Path.new(String.from(path)), io)
 );
 /// Check if a path is a directory (C string path variant).
-is_dir_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(bool, IO)))(
-  is_dir(Path.from_cstr(path), using(io))
+is_dir_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(bool, IO)))(
+  is_dir(Path.from_cstr(path), io)
 );
 /// Resolve a path to its canonical absolute form (resolves symlinks, `.` and `..`).
 /// Throws if the path does not exist.
-canonical :: (fn(path : Path, using(io : IO)) -> Impl(Future(Path, IO, Exception)))(
-  io.async((using(io, exn)) => {
+canonical :: (fn(path : Path, io : IO) -> Impl(Future(Path, IOErr)))(
+  io.async((e) => {
     path_str := path.to_string();
     cstr_bytes := path_str.to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     // Async stat to verify path exists (provides await point for proper RC cleanup)
     buf_size := __yo_statx_buf_size();
     stat_buf := *(u8)(malloc(buf_size).unwrap());
-    stat_result := io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, stat_buf));
+    stat_result := e.io.await(IO_file.statx(AT_FDCWD, cstr, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, stat_buf), e.io);
     free(.Some(*(void)(stat_buf)));
-    IOError.check(stat_result);
+    IOError.check(stat_result, e.exn);
     // Resolve the canonical path
     resolved_buf := *(u8)(malloc(usize(4096)).unwrap());
     rp_result := IO_path.realpath(cstr, resolved_buf);
     cond(
       (rp_result < i32(0)) => {
         free(.Some(*(void)(resolved_buf)));
-        IOError.check(rp_result);
+        IOError.check(rp_result, e.exn);
       },
       true => ()
     );
@@ -428,12 +422,12 @@ canonical :: (fn(path : Path, using(io : IO)) -> Impl(Future(Path, IO, Exception
   })
 );
 /// Resolve a path to its canonical absolute form (`str` path variant).
-canonical_str :: (fn(path : str, using(io : IO)) -> Impl(Future(Path, IO, Exception)))(
-  canonical(Path.new(String.from(path)))
+canonical_str :: (fn(path : str, io : IO) -> Impl(Future(Path, IOErr)))(
+  canonical(Path.new(String.from(path)), io)
 );
 /// Resolve a path to its canonical absolute form (C string path variant).
-canonical_cstr :: (fn(path : *(u8), using(io : IO)) -> Impl(Future(Path, IO, Exception)))(
-  canonical(Path.from_cstr(path))
+canonical_cstr :: (fn(path : *(u8), io : IO) -> Impl(Future(Path, IOErr)))(
+  canonical(Path.from_cstr(path), io)
 );
 export(
   read_string,

package/std/fs/metadata.yo

@@ -6,14 +6,8 @@
 //! ```rust
 //! { metadata } :: import "std/fs/metadata";
 //!
-//! main :: (fn(using(io : IO)) -> unit)({
-//!   given(exn) : Exception = {
-//!     throw : (fn(forall(T : Type), error: AnyError) -> T)(
-//!       { println(error.to_string()); exit(i32(1)); }
-//!     )
-//!   };
-//!
-//!   m := io.await(metadata(Path.new(`/tmp/test.txt`)));
+//! main :: (fn(io : IO, exn : Exception) -> unit)({
+//!   m := io.await(metadata(Path.new(`/tmp/test.txt`), io), { io, exn });
 //!   printf("size: %lld\n", m.size());
 //!   printf("is file: %d\n", i32(m.is_file()));
 //! });
@@ -23,7 +17,7 @@
 open(import("../string"));
 { Path } :: import("../path");
 { IOError } :: import("../sys/errors");
-{ Error, AnyError, Exception } :: import("../error");
+{ Error, AnyError, Exception, IOErr } :: import("../error");
 { Statx } :: import("../sys/statx");
 IO_file :: import("../sys/file");
 { AT_FDCWD, AT_SYMLINK_NOFOLLOW, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, S_IFMT, S_IFREG, S_IFDIR, S_IFLNK, S_IWUSR, S_IWGRP, S_IWOTH } :: import("../sys/constants");
@@ -107,17 +101,17 @@ extern(
 // ============================================================================
 // Internal helper to stat a path
 // ============================================================================
-_stat_path :: (fn(path : Path, flags : i32, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))(
-  io.async((using(io, exn)) => {
+_stat_path :: (fn(path : Path, flags : i32, io : IO) -> Impl(Future(Metadata, IOErr)))(
+  io.async((e) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     buf_size := __yo_statx_buf_size();
     buf := *(u8)(malloc(buf_size).unwrap());
-    result := io.await(IO_file.statx(AT_FDCWD, cstr, flags, STATX_BASIC_STATS, buf));
+    result := e.io.await(IO_file.statx(AT_FDCWD, cstr, flags, STATX_BASIC_STATS, buf), e.io);
     cond(
       (result < i32(0)) => {
         free(.Some(*(void)(buf)));
-        exn.throw(dyn(IOError.from_errno(i32(0) - result)))
+        e.exn.throw(dyn(IOError.from_errno(i32(0) - result)))
       },
       true => {
         sx := Statx(_buf_ptr : buf, _buf_size : buf_size);
@@ -127,11 +121,11 @@ _stat_path :: (fn(path : Path, flags : i32, using(io : IO)) -> Impl(Future(Metad
   })
 );
 /// Get metadata for a path (follows symlinks).
-metadata :: (fn(path : Path, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))(_stat_path(path, AT_STATX_SYNC_AS_STAT));
+metadata :: (fn(path : Path, io : IO) -> Impl(Future(Metadata, IOErr)))(_stat_path(path, AT_STATX_SYNC_AS_STAT, io));
 /// Get metadata for a path given as a raw string (follows symlinks).
-metadata_str :: (fn(path : str, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))(metadata(Path.new(String.from(path))));
+metadata_str :: (fn(path : str, io : IO) -> Impl(Future(Metadata, IOErr)))(metadata(Path.new(String.from(path)), io));
 /// Get metadata for a path (does NOT follow symlinks).
-symlink_metadata :: (fn(path : Path, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))(_stat_path(path, AT_SYMLINK_NOFOLLOW | AT_STATX_SYNC_AS_STAT));
+symlink_metadata :: (fn(path : Path, io : IO) -> Impl(Future(Metadata, IOErr)))(_stat_path(path, AT_SYMLINK_NOFOLLOW | AT_STATX_SYNC_AS_STAT, io));
 /// Get metadata for a path given as a raw string (does NOT follow symlinks).
-symlink_metadata_str :: (fn(path : str, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))(symlink_metadata(Path.new(String.from(path))));
+symlink_metadata_str :: (fn(path : str, io : IO) -> Impl(Future(Metadata, IOErr)))(symlink_metadata(Path.new(String.from(path)), io));
 export(metadata, metadata_str, symlink_metadata, symlink_metadata_str);