@shd101wyy/yo 0.1.28 → 0.1.30

package/std/imm/string.yo

@@ -2,6 +2,7 @@
 //!
 //! Uses atomic reference counting for safe sharing across threads.
 //! All "modification" operations return a new string; the original is unchanged.
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
 { memcpy, memcmp } :: import("../libc/string.yo");
@@ -57,7 +58,7 @@ impl(
       return(Self(_ptr :.None, _len : usize(0), _capacity : usize(0)));
     });
     ptr := _alloc_bytes(slen);
-    memcpy(*(void)(ptr), *(void)(s.ptr()), slen);
+    unsafe(memcpy(*(void)(ptr), *(void)(s.ptr()), slen));
     return(Self(_ptr :.Some(ptr), _len : slen, _capacity : slen));
   }),
   /// Create a string from a standard (mutable) String by copying its bytes.
@@ -68,7 +69,7 @@ impl(
     });
     ptr := _alloc_bytes(slen);
     (as_str : str) = s.as_str();
-    memcpy(*(void)(ptr), *(void)(as_str.ptr()), slen);
+    unsafe(memcpy(*(void)(ptr), *(void)(as_str.ptr()), slen));
     return(Self(_ptr :.Some(ptr), _len : slen, _capacity : slen));
   }),
   /// Byte length of the string.
@@ -138,7 +139,7 @@ impl(
           .Some(op) => match(
             self._ptr,
             .Some(sp) => {
-              memcpy(*(void)(sp &+ self._len), *(void)(op), other._len);
+              unsafe(memcpy(*(void)(sp &+ self._len), *(void)(op), other._len));
             },
             .None => ()
           ),
@@ -155,7 +156,7 @@ impl(
       match(
         self._ptr,
         .Some(sp) => {
-          memcpy(*(void)(ptr), *(void)(sp), self._len);
+          unsafe(memcpy(*(void)(ptr), *(void)(sp), self._len));
           free(.Some(*(void)(sp)));
         },
         .None => ()
@@ -163,7 +164,7 @@ impl(
       match(
         other._ptr,
         .Some(op) => {
-          memcpy(*(void)(ptr &+ self._len), *(void)(op), other._len);
+          unsafe(memcpy(*(void)(ptr &+ self._len), *(void)(op), other._len));
         },
         .None => ()
       );
@@ -176,14 +177,14 @@ impl(
     match(
       self._ptr,
       .Some(sp) => {
-        memcpy(*(void)(ptr), *(void)(sp), self._len);
+        unsafe(memcpy(*(void)(ptr), *(void)(sp), self._len));
       },
       .None => ()
     );
     match(
       other._ptr,
       .Some(op) => {
-        memcpy(*(void)(ptr &+ self._len), *(void)(op), other._len);
+        unsafe(memcpy(*(void)(ptr &+ self._len), *(void)(op), other._len));
       },
       .None => ()
     );
@@ -203,7 +204,7 @@ impl(
     match(
       self._ptr,
       .Some(sp) => {
-        memcpy(*(void)(ptr), *(void)(sp &+ clamped_start), new_len);
+        unsafe(memcpy(*(void)(ptr), *(void)(sp &+ clamped_start), new_len));
       },
       .None => ()
     );
@@ -221,7 +222,7 @@ impl(
       self._ptr,
       .Some(sp) => match(
         prefix._ptr,
-        .Some(pp) => (memcmp(*(void)(sp), *(void)(pp), prefix._len) == int(0)),
+        .Some(pp) => (unsafe(memcmp(*(void)(sp), *(void)(pp), prefix._len)) == int(0)),
         .None => true
       ),
       .None => (prefix._len == usize(0))
@@ -240,7 +241,7 @@ impl(
       self._ptr,
       .Some(sp) => match(
         suffix._ptr,
-        .Some(xp) => (memcmp(*(void)(sp &+ offset), *(void)(xp), suffix._len) == int(0)),
+        .Some(xp) => (unsafe(memcmp(*(void)(sp &+ offset), *(void)(xp), suffix._len)) == int(0)),
         .None => true
       ),
       .None => (suffix._len == usize(0))
@@ -269,7 +270,7 @@ impl(
           i := from_index;
           limit := ((self._len - needle._len) + usize(1));
           while(i < limit, i = (i + usize(1)), {
-            if(memcmp(*(void)(sp &+ i), *(void)(np), needle._len) == int(0), {
+            if(unsafe(memcmp(*(void)(sp &+ i), *(void)(np), needle._len)) == int(0), {
               return(.Some(i));
             });
           });
@@ -410,7 +411,7 @@ impl(
           return(self);
         });
         ptr := _alloc_bytes(self._len);
-        memcpy(*(void)(ptr), *(void)(sp), self._len);
+        unsafe(memcpy(*(void)(ptr), *(void)(sp), self._len));
         i := usize(0);
         while(i < self._len, i = (i + usize(1)), {
           (b : u8) = (ptr &+ i).*;
@@ -447,7 +448,7 @@ impl(
           return(self);
         });
         ptr := _alloc_bytes(self._len);
-        memcpy(*(void)(ptr), *(void)(sp), self._len);
+        unsafe(memcpy(*(void)(ptr), *(void)(sp), self._len));
         i := usize(0);
         while(i < self._len, i = (i + usize(1)), {
           (b : u8) = (ptr &+ i).*;
@@ -516,7 +517,7 @@ impl(
       .Some(sp) => {
         i := usize(0);
         while(i < n, i = (i + usize(1)), {
-          memcpy(*(void)(ptr &+ (i * self._len)), *(void)(sp), self._len);
+          unsafe(memcpy(*(void)(ptr &+ (i * self._len)), *(void)(sp), self._len));
         });
       },
       .None => ()
@@ -623,7 +624,7 @@ impl(
         self._ptr,
         .Some(sp) => match(
           other._ptr,
-          .Some(op) => (memcmp(*(void)(sp), *(void)(op), self._len) == int(0)),
+          .Some(op) => (unsafe(memcmp(*(void)(sp), *(void)(op), self._len)) == int(0)),
           .None => false
         ),
         .None => match(
@@ -653,7 +654,7 @@ impl(
     });
     match(
       self._ptr,
-      .Some(sp) => (memcmp(*(void)(sp), *(void)(other.ptr()), self._len) == int(0)),
+      .Some(sp) => (unsafe(memcmp(*(void)(sp), *(void)(other.ptr()), self._len)) == int(0)),
       .None => (other_len == usize(0))
     )
   })
@@ -670,7 +671,7 @@ impl(
           .Some(sp) => match(
             other._ptr,
             .Some(op) => {
-              (cmp_result : int) = memcmp(*(void)(sp), *(void)(op), min_len);
+              (cmp_result : int) = unsafe(memcmp(*(void)(sp), *(void)(op), min_len));
               if(cmp_result != int(0), {
                 return(cmp_result < int(0));
               });
@@ -697,15 +698,18 @@ impl(
 impl(
   String,
   Hash(
-    (hash) : (fn(self : *(Self)) -> u64)({
+    (hash) : (fn(ref(self) : Self) -> u64)({
       h := u64(14695981039346656037);
       match(
-        self.*._ptr,
+        self._ptr,
         .None => (),
         .Some(p) => {
           i := usize(0);
-          while(i < self.*._len, i = (i + usize(1)), {
-            h = (h ^ u64((p &+ i).*));
+          while(i < self._len, i = (i + usize(1)), {
+            // SAFETY: `p` points at the Rc-managed UTF-8 byte
+            // buffer of length `self._len`; the loop guard
+            // `i < self._len` keeps `p &+ i` inside the allocation.
+            h = (h ^ u64(unsafe((p &+ i).*)));
             h = (h * u64(1099511628211));
           });
         }
@@ -718,8 +722,8 @@ impl(
 impl(
   String,
   ToString(
-    to_string : (fn(self : *(Self)) -> std_string.String)(
-      std_string.String.from(self.*.as_str())
+    to_string : (fn(ref(self) : Self) -> std_string.String)(
+      std_string.String.from(self.as_str())
     )
   )
 );

package/std/imm/vec.yo

@@ -13,9 +13,10 @@
 //!
 //! v := Vec(i32).new();
 //! v = v.push(i32(1)).push(i32(2)).push(i32(3));
-//! assert((v.get(usize(0)).unwrap() == i32(1)), "first element");
+//! assert((v(usize(0)) == i32(1)), "first element");
 //! assert((v.len() == usize(3)), "length is 3");
 //! ```
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
 /// Persistent immutable vector.
@@ -406,7 +407,7 @@ impl(
     new_ptr := Vec(V)._raw_alloc(min_len);
     i := usize(0);
     while(i < min_len, i = (i + usize(1)), {
-      (new_ptr &+ i).* = f((self._ptr &+ i).*, other.get(i).unwrap());
+      (new_ptr &+ i).* = f((self._ptr &+ i).*, other(i));
     });
     Vec(V)(_ptr : new_ptr, _len : min_len, _cap : min_len)
   }),
@@ -445,4 +446,19 @@ impl(
     })
   )
 );
+/// Index trait — `vec(idx)` returns the element at `idx`, panicking if
+/// out of bounds. Body takes `&(self)` so the dispatcher's inlined call
+/// passes the right C-ABI shape. See plans/ITERATOR_REDESIGN.md.
+impl(
+  forall(T : Type),
+  where(T <: Send),
+  Vec(T),
+  Index(usize)(
+    Output : T,
+    index : (fn(ref(self) : Self, idx : usize) -> *(Self.Output))({
+      assert(idx < self._len, "imm.Vec: index out of bounds");
+      self._ptr &+ idx
+    })
+  )
+);
 export(Vec, PopResult);

package/std/io/reader.yo

@@ -1,10 +1,11 @@
 //! Reader trait for byte-level input.
+pragma(Pragma.AllowUnsafe);
 { Exception } :: import("../error");
 /// Common interface for reading bytes from various sources.
 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(ref(self) : Self, buf : *(u8), size : usize, exn : Exception) -> usize
 );
 export(Reader);

package/std/io/writer.yo

@@ -1,12 +1,13 @@
 //! Writer trait for byte-level output.
+pragma(Pragma.AllowUnsafe);
 { Exception } :: import("../error");
 /// Common interface for writing bytes to a destination.
 Writer :: trait(
   /// Write bytes from buffer. Returns number of bytes written.
   write :
-    fn(self : *(Self), buf : *(u8), size : usize, using(exn : Exception)) -> usize,
+    fn(ref(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(ref(self) : Self, exn : Exception) -> unit
 );
 export(Writer);

package/std/libc/assert.yo

@@ -1,5 +1,6 @@
 //! C11 `<assert.h>` — assertion debugging facility.
 //! Provides runtime assertion checking for debugging.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<assert.h>",
   // The actual assertion function called by the assert macro

package/std/libc/ctype.yo

@@ -1,4 +1,5 @@
 //! C11 `<ctype.h>` — character classification and conversion functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<ctype.h>",
   // Character classification functions

package/std/libc/dirent.yo

@@ -1,4 +1,5 @@
 //! C11 `<dirent.h>` — directory entry operations.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<dirent.h>",
   // Types

package/std/libc/errno.yo

@@ -1,4 +1,5 @@
 //! C11 `<errno.h>` — error handling constants and `errno` variable.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<errno.h>",
   // The errno variable - global error indicator

package/std/libc/fcntl.yo

@@ -1,5 +1,6 @@
 //! POSIX `<fcntl.h>` — file control options.
 //! Provides open flags and file control operations.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<fcntl.h>",
   // File access modes (for open)

package/std/libc/float.yo

@@ -1,4 +1,5 @@
 //! C11 `<float.h>` — floating-point implementation limits.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<float.h>",
   // Floating-point model parameters

package/std/libc/limits.yo

@@ -1,4 +1,5 @@
 //! C11 `<limits.h>` — implementation-defined limits for integer types.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<limits.h>",
   // Character limits

package/std/libc/math.yo

@@ -1,4 +1,5 @@
 //! C11 `<math.h>` — mathematical functions and constants.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<math.h>",
   // Mathematical constants (implementation-defined)

package/std/libc/signal.yo

@@ -1,4 +1,5 @@
 //! C11 `<signal.h>` — signal handling functions and constants.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<signal.h>",
   // Signal handler type

package/std/libc/stdatomic.yo

@@ -1,4 +1,5 @@
 //! C11 `<stdatomic.h>` — atomic operations and types.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<stdatomic.h>",
   // Atomic types

package/std/libc/stdint.yo

@@ -3,6 +3,7 @@
 //! Note: Yo already has `i8`, `i16`, `i32`, `i64`, `u8`, `u16`, `u32`, `u64`.
 //! This file provides C-compatible aliases and additional types/constants.
 // Type aliases for C compatibility (mapping Yo types to C stdint names)
+pragma(Pragma.AllowUnsafe);
 int8_t :: i8;
 int16_t :: i16;
 int32_t :: i32;

package/std/libc/stdio.yo

@@ -1,4 +1,5 @@
 //! C11 `<stdio.h>` — standard I/O functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<stdio.h>",
   // Types

package/std/libc/stdlib.yo

@@ -1,4 +1,5 @@
 //! C11 `<stdlib.h>` — general utility functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<stdlib.h>",
   // Types for div functions

package/std/libc/string.yo

@@ -1,4 +1,5 @@
 //! C11 `<string.h>` — string and memory functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<string.h>",
   // Memory functions

package/std/libc/sys/stat.yo

@@ -1,4 +1,5 @@
 //! POSIX `<sys/stat.h>` — file status and mode operations.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<sys/stat.h>",
   // Types

package/std/libc/time.yo

@@ -1,4 +1,5 @@
 //! C11 `<time.h>` — date and time functions.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<time.h>",
   // Types

package/std/libc/unistd.yo

@@ -1,4 +1,5 @@
 //! POSIX `<unistd.h>` — standard symbolic constants and types.
+pragma(Pragma.AllowUnsafe);
 c_include(
   "<unistd.h>",
   // Types

package/std/libc/wctype.yo

@@ -1,4 +1,5 @@
 //! C11 `<wctype.h>` — wide character classification and conversion functions.
+pragma(Pragma.AllowUnsafe);
 { wint_t } :: import("./stdint");
 c_include(
   "<wctype.h>",

package/std/libc/windows.yo

@@ -1,6 +1,8 @@
 //! Windows-specific C API bindings.
 //! Only available when compiling for Windows.
 // Windows type aliases (using Yo types that match the C types)
+pragma(Pragma.AllowUnsafe);
+pragma(Pragma.AllowUnsafe);
 DWORD :: ulong; // unsigned long on Windows
 WCHAR :: ushort; // unsigned short (UTF-16 code unit)
 BOOL :: int; // int

package/std/log.yo

@@ -1,4 +1,5 @@
 //! Structured logging with configurable level and output destination.
+pragma(Pragma.AllowUnsafe);
 open(import("./string"));
 { ToString } :: import("./fmt");
 { fwrite, stdout, stderr, FILE } :: import("./libc/stdio");
@@ -7,9 +8,9 @@ Level :: enum(Trace, Debug, Info, Warn, Error);
 impl(
   Level,
   ToString(
-    to_string : (fn(self : *(Self)) -> String)(
+    to_string : (fn(ref(self) : Self) -> String)(
       match(
-        self.*,
+        self,
         .Trace => String.from("TRACE"),
         .Debug => String.from("DEBUG"),
         .Info => String.from("INFO "),
@@ -60,7 +61,7 @@ _write_string :: (fn(s : String, dest : *(FILE)) -> unit)({
   cond(
     (bytes.len() > usize(0)) => {
       ptr := bytes.ptr().unwrap();
-      fwrite(*(void)(ptr), usize(1), bytes.len(), dest);
+      unsafe(fwrite(*(void)(ptr), usize(1), bytes.len(), dest));
     },
     true => ()
   );
@@ -79,11 +80,11 @@ log :: (fn(level : Level, msg : String) -> unit)({
     .Stderr => stderr
   );
   // Write "[LEVEL] msg\n"
-  fwrite(*(void)(*(u8)("[")), usize(1), usize(1), dest);
+  unsafe(fwrite(*(void)(*(u8)("[")), usize(1), usize(1), dest));
   _write_string(level_str, dest);
-  fwrite(*(void)(*(u8)("] ")), usize(1), usize(2), dest);
+  unsafe(fwrite(*(void)(*(u8)("] ")), usize(1), usize(2), dest));
   _write_string(msg, dest);
-  fwrite(*(void)(*(u8)("\n")), usize(1), usize(1), dest);
+  unsafe(fwrite(*(void)(*(u8)("\n")), usize(1), usize(1), dest));
 });
 export(log);
 // ============================================================================

package/std/net/addr.yo

@@ -7,6 +7,7 @@
 //   { IpAddr, SocketAddr } :: import "std/net/addr";
 //
 //   addr := SocketAddr.new(IpAddr.loopback_v4(), u16(8080));
+pragma(Pragma.AllowUnsafe);
 open(import("../string"));
 { ToString } :: import("../fmt");
 { Writer } :: import("../fmt/writer");
@@ -33,14 +34,14 @@ 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);
     val := u32(0);
     i := usize(0);
     while(runtime(i < bytes.len()), {
-      ch := bytes.get(i).unwrap();
+      ch := bytes(i);
       cond(
         (ch == _ASCII_DOT) => {
           // '.' separator
@@ -145,10 +146,10 @@ impl(
       self -> {
         return(
           match(
-            self.*,
+            self,
             .V4(a, b, c, d) => {
               buf := Array(u8, usize(16)).fill(u8(0));
-              snprintf(*(char)(&(buf(usize(0)))), usize(16), "%d.%d.%d.%d", i32(a), i32(b), i32(c), i32(d));
+              unsafe(snprintf(*(char)(&(buf(usize(0)))), usize(16), "%d.%d.%d.%d", i32(a), i32(b), i32(c), i32(d)));
               String.from_cstr(&(buf(usize(0)))).unwrap()
             },
             .V6(segs) => {
@@ -205,7 +206,7 @@ impl(
       self -> {
         ip_str := self.ip.to_string();
         buf := Array(u8, usize(8)).fill(u8(0));
-        snprintf(*(char)(&(buf(usize(0)))), usize(8), "%d", i32(self.port));
+        unsafe(snprintf(*(char)(&(buf(usize(0)))), usize(8), "%d", i32(self.port)));
         port_str := String.from_cstr(&(buf(usize(0)))).unwrap();
         return(
           match(

package/std/net/dns.yo

@@ -9,18 +9,15 @@
 //   { 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());
+//       println(addrs(i).to_string());
 //       i = (i + usize(1));
 //     };
 //   });
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 { ArrayList } :: import("../collections/array_list");
@@ -28,23 +25,23 @@ open(import("../string"));
 open(import("../fmt"));
 { NetError } :: import("./errors");
 { IpAddr, SocketAddr } :: import("./addr");
-{ Error, AnyError, Exception } :: import("../error");
+{ Error, AnyError, Exception, IoExn } :: 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), IoExn)))(
+  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,13 +83,13 @@ 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), IoExn)))(
+  io.async((e) => {
+    addrs := e.io.await(lookup_host(host, io), e);
     result := ArrayList(SocketAddr).new();
     i := usize(0);
     while(runtime(i < addrs.len()), {
-      ip := addrs.get(i).unwrap();
+      ip := addrs(i);
       result.push(SocketAddr.new(ip, port));
       i = (i + usize(1));
     });

package/std/net/errors.yo

@@ -1,12 +1,12 @@
 //! Network error types.
 // std/net/errors.yo - Network error type
 //
-// Higher-level network error that wraps IOError with network-specific variants.
+// Higher-level network error that wraps IoError with network-specific variants.
 //
 // Example:
 //   { NetError } :: import "std/net/errors";
 open(import("../string"));
-{ IOError } :: import("../sys/errors");
+{ IoError } :: import("../sys/errors");
 { ToString } :: import("../fmt");
 { Error, AnyError, Exception } :: import("../error");
 // ============================================================================
@@ -33,14 +33,14 @@ NetError :: enum(
   /// DNS resolution failed.
   DNSFailed(msg : String),
   /// A wrapped lower-level I/O error.
-  IO(err : IOError),
+  Io(err : IoError),
   /// An unclassified network error with a message.
   Other(msg : String)
 );
 impl(
   NetError,
-  /// Convert an `IOError` into the corresponding `NetError` variant.
-  from_io : (fn(err : IOError) -> Self)(
+  /// Convert an `IoError` into the corresponding `NetError` variant.
+  from_io : (fn(err : IoError) -> Self)(
     match(
       err,
       .ConnectionRefused =>.ConnectionRefused,
@@ -51,7 +51,7 @@ impl(
       .TimedOut =>.TimedOut,
       .HostUnreachable =>.HostUnreachable,
       .NetworkUnreachable =>.NetworkUnreachable,
-      _ =>.IO(err)
+      _ =>.Io(err)
     )
   )
 );
@@ -71,7 +71,7 @@ impl(
           .HostUnreachable => String.from("host unreachable"),
           .NetworkUnreachable => String.from("network unreachable"),
           .DNSFailed(msg) => `DNS lookup failed: ${msg}`,
-          .IO(err) => err.to_string(),
+          .Io(err) => err.to_string(),
           .Other(msg) => msg
         );
         return(s);
@@ -84,10 +84,10 @@ 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))))
+      true => exn.throw(dyn(Self.from_io(IoError.from_errno(i32(0) - result))))
     )
   )
 );