@shd101wyy/yo 0.1.29 → 0.1.30

package/std/collections/hash_map.yo

@@ -1,4 +1,5 @@
 //! Hash map using SwissTable algorithm with SIMD-accelerated lookup.
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator, AllocError } :: import("../allocator.yo");
 { malloc, calloc, realloc, free } :: GlobalAllocator;
 /// Error variants for HashMap operations.
@@ -491,7 +492,7 @@ impl(
   HashMapIter(K, V),
   Iterator(
     Item : Bucket(K, V),
-    next : (fn(self : *(Self)) -> Option(Bucket(K, V)))(
+    next : (fn(ref(self) : Self) -> Option(Bucket(K, V)))(
       cond(
         (self._map.capacity == usize(0)) =>.None,
         true => {
@@ -537,7 +538,7 @@ impl(
   HashMapIterPtr(K, V),
   Iterator(
     Item : *(Bucket(K, V)),
-    next : (fn(self : *(Self)) -> Option(*(Bucket(K, V))))(
+    next : (fn(ref(self) : Self) -> Option(*(Bucket(K, V))))(
       cond(
         (self._map.capacity == usize(0)) =>.None,
         true => {
@@ -563,8 +564,12 @@ impl(
   forall(K : Type, V : Type),
   where(K <: (Eq(K), Hash)),
   HashMap(K, V),
-  iter : (fn(self : *(Self)) -> HashMapIterPtr(K, V))(
-    HashMapIterPtr(K, V)(_map : self.*, _index : usize(0))
+  /// Pointer iterator — yields `*(Bucket(K, V))` for each occupied bucket.
+  /// Kept as a separate method (not `iter()`) so the Phase D for-macro's
+  /// `coll.iter()` call dispatches to the position-iter variant defined
+  /// later in the file, enabling `for(map, ref(b) => body)`.
+  iter_ptr : (fn(self : Self) -> HashMapIterPtr(K, V))(
+    HashMapIterPtr(K, V)(_map : self, _index : usize(0))
   )
 );
 /**
@@ -581,7 +586,7 @@ impl(
   HashMapKeys(K, V),
   Iterator(
     Item : K,
-    next : (fn(self : *(Self)) -> Option(K))(
+    next : (fn(ref(self) : Self) -> Option(K))(
       match(
         self._inner.next(),
         .None =>.None,
@@ -612,7 +617,7 @@ impl(
   HashMapValues(K, V),
   Iterator(
     Item : V,
-    next : (fn(self : *(Self)) -> Option(V))(
+    next : (fn(ref(self) : Self) -> Option(V))(
       match(
         self._inner.next(),
         .None =>.None,
@@ -634,13 +639,13 @@ impl(
   HashMap(K, V),
   Index(K)(
     Output : V,
-    index : (fn(self : *(Self), idx : K, where(K <: (Eq(K), Hash))) -> *(Self.Output))({
+    index : (fn(ref(self) : Self, idx : K, where(K <: (Eq(K), Hash))) -> *(Self.Output))({
       hash := idx.hash();
-      bucket_opt := Self._find_bucket(self.*, idx, hash);
+      bucket_opt := Self._find_bucket(self, idx, hash);
       match(
         bucket_opt,
         .Some(i) => {
-          data_ptr := Self._data_ptr(self.*);
+          data_ptr := Self._data_ptr(self);
           &((data_ptr &+ i).*.value)
         },
         .None => panic("HashMap: key not found")
@@ -648,15 +653,93 @@ impl(
     })
   )
 );
+/// Position iterator for HashMap that walks occupied buckets and yields
+/// their bucket indices. Pairs with the `Indexable(usize)` impl below to
+/// make `for(map, ref(b) => body)` legal: `b` becomes a `ref(Bucket(K, V))`
+/// and the loop body can destructure `b.key` / `b.value`.
+HashMapPosIter :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
+  struct(
+    _map : HashMap(K, V),
+    _index : usize
+  )
+);
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMapPosIter(K, V),
+  Iterator(
+    Item : usize,
+    next : (fn(ref(self) : Self) -> Option(usize))(
+      cond(
+        (self._map.capacity == usize(0)) =>.None,
+        true => {
+          ctrl_ptr := self._map.ctrl.unwrap();
+          result := Option(usize).None;
+          while((self._index < self._map.capacity) && result.is_none(), self._index = (self._index + usize(1)), {
+            ctrl_byte := (ctrl_ptr &+ self._index).*;
+            cond(
+              ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
+                result =.Some(self._index);
+              },
+              true => ()
+            );
+          });
+          result
+        }
+      )
+    )
+  )
+);
+/// Indexable(usize) — projects an occupied bucket index back to a
+/// `ref(Bucket(K, V))` so `for(map, ref(b) => ...)` works. The body of
+/// `for` (Phase D) calls `coll.iter()` to obtain a position iter and
+/// then `coll.project(pos)` for each yielded position. We override
+/// `iter` for HashMap to return the position-iter rather than the
+/// `*(Bucket)` iter — the for-macro only cares about which yields
+/// positions consumable by `project`.
+///
+/// See plans/ITERATOR_REDESIGN.md Open Question 3. The choice here is
+/// "projection-returns a single Bucket struct, user destructures
+/// inside the loop" — chosen over the rejected `(ref(K), ref(V))`
+/// tuple-of-inouts shape.
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMap(K, V),
+  Indexable(usize)(
+    Element : Bucket(K, V),
+    project : (fn(ref(self) : Self, pos : usize) -> ref(Bucket(K, V)))(
+      cond(
+        (pos >= self.capacity) => panic("HashMap: project out of bounds"),
+        // SAFETY: cond above bounds `pos`; `_data_ptr` returns the
+        // start of the Rc-managed _data buffer, which is alive while
+        // `self` holds the Rc.
+        true => unsafe(Self._data_ptr(self) &+ pos)
+      )
+    )
+  )
+);
+/// Position-iter constructor for HashMap (paired with the Indexable
+/// impl above): `iter()` yields each occupied bucket index, and the
+/// for-macro then calls `coll.project(pos)` to materialize the
+/// `ref(Bucket)` borrow for the body.
+impl(
+  forall(K : Type, V : Type),
+  where(K <: (Eq(K), Hash)),
+  HashMap(K, V),
+  iter : (fn(self : Self) -> HashMapPosIter(K, V))(
+    HashMapPosIter(K, V)(_map : self, _index : usize(0))
+  )
+);
 /// Clone implementation for HashMap — deep-clones all key-value entries.
 impl(
   forall(K : Type, V : Type),
   where(K <: (Clone, Eq(K), Hash), V <: Clone),
   HashMap(K, V),
   Clone(
-    clone : (fn(self : *(Self)) -> Self)({
+    clone : (fn(ref(self) : Self) -> Self)({
       result := Self.new();
-      it := self.iter();
+      it := self.iter_ptr();
       running := true;
       while(running, {
         nxt := it.next();
@@ -666,8 +749,13 @@ impl(
             running = false;
           },
           .Some(bucket_ptr) => {
-            k := (&(bucket_ptr.*.key)).clone();
-            v := (&(bucket_ptr.*.value)).clone();
+            // SAFETY: iter_ptr().next() returns .Some(p) only when p
+            // points at an occupied bucket within the Rc-managed
+            // _data buffer; the buffer is alive while `self` holds
+            // the Rc (we received `ref(self)` so the caller still
+            // owns it across this call).
+            k := unsafe(bucket_ptr.*.key.clone());
+            v := unsafe(bucket_ptr.*.value.clone());
             result.set(k, v);
           }
         );

package/std/collections/hash_set.yo

@@ -1,4 +1,5 @@
 //! Hash set using SwissTable algorithm with set-theoretic operations.
+pragma(Pragma.AllowUnsafe);
 { GlobalAllocator, AllocError } :: import("../allocator.yo");
 { malloc, calloc, realloc, free } :: GlobalAllocator;
 /// Error variants for HashSet operations.
@@ -688,7 +689,7 @@ impl(
   HashSetIter(T),
   Iterator(
     Item : T,
-    next : (fn(self : *(Self)) -> Option(T))(
+    next : (fn(ref(self) : Self) -> Option(T))(
       cond(
         (self._set.capacity == usize(0)) =>.None,
         true => {
@@ -734,7 +735,7 @@ impl(
   HashSetIterPtr(T),
   Iterator(
     Item : *(T),
-    next : (fn(self : *(Self)) -> Option(*(T)))(
+    next : (fn(ref(self) : Self) -> Option(*(T)))(
       cond(
         (self._set.capacity == usize(0)) =>.None,
         true => {
@@ -760,8 +761,8 @@ impl(
   forall(T : Type),
   where(T <: (Eq(T), Hash)),
   HashSet(T),
-  iter : (fn(self : *(Self)) -> HashSetIterPtr(T))(
-    HashSetIterPtr(T)(_set : self.*, _index : usize(0))
+  iter : (fn(self : Self) -> HashSetIterPtr(T))(
+    HashSetIterPtr(T)(_set : self, _index : usize(0))
   )
 );
 export(

package/std/collections/linked_list.yo

@@ -1,5 +1,6 @@
 //! Doubly-linked list with O(1) push/pop at both ends.
 /// Error variants for LinkedList operations.
+pragma(Pragma.AllowUnsafe);
 LinkedListError :: enum(
   /// Index is out of bounds for the current length.
   IndexOutOfBounds(index : usize, length : usize),
@@ -409,7 +410,7 @@ impl(
   LinkedListIter(T),
   Iterator(
     Item : T,
-    next : (fn(self : *(Self)) -> Option(T))(
+    next : (fn(ref(self) : Self) -> Option(T))(
       match(
         self._current,
         .None =>.None,
@@ -443,7 +444,7 @@ impl(
   LinkedListIterPtr(T),
   Iterator(
     Item : *(T),
-    next : (fn(self : *(Self)) -> Option(*(T)))(
+    next : (fn(ref(self) : Self) -> Option(*(T)))(
       match(
         self._current,
         .None =>.None,
@@ -458,8 +459,42 @@ impl(
 impl(
   forall(T : Type),
   LinkedList(T),
-  iter : (fn(self : *(Self)) -> LinkedListIterPtr(T))(
-    LinkedListIterPtr(T)(_current : self.*.head)
+  iter : (fn(self : Self) -> LinkedListIterPtr(T))(
+    LinkedListIterPtr(T)(_current : self.head)
+  )
+);
+/// Index trait — `list(idx)` returns the element at `idx`. O(n) walk.
+/// `&(node.value)` is a valid heap pointer while `self` keeps the
+/// Rc chain alive — the dispatcher inlines and dereferences this
+/// before any drop runs. Same pattern as `LinkedListIterPtr.next`.
+impl(
+  forall(T : Type),
+  LinkedList(T),
+  Index(usize)(
+    Output : T,
+    index : (fn(ref(self) : Self, idx : usize) -> *(Self.Output))({
+      assert(idx < self.length, "LinkedList: index out of bounds");
+      (current : Option(Node(T))) = self.head;
+      i := usize(0);
+      while(runtime(true), {
+        match(
+          current,
+          .Some(node) => {
+            if(i == idx, {
+              // SAFETY: `node` is held in an Rc-managed chain rooted
+              // at `self.head`; while `self` is borrowed (ref(self))
+              // every node we've walked stays alive, so `&node.value`
+              // is a valid borrow into Rc storage.
+              return(unsafe(&(node.value)));
+            });
+            current = node.next;
+            i = (i + usize(1));
+          },
+          .None => panic("LinkedList: unreachable past length check")
+        );
+      });
+      panic("LinkedList: index loop exited without return")
+    })
   )
 );
 export(

package/std/collections/ordered_map.yo

@@ -142,7 +142,7 @@ impl(
   forall(K : Type, V : Type),
   where(K <: (Eq(K), Hash)),
   OrderedMapKeys(K, V),
-  next : (fn(self : *(Self)) -> Option(K))({
+  next : (fn(ref(self) : Self) -> Option(K))({
     cond(
       (self._index >= self._map._order.len()) => {
         return(.None);
@@ -171,7 +171,7 @@ impl(
   forall(K : Type, V : Type),
   where(K <: (Eq(K), Hash)),
   OrderedMapValues(K, V),
-  next : (fn(self : *(Self)) -> Option(V))({
+  next : (fn(ref(self) : Self) -> Option(V))({
     cond(
       (self._index >= self._map._order.len()) => {
         return(.None);
@@ -219,7 +219,7 @@ impl(
   forall(K : Type, V : Type),
   where(K <: (Eq(K), Hash)),
   OrderedMapIter(K, V),
-  next : (fn(self : *(Self)) -> Option(OrderedMapEntry(K, V)))({
+  next : (fn(ref(self) : Self) -> Option(OrderedMapEntry(K, V)))({
     cond(
       (self._index >= self._map._order.len()) => {
         return(.None);

package/std/collections/priority_queue.yo

@@ -11,6 +11,7 @@
 //! pq.push(3);
 //! x := pq.pop().unwrap();  // 1
 //! ```
+pragma(Pragma.AllowUnsafe);
 { ArrayList } :: import("./array_list");
 /// Min-heap backed by an ArrayList.
 /// Elements are ordered ascending (smallest first). Negate keys for max-heap behavior.
@@ -48,8 +49,8 @@ impl(
     i := (self._data.len() - usize(1));
     while(i > usize(0), {
       parent := ((i - usize(1)) / usize(2));
-      child_val := self._data.get(i).unwrap();
-      parent_val := self._data.get(parent).unwrap();
+      child_val := self._data(i);
+      parent_val := self._data(parent);
       cond(
         (child_val < parent_val) => {
           &(self._data(i)).* = parent_val;
@@ -68,8 +69,8 @@ impl(
     cond(
       (n == usize(0)) =>.None,
       true => {
-        top := self._data.get(usize(0)).unwrap();
-        last := self._data.get(n - usize(1)).unwrap();
+        top := self._data(usize(0));
+        last := self._data(n - usize(1));
         &(self._data(usize(0))).* = last;
         self._data.pop();
         // Sift down
@@ -80,13 +81,13 @@ impl(
           smallest := i;
           new_n := self._data.len();
           cond(
-            ((left < new_n) && (self._data.get(left).unwrap() < self._data.get(smallest).unwrap())) => {
+            ((left < new_n) && (self._data(left) < self._data(smallest))) => {
               smallest = left;
             },
             true => ()
           );
           cond(
-            ((right < new_n) && (self._data.get(right).unwrap() < self._data.get(smallest).unwrap())) => {
+            ((right < new_n) && (self._data(right) < self._data(smallest))) => {
               smallest = right;
             },
             true => ()
@@ -96,8 +97,8 @@ impl(
               break;
             },
             true => {
-              a := self._data.get(i).unwrap();
-              b := self._data.get(smallest).unwrap();
+              a := self._data(i);
+              b := self._data(smallest);
               &(self._data(i)).* = b;
               &(self._data(smallest)).* = a;
               i = smallest;
@@ -124,11 +125,11 @@ impl(
   PriorityQueueIter(T),
   Iterator(
     Item : T,
-    next : (fn(self : *(Self)) -> Option(T))(
+    next : (fn(ref(self) : Self) -> Option(T))(
       cond(
         (self._index >= self._data.len()) =>.None,
         true => {
-          value := self._data.get(self._index).unwrap();
+          value := self._data(self._index);
           self._index = (self._index + usize(1));
           .Some(value)
         }
@@ -157,7 +158,7 @@ impl(
   PriorityQueueIterPtr(T),
   Iterator(
     Item : *(T),
-    next : (fn(self : *(Self)) -> Option(*(T)))(
+    next : (fn(ref(self) : Self) -> Option(*(T)))(
       cond(
         (self._index >= self._data.len()) =>.None,
         true =>
@@ -177,8 +178,8 @@ impl(
 impl(
   forall(T : Type),
   PriorityQueue(T),
-  iter : (fn(self : *(Self)) -> PriorityQueueIterPtr(T))(
-    PriorityQueueIterPtr(T)(_data : self.*._data, _index : usize(0))
+  iter : (fn(ref(self) : Self) -> PriorityQueueIterPtr(T))(
+    PriorityQueueIterPtr(T)(_data : self._data, _index : usize(0))
   )
 );
 export(

package/std/crypto/md5.yo

@@ -8,6 +8,7 @@
 //!
 //! digest := md5_hex(data);  // "5d41402abc4b2a76b9719d911017c592"
 //! ```
+pragma(Pragma.AllowUnsafe);
 { ArrayList } :: import("../collections/array_list");
 { hex_encode } :: import("../encoding/hex");
 open(import("../string"));
@@ -213,7 +214,7 @@ md5 :: (fn(data : ArrayList(u8)) -> Array(u8, usize(16)))({
   rem := (n - i);
   j := usize(0);
   while(j < rem, j = (j + usize(1)), {
-    (pad_ptr &+ j).* = data.get(i + j).unwrap();
+    (pad_ptr &+ j).* = data(i + j);
   });
   (pad_ptr &+ rem).* = u8(0x80);
   cond(

package/std/crypto/random.yo

@@ -9,6 +9,7 @@
 //!
 //! id := uuid_v4();  // "550e8400-e29b-41d4-a716-446655440000"
 //! ```
+pragma(Pragma.AllowUnsafe);
 { ArrayList } :: import("../collections/array_list");
 { platform, Platform } :: import("../process");
 open(import("../string"));
@@ -54,13 +55,15 @@ extern(
 // ============================================================================
 // Fill a buffer with cryptographically secure random bytes.
 // ============================================================================
-random_bytes :: (fn(buf : *(u8), size : usize, exn : Exception) -> unit)(
+random_bytes :: (fn(buf : Slice(u8), exn : Exception) -> unit)({
+  buf_ptr := buf.ptr();
+  size := buf.len();
   cond(
     (platform == Platform.Macos) => {
-      __yo_arc4random_buf(buf, size);
+      __yo_arc4random_buf(buf_ptr, size);
     },
     (platform == Platform.Windows) => {
-      r := __yo_bcrypt_gen_random(buf, u32(size));
+      r := __yo_bcrypt_gen_random(buf_ptr, u32(size));
       cond(
         (r == i32(0)) => (),
         true => {
@@ -77,7 +80,7 @@ random_bytes :: (fn(buf : *(u8), size : usize, exn : Exception) -> unit)(
           (remaining > usize(256)) => usize(256),
           true => remaining
         );
-        ret := __yo_getentropy(buf &+ offset, chunk);
+        ret := __yo_getentropy(buf_ptr &+ offset, chunk);
         cond(
           (ret < i32(0)) => {
             exn.throw(dyn(CryptoError.Unavailable));
@@ -90,7 +93,7 @@ random_bytes :: (fn(buf : *(u8), size : usize, exn : Exception) -> unit)(
     },
     true => {
       // Linux: getrandom syscall
-      ret := __yo_getrandom(buf, size, u32(0));
+      ret := __yo_getrandom(buf_ptr, size, u32(0));
       cond(
         (ret < isize(0)) => {
           exn.throw(dyn(CryptoError.Unavailable));
@@ -99,27 +102,26 @@ random_bytes :: (fn(buf : *(u8), size : usize, exn : Exception) -> unit)(
       );
     }
   )
-);
+});
 export(random_bytes);
 // ============================================================================
 // Typed helpers
 // ============================================================================
 random_u32 :: (fn(exn : Exception) -> u32)({
   buf := Array(u8, usize(4)).fill(u8(0));
-  buf_ptr := &(buf(usize(0)));
-  random_bytes(buf_ptr, usize(4));
+  random_bytes(Slice(u8).from_raw_parts(&(buf(usize(0))), usize(4)), exn);
   u32(buf(usize(0))) |
     (u32(buf(usize(1))) << u32(8)) |
       (u32(buf(usize(2))) << u32(16)) |
         (u32(buf(usize(3))) << u32(24))
       });
 random_u64 :: (fn(exn : Exception) -> u64)({
-  lo := u64(random_u32());
-  hi := u64(random_u32());
+  lo := u64(random_u32(exn));
+  hi := u64(random_u32(exn));
   lo | (hi << u64(32))
 });
 random_f64 :: (fn(exn : Exception) -> f64)(
-  f64(random_u64()) / f64(18446744073709551615.0)
+  f64(random_u64(exn)) / f64(18446744073709551615.0)
 );
 // Return a random integer in the half-open range [min, max).
 random_range :: (fn(min : i64, max : i64, exn : Exception) -> i64)({
@@ -127,7 +129,7 @@ random_range :: (fn(min : i64, max : i64, exn : Exception) -> i64)({
   cond(
     (span <= i64(0)) => min,
     true => {
-      r := random_u64();
+      r := random_u64(exn);
       min + i64(r % u64(span))
     }
   )
@@ -140,8 +142,7 @@ export(random_u32, random_u64, random_f64, random_range);
 uuid_v4 :: (fn(exn : Exception) -> String)({
   bytes := ArrayList(u8).with_capacity(usize(16));
   buf := Array(u8, usize(16)).fill(u8(0));
-  buf_ptr := &(buf(usize(0)));
-  random_bytes(buf_ptr, usize(16));
+  random_bytes(Slice(u8).from_raw_parts(&(buf(usize(0))), usize(16)), exn);
   // Set version bits (v4)
   buf(usize(6)) = ((buf(usize(6)) & u8(0x0F)) | u8(0x40));
   // Set variant bits
@@ -165,7 +166,7 @@ uuid_v4 :: (fn(exn : Exception) -> String)({
       },
       true => ()
     );
-    out.push(hex_bytes.get(j).unwrap());
+    out.push(hex_bytes(j));
   });
   String.from_bytes(out)
 });

package/std/crypto/sha256.yo

@@ -7,6 +7,7 @@
 //!
 //! digest := sha256_hex(data);  // "2cf24dba..."
 //! ```
+pragma(Pragma.AllowUnsafe);
 { ArrayList } :: import("../collections/array_list");
 { hex_encode } :: import("../encoding/hex");
 open(import("../string"));
@@ -176,7 +177,7 @@ impl(
   update : (fn(self : Self, data : ArrayList(u8)) -> Self)({
     i := usize(0);
     while(i < data.len(), i = (i + usize(1)), {
-      self._buf(self._buflen) = data.get(i).unwrap();
+      self._buf(self._buflen) = data(i);
       self._buflen = (self._buflen + usize(1));
       self._total = (self._total + u64(1));
       cond(

package/std/encoding/base64.yo

@@ -26,9 +26,9 @@ _encode_with :: (fn(data : ArrayList(u8), alpha : str, pad : bool) -> String)({
   out := ArrayList(u8).with_capacity(((n + usize(2)) / usize(3)) * usize(4));
   i := usize(0);
   while(i < n, i = (i + usize(3)), {
-    b0 := data.get(i).unwrap();
-    b1 := cond(((i + usize(1)) < n) => data.get(i + usize(1)).unwrap(), true => u8(0));
-    b2 := cond(((i + usize(2)) < n) => data.get(i + usize(2)).unwrap(), true => u8(0));
+    b0 := data(i);
+    b1 := cond(((i + usize(1)) < n) => data(i + usize(1)), true => u8(0));
+    b2 := cond(((i + usize(2)) < n) => data(i + usize(2)), true => u8(0));
     out.push(alpha.bytes(usize(b0 >> u8(2))));
     out.push(alpha.bytes(usize(((b0 & u8(3)) << u8(4)) | (b1 >> u8(4)))));
     cond(
@@ -83,19 +83,19 @@ _decode_with :: (fn(s : str, alpha : str, exn : Exception) -> ArrayList(u8))({
   out := ArrayList(u8).with_capacity((len * usize(3)) / usize(4));
   i := usize(0);
   while(i < len, i = (i + usize(4)), {
-    c0 := _decode_char(s.bytes(i), alpha);
+    c0 := _decode_char(s.bytes(i), alpha, exn);
     c1 := cond(
-      ((i + usize(1)) < len) => _decode_char(s.bytes(i + usize(1)), alpha),
+      ((i + usize(1)) < len) => _decode_char(s.bytes(i + usize(1)), alpha, exn),
       true => u8(0)
     );
     out.push((c0 << u8(2)) | (c1 >> u8(4)));
     cond(
       ((i + usize(2)) < len) => {
-        c2 := _decode_char(s.bytes(i + usize(2)), alpha);
+        c2 := _decode_char(s.bytes(i + usize(2)), alpha, exn);
         out.push(((c1 & u8(15)) << u8(4)) | (c2 >> u8(2)));
         cond(
           ((i + usize(3)) < len) => {
-            c3 := _decode_char(s.bytes(i + usize(3)), alpha);
+            c3 := _decode_char(s.bytes(i + usize(3)), alpha, exn);
             out.push(((c2 & u8(3)) << u8(6)) | c3);
           },
           true => ()
@@ -108,11 +108,11 @@ _decode_with :: (fn(s : str, alpha : str, exn : Exception) -> ArrayList(u8))({
 });
 /// Decode a standard base64 string to bytes. Throws via `Exception` on invalid input.
 base64_decode :: (fn(s : str, exn : Exception) -> ArrayList(u8))(
-  _decode_with(s, _STD_ALPHA)
+  _decode_with(s, _STD_ALPHA, exn)
 );
 /// Decode a URL-safe base64 string to bytes. Throws via `Exception` on invalid input.
 base64_decode_url :: (fn(s : str, exn : Exception) -> ArrayList(u8))(
-  _decode_with(s, _URL_ALPHA)
+  _decode_with(s, _URL_ALPHA, exn)
 );
 export(base64_decode, base64_decode_url);
 // ============================================================================
@@ -152,11 +152,11 @@ base64_decode_string :: (fn(input : String) -> Result(String, String))({
   });
   // Strip trailing padding
   len := cleaned.len();
-  while((len > usize(0)) && (cleaned.get(len - usize(1)).unwrap() == u8(61)), len = (len - usize(1)), ());
+  while((len > usize(0)) && (cleaned(len - usize(1)) == u8(61)), len = (len - usize(1)), ());
   out := ArrayList(u8).new();
   j := usize(0);
   while(j < len, j = (j + usize(4)), {
-    v0 := _base64_index(cleaned.get(j).unwrap());
+    v0 := _base64_index(cleaned(j));
     cond(
       (v0 == i32(-(1))) => {
         return(.Err(`Invalid base64 input`));
@@ -165,7 +165,7 @@ base64_decode_string :: (fn(input : String) -> Result(String, String))({
     );
     v1 := cond(
       ((j + usize(1)) < len) => {
-        tmp := _base64_index(cleaned.get(j + usize(1)).unwrap());
+        tmp := _base64_index(cleaned(j + usize(1)));
         cond(
           (tmp == i32(-(1))) => {
             return(.Err(`Invalid base64 input`));
@@ -179,7 +179,7 @@ base64_decode_string :: (fn(input : String) -> Result(String, String))({
     out.push(u8((v0 << i32(2)) | (v1 >> i32(4))));
     cond(
       ((j + usize(2)) < len) => {
-        v2 := _base64_index(cleaned.get(j + usize(2)).unwrap());
+        v2 := _base64_index(cleaned(j + usize(2)));
         cond(
           (v2 == i32(-(1))) => {
             return(.Err(`Invalid base64 input`));
@@ -189,7 +189,7 @@ base64_decode_string :: (fn(input : String) -> Result(String, String))({
         out.push(u8(((v1 & i32(15)) << i32(4)) | (v2 >> i32(2))));
         cond(
           ((j + usize(3)) < len) => {
-            v3 := _base64_index(cleaned.get(j + usize(3)).unwrap());
+            v3 := _base64_index(cleaned(j + usize(3)));
             cond(
               (v3 == i32(-(1))) => {
                 return(.Err(`Invalid base64 input`));

package/std/encoding/hex.yo

@@ -48,7 +48,7 @@ _hex_encode_impl :: (fn(data : ArrayList(u8), hex_chars : str) -> String)({
   out := ArrayList(u8).with_capacity(data.len() * usize(2));
   i := usize(0);
   while(i < data.len(), i = (i + usize(1)), {
-    b := data.get(i).unwrap();
+    b := data(i);
     hi := usize((b >> u8(4)) & u8(0xF));
     lo := usize(b & u8(0xF));
     out.push(hex_chars.bytes(hi));
@@ -86,8 +86,8 @@ hex_decode :: (fn(s : str, exn : Exception) -> ArrayList(u8))({
   out := ArrayList(u8).with_capacity(s.len() / usize(2));
   i := usize(0);
   while(i < s.len(), i = (i + usize(2)), {
-    hi := _hex_nibble(s.bytes(i));
-    lo := _hex_nibble(s.bytes(i + usize(1)));
+    hi := _hex_nibble(s.bytes(i), exn);
+    lo := _hex_nibble(s.bytes(i + usize(1)), exn);
     out.push((hi << u8(4)) | lo);
   });
   out