@shd101wyy/yo 0.1.28 → 0.1.29

package/std/net/tcp.yo

@@ -9,14 +9,10 @@
 //   { SocketAddr, IpAddr } :: import "std/net/addr";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(using(io : IO)) -> unit)({
-//     given(exn) := Exception(throw : ((err) -> {
-//       println(err.message());
-//       escape ();
-//     }));
+//   main :: (fn(io : IO, exn : Exception) -> unit)({
 //     addr := SocketAddr.new(IpAddr.any_v4(), u16(8080));
-//     listener := io.await(TcpListener.bind(addr));
-//     stream := io.await(listener.accept());
+//     listener := io.await(TcpListener.bind(addr, io), { io, exn });
+//     stream := io.await(listener.accept(io), { io, exn });
 //     // ...
 //   });
 { GlobalAllocator } :: import("../allocator");
@@ -27,7 +23,7 @@ open(import("../fmt"));
 { NetError } :: import("./errors");
 { IOError } :: import("../sys/errors");
 { IpAddr, SocketAddr } :: import("./addr");
-{ Error, AnyError, Exception } :: import("../error");
+{ Error, AnyError, Exception, IOErr } :: import("../error");
 IO_tcp :: import("../sys/tcp");
 { AF_INET, AF_INET6, SOCK_STREAM, SOL_SOCKET, SO_REUSEADDR, IPPROTO_TCP, TCP_NODELAY, SO_KEEPALIVE } :: import("../sys/socket");
 // ============================================================================
@@ -49,7 +45,7 @@ _make_sockaddr :: (fn(addr : SocketAddr) -> IO_tcp.SockAddr)(
       IO_tcp.make_sockaddr_in6(*(u8)("::1"), addr.port)
   )
 );
-_throw_io :: (fn(errno_val : i32, using(exn : Exception)) -> unit)(
+_throw_io :: (fn(errno_val : i32, exn : Exception) -> unit)(
   exn.throw(dyn(NetError.from_io(IOError.from_errno(errno_val))))
 );
 // ============================================================================
@@ -73,36 +69,36 @@ TcpListener :: object(
 impl(
   TcpListener,
   /// Bind to a socket address and start listening.
-  bind : (fn(addr : SocketAddr, using(io : IO)) -> Impl(Future(TcpListener, IO, Exception)))(
-    io.async((using(io : IO, exn : Exception)) => {
+  bind : (fn(addr : SocketAddr, io : IO) -> Impl(Future(TcpListener, IOErr)))(
+    io.async((e) => {
       domain := cond(
         addr.ip.is_v4() => AF_INET,
         true => AF_INET6
       );
       // Create socket
-      raw_fd := io.await(IO_tcp.socket(domain, SOCK_STREAM, i32(0)));
-      fd := NetError.check(raw_fd);
+      raw_fd := e.io.await(IO_tcp.socket(domain, SOCK_STREAM, i32(0)), e.io);
+      fd := NetError.check(raw_fd, e.exn);
       // Set SO_REUSEADDR
       reuse_val := i32(1);
       reuse_ptr := &(reuse_val);
-      io.await(IO_tcp.setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, *(u8)(reuse_ptr), u32(4)));
+      e.io.await(IO_tcp.setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, *(u8)(reuse_ptr), u32(4)), e.io);
       // Bind
       saddr := _make_sockaddr(addr);
-      bind_result := io.await(IO_tcp.bind(fd, saddr.buf, saddr.len));
+      bind_result := e.io.await(IO_tcp.bind(fd, saddr.buf, saddr.len), e.io);
       IO_tcp.free_sockaddr(saddr);
       cond(
         (bind_result < i32(0)) => {
-          io.await(IO_tcp.close(fd));
-          _throw_io(i32(0) - bind_result);
+          e.io.await(IO_tcp.close(fd), e.io);
+          _throw_io(i32(0) - bind_result, e.exn);
         },
         true => ()
       );
       // Listen
-      listen_result := io.await(IO_tcp.listen(fd, i32(128)));
+      listen_result := e.io.await(IO_tcp.listen(fd, i32(128)), e.io);
       cond(
         (listen_result < i32(0)) => {
-          io.await(IO_tcp.close(fd));
-          _throw_io(i32(0) - listen_result);
+          e.io.await(IO_tcp.close(fd), e.io);
+          _throw_io(i32(0) - listen_result, e.exn);
         },
         true => ()
       );
@@ -110,19 +106,19 @@ impl(
     })
   ),
   /// Accept an incoming connection, returning a new `TcpStream`.
-  accept : (fn(self : Self, using(io : IO)) -> Impl(Future(TcpStream, IO, Exception)))({
+  accept : (fn(self : Self, io : IO) -> Impl(Future(TcpStream, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
+    io.async((e) => {
       // Allocate space for the peer address
       addr_buf := *(u8)(malloc(usize(128)).unwrap());
       addr_len := *(u32)(malloc(usize(4)).unwrap());
       addr_len.* = u32(128);
-      client_fd := io.await(IO_tcp.accept(fd, addr_buf, addr_len));
+      client_fd := e.io.await(IO_tcp.accept(fd, addr_buf, addr_len), e.io);
       cond(
         (client_fd < i32(0)) => {
           free(.Some(*(void)(addr_buf)));
           free(.Some(*(void)(addr_len)));
-          _throw_io(i32(0) - client_fd);
+          _throw_io(i32(0) - client_fd, e.exn);
         },
         true => ()
       );
@@ -145,17 +141,17 @@ impl(
     self._local_addr
   ),
   /// Close the listener socket.
-  close : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  close : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
+    io.async((e) => {
       cond(
         self._is_closed => (),
         true => {
-          r := io.await(IO_tcp.close(fd));
+          r := e.io.await(IO_tcp.close(fd), e.io);
           self._is_closed = true;
           cond(
             (r < i32(0)) => {
-              _throw_io(i32(0) - r);
+              _throw_io(i32(0) - r, e.exn);
             },
             true => ()
           );
@@ -190,21 +186,21 @@ export(TcpListener);
 impl(
   TcpStream,
   /// Connect to a remote address, returning a new `TcpStream`.
-  connect : (fn(addr : SocketAddr, using(io : IO)) -> Impl(Future(TcpStream, IO, Exception)))(
-    io.async((using(io : IO, exn : Exception)) => {
+  connect : (fn(addr : SocketAddr, io : IO) -> Impl(Future(TcpStream, IOErr)))(
+    io.async((e) => {
       domain := cond(
         addr.ip.is_v4() => AF_INET,
         true => AF_INET6
       );
-      raw_fd := io.await(IO_tcp.socket(domain, SOCK_STREAM, i32(0)));
-      fd := NetError.check(raw_fd);
+      raw_fd := e.io.await(IO_tcp.socket(domain, SOCK_STREAM, i32(0)), e.io);
+      fd := NetError.check(raw_fd, e.exn);
       saddr := _make_sockaddr(addr);
-      conn_result := io.await(IO_tcp.connect(fd, saddr.buf, saddr.len));
+      conn_result := e.io.await(IO_tcp.connect(fd, saddr.buf, saddr.len), e.io);
       IO_tcp.free_sockaddr(saddr);
       cond(
         (conn_result < i32(0)) => {
-          io.await(IO_tcp.close(fd));
-          _throw_io(i32(0) - conn_result);
+          e.io.await(IO_tcp.close(fd), e.io);
+          _throw_io(i32(0) - conn_result, e.exn);
         },
         true => ()
       );
@@ -219,58 +215,58 @@ impl(
   ),
   /// Read bytes from the stream into `buf`.
   /// Returns the number of bytes read, or 0 if the peer closed the connection.
-  read : (fn(self : Self, buf : *(u8), size : usize, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  read : (fn(self : Self, buf : *(u8), size : usize, io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
-      r := io.await(IO_tcp.recv(fd, buf, size, i32(0)));
-      NetError.check(r)
+    io.async((e) => {
+      r := e.io.await(IO_tcp.recv(fd, buf, size, i32(0)), e.io);
+      NetError.check(r, e.exn)
     })
   }),
   /// Write a `str` to the stream.
   /// Returns the number of bytes written.
-  write_str : (fn(self : Self, data : str, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  write_str : (fn(self : Self, data : str, io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
     s := String.from(data);
     s_bytes := s.as_bytes();
-    io.async((using(io : IO, exn : Exception)) => {
-      r := io.await(IO_tcp.send(fd, s_bytes.ptr().unwrap(), s_bytes.len(), i32(0)));
-      NetError.check(r)
+    io.async((e) => {
+      r := e.io.await(IO_tcp.send(fd, s_bytes.ptr().unwrap(), s_bytes.len(), i32(0)), e.io);
+      NetError.check(r, e.exn)
     })
   }),
   /// Write a `String` to the stream.
   /// Returns the number of bytes written.
-  write_string : (fn(self : Self, data : String, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  write_string : (fn(self : Self, data : String, io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
     data_bytes := data.as_bytes();
-    io.async((using(io : IO, exn : Exception)) => {
-      r := io.await(IO_tcp.send(fd, data_bytes.ptr().unwrap(), data_bytes.len(), i32(0)));
-      NetError.check(r)
+    io.async((e) => {
+      r := e.io.await(IO_tcp.send(fd, data_bytes.ptr().unwrap(), data_bytes.len(), i32(0)), e.io);
+      NetError.check(r, e.exn)
     })
   }),
   /// Write raw bytes from an `ArrayList(u8)` to the stream.
   /// Returns the number of bytes written.
-  write_bytes : (fn(self : Self, data : ArrayList(u8), using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  write_bytes : (fn(self : Self, data : ArrayList(u8), io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
-      r := io.await(IO_tcp.send(fd, data.ptr().unwrap(), data.len(), i32(0)));
-      NetError.check(r)
+    io.async((e) => {
+      r := e.io.await(IO_tcp.send(fd, data.ptr().unwrap(), data.len(), i32(0)), e.io);
+      NetError.check(r, e.exn)
     })
   }),
   /// Read all available data from the stream into a byte list.
-  read_bytes : (fn(self : Self, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))({
+  read_bytes : (fn(self : Self, io : IO) -> Impl(Future(ArrayList(u8), IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
+    io.async((e) => {
       buf_size := usize(4096);
       buf := *(u8)(malloc(buf_size).unwrap());
       acc := ArrayList(u8).new();
       done := false;
       while(runtime(!(done)), {
-        n := io.await(IO_tcp.recv(fd, buf, buf_size, i32(0)));
+        n := e.io.await(IO_tcp.recv(fd, buf, buf_size, i32(0)), e.io);
         cond(
           (n < i32(0)) => {
             free(.Some(*(void)(buf)));
             done = true;
-            _throw_io(i32(0) - n);
+            _throw_io(i32(0) - n, e.exn);
           },
           (n == i32(0)) => {
             done = true;
@@ -290,30 +286,30 @@ impl(
   }),
   /// Shut down part or all of the connection.
   /// `how`: 0 = read, 1 = write, 2 = both.
-  shutdown : (fn(self : Self, how : i32, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  shutdown : (fn(self : Self, how : i32, io : IO) -> Impl(Future(unit, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
-      r := io.await(IO_tcp.shutdown(fd, how));
+    io.async((e) => {
+      r := e.io.await(IO_tcp.shutdown(fd, how), e.io);
       cond(
         (r < i32(0)) => {
-          _throw_io(i32(0) - r);
+          _throw_io(i32(0) - r, e.exn);
         },
         true => ()
       );
     })
   }),
   /// Close the stream.
-  close : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  close : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
+    io.async((e) => {
       cond(
         self._is_closed => (),
         true => {
-          r := io.await(IO_tcp.close(fd));
+          r := e.io.await(IO_tcp.close(fd), e.io);
           self._is_closed = true;
           cond(
             (r < i32(0)) => {
-              _throw_io(i32(0) - r);
+              _throw_io(i32(0) - r, e.exn);
             },
             true => ()
           );
@@ -330,30 +326,30 @@ impl(
     self._fd
   ),
   /// Enable or disable TCP_NODELAY (disables Nagle's algorithm).
-  set_nodelay : (fn(self : Self, nodelay : bool, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  set_nodelay : (fn(self : Self, nodelay : bool, io : IO) -> Impl(Future(unit, IOErr)))({
     sock_fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
+    io.async((e) => {
       val := cond(nodelay => i32(1), true => i32(0));
       val_ptr := &(val);
-      r := io.await(IO_tcp.setsockopt(sock_fd, IPPROTO_TCP, TCP_NODELAY, *(u8)(val_ptr), u32(4)));
+      r := e.io.await(IO_tcp.setsockopt(sock_fd, IPPROTO_TCP, TCP_NODELAY, *(u8)(val_ptr), u32(4)), e.io);
       cond(
         (r < i32(0)) => {
-          _throw_io(i32(0) - r);
+          _throw_io(i32(0) - r, e.exn);
         },
         true => ()
       );
     })
   }),
   /// Enable or disable SO_KEEPALIVE on the socket.
-  set_keepalive : (fn(self : Self, enabled : bool, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  set_keepalive : (fn(self : Self, enabled : bool, io : IO) -> Impl(Future(unit, IOErr)))({
     sock_fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
+    io.async((e) => {
       val := cond(enabled => i32(1), true => i32(0));
       val_ptr := &(val);
-      r := io.await(IO_tcp.setsockopt(sock_fd, SOL_SOCKET, SO_KEEPALIVE, *(u8)(val_ptr), u32(4)));
+      r := e.io.await(IO_tcp.setsockopt(sock_fd, SOL_SOCKET, SO_KEEPALIVE, *(u8)(val_ptr), u32(4)), e.io);
       cond(
         (r < i32(0)) => {
-          _throw_io(i32(0) - r);
+          _throw_io(i32(0) - r, e.exn);
         },
         true => ()
       );

package/std/net/udp.yo

@@ -9,14 +9,10 @@
 //   { SocketAddr, IpAddr } :: import "std/net/addr";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(using(io : IO)) -> unit)({
-//     given(exn) := Exception(throw : ((err) -> {
-//       println(err.message());
-//       escape ();
-//     }));
+//   main :: (fn(io : IO, exn : Exception) -> unit)({
 //     addr := SocketAddr.new(IpAddr.loopback_v4(), u16(9999));
-//     sock := io.await(UdpSocket.bind(addr));
-//     io.await(sock.close());
+//     sock := io.await(UdpSocket.bind(addr, io), { io, exn });
+//     io.await(sock.close(io), { io, exn });
 //   });
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
@@ -26,7 +22,7 @@ open(import("../fmt"));
 { NetError } :: import("./errors");
 { IOError } :: import("../sys/errors");
 { IpAddr, SocketAddr } :: import("./addr");
-{ Error, AnyError, Exception } :: import("../error");
+{ Error, AnyError, Exception, IOErr } :: import("../error");
 IO_udp :: import("../sys/udp");
 IO_tcp :: import("../sys/tcp");
 { AF_INET, AF_INET6, SOCK_DGRAM, SOL_SOCKET, SO_BROADCAST } :: import("../sys/socket");
@@ -46,7 +42,7 @@ _make_sockaddr :: (fn(addr : SocketAddr) -> IO_tcp.SockAddr)(
       IO_tcp.make_sockaddr_in6(*(u8)("::1"), addr.port)
   )
 );
-_throw_net_io :: (fn(errno_val : i32, using(exn : Exception)) -> unit)(
+_throw_net_io :: (fn(errno_val : i32, exn : Exception) -> unit)(
   exn.throw(dyn(NetError.from_io(IOError.from_errno(errno_val))))
 );
 // ============================================================================
@@ -61,21 +57,21 @@ UdpSocket :: object(
 impl(
   UdpSocket,
   /// Create and bind a UDP socket to the given address.
-  bind : (fn(addr : SocketAddr, using(io : IO)) -> Impl(Future(UdpSocket, IO, Exception)))(
-    io.async((using(io : IO, exn : Exception)) => {
+  bind : (fn(addr : SocketAddr, io : IO) -> Impl(Future(UdpSocket, IOErr)))(
+    io.async((e) => {
       domain := cond(
         addr.ip.is_v4() => AF_INET,
         true => AF_INET6
       );
-      raw_fd := io.await(IO_udp.socket(domain, i32(0)));
-      fd := NetError.check(raw_fd);
+      raw_fd := e.io.await(IO_udp.socket(domain, i32(0)), e.io);
+      fd := NetError.check(raw_fd, e.exn);
       saddr := _make_sockaddr(addr);
-      bind_r := io.await(IO_udp.bind(fd, saddr.buf, saddr.len));
+      bind_r := e.io.await(IO_udp.bind(fd, saddr.buf, saddr.len), e.io);
       IO_tcp.free_sockaddr(saddr);
       cond(
         (bind_r < i32(0)) => {
-          io.await(IO_udp.close(fd));
-          _throw_net_io(i32(0) - bind_r);
+          e.io.await(IO_udp.close(fd), e.io);
+          _throw_net_io(i32(0) - bind_r, e.exn);
         },
         true => ()
       );
@@ -84,53 +80,53 @@ impl(
   ),
   /// Send a datagram to a specific address.
   /// Returns the number of bytes sent.
-  send_to : (fn(self : Self, data : ArrayList(u8), addr : SocketAddr, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  send_to : (fn(self : Self, data : ArrayList(u8), addr : SocketAddr, io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
+    io.async((e) => {
       saddr := _make_sockaddr(addr);
-      r := io.await(IO_udp.sendto(fd, data.ptr().unwrap(), data.len(), i32(0), saddr.buf, saddr.len));
+      r := e.io.await(IO_udp.sendto(fd, data.ptr().unwrap(), data.len(), i32(0), saddr.buf, saddr.len), e.io);
       IO_tcp.free_sockaddr(saddr);
-      NetError.check(r)
+      NetError.check(r, e.exn)
     })
   }),
   /// Receive a datagram into the provided buffer.
   /// Returns the number of bytes received.
-  recv : (fn(self : Self, buf : *(u8), size : usize, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  recv : (fn(self : Self, buf : *(u8), size : usize, io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
-      r := io.await(IO_udp.recv(fd, buf, size, i32(0)));
-      NetError.check(r)
+    io.async((e) => {
+      r := e.io.await(IO_udp.recv(fd, buf, size, i32(0)), e.io);
+      NetError.check(r, e.exn)
     })
   }),
   /// Receive a datagram and retrieve the sender's address.
   /// Returns the number of bytes received.
-  recv_from : (fn(self : Self, buf : *(u8), size : usize, src_addr : *(u8), src_addr_len : *(u32), using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  recv_from : (fn(self : Self, buf : *(u8), size : usize, src_addr : *(u8), src_addr_len : *(u32), io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
-      r := io.await(IO_udp.recvfrom(fd, buf, size, i32(0), src_addr, src_addr_len));
-      NetError.check(r)
+    io.async((e) => {
+      r := e.io.await(IO_udp.recvfrom(fd, buf, size, i32(0), src_addr, src_addr_len), e.io);
+      NetError.check(r, e.exn)
     })
   }),
   /// Send data on a connected socket (requires prior connect).
-  send : (fn(self : Self, data : ArrayList(u8), using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
+  send : (fn(self : Self, data : ArrayList(u8), io : IO) -> Impl(Future(i32, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
-      r := io.await(IO_udp.send(fd, data.ptr().unwrap(), data.len(), i32(0)));
-      NetError.check(r)
+    io.async((e) => {
+      r := e.io.await(IO_udp.send(fd, data.ptr().unwrap(), data.len(), i32(0)), e.io);
+      NetError.check(r, e.exn)
     })
   }),
   /// Close the socket.
-  close : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  close : (fn(self : Self, io : IO) -> Impl(Future(unit, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
+    io.async((e) => {
       cond(
         self._is_closed => (),
         true => {
-          r := io.await(IO_udp.close(fd));
+          r := e.io.await(IO_udp.close(fd), e.io);
           self._is_closed = true;
           cond(
             (r < i32(0)) => {
-              _throw_net_io(i32(0) - r);
+              _throw_net_io(i32(0) - r, e.exn);
             },
             true => ()
           );
@@ -139,15 +135,15 @@ impl(
     })
   }),
   /// Enable or disable SO_BROADCAST on the socket.
-  set_broadcast : (fn(self : Self, enabled : bool, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  set_broadcast : (fn(self : Self, enabled : bool, io : IO) -> Impl(Future(unit, IOErr)))({
     fd := self._fd;
-    io.async((using(io : IO, exn : Exception)) => {
+    io.async((e) => {
       val := cond(enabled => i32(1), true => i32(0));
       val_ptr := &(val);
-      r := io.await(IO_udp.setsockopt(fd, SOL_SOCKET, SO_BROADCAST, *(u8)(val_ptr), u32(4)));
+      r := e.io.await(IO_udp.setsockopt(fd, SOL_SOCKET, SO_BROADCAST, *(u8)(val_ptr), u32(4)), e.io);
       cond(
         (r < i32(0)) => {
-          _throw_net_io(i32(0) - r);
+          _throw_net_io(i32(0) - r, e.exn);
         },
         true => ()
       );

package/std/os/signal.yo

@@ -78,7 +78,7 @@ _signal_num :: (fn(sig : Signal) -> i32)(
 // on_signal / off_signal
 // ============================================================================
 /// Register a handler for the given signal.
-on_signal :: (fn(sig : Signal, handler : SignalHandler, using(exn : Exception)) -> unit)({
+on_signal :: (fn(sig : Signal, handler : SignalHandler, exn : Exception) -> unit)({
   num := _signal_num(sig);
   r := _on_signal(num, handler);
   cond(
@@ -89,7 +89,7 @@ on_signal :: (fn(sig : Signal, handler : SignalHandler, using(exn : Exception))
   );
 });
 /// Remove the handler for the given signal.
-off_signal :: (fn(sig : Signal, using(exn : Exception)) -> unit)({
+off_signal :: (fn(sig : Signal, exn : Exception) -> unit)({
   num := _signal_num(sig);
   r := _off_signal(num);
   cond(

package/std/prelude.yo

@@ -113,7 +113,7 @@ extern(
   __yo_process_node_version : (fn() -> comptime(comptime_string))
 );
 export(__yo_as);
-/// The `unsafe` module — provides low-level escape hatches.
+/// The `unsafe` module — provides low-level unwind hatches.
 unsafe :: impl({
   /// Manually drop `value`, running its destructor immediately.
   drop :: (fn(quote(value) : Expr) -> unquote(Expr))(quote(___drop(unquote(value))));
@@ -5903,6 +5903,12 @@ impl(
 );
 _Type :: Type;
 export(Type : _Type);
+// Kind-constraint syntax `Type.Struct`, `Type.Enum`, `Type.Union`,
+// `Type.Trait`, `Type.Function` is recognised by the evaluator (see
+// `src/evaluator/exprs/property-access.ts`). Use `T : Type.Struct` for
+// forall type-variable constraints that signal an effect record (or
+// other kind-restricted type). The legacy `Struct :: Type` alias was
+// removed in favour of this syntax.
 /// Type reflection metadata structs — used by `Type.get_info()`.
 /// StructKind — discriminant for struct flavors.
 StructKind :: enum(
@@ -6591,7 +6597,7 @@ __derive_eq :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(t
       );
       ctx.make_impl(
         quote(
-          Eq(...(#(trait_params)))(
+          Eq(...#(trait_params))(
             (==) : ((lhs, rhs) -> #(eq_body))
           )
         )
@@ -6661,7 +6667,7 @@ __derive_eq :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(t
       match_body :: __s3("match(lhs,\n    ", eq_branches, "\n  )");
       ctx.make_impl(
         quote(
-          Eq(...(#(trait_params)))(
+          Eq(...#(trait_params))(
             (==) : ((lhs, rhs) -> #(match_body.to_expr()))
           )
         )
@@ -6670,7 +6676,7 @@ __derive_eq :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(t
     true =>
       ctx.make_impl(
         quote(
-          Eq(...(#(trait_params)))(
+          Eq(...#(trait_params))(
             (==) : ((lhs, rhs) -> true)
           )
         )
@@ -6951,7 +6957,7 @@ __derive_ord :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(
         (fc == 0) =>
           ctx.make_impl(
             quote(
-              Ord(...(#(trait_params)))(
+              Ord(...#(trait_params))(
                 (<) : ((lhs, rhs) -> false),
                 (<=) : ((lhs, rhs) -> true),
                 (>) : ((lhs, rhs) -> false),
@@ -6966,7 +6972,7 @@ __derive_ord :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(
           ge_body :: __derive_ord_struct_body(T, ">=");
           ctx.make_impl(
             quote(
-              Ord(...(#(trait_params)))(
+              Ord(...#(trait_params))(
                 (<) : ((lhs, rhs) -> #(lt_body.to_expr())),
                 (<=) : ((lhs, rhs) -> #(le_body.to_expr())),
                 (>) : ((lhs, rhs) -> #(gt_body.to_expr())),
@@ -7037,7 +7043,7 @@ __derive_ord :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(
       ge_match :: __gen_op_branches(">=", "true");
       ctx.make_impl(
         quote(
-          Ord(...(#(trait_params)))(
+          Ord(...#(trait_params))(
             (<) : ((lhs, rhs) -> #(lt_match.to_expr())),
             (<=) : ((lhs, rhs) -> #(le_match.to_expr())),
             (>) : ((lhs, rhs) -> #(gt_match.to_expr())),
@@ -7049,7 +7055,7 @@ __derive_ord :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comptime(
     true =>
       ctx.make_impl(
         quote(
-          Ord(...(#(trait_params)))(
+          Ord(...#(trait_params))(
             (<) : ((lhs, rhs) -> false),
             (<=) : ((lhs, rhs) -> true),
             (>) : ((lhs, rhs) -> false),
@@ -8145,7 +8151,7 @@ FutureState :: enum(
   Running = 1,
   /// The future completed successfully.
   Completed = -(1),
-  /// The future was aborted (e.g., via `escape`).
+  /// The future was aborted (e.g., via `unwind`).
   Aborted = -(2)
 );
 impl(FutureState, Acyclic());
@@ -8172,27 +8178,27 @@ export(JoinHandle);
 /// IO module — the async runtime effect.
 ///
 /// Provides `io.async`, `io.await`, `io.spawn`, and `io.state` operations.
-/// Automatically injected into `main` when declared with `using(io : IO)`.
+/// Automatically injected into `main` when declared with `io : IO`.
 IO :: struct(
   /// Create a new `Future` from an async closure.
-  async : (fn(forall(T : Type, ...(E)), action : Impl(Fn(using(...(E))) -> T)) -> Impl(Future(T, ...(E)))),
+  async : (fn(forall(T : Type, E : Type.Struct), action : Impl(Fn(e : E) -> T)) -> Impl(Future(T, E))),
   /// Await a `Future`, suspending until its result is ready.
-  await : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E))), using(...(E))) -> T),
+  await : (fn(forall(T : Type, E : Type.Struct), fut : Impl(Future(T, E)), e : E) -> T),
   /// Inspect the current state of a `Future` without blocking.
-  state : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E)))) -> FutureState),
+  state : (fn(forall(T : Type, E : Type), fut : Impl(Future(T, E))) -> FutureState),
   /// Spawn a `Future` as an independent task, returning a `JoinHandle`.
-  spawn : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E))), using(...(E))) -> JoinHandle(T))
+  spawn : (fn(forall(T : Type, E : Type.Struct), fut : Impl(Future(T, E)), e : E) -> JoinHandle(T))
 );
 export(IO);
 extern(
   "Yo",
-  __yo_io_async : (fn(forall(T : Type, ...(E)), action : Impl(Fn(using(...(E))) -> T)) -> Impl(Future(T, ...(E)))),
-  __yo_io_await : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E))), using(...(E))) -> T),
-  __yo_io_state : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E)))) -> FutureState),
-  __yo_io_spawn : (fn(forall(T : Type, ...(E)), fut : Impl(Future(T, ...(E))), using(...(E))) -> JoinHandle(T))
+  __yo_io_async : (fn(forall(T : Type, E : Type.Struct), action : Impl(Fn(e : E) -> T)) -> Impl(Future(T, E))),
+  __yo_io_await : (fn(forall(T : Type, E : Type.Struct), fut : Impl(Future(T, E)), e : E) -> T),
+  __yo_io_state : (fn(forall(T : Type, E : Type), fut : Impl(Future(T, E))) -> FutureState),
+  __yo_io_spawn : (fn(forall(T : Type, E : Type.Struct), fut : Impl(Future(T, E)), e : E) -> JoinHandle(T))
 );
 /// Built-in IO module instance. Automatically injected for `main` functions
-/// with `using(io : IO)`.
+/// with `io : IO`.
 __yo_builtin_io :: IO(
   async : __yo_io_async,
   await : __yo_io_await,
@@ -8200,10 +8206,10 @@ __yo_builtin_io :: IO(
   spawn : __yo_io_spawn
 );
 export(__yo_builtin_io);
-/// JoinHandle methods — defined after IO so `using(io : IO)` resolves.
+/// JoinHandle methods — defined after IO so `io : IO` resolves.
 extern(
   "Yo",
-  __yo_join_handle_await : (fn(forall(T : Type), self : JoinHandle(T), using(io : IO)) -> Option(T))
+  __yo_join_handle_await : (fn(forall(T : Type), self : JoinHandle(T), io : IO) -> Option(T))
 );
 impl(
   forall(T : Type),