@shd101wyy/yo 0.0.25 → 0.0.27

package/std/fs/temp.yo

@@ -7,14 +7,15 @@
 //   { TempDir } :: import "std/fs/temp";
 //
 //   main :: (fn(using(io : IO)) -> unit)({
-//     td := io.await(TempDir.new());
-//     match(td,
-//       .Ok(dir) => {
-//         println(dir.path());
-//         io.await(dir.remove());
-//       },
-//       .Err(e) => println(e.to_string())
-//     );
+//     given(exn) : Exception = {
+//       throw : (fn(forall(T : Type), error: AnyError) -> T)(
+//         { println(error.to_string()); exit(i32(1)); }
+//       )
+//     };
+//
+//     dir := io.await(TempDir.new());
+//     println(dir.path());
+//     io.await(dir.remove());
 //   });
 
 { GlobalAllocator } :: import "../allocator";
@@ -23,6 +24,7 @@ open import "../string";
 open import "../fmt";
 { Path } :: import "../path";
 { IOError } :: import "../sys/errors";
+{ Error, AnyError, Exception } :: import "../error";
 _file_mod :: import "./file";
 _dir_mod :: import "./dir";
 IO_temp :: import "../sys/temp";
@@ -61,8 +63,8 @@ TempDir :: object(
 
 impl(TempDir,
   // Create a temporary directory in the given parent directory.
-  new_in : (fn(parent: Path, using(io : IO)) -> Impl(Future(Result(TempDir, IOError), IO)))(
-    io.async((using(io : IO)) => {
+  new_in : (fn(parent: Path, using(io : IO)) -> Impl(Future(TempDir, IO, Exception)))(
+    io.async((using(io, exn)) => {
       // Build template: parent/yo_tmp_XXXXXX
       template_path := parent.join(Path.new(`yo_tmp_XXXXXX`));
       template_str := template_path.to_string();
@@ -76,22 +78,19 @@ impl(TempDir,
       cond(
         (result < i32(0)) => {
           free(.Some(*(void)(buf)));
-          (ret : Result(TempDir, IOError)) = .Err(IOError.from_errno((i32(0) - result)));
-          return ret;
+          exn.throw(dyn IOError.from_errno((i32(0) - result)));
         },
-        true => {
-          path_str := String.from_cstr(buf).unwrap();
-          free(.Some(*(void)(buf)));
-          (ret : Result(TempDir, IOError)) = .Ok(TempDir(_path: Path.new(path_str), _removed: false));
-          return ret;
-        }
-      )
+        true => ()
+      );
+      path_str := String.from_cstr(buf).unwrap();
+      free(.Some(*(void)(buf)));
+      TempDir(_path: Path.new(path_str), _removed: false)
     })
   ),
 
   // Create a temporary directory in the system temp dir.
-  new : (fn(using(io : IO)) -> Impl(Future(Result(TempDir, IOError), IO)))(
-    TempDir.new_in(Path.new(_default_tmp_dir()), using(io))
+  new : (fn(using(io : IO)) -> Impl(Future(TempDir, IO, Exception)))(
+    TempDir.new_in(Path.new(_default_tmp_dir()))
   ),
 
   // Get the path of the temporary directory.
@@ -100,15 +99,14 @@ impl(TempDir,
   ),
 
   // Remove the temporary directory.
-  remove : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))({
+  remove : (fn(self: Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     self_path := self._path;
-    io.async((using(io : IO)) => 
+    io.async((using(io, exn)) => 
       cond(
-        self._removed => .Ok(()),
+        self._removed => (),
         true => {
-          result := io.await(_dir_mod.remove_dir(self_path, using(io)));
+          io.await(_dir_mod.remove_dir(self_path));
           self._removed = true;
-          return result;
         }
       )
     )
@@ -129,8 +127,8 @@ TempFile :: object(
 
 impl(TempFile,
   // Create a temporary file in the given parent directory.
-  new_in : (fn(parent: Path, using(io : IO)) -> Impl(Future(Result(TempFile, IOError), IO)))(
-    io.async((using(io : IO)) => {
+  new_in : (fn(parent: Path, using(io : IO)) -> Impl(Future(TempFile, IO, Exception)))(
+    io.async((using(io, exn)) => {
       // Build template: parent/yo_tmp_XXXXXX
       template_path := parent.join(Path.new(`yo_tmp_XXXXXX`));
       template_str := template_path.to_string();
@@ -143,24 +141,21 @@ impl(TempFile,
       cond(
         (fd < i32(0)) => {
           free(.Some(*(void)(buf)));
-          (ret : Result(TempFile, IOError)) = .Err(IOError.from_errno((i32(0) - fd)));
-          return ret;
+          exn.throw(dyn IOError.from_errno((i32(0) - fd)));
         },
-        true => {
-          path_str := String.from_cstr(buf).unwrap();
-          free(.Some(*(void)(buf)));
-          path := Path.new(path_str);
-          file := _file_mod.File(_fd: fd, _path: path, _is_closed: false);
-          (ret : Result(TempFile, IOError)) = .Ok(TempFile(_file: file, _path: path, _removed: false));
-          return ret;
-        }
-      )
+        true => ()
+      );
+      path_str := String.from_cstr(buf).unwrap();
+      free(.Some(*(void)(buf)));
+      path := Path.new(path_str);
+      file := _file_mod.File(_fd: fd, _path: path, _is_closed: false);
+      TempFile(_file: file, _path: path, _removed: false)
     })
   ),
 
   // Create a temporary file in the system temp dir.
-  new : (fn(using(io : IO)) -> Impl(Future(Result(TempFile, IOError), IO)))(
-    TempFile.new_in(Path.new(_default_tmp_dir()), using(io))
+  new : (fn(using(io : IO)) -> Impl(Future(TempFile, IO, Exception)))(
+    TempFile.new_in(Path.new(_default_tmp_dir()))
   ),
 
   // Get the underlying File object.
@@ -174,17 +169,16 @@ impl(TempFile,
   ),
 
   // Remove the temporary file.
-  remove : (fn(self: Self, using(io : IO)) -> Impl(Future(Result(unit, IOError), IO)))({
+  remove : (fn(self: Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     self_file := self._file;
     self_path := self._path;
-    io.async((using(io : IO)) =>
+    io.async((using(io, exn)) =>
       cond(
-        self._removed => .Ok(()),
+        self._removed => (),
         true => {
-          io.await(self_file.close(using(io)));
-          result := io.await(_dir_mod.remove_file(self_path, using(io)));
+          io.await(self_file.close());
+          io.await(_dir_mod.remove_file(self_path));
           self._removed = true;
-          return result;
         }
       )
     )

package/std/fs/walker.yo

@@ -6,24 +6,26 @@
 //   { 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`));
-//     match(entries,
-//       .Ok(list) => {
-//         i := usize(0);
-//         while runtime((i < list.len())), {
-//           e := list.get(i).unwrap();
-//           println(e.path);
-//           i = (i + usize(1));
-//         };
-//       },
-//       .Err(e) => println(e.to_string())
-//     );
+//     i := usize(0);
+//     while runtime((i < entries.len())), {
+//       e := entries.get(i).unwrap();
+//       println(e.path);
+//       i = (i + usize(1));
+//     };
 //   });
 
 { ArrayList } :: import "../collections/array_list";
 open import "../string";
 { Path } :: import "../path";
 { IOError } :: import "../sys/errors";
+{ Error, AnyError, Exception } :: import "../error";
 { FileType } :: import "./dir";
 { DirEntry } :: import "./dir";
 _dir :: import "./dir";
@@ -79,9 +81,9 @@ _join_path :: (fn(base: String, name: String) -> String)(
 // ============================================================================
 
 // Walk a directory tree with custom options.
-walk_with :: (fn(root: Path, options: WalkOptions, using(io : IO)) -> Impl(Future(Result(ArrayList(WalkEntry), IOError), IO)))({
+walk_with :: (fn(root: Path, options: WalkOptions, using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))({
   root_s := root.to_string();
-  io.async((using(io : IO)) => {
+  io.async((using(io, exn)) => {
     results := ArrayList(WalkEntry).new();
     // Stack of (path, depth) pairs to process
     stack := ArrayList(struct(path: String, depth: u32)).new();
@@ -100,67 +102,58 @@ walk_with :: (fn(root: Path, options: WalkOptions, using(io : IO)) -> Impl(Futur
 
       cond(
         should_continue => {
-          dir_result := io.await(_dir.read_dir(Path.new(cur_path), using(io)));
-          match(dir_result,
-            .Ok(entries) => {
-              i := usize(0);
-              while runtime((i < entries.len())), {
-                entry := entries.get(i).unwrap();
-                entry_path := _join_path(cur_path, entry.name);
-                match(entry.file_type,
-                  .Directory => {
-                    cond(
-                      options.include_dirs => {
-                        results.push(WalkEntry(
-                          path: Path.new(entry_path),
-                          name: entry.name,
-                          depth: cur_depth,
-                          file_type: .Directory
-                        ));
-                      },
-                      true => ()
-                    );
-                    // Push subdirectory for processing
-                    stack.push({ path: entry_path, depth: (cur_depth + u32(1)) });
-                  },
-                  _ => {
+          entries := io.await(_dir.read_dir(Path.new(cur_path)));
+          i := usize(0);
+          while runtime((i < entries.len())), {
+            entry := entries.get(i).unwrap();
+            entry_path := _join_path(cur_path, entry.name);
+            match(entry.file_type,
+              .Directory => {
+                cond(
+                  options.include_dirs => {
                     results.push(WalkEntry(
                       path: Path.new(entry_path),
                       name: entry.name,
                       depth: cur_depth,
-                      file_type: entry.file_type
+                      file_type: .Directory
                     ));
-                  }
+                  },
+                  true => ()
                 );
-                i = (i + usize(1));
-              };
-            },
-            .Err(e) => {
-              (ret : Result(ArrayList(WalkEntry), IOError)) = .Err(e);
-              return ret;
-            }
-          );
+                // Push subdirectory for processing
+                stack.push({ path: entry_path, depth: (cur_depth + u32(1)) });
+              },
+              _ => {
+                results.push(WalkEntry(
+                  path: Path.new(entry_path),
+                  name: entry.name,
+                  depth: cur_depth,
+                  file_type: entry.file_type
+                ));
+              }
+            );
+            i = (i + usize(1));
+          };
         },
         true => ()
       );
     };
 
-    (ret : Result(ArrayList(WalkEntry), IOError)) = .Ok(results);
-    return ret;
+    results
   })
 });
 
-walk_with_cstr :: (fn(root: *(u8), options: WalkOptions, using(io : IO)) -> Impl(Future(Result(ArrayList(WalkEntry), IOError), IO)))(
-  walk_with(Path.from_cstr(root), options, using(io))
+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 a directory tree with default options.
-walk :: (fn(root: Path, using(io : IO)) -> Impl(Future(Result(ArrayList(WalkEntry), IOError), IO)))
-  walk_with(root, WalkOptions.defaults(), using(io))
+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(Result(ArrayList(WalkEntry), IOError), IO)))
-  walk(Path.from_cstr(root), using(io))
+walk_cstr :: (fn(root: *(u8), using(io : IO)) -> Impl(Future(ArrayList(WalkEntry), IO, Exception)))
+  walk(Path.from_cstr(root))
 ;
 
 export walk, walk_cstr, walk_with, walk_with_cstr;

package/std/net/addr.yo

@@ -14,6 +14,7 @@ open import "../string";
 { snprintf } :: import "../libc/stdio";
 { GlobalAllocator } :: import "../allocator";
 { malloc, free } :: GlobalAllocator;
+{ Error, AnyError, Exception } :: import "../error";
 
 // ============================================================================
 // IpAddr
@@ -32,7 +33,7 @@ IpAddr :: enum(
 impl(IpAddr,
   // Parse an IPv4 address from a String like "127.0.0.1".
   // Only supports IPv4 dotted-decimal notation.
-  parse_v4 : (fn(s: String) -> Result(IpAddr, NetError))({
+  parse_v4 : (fn(s: String, using(exn : Exception)) -> IpAddr)({
     bytes := s.as_bytes();
     parts := Array(u8, usize(4)).fill(u8(0));
     part_idx := usize(0);
@@ -45,13 +46,13 @@ impl(IpAddr,
           // '.' separator
           cond(
             (part_idx >= usize(3)) => {
-              return .Err(.Other(String.from("invalid IPv4 address")));
+              exn.throw(dyn NetError.Other(String.from("invalid IPv4 address")));
             },
             true => ()
           );
           cond(
             (val > u32(255)) => {
-              return .Err(.Other(String.from("IPv4 octet out of range")));
+              exn.throw(dyn NetError.Other(String.from("IPv4 octet out of range")));
             },
             true => ()
           );
@@ -64,25 +65,25 @@ impl(IpAddr,
           val = ((val * u32(10)) + u32((ch - _ASCII_ZERO)));
         },
         true => {
-          return .Err(.Other(String.from("invalid character in IPv4 address")));
+          exn.throw(dyn NetError.Other(String.from("invalid character in IPv4 address")));
         }
       );
       i = (i + usize(1));
     };
     cond(
       (part_idx != usize(3)) => {
-        return .Err(.Other(String.from("invalid IPv4 address")));
+        exn.throw(dyn NetError.Other(String.from("invalid IPv4 address")));
       },
       true => ()
     );
     cond(
       (val > u32(255)) => {
-        return .Err(.Other(String.from("IPv4 octet out of range")));
+        exn.throw(dyn NetError.Other(String.from("IPv4 octet out of range")));
       },
       true => ()
     );
     parts(usize(3)) = u8(val);
-    return .Ok(.V4(parts(usize(0)), parts(usize(1)), parts(usize(2)), parts(usize(3))));
+    .V4(parts(usize(0)), parts(usize(1)), parts(usize(2)), parts(usize(3)))
   }),
 
   // IPv4 loopback address (127.0.0.1).

package/std/net/dns.yo

@@ -1,23 +1,24 @@
 // std/net/dns.yo - High-level DNS resolution
 //
 // Wraps std/sys/dns with typed DNS lookup functions.
+// Uses the Exception effect for error handling.
 //
 // Example:
 //   { lookup_host } :: import "std/net/dns";
 //   { 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`));
-//     match(addrs,
-//       .Ok(list) => {
-//         i := usize(0);
-//         while runtime((i < list.len())), {
-//           println(list.get(i).unwrap().to_string());
-//           i = (i + usize(1));
-//         };
-//       },
-//       .Err(e) => println(e.to_string())
-//     );
+//     i := usize(0);
+//     while runtime((i < addrs.len())), {
+//       println(addrs.get(i).unwrap().to_string());
+//       i = (i + usize(1));
+//     };
 //   });
 
 { GlobalAllocator } :: import "../allocator";
@@ -27,6 +28,7 @@ open import "../string";
 open import "../fmt";
 { NetError } :: import "./errors";
 { IpAddr, SocketAddr } :: import "./addr";
+{ Error, AnyError, Exception } :: import "../error";
 IO_dns :: import "../sys/dns";
 { AF_INET, AF_INET6 } :: import "../sys/socket";
 
@@ -35,8 +37,8 @@ IO_dns :: import "../sys/dns";
 // ============================================================================
 
 // Resolve a hostname to a list of IP addresses.
-lookup_host :: (fn(host: String, using(io : IO)) -> Impl(Future(Result(ArrayList(IpAddr), NetError), IO)))(
-  io.async((using(io : IO)) => {
+lookup_host :: (fn(host: String, using(io : IO)) -> Impl(Future(ArrayList(IpAddr), IO, Exception)))(
+  io.async((using(io : IO, exn : Exception)) => {
     host_cstr_bytes := host.to_cstr();
     host_cstr := host_cstr_bytes.ptr().unwrap();
     result_ptr := IO_dns.alloc_result();
@@ -44,8 +46,7 @@ lookup_host :: (fn(host: String, using(io : IO)) -> Impl(Future(Result(ArrayList
     cond(
       (ret != i32(0)) => {
         IO_dns.free_result(result_ptr);
-        (err_ret : Result(ArrayList(IpAddr), NetError)) = .Err(.DNSFailed(host));
-        return err_ret;
+        exn.throw(dyn NetError.DNSFailed(host));
       },
       true => ()
     );
@@ -79,29 +80,22 @@ lookup_host :: (fn(host: String, using(io : IO)) -> Impl(Future(Result(ArrayList
       .None => ()
     );
     IO_dns.free_result(result_ptr);
-    (ok_ret : Result(ArrayList(IpAddr), NetError)) = .Ok(addrs);
-    return ok_ret;
+    return addrs;
   })
 );
 
 // Resolve a hostname and port to a list of socket addresses.
-resolve :: (fn(host: String, port: u16, using(io : IO)) -> Impl(Future(Result(ArrayList(SocketAddr), NetError), IO)))(
-  io.async((using(io : IO)) => {
-    addrs_result := io.await(lookup_host(host, using(io)));
-    (ret : Result(ArrayList(SocketAddr), NetError)) = match(addrs_result,
-      .Ok(addrs) => {
-        result := ArrayList(SocketAddr).new();
-        i := usize(0);
-        while runtime((i < addrs.len())), {
-          ip := addrs.get(i).unwrap();
-          result.push(SocketAddr.new(ip, port));
-          i = (i + usize(1));
-        };
-        .Ok(result)
-      },
-      .Err(e) => .Err(e)
-    );
-    return ret;
+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)));
+    result := ArrayList(SocketAddr).new();
+    i := usize(0);
+    while runtime((i < addrs.len())), {
+      ip := addrs.get(i).unwrap();
+      result.push(SocketAddr.new(ip, port));
+      i = (i + usize(1));
+    };
+    return result;
   })
 );
 

package/std/net/errors.yo

@@ -8,6 +8,7 @@
 open import "../string";
 { IOError } :: import "../sys/errors";
 { ToString } :: import "../fmt";
+{ Error, AnyError, Exception } :: import "../error";
 
 // ============================================================================
 // NetError
@@ -41,14 +42,6 @@ impl(NetError,
       .NetworkUnreachable => .NetworkUnreachable,
       _                  => .IO(err)
     )
-  ),
-
-  // Convert a raw result (positive = ok, negative = -errno) to Result.
-  from_result : (fn(result: i32) -> Result(i32, Self))(
-    cond(
-      (result >= i32(0)) => .Ok(result),
-      true => .Err(Self.from_io(IOError.from_errno((i32(0) - result))))
-    )
   )
 );
 
@@ -71,4 +64,16 @@ impl(NetError, ToString(
   })
 ));
 
+impl(NetError, Error());
+
+impl(NetError,
+  // Check a raw result (positive = ok, negative = -errno) and throw on error.
+  check : (fn(result: i32, using(exn : Exception)) -> i32)(
+    cond(
+      (result >= i32(0)) => result,
+      true => exn.throw(dyn Self.from_io(IOError.from_errno((i32(0) - result))))
+    )
+  )
+);
+
 export NetError;