@shd101wyy/yo 0.1.28 → 0.1.29

package/package.json

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

package/std/async.yo

@@ -1,7 +1,7 @@
 //! Async utilities for cooperative task scheduling.
 /// Suspend the current async task, allowing other tasks to run on the event loop.
 /// Implemented as an immediately-completing async block that forces a suspension point.
-yield :: (fn(using(io : IO)) -> Impl(Future(unit)))(
+yield :: (fn(io : IO) -> Impl(Future(unit)))(
   io.async(() => {
     return(());
   })

package/std/crypto/random.yo

@@ -54,7 +54,7 @@ extern(
 // ============================================================================
 // Fill a buffer with cryptographically secure random bytes.
 // ============================================================================
-random_bytes :: (fn(buf : *(u8), size : usize, using(exn : Exception)) -> unit)(
+random_bytes :: (fn(buf : *(u8), size : usize, exn : Exception) -> unit)(
   cond(
     (platform == Platform.Macos) => {
       __yo_arc4random_buf(buf, size);
@@ -104,7 +104,7 @@ export(random_bytes);
 // ============================================================================
 // Typed helpers
 // ============================================================================
-random_u32 :: (fn(using(exn : Exception)) -> u32)({
+random_u32 :: (fn(exn : Exception) -> u32)({
   buf := Array(u8, usize(4)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));
   random_bytes(buf_ptr, usize(4));
@@ -113,16 +113,16 @@ random_u32 :: (fn(using(exn : Exception)) -> u32)({
       (u32(buf(usize(2))) << u32(16)) |
         (u32(buf(usize(3))) << u32(24))
       });
-random_u64 :: (fn(using(exn : Exception)) -> u64)({
+random_u64 :: (fn(exn : Exception) -> u64)({
   lo := u64(random_u32());
   hi := u64(random_u32());
   lo | (hi << u64(32))
 });
-random_f64 :: (fn(using(exn : Exception)) -> f64)(
+random_f64 :: (fn(exn : Exception) -> f64)(
   f64(random_u64()) / f64(18446744073709551615.0)
 );
 // Return a random integer in the half-open range [min, max).
-random_range :: (fn(min : i64, max : i64, using(exn : Exception)) -> i64)({
+random_range :: (fn(min : i64, max : i64, exn : Exception) -> i64)({
   span := (max - min);
   cond(
     (span <= i64(0)) => min,
@@ -137,7 +137,7 @@ export(random_u32, random_u64, random_f64, random_range);
 // UUID v4
 // ============================================================================
 // Generate a random UUID v4 string: "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
-uuid_v4 :: (fn(using(exn : Exception)) -> String)({
+uuid_v4 :: (fn(exn : Exception) -> String)({
   bytes := ArrayList(u8).with_capacity(usize(16));
   buf := Array(u8, usize(16)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));

package/std/encoding/base64.yo

@@ -64,7 +64,7 @@ export(base64_encode, base64_encode_url);
 // ============================================================================
 // Decoding
 // ============================================================================
-_decode_char :: (fn(c : u8, alpha : str, using(exn : Exception)) -> u8)({
+_decode_char :: (fn(c : u8, alpha : str, exn : Exception) -> u8)({
   i := usize(0);
   while(i < usize(64), i = (i + usize(1)), {
     cond(
@@ -76,7 +76,7 @@ _decode_char :: (fn(c : u8, alpha : str, using(exn : Exception)) -> u8)({
   });
   exn.throw(dyn(EncodingError.InvalidChar(c)))
 });
-_decode_with :: (fn(s : str, alpha : str, using(exn : Exception)) -> ArrayList(u8))({
+_decode_with :: (fn(s : str, alpha : str, exn : Exception) -> ArrayList(u8))({
   // Strip trailing padding
   len := s.len();
   while((len > usize(0)) && (s.bytes(len - usize(1)) == _PAD), len = (len - usize(1)), ());
@@ -107,11 +107,11 @@ _decode_with :: (fn(s : str, alpha : str, using(exn : Exception)) -> ArrayList(u
   out
 });
 /// Decode a standard base64 string to bytes. Throws via `Exception` on invalid input.
-base64_decode :: (fn(s : str, using(exn : Exception)) -> ArrayList(u8))(
+base64_decode :: (fn(s : str, exn : Exception) -> ArrayList(u8))(
   _decode_with(s, _STD_ALPHA)
 );
 /// Decode a URL-safe base64 string to bytes. Throws via `Exception` on invalid input.
-base64_decode_url :: (fn(s : str, using(exn : Exception)) -> ArrayList(u8))(
+base64_decode_url :: (fn(s : str, exn : Exception) -> ArrayList(u8))(
   _decode_with(s, _URL_ALPHA)
 );
 export(base64_decode, base64_decode_url);

package/std/encoding/hex.yo

@@ -64,7 +64,7 @@ export(hex_encode);
 // ============================================================================
 // Decoding
 // ============================================================================
-_hex_nibble :: (fn(c : u8, using(exn : Exception)) -> u8)(
+_hex_nibble :: (fn(c : u8, exn : Exception) -> u8)(
   cond(
     ((c >= u8(48)) && (c <= u8(57))) => (c - u8(48)),
     // '0'-'9'
@@ -76,7 +76,7 @@ _hex_nibble :: (fn(c : u8, using(exn : Exception)) -> u8)(
   )
 );
 /// Decode a hexadecimal string to bytes. Throws via `Exception` on invalid input.
-hex_decode :: (fn(s : str, using(exn : Exception)) -> ArrayList(u8))({
+hex_decode :: (fn(s : str, exn : Exception) -> ArrayList(u8))({
   cond(
     ((s.len() % usize(2)) != usize(0)) => {
       exn.throw(dyn(EncodingError.OddLength));

package/std/encoding/json.yo

@@ -8,7 +8,7 @@
 //! { json_parse, json_stringify, JsonValue } :: import "std/encoding/json";
 //! { Exception } :: import "std/error";
 //!
-//! given(exn) := Exception(throw : ((err) -> { escape (); }));
+//! exn := Exception(throw : ((err) -> { unwind (); }));
 //! v := json_parse(`{"x": 1}`);
 //! println(json_stringify(v));
 //! ```
@@ -30,7 +30,7 @@ JsonError :: enum(
   InvalidNumber,
   /// Invalid escape sequence in a string.
   InvalidEscape,
-  /// Invalid Unicode escape in a string.
+  /// Invalid Unicode unwind in a string.
   InvalidUnicode,
   /// Other error with a descriptive message.
   Other(msg : String)
@@ -553,7 +553,7 @@ _parse_value :: (fn(p : _Parser) -> Result(JsonValue, JsonError))({
 // Public API
 // ============================================================================
 /// Parse a JSON string into a `JsonValue` tree. Throws via `Exception` on invalid input.
-json_parse :: (fn(s : str, using(exn : Exception)) -> JsonValue)({
+json_parse :: (fn(s : str, exn : Exception) -> JsonValue)({
   p := _Parser.new(s);
   match(
     _parse_value(p),

package/std/encoding/utf16.yo

@@ -68,7 +68,7 @@ export(utf8_to_utf16);
 ///
 /// Decodes surrogate pairs back into supplementary code points.
 /// Throws via `Exception` on unpaired surrogates.
-utf16_to_utf8 :: (fn(data : ArrayList(u16), using(exn : Exception)) -> String)({
+utf16_to_utf8 :: (fn(data : ArrayList(u16), exn : Exception) -> String)({
   out := ArrayList(u8).new();
   i := usize(0);
   while(i < data.len(), {

package/std/error.yo

@@ -15,15 +15,27 @@ export(AnyError);
 impl(String, Error());
 /// Non-resumable exception handling effect record.
 /// Use `throw` to raise an `AnyError` and abort the current computation.
+/// `throw` is `ctl(...)` — handler body may contain `unwind`, and the
+/// handler value is frame-bound (see plans/EXPLICIT_EFFECTS.md §4).
 Exception :: struct(
-  throw : (fn(forall(ResumeType : Type), error : AnyError) -> ResumeType)
+  throw : (ctl(forall(ResumeType : Type), error : AnyError) -> ResumeType)
 );
 export(Exception);
 /// Creates a resumable exception effect record parameterized by the resume type.
 /// Unlike `Exception`, the handler can return a value to resume the computation.
+/// `throw` is still `ctl(...)` because the handler MAY choose to unwind;
+/// regular `fn` returns are also valid via subtyping `fn <: ctl`.
 ResumableException :: (fn(comptime(ResumeType) : Type) -> comptime(Type))(
   struct(
-    throw : (fn(error : AnyError) -> ResumeType)
+    throw : (ctl(error : AnyError) -> ResumeType)
   )
 );
 export(ResumableException);
+/// Common effect bundle: IO + Exception.
+/// Used as the effect parameter for Futures that perform IO and may throw.
+/// Construct with `{ io, exn }`; project with `e.io` or `e.exn`.
+IOErr :: struct(
+  io : IO,
+  exn : Exception
+);
+export(IOErr);

package/std/fs/dir.yo

@@ -8,16 +8,10 @@
 //! { create_dir, remove_dir, read_dir } :: import "std/fs/dir";
 //! { Path } :: import "std/path";
 //!
-//! main :: (fn(using(io : IO)) -> unit)({
-//!   given(exn) : Exception = {
-//!     throw : (fn(forall(T : Type), error: AnyError) -> T)(
-//!       { println(error.to_string()); exit(i32(1)); }
-//!     )
-//!   };
-//!
-//!   io.await(create_dir(Path.new(`/tmp/yo_test`)));
-//!   entries := io.await(read_dir(Path.new(`/tmp/yo_test`)));
-//!   io.await(remove_dir(Path.new(`/tmp/yo_test`)));
+//! main :: (fn(io : IO, exn : Exception) -> unit)({
+//!   io.await(create_dir(Path.new(`/tmp/yo_test`), io), { io, exn });
+//!   entries := io.await(read_dir(Path.new(`/tmp/yo_test`), io), { io, exn });
+//!   io.await(remove_dir(Path.new(`/tmp/yo_test`), io), { io, exn });
 //! });
 //! ```
 { GlobalAllocator } :: import("../allocator");
@@ -26,7 +20,7 @@
 open(import("../string"));
 { Path } :: import("../path");
 { IOError } :: import("../sys/errors");
-{ Error, AnyError, Exception } :: import("../error");
+{ Error, AnyError, Exception, IOErr } :: import("../error");
 { EEXIST, ENOENT } :: import("../libc/errno");
 IO_dir :: import("../sys/dir");
 IO_file :: import("../sys/file");
@@ -61,30 +55,30 @@ export(DirEntry);
 // Directory operations
 // ============================================================================
 /// Create a directory at the given path.
-create_dir :: (fn(path : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  io.async((using(io, exn)) => {
+create_dir :: (fn(path : Path, io : IO) -> Impl(Future(unit, IOErr)))(
+  io.async((e) => {
     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)));
+    result := e.io.await(IO_dir.mkdir(AT_FDCWD, cstr, i32(DEFAULT_DIR_MODE)), 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 => ()
     )
   })
 );
 /// Create a directory (`str` path variant).
-create_dir_str :: (fn(path : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  create_dir(Path.new(String.from(path)))
+create_dir_str :: (fn(path : str, io : IO) -> Impl(Future(unit, IOErr)))(
+  create_dir(Path.new(String.from(path)), io)
 );
 /// 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)))(
-  io.async((using(io, exn)) => {
+create_dir_all :: (fn(path : Path, io : IO) -> Impl(Future(unit, IOErr)))(
+  io.async((e) => {
     path_s := path.to_string();
     cstr_bytes := path_s.to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
     // Try creating the directory directly first
-    result := io.await(IO_dir.mkdir(AT_FDCWD, cstr, i32(DEFAULT_DIR_MODE)));
+    result := e.io.await(IO_dir.mkdir(AT_FDCWD, cstr, i32(DEFAULT_DIR_MODE)), e.io);
     cond(
       (result >= i32(0)) => (),
       true => {
@@ -126,11 +120,11 @@ create_dir_all :: (fn(path : Path, using(io : IO)) -> Impl(Future(unit, IO, Exce
                   prefix := path_s.substring(usize(0), i);
                   prefix_cstr_bytes := prefix.to_cstr();
                   prefix_cstr := prefix_cstr_bytes.ptr().unwrap();
-                  r := io.await(IO_dir.mkdir(AT_FDCWD, prefix_cstr, i32(DEFAULT_DIR_MODE)));
+                  r := e.io.await(IO_dir.mkdir(AT_FDCWD, prefix_cstr, i32(DEFAULT_DIR_MODE)), e.io);
                   // Ignore EEXIST errors
                   cond(
                     ((r < i32(0)) && ((i32(0) - r) != i32(EEXIST))) => {
-                      exn.throw(dyn(IOError.from_errno(i32(0) - r)));
+                      e.exn.throw(dyn(IOError.from_errno(i32(0) - r)));
                     },
                     true => ()
                   );
@@ -140,114 +134,114 @@ create_dir_all :: (fn(path : Path, using(io : IO)) -> Impl(Future(unit, IO, Exce
               i = (i + usize(1));
             });
             // Create the final directory
-            final_result := io.await(IO_dir.mkdir(AT_FDCWD, cstr, i32(DEFAULT_DIR_MODE)));
+            final_result := e.io.await(IO_dir.mkdir(AT_FDCWD, cstr, i32(DEFAULT_DIR_MODE)), e.io);
             cond(
               (final_result >= i32(0)) => (),
               true => {
                 final_errno := (i32(0) - final_result);
                 cond(
                   (final_errno == i32(EEXIST)) => (),
-                  true => exn.throw(dyn(IOError.from_errno(final_errno)))
+                  true => e.exn.throw(dyn(IOError.from_errno(final_errno)))
                 )
               }
             )
           },
-          true => exn.throw(dyn(IOError.from_errno(errno)))
+          true => e.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(Path.new(String.from(path)))
+create_dir_all_str :: (fn(path : str, io : IO) -> Impl(Future(unit, IOErr)))(
+  create_dir_all(Path.new(String.from(path)), io)
 );
 /// Remove an empty directory. Throws if the directory is not empty.
-remove_dir :: (fn(path : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  io.async((using(io, exn)) => {
+remove_dir :: (fn(path : Path, io : IO) -> Impl(Future(unit, IOErr)))(
+  io.async((e) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
-    result := io.await(IO_dir.unlink(AT_FDCWD, cstr, AT_REMOVEDIR));
+    result := e.io.await(IO_dir.unlink(AT_FDCWD, cstr, AT_REMOVEDIR), 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 => ()
     )
   })
 );
-remove_dir_str :: (fn(path : str, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  remove_dir(Path.new(String.from(path)))
+remove_dir_str :: (fn(path : str, io : IO) -> Impl(Future(unit, IOErr)))(
+  remove_dir(Path.new(String.from(path)), io)
 );
 /// Remove a file at the given path.
-remove_file :: (fn(path : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  io.async((using(io, exn)) => {
+remove_file :: (fn(path : Path, io : IO) -> Impl(Future(unit, IOErr)))(
+  io.async((e) => {
     cstr_bytes := path.to_string().to_cstr();
     cstr := cstr_bytes.ptr().unwrap();
-    result := io.await(IO_dir.unlink(AT_FDCWD, cstr, i32(0)));
+    result := e.io.await(IO_dir.unlink(AT_FDCWD, cstr, i32(0)), 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 => ()
     )
   })
 );
-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, io : IO) -> Impl(Future(unit, IOErr)))(remove_file(Path.new(String.from(path)), io));
 /// 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)))(
-  io.async((using(io, exn)) => {
+rename :: (fn(from : Path, to : Path, io : IO) -> Impl(Future(unit, IOErr)))(
+  io.async((e) => {
     from_cstr_bytes := from.to_string().to_cstr();
     from_cstr := from_cstr_bytes.ptr().unwrap();
     to_cstr_bytes := to.to_string().to_cstr();
     to_cstr := to_cstr_bytes.ptr().unwrap();
-    result := io.await(IO_dir.rename(AT_FDCWD, from_cstr, AT_FDCWD, to_cstr));
+    result := e.io.await(IO_dir.rename(AT_FDCWD, from_cstr, AT_FDCWD, to_cstr), 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 => ()
     )
   })
 );
-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, io : IO) -> Impl(Future(unit, IOErr)))(rename(Path.new(String.from(from)), Path.new(String.from(to)), io));
 /// Create a hard link from `src` to `dst`.
-hard_link :: (fn(src : Path, dst : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  io.async((using(io, exn)) => {
+hard_link :: (fn(src : Path, dst : Path, io : IO) -> Impl(Future(unit, IOErr)))(
+  io.async((e) => {
     src_cstr_bytes := src.to_string().to_cstr();
     src_cstr := src_cstr_bytes.ptr().unwrap();
     dst_cstr_bytes := dst.to_string().to_cstr();
     dst_cstr := dst_cstr_bytes.ptr().unwrap();
-    result := io.await(IO_dir.link(AT_FDCWD, src_cstr, AT_FDCWD, dst_cstr, i32(0)));
+    result := e.io.await(IO_dir.link(AT_FDCWD, src_cstr, AT_FDCWD, dst_cstr, i32(0)), 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 => ()
     )
   })
 );
-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, io : IO) -> Impl(Future(unit, IOErr)))(hard_link(Path.new(String.from(src)), Path.new(String.from(dst)), io));
 /// Create a symbolic link at `dst` pointing to `src`.
-symlink :: (fn(src : Path, dst : Path, using(io : IO)) -> Impl(Future(unit, IO, Exception)))(
-  io.async((using(io, exn)) => {
+symlink :: (fn(src : Path, dst : Path, io : IO) -> Impl(Future(unit, IOErr)))(
+  io.async((e) => {
     src_cstr_bytes := src.to_string().to_cstr();
     src_cstr := src_cstr_bytes.ptr().unwrap();
     dst_cstr_bytes := dst.to_string().to_cstr();
     dst_cstr := dst_cstr_bytes.ptr().unwrap();
-    result := io.await(IO_dir.symlink(src_cstr, AT_FDCWD, dst_cstr));
+    result := e.io.await(IO_dir.symlink(src_cstr, AT_FDCWD, dst_cstr), 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 => ()
     )
   })
 );
-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, io : IO) -> Impl(Future(unit, IOErr)))(symlink(Path.new(String.from(src)), Path.new(String.from(dst)), io));
 // ============================================================================
 // 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)))(
-  io.async((using(io, exn)) => {
+read_dir :: (fn(path : Path, io : IO) -> Impl(Future(ArrayList(DirEntry), IOErr)))(
+  io.async((e) => {
     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 := e.io.await(IO_file.openat(AT_FDCWD, cstr, O_RDONLY | O_DIRECTORY, i32(0)), e.io);
     cond(
-      (fd_result < i32(0)) => exn.throw(dyn(IOError.from_errno(i32(0) - fd_result))),
+      (fd_result < i32(0)) => e.exn.throw(dyn(IOError.from_errno(i32(0) - fd_result))),
       true => ()
     );
     fd := fd_result;
@@ -255,12 +249,12 @@ read_dir :: (fn(path : Path, using(io : IO)) -> Impl(Future(ArrayList(DirEntry),
     buf_size := u32(4096);
     buf := *(u8)(malloc(usize(buf_size)).unwrap());
     while(runtime(true), {
-      n := io.await(IO_dir.getdents(fd, buf, buf_size));
+      n := e.io.await(IO_dir.getdents(fd, buf, buf_size), e.io);
       cond(
         (n < i32(0)) => {
           free(.Some(*(void)(buf)));
-          io.await(IO_file.close(fd));
-          exn.throw(dyn(IOError.from_errno(i32(0) - n)));
+          e.io.await(IO_file.close(fd), e.io);
+          e.exn.throw(dyn(IOError.from_errno(i32(0) - n)));
         },
         (n == i32(0)) => {
           break;
@@ -297,11 +291,11 @@ read_dir :: (fn(path : Path, using(io : IO)) -> Impl(Future(ArrayList(DirEntry),
       );
     });
     free(.Some(*(void)(buf)));
-    io.await(IO_file.close(fd));
+    e.io.await(IO_file.close(fd), e.io);
     entries
   })
 );
-read_dir_str :: (fn(path : str, using(io : IO)) -> Impl(Future(ArrayList(DirEntry), IO, Exception)))(read_dir(Path.new(String.from(path))));
+read_dir_str :: (fn(path : str, io : IO) -> Impl(Future(ArrayList(DirEntry), IOErr)))(read_dir(Path.new(String.from(path)), io));
 export(
   create_dir,
   create_dir_str,