@shd101wyy/yo 0.0.26 → 0.0.28

package/std/fs/file.yo

@@ -1,20 +1,24 @@
 // std/fs/file.yo - High-level file object
 //
 // Wraps a file descriptor with typed async I/O operations.
+// Uses Exception effect for error handling.
 //
 // Example:
-//   { File, read_to_string, write_file, OpenMode } :: import "std/fs/file";
+//   { 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."); }
+//       )
+//     );
+//
 //     // Write a file
 //     io.await(write_file(Path.new(`test.txt`), `hello world`));
 //
 //     // Read it back
-//     content := io.await(read_to_string(Path.new(`test.txt`)));
-//     match(content,
-//       .Ok(s) => println(s),
-//       .Err(e) => println(e.to_string())
-//     );
+//     content := io.await(read_string(Path.new(`test.txt`)));
+//     println(content);
 //
 //     // Open with OpenMode
 //     f := io.await(File.open(Path.new(`test.txt`), .Read));
@@ -27,13 +31,15 @@ open import "../string";
 open import "../fmt";
 { Path } :: import "../path";
 { IOError } :: import "../sys/errors";
+{ Error, AnyError, Exception } :: import "../error";
 { Metadata } :: import "./metadata";
 _metadata_mod :: import "./metadata";
 { OpenMode, FilePermission, _open_mode_to_flags, _open_mode_needs_perm } :: import "./types";
 IO_file :: import "../sys/file";
 IO_seek :: import "../sys/seek";
 {
-  AT_FDCWD, O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND,
+  AT_FDCWD, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS,
+  O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_APPEND,
   O_CLOEXEC, DEFAULT_FILE_MODE
 } :: import "../sys/constants";
 
@@ -49,74 +55,72 @@ File :: object(
 
 impl(File,
   // Open a file with OpenMode and custom permissions.
-  open_with : (fn(path: Path, mode: OpenMode, perm: FilePermission, using(io : IO)) -> Impl(Future(Result(File, IOError), IO)))({
+  open_with : (fn(path: Path, mode: OpenMode, perm: FilePermission, using(io : IO)) -> Impl(Future(File, IO, Exception)))({
     flags := _open_mode_to_flags(mode);
     file_mode := cond(
       _open_mode_needs_perm(mode) => i32(perm.mode),
       true => i32(0)
     );
-    io.async((using(io : IO)) => {
+    io.async((using(io, exn)) => {
       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));
-      cond(
-        (result < i32(0)) => .Err(IOError.from_errno((i32(0) - result))),
-        true => .Ok(File(
-          _fd: result,
-          _path: path,
-          _is_closed: false
-        ))
+      fd := IOError.check(result);
+      File(
+        _fd: fd,
+        _path: path,
+        _is_closed: false
       )
     })
   }),
 
   // Open a file from a str path with OpenMode and custom permissions.
-  open_with_str : (fn(path: str, mode: OpenMode, perm: FilePermission, using(io : IO)) -> Impl(Future(Result(File, IOError), IO)))(
-    File.open_with(Path.new(String.from(path)), mode, perm, using(io))
+  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 a file from a C string path with OpenMode and custom permissions.
-  open_with_cstr : (fn(path: *(u8), mode: OpenMode, perm: FilePermission, using(io : IO)) -> Impl(Future(Result(File, IOError), IO)))(
-    File.open_with(Path.from_cstr(path), mode, perm, using(io))
+  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 a file with OpenMode and default permissions.
-  open : (fn(path: Path, mode: OpenMode, using(io : IO)) -> Impl(Future(Result(File, IOError), IO)))(
-    File.open_with(path, mode, FilePermission.default(), using(io))
+  open : (fn(path: Path, mode: OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
+    File.open_with(path, mode, FilePermission.default())
   ),
 
   // Open a file from a str path with OpenMode and default permissions.
-  open_str : (fn(path: str, mode: OpenMode, using(io : IO)) -> Impl(Future(Result(File, IOError), IO)))(
-    File.open(Path.new(String.from(path)), mode, using(io))
+  open_str : (fn(path: str, mode: OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
+    File.open(Path.new(String.from(path)), mode)
   ),
 
   // Open a file from a C string path with OpenMode and default permissions.
-  open_cstr : (fn(path: *(u8), mode: OpenMode, using(io : IO)) -> Impl(Future(Result(File, IOError), IO)))(
-    File.open(Path.from_cstr(path), mode, using(io))
+  open_cstr : (fn(path: *(u8), mode: OpenMode, using(io : IO)) -> Impl(Future(File, IO, Exception)))(
+    File.open(Path.from_cstr(path), mode)
   ),
 
   // Read up to `size` bytes into buffer.
   // Returns number of bytes read.
-  read : (fn(self: Self, buf: *(u8), size: u32, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+  read : (fn(self: Self, buf: *(u8), size: u32, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((using(io, exn)) => {
       result := io.await(IO_file.read(fd, buf, size, u64(0)));
-      IOError.from_result(result)
+      IOError.check(result)
     })
   }),
 
   // Write a String to the file.
   // Returns number of bytes written.
-  write : (fn(self: Self, data: String, using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+  write_string : (fn(self: Self, data: String, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((using(io, exn)) => {
       data_bytes := data.as_bytes();
       cond(
-        (data_bytes.len() == usize(0)) => .Ok(i32(0)),
+        (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.from_result(result)
+          IOError.check(result)
         }
       )
     })
@@ -124,34 +128,33 @@ impl(File,
 
   // Write bytes from an ArrayList to the file.
   // Returns number of bytes written.
-  write_bytes : (fn(self: Self, data: ArrayList(u8), using(io : IO)) -> Impl(Future(Result(i32, IOError), IO)))({
+  write_bytes : (fn(self: Self, data: ArrayList(u8), using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
-    io.async((using(io : IO)) =>
+    io.async((using(io, exn)) =>
       cond(
-        (data.len() == usize(0)) => .Ok(i32(0)),
+        (data.len() == usize(0)) => i32(0),
         true => {
           result := io.await(IO_file.write(fd, data.ptr().unwrap(), u32(data.len()), u64(0)));
-          IOError.from_result(result)
+          IOError.check(result)
         }
       )
     )
   }),
 
   // Read the entire file into a byte list.
-  read_all : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(ArrayList(u8), IOError), IO)))({
+  read_bytes : (fn(self: Self, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))({
     fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((using(io, exn)) => {
       buf_size := usize(4096);
       buf := *(u8)(malloc(buf_size).unwrap());
       result := ArrayList(u8).new();
       offset := u64(0);
-      (read_err : Option(IOError)) = .None;
       while runtime(true), {
         n := io.await(IO_file.read(fd, buf, u32(buf_size), offset));
         cond(
           (n < i32(0)) => {
-            read_err = .Some(IOError.from_errno((i32(0) - n)));
-            break;
+            free(.Some(*(void)(buf)));
+            exn.throw(dyn IOError.from_errno((i32(0) - n)));
           },
           (n == i32(0)) => break,
           true => {
@@ -165,43 +168,37 @@ impl(File,
         );
       };
       free(.Some(*(void)(buf)));
-      match(read_err,
-        .Some(e) => .Err(e),
-        .None => .Ok(result)
-      )
+      result
     })
   }),
 
   // Read the entire file into a String.
-  read_to_string : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(String, IOError), IO)))(
-    io.async((using(io : IO)) => {
-      bytes_result := io.await(self.read_all(using(io)));
-      match(bytes_result,
-        .Ok(bytes) => .Ok(String.from_bytes(bytes)),
-        .Err(e) => .Err(e)
-      )
+  read_string : (fn(self: Self, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
+    io.async((using(io, exn)) => {
+      bytes := io.await(self.read_bytes());
+      String.from_bytes(bytes)
     })
   ),
 
   // Sync file data to disk.
-  flush : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))({
+  flush : (fn(self: Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     fd := self._fd;
-    io.async((using(io : IO)) => {
+    io.async((using(io, exn)) => {
       result := io.await(IO_file.fsync(fd));
       cond(
-        (result < i32(0)) => .Err(IOError.from_errno((i32(0) - result))),
-        true => .Ok(())
+        (result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - result))),
+        true => ()
       )
     })
   }),
 
   // Seek to a position. Returns the new absolute position.
   // whence: SEEK_SET(0), SEEK_CUR(1), SEEK_END(2)
-  seek : (fn(self: Self, offset: i64, whence: i32) -> Result(i64, IOError))({
+  seek : (fn(self: Self, offset: i64, whence: i32, using(exn : Exception)) -> i64)({
     result := IO_seek.lseek(self._fd, offset, whence);
     cond(
-      (result < i64(0)) => .Err(IOError.from_errno(i32((i64(0) - result)))),
-      true => .Ok(result)
+      (result < i64(0)) => exn.throw(dyn IOError.from_errno(i32((i64(0) - result)))),
+      true => result
     )
   }),
 
@@ -216,17 +213,17 @@ impl(File,
   ),
 
   // Close the file.
-  close : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))({
+  close : (fn(self: Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     fd := self._fd;
-    io.async((using(io : IO)) =>
+    io.async((using(io, exn)) =>
       cond(
-        self._is_closed => .Ok(()),
+        self._is_closed => (),
         true => {
           result := io.await(IO_file.close(fd));
           self._is_closed = true;
           cond(
-            (result < i32(0)) => .Err(IOError.from_errno((i32(0) - result))),
-            true => .Ok(())
+            (result < i32(0)) => exn.throw(dyn IOError.from_errno((i32(0) - result))),
+            true => ()
           )
         }
       )
@@ -244,8 +241,8 @@ impl(File,
   ),
 
   // Get file metadata.
-  metadata : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(Metadata, IOError), IO)))(
-    _metadata_mod.metadata(self._path, using(io))
+  metadata : (fn(self: Self, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))(
+    _metadata_mod.metadata(self._path)
   )
 );
 
@@ -268,150 +265,117 @@ export File, OpenMode, FilePermission;
 // ============================================================================
 
 // Read an entire file into a String (Path version).
-read_to_string :: (fn(path: Path, using(io : IO)) -> Impl(Future(Result(String, IOError), IO)))(
-  io.async((using(io : IO)) => {
-    file_result := io.await(File.open(path, .Read, using(io)));
-    match(file_result,
-      .Ok(file) => {
-        content := io.await(file.read_to_string(using(io)));
-        io.await(file.close(using(io)));
-        return content;
-      },
-      .Err(e) => .Err(e)
-    )
+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());
+    return content;
   })
 );
 
 // Read an entire file into a String (str version).
-read_to_string_str :: (fn(path: str, using(io : IO)) -> Impl(Future(Result(String, IOError), IO)))(
-  read_to_string(Path.new(String.from(path)), using(io))
+read_string_str :: (fn(path: str, using(io : IO)) -> Impl(Future(String, IO, Exception)))(
+  read_string(Path.new(String.from(path)))
 );
 
 // Read an entire file into a String (C string version).
-read_to_string_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(Result(String, IOError), IO)))(
-  read_to_string(Path.from_cstr(path), using(io))
+read_string_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(String, IO, Exception)))(
+  read_string(Path.from_cstr(path))
 );
 
 // Read an entire file into bytes (Path version).
-read_file :: (fn(path: Path, using(io : IO)) -> Impl(Future(Result(ArrayList(u8), IOError), IO)))(
-  io.async((using(io : IO)) => {
-    file_result := io.await(File.open(path, .Read, using(io)));
-    match(file_result,
-      .Ok(file) => {
-        content := io.await(file.read_all(using(io)));
-        io.await(file.close(using(io)));
-        return content;
-      },
-      .Err(e) => .Err(e)
-    )
+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());
+    return content;
   })
 );
 
 // Read an entire file into bytes (str version).
-read_file_str :: (fn(path: str, using(io : IO)) -> Impl(Future(Result(ArrayList(u8), IOError), IO)))(
-  read_file(Path.new(String.from(path)), using(io))
+read_file_str :: (fn(path: str, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
+  read_file(Path.new(String.from(path)))
 );
 
 // Read an entire file into bytes (C string version).
-read_file_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(Result(ArrayList(u8), IOError), IO)))(
-  read_file(Path.from_cstr(path), using(io))
+read_file_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))(
+  read_file(Path.from_cstr(path))
 );
 
-// Write a str to a file (creates or truncates) (Path version).
-write_file :: (fn(path: Path, data: str, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
-  io.async((using(io : IO)) => {
-    file_result := io.await(File.open(path, .Write, using(io)));
-    match(file_result,
-      .Ok(file) => {
-        write_result := io.await(file.write(String.from(data), using(io)));
-        io.await(file.close(using(io)));
-        match(write_result,
-          .Ok(_) => .Ok(()),
-          .Err(e) => .Err(e)
-        )
-      },
-      .Err(e) => .Err(e)
-    )
+// Write a String to a file (creates or truncates) (Path version).
+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 a str to a file (creates or truncates) (str path version).
-write_file_str :: (fn(path: str, data: str, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
-  write_file(Path.new(String.from(path)), data, using(io))
+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 a str to a file (creates or truncates) (C string path version).
-write_file_cstr :: (fn(path: *(u8), data: str, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
-  write_file(Path.from_cstr(path), data, using(io))
+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 bytes to a file (creates or truncates) (Path version).
-write_bytes :: (fn(path: Path, data: ArrayList(u8), using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
-  io.async((using(io : IO)) => {
-    file_result := io.await(File.open(path, .Write, using(io)));
-    match(file_result,
-      .Ok(file) => {
-        write_result := io.await(file.write_bytes(data, using(io)));
-        io.await(file.close(using(io)));
-        match(write_result,
-          .Ok(_) => .Ok(()),
-          .Err(e) => .Err(e)
-        )
-      },
-      .Err(e) => .Err(e)
-    )
+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());
   })
 );
 
 // Append a str to a file (creates if not exists) (Path version).
-append_file :: (fn(path: Path, data: str, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
-  io.async((using(io : IO)) => {
-    file_result := io.await(File.open(path, .Append, using(io)));
-    match(file_result,
-      .Ok(file) => {
-        write_result := io.await(file.write(String.from(data), using(io)));
-        io.await(file.close(using(io)));
-        match(write_result,
-          .Ok(_) => .Ok(()),
-          .Err(e) => .Err(e)
-        )
-      },
-      .Err(e) => .Err(e)
-    )
+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 a str to a file (str path version).
-append_file_str :: (fn(path: str, data: str, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))(
-  append_file(Path.new(String.from(path)), data, using(io))
+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))
 );
 
+extern "Yo",
+  __yo_statx_buf_size : (fn() -> usize)
+;
+
 // Check if a path exists (Path version).
-exists :: (fn(path: Path, using(io : IO)) -> Impl(Future(Result(bool, IOError), IO)))(
+// Does NOT use Exception — returns false for any error (including file not found).
+exists :: (fn(path: Path, using(io : IO)) -> Impl(Future(bool, IO)))(
   io.async((using(io : IO)) => {
-    meta_result := io.await(_metadata_mod.metadata(path, using(io)));
-    match(meta_result,
-      .Ok(_) => .Ok(true),
-      .Err(e) => match(e,
-        .NotFound => .Ok(false),
-        _ => .Err(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, AT_STATX_SYNC_AS_STAT, STATX_BASIC_STATS, buf));
+    free(.Some(*(void)(buf)));
+    (result >= i32(0))
   })
 );
 
 // Check if a path exists (str version).
-exists_str :: (fn(path: str, using(io : IO)) -> Impl(Future(Result(bool, IOError), IO)))(
+exists_str :: (fn(path: str, using(io : IO)) -> Impl(Future(bool, IO)))(
   exists(Path.new(String.from(path)), using(io))
 );
 
 // Check if a path exists (C string version).
-exists_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(Result(bool, IOError), IO)))(
+exists_cstr :: (fn(path: *(u8), using(io : IO)) -> Impl(Future(bool, IO)))(
   exists(Path.from_cstr(path), using(io))
 );
 
 export
-  read_to_string, read_to_string_str, read_to_string_cstr,
+  read_string, read_string_str, read_string_cstr,
   read_file, read_file_str, read_file_cstr,
   write_file, write_file_str, write_file_cstr,
   write_bytes,

package/std/fs/metadata.yo

@@ -1,19 +1,21 @@
 // std/fs/metadata.yo - File metadata
 //
 // Wraps the low-level statx buffer with ergonomic accessors.
+// Uses Exception effect for error handling.
 //
 // Example:
 //   { metadata } :: import "std/fs/metadata";
 //
 //   main :: (fn(using(io : IO)) -> unit)({
-//     m := io.await(metadata(`/tmp/test.txt`));
-//     match(m,
-//       .Ok(meta) => {
-//         printf("size: %lld\n", meta.size());
-//         printf("is file: %d\n", i32(meta.is_file()));
-//       },
-//       .Err(e) => printf("error\n")
-//     );
+//     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`)));
+//     printf("size: %lld\n", m.size());
+//     printf("is file: %d\n", i32(m.is_file()));
 //   });
 
 { GlobalAllocator } :: import "../allocator";
@@ -21,6 +23,7 @@
 open import "../string";
 { Path } :: import "../path";
 { IOError } :: import "../sys/errors";
+{ Error, AnyError, Exception } :: import "../error";
 { Statx } :: import "../sys/statx";
 IO_file :: import "../sys/file";
 {
@@ -126,8 +129,8 @@ extern "Yo",
 // Internal helper to stat a path
 // ============================================================================
 
-_stat_path :: (fn(path: Path, flags: i32, using(io : IO)) -> Impl(Future(Result(Metadata, IOError), IO)))(
-  io.async((using(io)) => {
+_stat_path :: (fn(path: Path, flags: i32, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))(
+  io.async((using(io, exn)) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     buf_size := __yo_statx_buf_size();
@@ -136,34 +139,32 @@ _stat_path :: (fn(path: Path, flags: i32, using(io : IO)) -> Impl(Future(Result(
     cond(
       (result < i32(0)) => {
         free(.Some(*(void)(buf)));
-        (ret : Result(Metadata, IOError)) = .Err(IOError.from_errno((i32(0) - result)));
-        return ret;
+        exn.throw(dyn IOError.from_errno((i32(0) - result)))
       },
       true => {
         sx := Statx(_buf_ptr: buf, _buf_size: buf_size);
-        (ret : Result(Metadata, IOError)) = .Ok(Metadata(_statx: sx, _buf_ptr: buf));
-        return ret;
+        Metadata(_statx: sx, _buf_ptr: buf)
       }
     )
   })
 );
 
 // Get metadata for a path (follows symlinks).
-metadata :: (fn(path: Path, using(io : IO)) -> Impl(Future(Result(Metadata, IOError), IO)))
-  _stat_path(path, AT_STATX_SYNC_AS_STAT, using(io))
+metadata :: (fn(path: Path, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))
+  _stat_path(path, AT_STATX_SYNC_AS_STAT)
 ;
 
-metadata_str :: (fn(path: str, using(io : IO)) -> Impl(Future(Result(Metadata, IOError), IO)))
-  metadata(Path.new(String.from(path)), using(io))
+metadata_str :: (fn(path: str, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))
+  metadata(Path.new(String.from(path)))
 ;
 
 // Get metadata for a path (does NOT follow symlinks).
-symlink_metadata :: (fn(path: Path, using(io : IO)) -> Impl(Future(Result(Metadata, IOError), IO)))
-  _stat_path(path, (AT_SYMLINK_NOFOLLOW | AT_STATX_SYNC_AS_STAT), using(io))
+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_str :: (fn(path: str, using(io : IO)) -> Impl(Future(Result(Metadata, IOError), IO)))
-  symlink_metadata(Path.new(String.from(path)), using(io))
+symlink_metadata_str :: (fn(path: str, using(io : IO)) -> Impl(Future(Metadata, IO, Exception)))
+  symlink_metadata(Path.new(String.from(path)))
 ;
 
 export metadata, metadata_str, symlink_metadata, symlink_metadata_str;