@shd101wyy/yo 0.1.25 → 0.1.27

package/std/net/tcp.yo

@@ -19,33 +19,27 @@
 //     stream := io.await(listener.accept());
 //     // ...
 //   });
-
-{ GlobalAllocator } :: import "../allocator";
+{ GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
-{ ArrayList } :: import "../collections/array_list";
-open import "../string";
-open import "../fmt";
-{ NetError } :: import "./errors";
-{ IOError } :: import "../sys/errors";
-{ IpAddr, SocketAddr } :: import "./addr";
-{ Error, AnyError, Exception } :: 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";
-
+{ ArrayList } :: import("../collections/array_list");
+open(import("../string"));
+open(import("../fmt"));
+{ NetError } :: import("./errors");
+{ IOError } :: import("../sys/errors");
+{ IpAddr, SocketAddr } :: import("./addr");
+{ Error, AnyError, Exception } :: 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");
 // ============================================================================
 // Internal helpers
 // ============================================================================
-
 // Convert a SocketAddr to a low-level SockAddr buffer.
-_make_sockaddr :: (fn(addr: SocketAddr) -> IO_tcp.SockAddr)(
-  match(addr.ip,
+_make_sockaddr :: (fn(addr : SocketAddr) -> IO_tcp.SockAddr)(
+  match(
+    addr.ip,
     .V4(a, b, c, d) => {
       // Build the IP string "a.b.c.d"
-      { snprintf } :: import "../libc/stdio";
+      { snprintf } :: import("../libc/stdio");
       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));
       IO_tcp.make_sockaddr_in(&(buf(usize(0))), addr.port)
@@ -55,36 +49,31 @@ _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)(
-  exn.throw(dyn NetError.from_io(IOError.from_errno(errno_val)))
+_throw_io :: (fn(errno_val : i32, using(exn : Exception)) -> unit)(
+  exn.throw(dyn(NetError.from_io(IOError.from_errno(errno_val))))
 );
-
 // ============================================================================
 // TcpStream (declared before TcpListener so accept can reference it)
 // ============================================================================
-
 /// A connected TCP stream for bidirectional data transfer.
 TcpStream :: object(
-  _fd        : i32,
+  _fd : i32,
   _peer_addr : SocketAddr,
   _is_closed : bool
 );
-
 // ============================================================================
 // TcpListener
 // ============================================================================
-
 /// A TCP socket that listens for incoming connections.
 TcpListener :: object(
-  _fd         : i32,
+  _fd : i32,
   _local_addr : SocketAddr,
-  _is_closed  : bool
+  _is_closed : bool
 );
-
-impl(TcpListener,
+impl(
+  TcpListener,
   /// Bind to a socket address and start listening.
-  bind : (fn(addr: SocketAddr, using(io : IO)) -> Impl(Future(TcpListener, IO, Exception)))(
+  bind : (fn(addr : SocketAddr, using(io : IO)) -> Impl(Future(TcpListener, IO, Exception)))(
     io.async((using(io : IO, exn : Exception)) => {
       domain := cond(
         addr.ip.is_v4() => AF_INET,
@@ -95,7 +84,7 @@ impl(TcpListener,
       fd := NetError.check(raw_fd);
       // Set SO_REUSEADDR
       reuse_val := i32(1);
-      reuse_ptr := &reuse_val;
+      reuse_ptr := &(reuse_val);
       io.await(IO_tcp.setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, *(u8)(reuse_ptr), u32(4)));
       // Bind
       saddr := _make_sockaddr(addr);
@@ -104,7 +93,7 @@ impl(TcpListener,
       cond(
         (bind_result < i32(0)) => {
           io.await(IO_tcp.close(fd));
-          _throw_io((i32(0) - bind_result));
+          _throw_io(i32(0) - bind_result);
         },
         true => ()
       );
@@ -113,16 +102,15 @@ impl(TcpListener,
       cond(
         (listen_result < i32(0)) => {
           io.await(IO_tcp.close(fd));
-          _throw_io((i32(0) - listen_result));
+          _throw_io(i32(0) - listen_result);
         },
         true => ()
       );
-      return TcpListener(_fd: fd, _local_addr: addr, _is_closed: false);
+      return(TcpListener(_fd : fd, _local_addr : addr, _is_closed : false));
     })
   ),
-
   /// Accept an incoming connection, returning a new `TcpStream`.
-  accept : (fn(self: Self, using(io : IO)) -> Impl(Future(TcpStream, IO, Exception)))({
+  accept : (fn(self : Self, using(io : IO)) -> Impl(Future(TcpStream, IO, Exception)))({
     fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       // Allocate space for the peer address
@@ -134,7 +122,7 @@ impl(TcpListener,
         (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);
         },
         true => ()
       );
@@ -143,21 +131,21 @@ impl(TcpListener,
       free(.Some(*(void)(addr_buf)));
       free(.Some(*(void)(addr_len)));
       peer_addr := SocketAddr.new(IpAddr.any_v4(), peer_port);
-      return TcpStream(
-        _fd: client_fd,
-        _peer_addr: peer_addr,
-        _is_closed: false
+      return(
+        TcpStream(
+          _fd : client_fd,
+          _peer_addr : peer_addr,
+          _is_closed : false
+        )
       );
     })
   }),
-
   /// Get the local address this listener is bound to.
-  local_addr : (fn(self: Self) -> SocketAddr)(
+  local_addr : (fn(self : Self) -> SocketAddr)(
     self._local_addr
   ),
-
   /// Close the listener socket.
-  close : (fn(self: Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  close : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       cond(
@@ -166,42 +154,43 @@ impl(TcpListener,
           r := io.await(IO_tcp.close(fd));
           self._is_closed = true;
           cond(
-            (r < i32(0)) => { _throw_io((i32(0) - r)); },
+            (r < i32(0)) => {
+              _throw_io(i32(0) - r);
+            },
             true => ()
           );
         }
       );
     })
   }),
-
   /// Get the underlying file descriptor.
-  fd : (fn(self: Self) -> i32)(
+  fd : (fn(self : Self) -> i32)(
     self._fd
   )
 );
-
-impl(TcpListener, Dispose(
-  dispose : (fn(self: Self) -> unit)({
-    cond(
-      (!(self._is_closed)) => {
-        { close_sync } :: import "../sys/file";
-        close_sync(self._fd);
-        self._is_closed = true;
-      },
-      true => ()
-    );
-  })
-));
-
-export TcpListener;
-
+impl(
+  TcpListener,
+  Dispose(
+    dispose : (fn(self : Self) -> unit)({
+      cond(
+        (!(self._is_closed)) => {
+          { close_sync } :: import("../sys/file");
+          close_sync(self._fd);
+          self._is_closed = true;
+        },
+        true => ()
+      );
+    })
+  )
+);
+export(TcpListener);
 // ============================================================================
 // TcpStream impl
 // ============================================================================
-
-impl(TcpStream,
+impl(
+  TcpStream,
   /// Connect to a remote address, returning a new `TcpStream`.
-  connect : (fn(addr: SocketAddr, using(io : IO)) -> Impl(Future(TcpStream, IO, Exception)))(
+  connect : (fn(addr : SocketAddr, using(io : IO)) -> Impl(Future(TcpStream, IO, Exception)))(
     io.async((using(io : IO, exn : Exception)) => {
       domain := cond(
         addr.ip.is_v4() => AF_INET,
@@ -215,31 +204,31 @@ impl(TcpStream,
       cond(
         (conn_result < i32(0)) => {
           io.await(IO_tcp.close(fd));
-          _throw_io((i32(0) - conn_result));
+          _throw_io(i32(0) - conn_result);
         },
         true => ()
       );
-      return TcpStream(
-        _fd: fd,
-        _peer_addr: addr,
-        _is_closed: false
+      return(
+        TcpStream(
+          _fd : fd,
+          _peer_addr : addr,
+          _is_closed : false
+        )
       );
     })
   ),
-
   /// 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, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       r := io.await(IO_tcp.recv(fd, buf, size, i32(0)));
       NetError.check(r)
     })
   }),
-
   /// 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, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
     s := String.from(data);
     s_bytes := s.as_bytes();
@@ -248,10 +237,9 @@ impl(TcpStream,
       NetError.check(r)
     })
   }),
-
   /// 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, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
     data_bytes := data.as_bytes();
     io.async((using(io : IO, exn : Exception)) => {
@@ -259,65 +247,63 @@ impl(TcpStream,
       NetError.check(r)
     })
   }),
-
   /// 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), using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     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)
     })
   }),
-
   /// 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, using(io : IO)) -> Impl(Future(ArrayList(u8), IO, Exception)))({
     fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       buf_size := usize(4096);
       buf := *(u8)(malloc(buf_size).unwrap());
       acc := ArrayList(u8).new();
       done := false;
-      while runtime(!(done)), {
+      while(runtime(!(done)), {
         n := io.await(IO_tcp.recv(fd, buf, buf_size, i32(0)));
         cond(
           (n < i32(0)) => {
             free(.Some(*(void)(buf)));
             done = true;
-            _throw_io((i32(0) - n));
+            _throw_io(i32(0) - n);
           },
           (n == i32(0)) => {
             done = true;
           },
           true => {
             i := usize(0);
-            while runtime((i < usize(n))), {
+            while(runtime(i < usize(n)), {
               acc.push((buf &+ i).*);
               i = (i + usize(1));
-            };
+            });
           }
         );
-      };
+      });
       free(.Some(*(void)(buf)));
-      return acc;
+      return(acc);
     })
   }),
-
   /// 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, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       r := io.await(IO_tcp.shutdown(fd, how));
       cond(
-        (r < i32(0)) => { _throw_io((i32(0) - r)); },
+        (r < i32(0)) => {
+          _throw_io(i32(0) - r);
+        },
         true => ()
       );
     })
   }),
-
   /// Close the stream.
-  close : (fn(self: Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  close : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       cond(
@@ -326,64 +312,67 @@ impl(TcpStream,
           r := io.await(IO_tcp.close(fd));
           self._is_closed = true;
           cond(
-            (r < i32(0)) => { _throw_io((i32(0) - r)); },
+            (r < i32(0)) => {
+              _throw_io(i32(0) - r);
+            },
             true => ()
           );
         }
       );
     })
   }),
-
   /// Get the remote peer's socket address.
-  peer_addr : (fn(self: Self) -> SocketAddr)(
+  peer_addr : (fn(self : Self) -> SocketAddr)(
     self._peer_addr
   ),
-
   /// Get the underlying file descriptor.
-  fd : (fn(self: Self) -> i32)(
+  fd : (fn(self : Self) -> i32)(
     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, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     sock_fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       val := cond(nodelay => i32(1), true => i32(0));
-      val_ptr := &val;
+      val_ptr := &(val);
       r := io.await(IO_tcp.setsockopt(sock_fd, IPPROTO_TCP, TCP_NODELAY, *(u8)(val_ptr), u32(4)));
       cond(
-        (r < i32(0)) => { _throw_io((i32(0) - r)); },
+        (r < i32(0)) => {
+          _throw_io(i32(0) - r);
+        },
         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, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     sock_fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       val := cond(enabled => i32(1), true => i32(0));
-      val_ptr := &val;
+      val_ptr := &(val);
       r := io.await(IO_tcp.setsockopt(sock_fd, SOL_SOCKET, SO_KEEPALIVE, *(u8)(val_ptr), u32(4)));
       cond(
-        (r < i32(0)) => { _throw_io((i32(0) - r)); },
+        (r < i32(0)) => {
+          _throw_io(i32(0) - r);
+        },
         true => ()
       );
     })
   })
 );
-
-impl(TcpStream, Dispose(
-  dispose : (fn(self: Self) -> unit)({
-    cond(
-      (!(self._is_closed)) => {
-        { close_sync } :: import "../sys/file";
-        close_sync(self._fd);
-        self._is_closed = true;
-      },
-      true => ()
-    );
-  })
-));
-
-export TcpStream;
+impl(
+  TcpStream,
+  Dispose(
+    dispose : (fn(self : Self) -> unit)({
+      cond(
+        (!(self._is_closed)) => {
+          { close_sync } :: import("../sys/file");
+          close_sync(self._fd);
+          self._is_closed = true;
+        },
+        true => ()
+      );
+    })
+  )
+);
+export(TcpStream);

package/std/net/udp.yo

@@ -18,30 +18,25 @@
 //     sock := io.await(UdpSocket.bind(addr));
 //     io.await(sock.close());
 //   });
-
-{ GlobalAllocator } :: import "../allocator";
+{ GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
-{ ArrayList } :: import "../collections/array_list";
-open import "../string";
-open import "../fmt";
-{ NetError } :: import "./errors";
-{ IOError } :: import "../sys/errors";
-{ IpAddr, SocketAddr } :: import "./addr";
-{ Error, AnyError, Exception } :: 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";
-{ snprintf } :: import "../libc/stdio";
-
+{ ArrayList } :: import("../collections/array_list");
+open(import("../string"));
+open(import("../fmt"));
+{ NetError } :: import("./errors");
+{ IOError } :: import("../sys/errors");
+{ IpAddr, SocketAddr } :: import("./addr");
+{ Error, AnyError, Exception } :: 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");
+{ snprintf } :: import("../libc/stdio");
 // ============================================================================
 // Internal helpers
 // ============================================================================
-
-_make_sockaddr :: (fn(addr: SocketAddr) -> IO_tcp.SockAddr)(
-  match(addr.ip,
+_make_sockaddr :: (fn(addr : SocketAddr) -> IO_tcp.SockAddr)(
+  match(
+    addr.ip,
     .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));
@@ -51,25 +46,22 @@ _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)(
-  exn.throw(dyn NetError.from_io(IOError.from_errno(errno_val)))
+_throw_net_io :: (fn(errno_val : i32, using(exn : Exception)) -> unit)(
+  exn.throw(dyn(NetError.from_io(IOError.from_errno(errno_val))))
 );
-
 // ============================================================================
 // UdpSocket
 // ============================================================================
-
 /// A UDP socket for sending and receiving datagrams.
 UdpSocket :: object(
-  _fd         : i32,
+  _fd : i32,
   _local_addr : SocketAddr,
-  _is_closed  : bool
+  _is_closed : bool
 );
-
-impl(UdpSocket,
+impl(
+  UdpSocket,
   /// Create and bind a UDP socket to the given address.
-  bind : (fn(addr: SocketAddr, using(io : IO)) -> Impl(Future(UdpSocket, IO, Exception)))(
+  bind : (fn(addr : SocketAddr, using(io : IO)) -> Impl(Future(UdpSocket, IO, Exception)))(
     io.async((using(io : IO, exn : Exception)) => {
       domain := cond(
         addr.ip.is_v4() => AF_INET,
@@ -83,17 +75,16 @@ impl(UdpSocket,
       cond(
         (bind_r < i32(0)) => {
           io.await(IO_udp.close(fd));
-          _throw_net_io((i32(0) - bind_r));
+          _throw_net_io(i32(0) - bind_r);
         },
         true => ()
       );
-      return UdpSocket(_fd: fd, _local_addr: addr, _is_closed: false);
+      return(UdpSocket(_fd : fd, _local_addr : addr, _is_closed : false));
     })
   ),
-
   /// 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, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       saddr := _make_sockaddr(addr);
@@ -102,38 +93,34 @@ impl(UdpSocket,
       NetError.check(r)
     })
   }),
-
   /// 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, using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       r := io.await(IO_udp.recv(fd, buf, size, i32(0)));
       NetError.check(r)
     })
   }),
-
   /// 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), using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     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)
     })
   }),
-
   /// 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), using(io : IO)) -> Impl(Future(i32, IO, Exception)))({
     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)
     })
   }),
-
   /// Close the socket.
-  close : (fn(self: Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  close : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       cond(
@@ -142,50 +129,52 @@ impl(UdpSocket,
           r := io.await(IO_udp.close(fd));
           self._is_closed = true;
           cond(
-            (r < i32(0)) => { _throw_net_io((i32(0) - r)); },
+            (r < i32(0)) => {
+              _throw_net_io(i32(0) - r);
+            },
             true => ()
           );
         }
       );
     })
   }),
-
   /// 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, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
     fd := self._fd;
     io.async((using(io : IO, exn : Exception)) => {
       val := cond(enabled => i32(1), true => i32(0));
-      val_ptr := &val;
+      val_ptr := &(val);
       r := io.await(IO_udp.setsockopt(fd, SOL_SOCKET, SO_BROADCAST, *(u8)(val_ptr), u32(4)));
       cond(
-        (r < i32(0)) => { _throw_net_io((i32(0) - r)); },
+        (r < i32(0)) => {
+          _throw_net_io(i32(0) - r);
+        },
         true => ()
       );
     })
   }),
-
   /// Get the local address this socket is bound to.
-  local_addr : (fn(self: Self) -> SocketAddr)(
+  local_addr : (fn(self : Self) -> SocketAddr)(
     self._local_addr
   ),
-
   /// Get the underlying file descriptor.
-  fd : (fn(self: Self) -> i32)(
+  fd : (fn(self : Self) -> i32)(
     self._fd
   )
 );
-
-impl(UdpSocket, Dispose(
-  dispose : (fn(self: Self) -> unit)({
-    cond(
-      (!(self._is_closed)) => {
-        { close_sync } :: import "../sys/file";
-        close_sync(self._fd);
-        self._is_closed = true;
-      },
-      true => ()
-    );
-  })
-));
-
-export UdpSocket;
+impl(
+  UdpSocket,
+  Dispose(
+    dispose : (fn(self : Self) -> unit)({
+      cond(
+        (!(self._is_closed)) => {
+          { close_sync } :: import("../sys/file");
+          close_sync(self._fd);
+          self._is_closed = true;
+        },
+        true => ()
+      );
+    })
+  )
+);
+export(UdpSocket);