@shd101wyy/yo 0.1.28 → 0.1.30

package/std/fs/temp.yo

@@ -5,25 +5,20 @@
 //! ```rust
 //! { TempDir } :: import "std/fs/temp";
 //!
-//! main :: (fn(using(io : IO)) -> unit)({
-//!   given(exn) : Exception = {
-//!     throw : (fn(forall(T : Type), error: AnyError) -> T)(
-//!       { println(error.to_string()); exit(i32(1)); }
-//!     )
-//!   };
-//!
-//!   dir := io.await(TempDir.new());
+//! main :: (fn(io : Io, exn : Exception) -> unit)({
+//!   dir := io.await(TempDir.new(io), { io, exn });
 //!   println(dir.path());
-//!   io.await(dir.remove());
+//!   io.await(dir.remove(io), { io, exn });
 //! });
 //! ```
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 open(import("../string"));
 open(import("../fmt"));
 { Path } :: import("../path");
-{ IOError } :: import("../sys/errors");
-{ Error, AnyError, Exception } :: import("../error");
+{ IoError } :: import("../sys/errors");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 _file_mod :: import("./file");
 _dir_mod :: import("./dir");
 IO_temp :: import("../sys/temp");
@@ -59,8 +54,8 @@ TempDir :: object(
 impl(
   TempDir,
   // Create a temporary directory in the given parent directory.
-  new_in : (fn(parent : Path, using(io : IO)) -> Impl(Future(TempDir, IO, Exception)))(
-    io.async((using(io, exn)) => {
+  new_in : (fn(parent : Path, io : Io) -> Impl(Future(TempDir, IoExn)))(
+    io.async((e) => {
       // Build template: parent/yo_tmp_XXXXXX
       template_path := parent.join(Path.new(`yo_tmp_XXXXXX`));
       template_str := template_path.to_string();
@@ -68,13 +63,19 @@ impl(
       template_bytes := template_str.as_bytes();
       buf_len := (template_bytes.len() + usize(1));
       buf := *(u8)(malloc(buf_len).unwrap());
-      memcpy(*(void)(buf), *(void)(template_bytes.ptr().unwrap()), template_bytes.len());
+      // SAFETY: `buf` is a fresh malloc'd `buf_len = template_bytes.len() + 1`
+      // byte buffer; we copy exactly `template_bytes.len()` bytes from
+      // `template_bytes`'s underlying storage (alive for the duration of this
+      // statement — it's the bytes of `template_str` which we own) and write
+      // the trailing NUL at `buf[template_bytes.len()]`. `buf` is freed in
+      // both the error branch and after `IO_temp.mkdtemp` returns.
+      unsafe(memcpy(*(void)(buf), *(void)(template_bytes.ptr().unwrap()), template_bytes.len()));
       (buf &+ template_bytes.len()).* = u8(0);
       result := IO_temp.mkdtemp(buf);
       cond(
         (result < i32(0)) => {
           free(.Some(*(void)(buf)));
-          exn.throw(dyn(IOError.from_errno(i32(0) - result)));
+          e.exn.throw(dyn(IoError.from_errno(i32(0) - result)));
         },
         true => ()
       );
@@ -84,22 +85,22 @@ impl(
     })
   ),
   // Create a temporary directory in the system temp dir.
-  new : (fn(using(io : IO)) -> Impl(Future(TempDir, IO, Exception)))(
-    TempDir.new_in(Path.new(_default_tmp_dir()))
+  new : (fn(io : Io) -> Impl(Future(TempDir, IoExn)))(
+    TempDir.new_in(Path.new(_default_tmp_dir()), io)
   ),
   // Get the path of the temporary directory.
   path : (fn(self : Self) -> Path)(
     self._path
   ),
   // Remove the temporary directory.
-  remove : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  remove : (fn(self : Self, io : Io) -> Impl(Future(unit, IoExn)))({
     self_path := self._path;
     io.async(
-      (using(io, exn)) =>
+      (e) =>
         cond(
           self._removed => (),
           true => {
-            io.await(_dir_mod.remove_dir(self_path));
+            e.io.await(_dir_mod.remove_dir(self_path, io), e);
             self._removed = true;
           }
         )
@@ -116,21 +117,25 @@ TempFile :: object(
 impl(
   TempFile,
   // Create a temporary file in the given parent directory.
-  new_in : (fn(parent : Path, using(io : IO)) -> Impl(Future(TempFile, IO, Exception)))(
-    io.async((using(io, exn)) => {
+  new_in : (fn(parent : Path, io : Io) -> Impl(Future(TempFile, IoExn)))(
+    io.async((e) => {
       // Build template: parent/yo_tmp_XXXXXX
       template_path := parent.join(Path.new(`yo_tmp_XXXXXX`));
       template_str := template_path.to_string();
       template_bytes := template_str.as_bytes();
       buf_len := (template_bytes.len() + usize(1));
       buf := *(u8)(malloc(buf_len).unwrap());
-      memcpy(*(void)(buf), *(void)(template_bytes.ptr().unwrap()), template_bytes.len());
+      // SAFETY: as in `TempDir.new_in` above — `buf` is a fresh malloc'd
+      // `template_bytes.len() + 1` byte buffer, we copy exactly the template
+      // bytes plus a trailing NUL. `buf` is freed in the error branch and
+      // released to mkstemp's owned-fd lifecycle on success.
+      unsafe(memcpy(*(void)(buf), *(void)(template_bytes.ptr().unwrap()), template_bytes.len()));
       (buf &+ template_bytes.len()).* = u8(0);
       fd := IO_temp.mkstemp(buf);
       cond(
         (fd < i32(0)) => {
           free(.Some(*(void)(buf)));
-          exn.throw(dyn(IOError.from_errno(i32(0) - fd)));
+          e.exn.throw(dyn(IoError.from_errno(i32(0) - fd)));
         },
         true => ()
       );
@@ -142,8 +147,8 @@ impl(
     })
   ),
   // Create a temporary file in the system temp dir.
-  new : (fn(using(io : IO)) -> Impl(Future(TempFile, IO, Exception)))(
-    TempFile.new_in(Path.new(_default_tmp_dir()))
+  new : (fn(io : Io) -> Impl(Future(TempFile, IoExn)))(
+    TempFile.new_in(Path.new(_default_tmp_dir()), io)
   ),
   // Get the underlying File object.
   file : (fn(self : Self) -> _file_mod.File)(
@@ -154,16 +159,16 @@ impl(
     self._path
   ),
   // Remove the temporary file.
-  remove : (fn(self : Self, using(io : IO)) -> Impl(Future(unit, IO, Exception)))({
+  remove : (fn(self : Self, io : Io) -> Impl(Future(unit, IoExn)))({
     self_file := self._file;
     self_path := self._path;
     io.async(
-      (using(io, exn)) =>
+      (e) =>
         cond(
           self._removed => (),
           true => {
-            io.await(self_file.close());
-            io.await(_dir_mod.remove_file(self_path));
+            e.io.await(self_file.close(io), e);
+            e.io.await(_dir_mod.remove_file(self_path, io), e);
             self._removed = true;
           }
         )

package/std/fs/walker.yo

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

package/std/gc.yo

@@ -1,4 +1,5 @@
 //! Garbage collection interface for cycle collection.
+pragma(Pragma.AllowUnsafe);
 extern(
   "Yo",
   __yo_gc_collect : (fn() -> unit),

package/std/glob.yo

@@ -17,12 +17,12 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
     },
     true => ()
   );
-  p := pb.get(pi).unwrap();
+  p := pb(pi);
   // Handle * and **
   cond(
     (p == u8(42)) => {
       is_dbl := cond(
-        ((pi + usize(1)) < pb.len()) => (pb.get(pi + usize(1)).unwrap() == u8(42)),
+        ((pi + usize(1)) < pb.len()) => (pb(pi + usize(1)) == u8(42)),
         true => false
       );
       cond(
@@ -33,7 +33,7 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
           cond(
             (npi < pb.len()) => {
               cond(
-                (pb.get(npi).unwrap() == u8(47)) => {
+                (pb(npi) == u8(47)) => {
                   npi = (npi + usize(1));
                 },
                 true => ()
@@ -70,7 +70,7 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
           // Try * consuming one non-/ char
           cond(
             (ti < tb.len()) => {
-              tc := tb.get(ti).unwrap();
+              tc := tb(ti);
               cond(
                 (tc != u8(47)) => {
                   return(recur(pb, pi, tb, ti + usize(1)));
@@ -96,7 +96,7 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
     },
     true => ()
   );
-  t := tb.get(ti).unwrap();
+  t := tb(ti);
   // Handle ?
   cond(
     (p == u8(63)) => {
@@ -119,7 +119,7 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
       // Check for negation: ! or ^
       cond(
         (ci < pb.len()) => {
-          nc := pb.get(ci).unwrap();
+          nc := pb(ci);
           cond(
             ((nc == u8(33)) || (nc == u8(94))) => {
               neg = true;
@@ -134,7 +134,7 @@ _glob_match_impl :: (fn(pb : ArrayList(u8), pi : usize, tb : ArrayList(u8), ti :
       found := false;
       cdone := false;
       while((ci < pb.len()) && (!(cdone)), ci = (ci + usize(1)), {
-        ch := pb.get(ci).unwrap();
+        ch := pb(ci);
         cond(
           (ch == u8(93)) => {
             cdone = true;

package/std/http/client.yo

@@ -8,20 +8,17 @@
 //   { fetch, HttpResponse } :: import "std/http";
 //   { Exception } :: import "std/error";
 //
-//   main :: (fn(using(io : IO)) -> unit)({
-//     given(exn) := Exception(throw : ((err) -> {
-//       println(err.message());
-//       escape ();
-//     }));
-//     resp := io.await(fetch(`http://example.com/api/data`, using(io)));
+//   main :: (fn(io : Io, exn : Exception) -> unit)({
+//     resp := io.await(fetch(`http://example.com/api/data`, io), { io, exn });
 //     println(resp.body);
 //   });
+pragma(Pragma.AllowUnsafe);
 open(import("../string"));
 { ArrayList } :: import("../collections/array_list");
 { GlobalAllocator } :: import("../allocator");
 { malloc, free } :: GlobalAllocator;
 open(import("../fmt"));
-{ Error, AnyError, Exception } :: import("../error");
+{ Error, AnyError, Exception, IoExn } :: import("../error");
 { TcpStream } :: import("../net/tcp");
 { IpAddr, SocketAddr } :: import("../net/addr");
 { lookup_host } :: import("../net/dns");
@@ -120,12 +117,12 @@ _find_header_end :: (fn(data : ArrayList(u8)) -> usize)({
   while(runtime(i < limit), {
     cond(
       (
-        (data.get(i).unwrap() == u8(13)) &&
+        (data(i) == u8(13)) &&
           (
-            (data.get(i + usize(1)).unwrap() == u8(10)) &&
+            (data(i + usize(1)) == u8(10)) &&
               (
-                (data.get(i + usize(2)).unwrap() == u8(13)) &&
-                  (data.get(i + usize(3)).unwrap() == u8(10))
+                (data(i + usize(2)) == u8(13)) &&
+                  (data(i + usize(3)) == u8(10))
               )
           )
       ) => {
@@ -143,7 +140,7 @@ _find_content_length :: (fn(data : ArrayList(u8), header_end : usize) -> i32)({
   header_bytes := ArrayList(u8).new();
   i := usize(0);
   while(runtime(i < header_end), {
-    header_bytes.push(data.get(i).unwrap());
+    header_bytes.push(data(i));
     i = (i + usize(1));
   });
   header_str := String.from_bytes(header_bytes).to_lowercase();
@@ -179,14 +176,14 @@ _find_content_length :: (fn(data : ArrayList(u8), header_end : usize) -> i32)({
 // ============================================================================
 // Internal: read full HTTP response from a TCP stream
 // ============================================================================
-_read_http_response :: (fn(stream : TcpStream, using(io : IO, exn : Exception)) -> String)({
+_read_http_response :: (fn(stream : TcpStream, e : IoExn) -> String)({
   buf_size := usize(8192);
   buf := *(u8)(malloc(buf_size).unwrap());
   result := ArrayList(u8).new();
   // Read until connection closes or we've read the full response
   done := false;
   while(runtime(!(done)), {
-    n := io.await(stream.read(buf, buf_size, using(io)));
+    n := e.io.await(stream.read(buf, buf_size, e.io), e);
     cond(
       (n <= i32(0)) => {
         done = true;
@@ -243,15 +240,15 @@ _read_http_response :: (fn(stream : TcpStream, using(io : IO, exn : Exception))
 ///
 /// ```rust
 /// opts := FetchOptions.new().with_method(.POST).with_body(`{"key": "value"}`);
-/// resp := io.await(fetch_with(`http://example.com/api`, opts, using(io)));
+/// resp := io.await(fetch_with(`http://example.com/api`, opts, io), { io, exn });
 /// ```
 fetch_with :: (
-  fn(url_str : String, opts : FetchOptions, using(io : IO)) ->
-    Impl(Future(HttpResponse, IO, Exception))
+  fn(url_str : String, opts : FetchOptions, io : Io) ->
+    Impl(Future(HttpResponse, IoExn))
 )(
-  io.async((using(io : IO, exn : Exception)) => {
+  io.async((e) => {
     // Parse URL
-    url := Url.parse(url_str.as_str(), using(exn));
+    url := Url.parse(url_str.as_str(), e.exn);
     // Validate scheme
     scheme := url.scheme();
     is_http := (scheme == `http`);
@@ -259,7 +256,7 @@ fetch_with :: (
     cond(
       (is_http || is_https) => (),
       true => {
-        exn.throw(dyn(HttpError.UnsupportedScheme(scheme)));
+        e.exn.throw(dyn(HttpError.UnsupportedScheme(scheme)));
       }
     );
     // Extract host
@@ -267,7 +264,7 @@ fetch_with :: (
       url.host(),
       .Some(h) => h,
       .None => {
-        exn.throw(dyn(HttpError.InvalidUrl(`missing host`)));
+        e.exn.throw(dyn(HttpError.InvalidUrl(`missing host`)));
         `_` // unreachable
       }
     );
@@ -281,17 +278,17 @@ fetch_with :: (
       )
     );
     // Resolve hostname to IP
-    addrs := io.await(lookup_host(host, using(io)));
+    addrs := e.io.await(lookup_host(host, e.io), e);
     cond(
       (addrs.len() == usize(0)) => {
-        exn.throw(dyn(HttpError.ConnectionFailed(`DNS resolution failed for ${host}`)));
+        e.exn.throw(dyn(HttpError.ConnectionFailed(`DNS resolution failed for ${host}`)));
       },
       true => ()
     );
-    ip := addrs.get(usize(0)).unwrap();
+    ip := addrs(usize(0));
     addr := SocketAddr.new(ip, port);
     // Connect
-    stream := io.await(TcpStream.connect(addr, using(io)));
+    stream := e.io.await(TcpStream.connect(addr, e.io), e);
     // Build the request path (include query string if present)
     req_path := url.path();
     cond(
@@ -313,7 +310,7 @@ fetch_with :: (
     // Add user-provided headers
     hi := usize(0);
     while(runtime(hi < opts.headers.len()), {
-      h := opts.headers.get(hi).unwrap();
+      h := opts.headers(hi);
       req.set_header(h.name, h.value);
       hi = (hi + usize(1));
     });
@@ -329,17 +326,17 @@ fetch_with :: (
     req.set_header(`Connection`, `close`);
     // Send request
     req_str := req.to_string();
-    io.await(stream.write_string(req_str, using(io)));
+    e.io.await(stream.write_string(req_str, e.io), e);
     // Read response
-    raw_response := _read_http_response(stream, using(io, exn));
+    raw_response := _read_http_response(stream, e);
     // Close connection
-    io.await(stream.close(using(io)));
+    e.io.await(stream.close(e.io), e);
     // Parse response
     match(
       parse_response(raw_response),
       .Ok(resp) => resp,
-      .Err(e) => {
-        exn.throw(dyn(HttpError.Other(e)));
+      .Err(err) => {
+        e.exn.throw(dyn(HttpError.Other(err)));
         HttpResponse.new(i32(0), ``) // unreachable
       }
     )
@@ -352,15 +349,15 @@ export(fetch_with);
 /// # Example
 ///
 /// ```rust
-/// resp := io.await(fetch(`http://example.com`, using(io)));
+/// resp := io.await(fetch(`http://example.com`, io), { io, exn });
 /// cond(resp.is_ok() => println(resp.body), true => println(`Error`));
 /// ```
 fetch :: (
-  fn(url_str : String, using(io : IO)) ->
-    Impl(Future(HttpResponse, IO, Exception))
+  fn(url_str : String, io : Io) ->
+    Impl(Future(HttpResponse, IoExn))
 )(
-  io.async((using(io : IO, exn : Exception)) => {
-    return(io.await(fetch_with(url_str, FetchOptions.new(), using(io))));
+  io.async((e) => {
+    return(e.io.await(fetch_with(url_str, FetchOptions.new(), e.io), e));
   })
 );
 export(fetch);

package/std/http/http.yo

@@ -71,7 +71,7 @@ impl(
     result := `${self.method.to_string()} ${self.path} HTTP/1.1\r\n`;
     i := usize(0);
     while(i < self.headers.len(), i = (i + usize(1)), {
-      h := self.headers.get(i).unwrap();
+      h := self.headers(i);
       result = `${result}${h.name}: ${h.value}\r\n`;
     });
     result = `${result}\r\n`;
@@ -102,7 +102,7 @@ impl(
     lower_name := name.to_lowercase();
     i := usize(0);
     while(i < self.headers.len(), i = (i + usize(1)), {
-      h := self.headers.get(i).unwrap();
+      h := self.headers(i);
       cond(
         (h.name.to_lowercase() == lower_name) => {
           return(.Some(h.value));
@@ -134,7 +134,7 @@ parse_response :: (fn(raw : String) -> Result(HttpResponse, String))({
     },
     true => ()
   );
-  status_line := lines.get(usize(0)).unwrap();
+  status_line := lines(usize(0));
   cond(
     (!(status_line.starts_with(`HTTP/`))) => {
       return(.Err(`Invalid status line`));
@@ -172,7 +172,7 @@ parse_response :: (fn(raw : String) -> Result(HttpResponse, String))({
   j := usize(1);
   body_start := lines.len();
   while(j < lines.len(), j = (j + usize(1)), {
-    hline := lines.get(j).unwrap();
+    hline := lines(j);
     cond(
       hline.is_empty() => {
         body_start = (j + usize(1));
@@ -194,10 +194,10 @@ parse_response :: (fn(raw : String) -> Result(HttpResponse, String))({
   });
   cond(
     (body_start < lines.len()) => {
-      resp.body = lines.get(body_start).unwrap();
+      resp.body = lines(body_start);
       m := (body_start + usize(1));
       while(m < lines.len(), m = (m + usize(1)), {
-        resp.body = `${resp.body}\r\n${lines.get(m).unwrap()}`;
+        resp.body = `${resp.body}\r\n${lines(m)}`;
       });
     },
     true => ()

package/std/http/index.yo

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

package/std/imm/list.yo

@@ -15,6 +15,7 @@
 //! assert((xs.head().unwrap() == i32(1)), "head is 1");
 //! assert((xs.len() == usize(3)), "length is 3");
 //! ```
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
 { memcpy } :: import("../libc/string.yo");
@@ -243,6 +244,38 @@ impl(
     })
   )
 );
+/// Index trait — `list(idx)` walks the chain and returns the element at
+/// `idx`, panicking on out-of-bounds. O(n). The Rc-managed `ListNode`
+/// keeps the value field on the heap, so `&(node._value)` is a valid
+/// pointer for the immediate read; the dispatcher inlines and
+/// dereferences before any drop runs.
+impl(
+  forall(T : Type),
+  where(T <: Send),
+  List(T),
+  Index(usize)(
+    Output : T,
+    index : (fn(ref(self) : Self, idx : usize) -> *(Self.Output))({
+      assert(idx < self._len, "imm.List: index out of bounds");
+      (current : Option(ListNode(T))) = self._head;
+      i := usize(0);
+      while(runtime(true), {
+        match(
+          current,
+          .Some(node) => {
+            if(i == idx, {
+              return(unsafe(&(node._value)));
+            });
+            current = node._next;
+            i = (i + usize(1));
+          },
+          .None => panic("imm.List: unreachable past length check")
+        );
+      });
+      panic("imm.List: index loop exited without return")
+    })
+  )
+);
 export(
   List,
   ListNode

package/std/imm/map.yo

@@ -14,9 +14,10 @@
 //! m := Map(i32, i32).new();
 //! m = m.insert(i32(1), i32(100));
 //! m = m.insert(i32(2), i32(200));
-//! assert((m.get(i32(1)).unwrap() == i32(100)), "key 1 maps to 100");
+//! assert((m(i32(1)) == i32(100)), "key 1 maps to 100");
 //! assert((m.len() == usize(2)), "two entries");
 //! ```
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
 /// Number of bits per HAMT level.

package/std/imm/set.yo

@@ -17,6 +17,7 @@
 //! assert(s.contains(i32(1)), "set contains 1");
 //! assert((s.len() == usize(2)), "two elements");
 //! ```
+pragma(Pragma.AllowUnsafe);
 { Map } :: import("./map.yo");
 { List } :: import("./list.yo");
 /// Persistent immutable hash set backed by a HAMT.

package/std/imm/sorted_map.yo

@@ -17,6 +17,7 @@
 //! m = m.insert(i32(2), i32(20));
 //! // keys are always sorted: 1, 2, 3
 //! ```
+pragma(Pragma.AllowUnsafe);
 { List } :: import("./list.yo");
 { Pair } :: import("./map.yo");
 /// Color of a red-black tree node.

package/std/imm/sorted_set.yo

@@ -17,6 +17,7 @@
 //! s = s.insert(i32(2));
 //! // elements are always sorted: 1, 2, 3
 //! ```
+pragma(Pragma.AllowUnsafe);
 { SortedMap } :: import("./sorted_map.yo");
 { List } :: import("./list.yo");
 /// Persistent immutable sorted set backed by a left-leaning red-black tree.