@shd101wyy/yo 0.1.27 → 0.1.29

package/std/fs/temp.yo

@@ -5,16 +5,10 @@
 //! ```rust
 //! { TempDir } :: import "std/fs/temp";
 //!
-//! main :: (fn(using(io : IO)) -> unit)({
-//!   given(exn) : Exception = {
-//!     throw : (fn(forall(T : Type), error: AnyError) -> T)(
-//!       { println(error.to_string()); exit(i32(1)); }
-//!     )
-//!   };
-//!
-//!   dir := io.await(TempDir.new());
+//! main :: (fn(io : IO, exn : Exception) -> unit)({
+//!   dir := io.await(TempDir.new(io), { io, exn });
 //!   println(dir.path());
-//!   io.await(dir.remove());
+//!   io.await(dir.remove(io), { io, exn });
 //! });
 //! ```
 { GlobalAllocator } :: import("../allocator");
@@ -23,7 +17,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");
 _file_mod :: import("./file");
 _dir_mod :: import("./dir");
 IO_temp :: import("../sys/temp");
@@ -59,8 +53,8 @@ TempDir :: object(
 impl(
   TempDir,
   // Create a temporary directory in the given parent directory.
-  new_in : (fn(parent : Path, using(io : IO)) -> Impl(Future(TempDir, IO, Exception)))(
-    io.async((using(io, exn)) => {
+  new_in : (fn(parent : Path, io : IO) -> Impl(Future(TempDir, IOErr)))(
+    io.async((e) => {
       // Build template: parent/yo_tmp_XXXXXX
       template_path := parent.join(Path.new(`yo_tmp_XXXXXX`));
       template_str := template_path.to_string();
@@ -74,7 +68,7 @@ impl(
       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 => ()
       );
@@ -84,22 +78,22 @@ impl(
     })
   ),
   // Create a temporary directory in the system temp dir.
-  new : (fn(using(io : IO)) -> Impl(Future(TempDir, IO, Exception)))(
-    TempDir.new_in(Path.new(_default_tmp_dir()))
+  new : (fn(io : IO) -> Impl(Future(TempDir, IOErr)))(
+    TempDir.new_in(Path.new(_default_tmp_dir()), io)
   ),
   // Get the path of the temporary directory.
   path : (fn(self : Self) -> Path)(
     self._path
   ),
   // Remove the temporary directory.
-  remove : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  remove : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
     self_path := self._path;
     io.async(
-      (using(io, exn)) =>
+      (e) =>
         cond(
           self._removed => (),
           true => {
-            io.await(_dir_mod.remove_dir(self_path));
+            e.io.await(_dir_mod.remove_dir(self_path, io), e);
             self._removed = true;
           }
         )
@@ -116,8 +110,8 @@ TempFile :: object(
 impl(
   TempFile,
   // Create a temporary file in the given parent directory.
-  new_in : (fn(parent : Path, using(io : IO)) -> Impl(Future(TempFile, IO, Exception)))(
-    io.async((using(io, exn)) => {
+  new_in : (fn(parent : Path, io : IO) -> Impl(Future(TempFile, IOErr)))(
+    io.async((e) => {
       // Build template: parent/yo_tmp_XXXXXX
       template_path := parent.join(Path.new(`yo_tmp_XXXXXX`));
       template_str := template_path.to_string();
@@ -130,7 +124,7 @@ impl(
       cond(
         (fd < i32(0)) => {
           free(.Some(*(void)(buf)));
-          exn.throw(dyn(IOError.from_errno(i32(0) - fd)));
+          e.exn.throw(dyn(IOError.from_errno(i32(0) - fd)));
         },
         true => ()
       );
@@ -142,8 +136,8 @@ impl(
     })
   ),
   // Create a temporary file in the system temp dir.
-  new : (fn(using(io : IO)) -> Impl(Future(TempFile, IO, Exception)))(
-    TempFile.new_in(Path.new(_default_tmp_dir()))
+  new : (fn(io : IO) -> Impl(Future(TempFile, IOErr)))(
+    TempFile.new_in(Path.new(_default_tmp_dir()), io)
   ),
   // Get the underlying File object.
   file : (fn(self : Self) -> _file_mod.File)(
@@ -154,16 +148,16 @@ impl(
     self._path
   ),
   // Remove the temporary file.
-  remove : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  remove : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
     self_file := self._file;
     self_path := self._path;
     io.async(
-      (using(io, exn)) =>
+      (e) =>
         cond(
           self._removed => (),
           true => {
-            io.await(self_file.close());
-            io.await(_dir_mod.remove_file(self_path));
+            e.io.await(self_file.close(io), e);
+            e.io.await(_dir_mod.remove_file(self_path, io), e);
             self._removed = true;
           }
         )

package/std/fs/walker.yo

@@ -5,14 +5,8 @@
 //! ```rust
 //! { walk, WalkEntry } :: import "std/fs/walker";
 //!
-//! main :: (fn(using(io : IO)) -> unit)({
-//!   given(exn) : Exception = {
-//!     throw : (fn(forall(T : Type), error: AnyError) -> T)(
-//!       { println(error.to_string()); exit(i32(1)); }
-//!     )
-//!   };
-//!
-//!   entries := io.await(walk(`/tmp`));
+//! main :: (fn(io : IO, exn : Exception) -> unit)({
+//!   entries := io.await(walk(Path.new(`/tmp`), io), { io, exn });
 //!   i := usize(0);
 //!   while runtime((i < entries.len())), {
 //!     e := entries.get(i).unwrap();
@@ -25,7 +19,7 @@
 open(import("../string"));
 { Path } :: import("../path");
 { IOError } :: import("../sys/errors");
-{ Error, AnyError, Exception } :: import("../error");
+{ Error, AnyError, Exception, IOErr } :: import("../error");
 { FileType } :: import("./dir");
 { DirEntry } :: import("./dir");
 _dir :: import("./dir");
@@ -67,9 +61,9 @@ _join_path :: (fn(base : String, name : String) -> String)(
 // Walk functions
 // ============================================================================
 // Walk a directory tree with custom options.
-walk_with :: (fn(root : Path, options : WalkOptions, using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))({
+walk_with :: (fn(root : Path, options : WalkOptions, io : IO) -> Impl(Future(ArrayList(WalkEntry), IOErr)))({
   root_s := root.to_string();
-  io.async((using(io, exn)) => {
+  io.async((e) => {
     results := ArrayList(WalkEntry).new();
     // Stack of (path, depth) pairs to process
     stack := ArrayList(struct(path : String, depth : u32)).new();
@@ -86,7 +80,7 @@ walk_with :: (fn(root : Path, options : WalkOptions, using(io : IO)) -> Impl(Fut
       );
       cond(
         should_continue => {
-          entries := io.await(_dir.read_dir(Path.new(cur_path)));
+          entries := e.io.await(_dir.read_dir(Path.new(cur_path), e.io), e);
           i := usize(0);
           while(runtime(i < entries.len()), {
             entry := entries.get(i).unwrap();
@@ -130,10 +124,10 @@ walk_with :: (fn(root : Path, options : WalkOptions, using(io : IO)) -> Impl(Fut
     results
   })
 });
-walk_with_cstr :: (fn(root : *(u8), options : WalkOptions, using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))(
-  walk_with(Path.from_cstr(root), options)
+walk_with_cstr :: (fn(root : *(u8), options : WalkOptions, io : IO) -> Impl(Future(ArrayList(WalkEntry), IOErr)))(
+  walk_with(Path.from_cstr(root), options, io)
 );
 /// Walk a directory tree with default options.
-walk :: (fn(root : Path, using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))(walk_with(root, WalkOptions.defaults()));
-walk_cstr :: (fn(root : *(u8), using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))(walk(Path.from_cstr(root)));
+walk :: (fn(root : Path, io : IO) -> Impl(Future(ArrayList(WalkEntry), IOErr)))(walk_with(root, WalkOptions.defaults(), io));
+walk_cstr :: (fn(root : *(u8), io : IO) -> Impl(Future(ArrayList(WalkEntry), IOErr)))(walk(Path.from_cstr(root), io));
 export(walk, walk_cstr, walk_with, walk_with_cstr);

package/std/http/client.yo

@@ -8,12 +8,8 @@
 //   { fetch, HttpResponse } :: import "std/http";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(using(io : IO)) -> unit)({
-//     given(exn) := Exception(throw : ((err) -> {
-//       println(err.message());
-//       escape ();
-//     }));
-//     resp := io.await(fetch(`http://example.com/api/data`, using(io)));
+//   main :: (fn(io : IO, exn : Exception) -> unit)({
+//     resp := io.await(fetch(`http://example.com/api/data`, io), { io, exn });
 //     println(resp.body);
 //   });
 open(import("../string"));
@@ -21,7 +17,7 @@ open(import("../string"));
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 open(import("../fmt"));
-{ Error, AnyError, Exception } :: import("../error");
+{ Error, AnyError, Exception, IOErr } :: import("../error");
 { TcpStream } :: import("../net/tcp");
 { IpAddr, SocketAddr } :: import("../net/addr");
 { lookup_host } :: import("../net/dns");
@@ -179,14 +175,14 @@ _find_content_length :: (fn(data : ArrayList(u8), header_end : usize) -> i32)({
 // ============================================================================
 // Internal: read full HTTP response from a TCP stream
 // ============================================================================
-_read_http_response :: (fn(stream : TcpStream, using(io : IO, exn : Exception)) -> String)({
+_read_http_response :: (fn(stream : TcpStream, e : IOErr) -> String)({
   buf_size := usize(8192);
   buf := *(u8)(malloc(buf_size).unwrap());
   result := ArrayList(u8).new();
   // Read until connection closes or we've read the full response
   done := false;
   while(runtime(!(done)), {
-    n := io.await(stream.read(buf, buf_size, using(io)));
+    n := e.io.await(stream.read(buf, buf_size, e.io), e);
     cond(
       (n <= i32(0)) => {
         done = true;
@@ -243,15 +239,15 @@ _read_http_response :: (fn(stream : TcpStream, using(io : IO, exn : Exception))
 ///
 /// ```rust
 /// opts := FetchOptions.new().with_method(.POST).with_body(`{"key": "value"}`);
-/// resp := io.await(fetch_with(`http://example.com/api`, opts, using(io)));
+/// resp := io.await(fetch_with(`http://example.com/api`, opts, io), { io, exn });
 /// ```
 fetch_with :: (
-  fn(url_str : String, opts : FetchOptions, using(io : IO)) ->
-    Impl(Future(HttpResponse, IO, Exception))
+  fn(url_str : String, opts : FetchOptions, io : IO) ->
+    Impl(Future(HttpResponse, IOErr))
 )(
-  io.async((using(io : IO, exn : Exception)) => {
+  io.async((e) => {
     // Parse URL
-    url := Url.parse(url_str.as_str(), using(exn));
+    url := Url.parse(url_str.as_str(), e.exn);
     // Validate scheme
     scheme := url.scheme();
     is_http := (scheme == `http`);
@@ -259,7 +255,7 @@ fetch_with :: (
     cond(
       (is_http || is_https) => (),
       true => {
-        exn.throw(dyn(HttpError.UnsupportedScheme(scheme)));
+        e.exn.throw(dyn(HttpError.UnsupportedScheme(scheme)));
       }
     );
     // Extract host
@@ -267,7 +263,7 @@ fetch_with :: (
       url.host(),
       .Some(h) => h,
       .None => {
-        exn.throw(dyn(HttpError.InvalidUrl(`missing host`)));
+        e.exn.throw(dyn(HttpError.InvalidUrl(`missing host`)));
         `_` // unreachable
       }
     );
@@ -281,17 +277,17 @@ fetch_with :: (
       )
     );
     // Resolve hostname to IP
-    addrs := io.await(lookup_host(host, using(io)));
+    addrs := e.io.await(lookup_host(host, e.io), e);
     cond(
       (addrs.len() == usize(0)) => {
-        exn.throw(dyn(HttpError.ConnectionFailed(`DNS resolution failed for ${host}`)));
+        e.exn.throw(dyn(HttpError.ConnectionFailed(`DNS resolution failed for ${host}`)));
       },
       true => ()
     );
     ip := addrs.get(usize(0)).unwrap();
     addr := SocketAddr.new(ip, port);
     // Connect
-    stream := io.await(TcpStream.connect(addr, using(io)));
+    stream := e.io.await(TcpStream.connect(addr, e.io), e);
     // Build the request path (include query string if present)
     req_path := url.path();
     cond(
@@ -329,17 +325,17 @@ fetch_with :: (
     req.set_header(`Connection`, `close`);
     // Send request
     req_str := req.to_string();
-    io.await(stream.write_string(req_str, using(io)));
+    e.io.await(stream.write_string(req_str, e.io), e);
     // Read response
-    raw_response := _read_http_response(stream, using(io, exn));
+    raw_response := _read_http_response(stream, e);
     // Close connection
-    io.await(stream.close(using(io)));
+    e.io.await(stream.close(e.io), e);
     // Parse response
     match(
       parse_response(raw_response),
       .Ok(resp) => resp,
-      .Err(e) => {
-        exn.throw(dyn(HttpError.Other(e)));
+      .Err(err) => {
+        e.exn.throw(dyn(HttpError.Other(err)));
         HttpResponse.new(i32(0), ``) // unreachable
       }
     )
@@ -352,15 +348,15 @@ export(fetch_with);
 /// # Example
 ///
 /// ```rust
-/// resp := io.await(fetch(`http://example.com`, using(io)));
+/// resp := io.await(fetch(`http://example.com`, io), { io, exn });
 /// cond(resp.is_ok() => println(resp.body), true => println(`Error`));
 /// ```
 fetch :: (
-  fn(url_str : String, using(io : IO)) ->
-    Impl(Future(HttpResponse, IO, Exception))
+  fn(url_str : String, io : IO) ->
+    Impl(Future(HttpResponse, IOErr))
 )(
-  io.async((using(io : IO, exn : Exception)) => {
-    return(io.await(fetch_with(url_str, FetchOptions.new(), using(io))));
+  io.async((e) => {
+    return(e.io.await(fetch_with(url_str, FetchOptions.new(), e.io), e));
   })
 );
 export(fetch);

package/std/http/index.yo

@@ -5,12 +5,12 @@
 //   { HttpRequest, HttpResponse, fetch } :: import "std/http";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(using(io : IO)) -> unit)({
-//     given(exn) := Exception(throw : ((err) -> {
+//   main :: (fn(io : IO) -> unit)({
+//     exn := Exception(throw : ((err) -> {
 //       println(err.message());
-//       escape ();
+//       unwind ();
 //     }));
-//     resp := io.await(fetch(`http://example.com`, using(io)));
+//     resp := io.await(fetch(`http://example.com`, io));
 //     println(resp.body);
 //   });
 _http :: import("./http.yo");

package/std/io/reader.yo

@@ -5,6 +5,6 @@ Reader :: trait(
   /// Read up to `size` bytes into buffer `buf`.
   /// Returns the number of bytes actually read (0 at end-of-stream).
   read :
-    fn(self : *(Self), buf : *(u8), size : usize, using(exn : Exception)) -> usize
+    fn(self : *(Self), buf : *(u8), size : usize, exn : Exception) -> usize
 );
 export(Reader);

package/std/io/writer.yo

@@ -4,9 +4,9 @@
 Writer :: trait(
   /// Write bytes from buffer. Returns number of bytes written.
   write :
-    fn(self : *(Self), buf : *(u8), size : usize, using(exn : Exception)) -> usize,
+    fn(self : *(Self), buf : *(u8), size : usize, exn : Exception) -> usize,
   /// Flush any buffered data to the underlying destination.
   flush :
-    fn(self : *(Self), using(exn : Exception)) -> unit
+    fn(self : *(Self), exn : Exception) -> unit
 );
 export(Writer);

package/std/net/addr.yo

@@ -33,7 +33,7 @@ impl(
   IpAddr,
   /// Parse an IPv4 address from a dotted-decimal `String` (e.g. "127.0.0.1").
   /// Throws on invalid input.
-  parse_v4 : (fn(s : String, using(exn : Exception)) -> IpAddr)({
+  parse_v4 : (fn(s : String, exn : Exception) -> IpAddr)({
     bytes := s.as_bytes();
     parts := Array(u8, usize(4)).fill(u8(0));
     part_idx := usize(0);

package/std/net/dns.yo

@@ -9,12 +9,8 @@
 //   { IpAddr } :: import "std/net/addr";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(using(io : IO)) -> unit)({
-//     given(exn) := Exception(throw : ((err) -> {
-//       println(err.message());
-//       escape ();
-//     }));
-//     addrs := io.await(lookup_host(`localhost`));
+//   main :: (fn(io : IO, exn : Exception) -> unit)({
+//     addrs := io.await(lookup_host(`localhost`, io), { io, exn });
 //     i := usize(0);
 //     while runtime((i < addrs.len())), {
 //       println(addrs.get(i).unwrap().to_string());
@@ -28,23 +24,23 @@ open(import("../string"));
 open(import("../fmt"));
 { NetError } :: import("./errors");
 { IpAddr, SocketAddr } :: import("./addr");
-{ Error, AnyError, Exception } :: import("../error");
+{ Error, AnyError, Exception, IOErr } :: import("../error");
 IO_dns :: import("../sys/dns");
 { AF_INET, AF_INET6 } :: import("../sys/socket");
 // ============================================================================
 // DNS lookup
 // ============================================================================
 /// Resolve a hostname to a list of IP addresses.
-lookup_host :: (fn(host : String, using(io : IO)) -> Impl(Future(ArrayList(IpAddr), IO, Exception)))(
-  io.async((using(io : IO, exn : Exception)) => {
+lookup_host :: (fn(host : String, io : IO) -> Impl(Future(ArrayList(IpAddr), IOErr)))(
+  io.async((e) => {
     host_cstr_bytes := host.to_cstr();
     host_cstr := host_cstr_bytes.ptr().unwrap();
     result_ptr := IO_dns.alloc_result();
-    ret := io.await(IO_dns.getaddrinfo(host_cstr,.None,.None, result_ptr));
+    ret := e.io.await(IO_dns.getaddrinfo(host_cstr,.None,.None, result_ptr), e.io);
     cond(
       (ret != i32(0)) => {
         IO_dns.free_result(result_ptr);
-        exn.throw(dyn(NetError.DNSFailed(host)));
+        e.exn.throw(dyn(NetError.DNSFailed(host)));
       },
       true => ()
     );
@@ -86,9 +82,9 @@ lookup_host :: (fn(host : String, using(io : IO)) -> Impl(Future(ArrayList(IpAdd
   })
 );
 /// Resolve a hostname and port to a list of socket addresses.
-resolve :: (fn(host : String, port : u16, using(io : IO)) -> Impl(Future(ArrayList(SocketAddr), IO, Exception)))(
-  io.async((using(io : IO, exn : Exception)) => {
-    addrs := io.await(lookup_host(host, using(io)));
+resolve :: (fn(host : String, port : u16, io : IO) -> Impl(Future(ArrayList(SocketAddr), IOErr)))(
+  io.async((e) => {
+    addrs := e.io.await(lookup_host(host, io), e);
     result := ArrayList(SocketAddr).new();
     i := usize(0);
     while(runtime(i < addrs.len()), {

package/std/net/errors.yo

@@ -84,7 +84,7 @@ impl(
   NetError,
   /// Check a raw syscall result and throw on error.
   /// Positive values are returned as-is; negative values are converted to a `NetError` and thrown.
-  check : (fn(result : i32, using(exn : Exception)) -> i32)(
+  check : (fn(result : i32, exn : Exception) -> i32)(
     cond(
       (result >= i32(0)) => result,
       true => exn.throw(dyn(Self.from_io(IOError.from_errno(i32(0) - result))))