@shd101wyy/yo 0.0.23 → 0.0.25

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shd101wyy/yo",
   "displayName": "Yo",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "main": "./out/cjs/index.cjs",
   "module": "./out/esm/index.mjs",
   "types": "./out/types/src/index.d.ts",

package/std/collections/array_list.yo

@@ -54,16 +54,16 @@ impl(forall(T : Type), ArrayList(T),
 
   /**
     * Get a slice view of the ArrayList
-    * Returns a fat pointer [T] with data pointer and length
+    * Returns a fat pointer Slice(T) with data pointer and length
     * This allows passing ArrayList to functions expecting slices
+    * Returns .None for an empty ArrayList with no allocated buffer
     */
-  // as_slice :: (fn(self: Self) -> [T])({
-  //   ptr := match(self._ptr,
-  //     .Some(p) => p,
-  //     .None => (*(T))(*(void)(usize(0)))  // NULL for empty list
-  //   );
-  //   return [T](ptr, self._length);
-  // }),
+  as_slice : (fn(self: Self) -> Option(Slice(T)))(
+    match(self._ptr,
+      .Some(p) => .Some(Slice(T).from_raw_parts(p, self._length)),
+      .None => .None
+    )
+  ),
 
   /**     * Directly set the length of the ArrayList
     * UNSAFE: This does not initialize new elements or free removed elements
@@ -400,7 +400,7 @@ impl(forall(T : Type), ArrayList(T),
                     while(i < slice_length, i = (i + usize(1)), {
                       src := (src_ptr &+ (start + i));
                       dst := (dst_ptr &+ i);
-                      dst.* = src.*;
+                      consume(dst.* = src.*);
                     });
                     
                     // Set the length of the new list
@@ -441,7 +441,77 @@ impl(forall(T : Type), ArrayList(T), Dispose(
   })
 ));
 
+// === Iterator support ===
+
+/**
+ * Value iterator for ArrayList - yields elements by value (T)
+ * Used by into_iter() / IntoIterator trait
+ */
+ArrayListIter :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _list  : ArrayList(T),
+    _index : usize
+  )
+);
+
+impl(forall(T : Type), ArrayListIter(T), Iterator(
+  Item : T,
+  next : (fn(self : *(Self)) -> Option(T))(
+    cond(
+      (self._index >= self._list._length) => .None,
+      true => {
+        value := self._list.get(self._index);
+        self._index = (self._index + usize(1));
+        value
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), ArrayList(T),
+  into_iter : (fn(self : Self) -> ArrayListIter(T))(
+    ArrayListIter(T)(_list: self, _index: usize(0))
+  )
+);
+
+/**
+ * Pointer iterator for ArrayList - yields pointers to elements (*(T))
+ * Used by iter() method
+ */
+ArrayListIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _list  : ArrayList(T),
+    _index : usize
+  )
+);
+
+impl(forall(T : Type), ArrayListIterPtr(T), Iterator(
+  Item : *(T),
+  next : (fn(self : *(Self)) -> Option(*(T)))(
+    cond(
+      (self._index >= self._list._length) => .None,
+      true =>
+        match(self._list._ptr,
+          .Some(ptr) => {
+            element_ptr := (ptr &+ self._index);
+            self._index = (self._index + usize(1));
+            .Some(element_ptr)
+          },
+          .None => .None
+        )
+    )
+  )
+));
+
+impl(forall(T : Type), ArrayList(T),
+  iter : (fn(self : *(Self)) -> ArrayListIterPtr(T))(
+    ArrayListIterPtr(T)(_list: self.*, _index: usize(0))
+  )
+);
+
 export
   ArrayList,
-  ArrayListError
+  ArrayListError,
+  ArrayListIter,
+  ArrayListIterPtr
 ;

package/std/collections/btree_map.yo

@@ -130,8 +130,126 @@ impl(forall(K : Type, V : Type), BTreeMap(K, V),
       true => .Some(self._entries.get((self._entries.len() - usize(1))).unwrap())
     )
   )
+);
+
+/**
+ * Value iterator for BTreeMap - yields BTreeEntry(K, V) in sorted key order
+ */
+BTreeMapIter :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
+  struct(
+    _entries : ArrayList(BTreeEntry(K, V)),
+    _index   : usize
+  )
+);
+
+impl(forall(K : Type, V : Type), BTreeMapIter(K, V), Iterator(
+  Item : BTreeEntry(K, V),
+  next : (fn(self : *(Self)) -> Option(BTreeEntry(K, V)))(
+    cond(
+      (self._index >= self._entries.len()) => .None,
+      true => {
+        entry := self._entries.get(self._index).unwrap();
+        self._index = (self._index + usize(1));
+        .Some(entry)
+      }
+    )
+  )
+));
+
+impl(forall(K : Type, V : Type), BTreeMap(K, V),
+  into_iter : (fn(self : Self) -> BTreeMapIter(K, V))(
+    BTreeMapIter(K, V)(_entries: self._entries, _index: usize(0))
+  )
+);
+
+/**
+ * Pointer iterator for BTreeMap - yields pointers to BTreeEntry(K, V) in sorted key order
+ */
+BTreeMapIterPtr :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
+  struct(
+    _entries : ArrayList(BTreeEntry(K, V)),
+    _index   : usize
+  )
+);
 
-  // TODO: Add iteration via Iterator trait once supported.
+impl(forall(K : Type, V : Type), BTreeMapIterPtr(K, V), Iterator(
+  Item : *(BTreeEntry(K, V)),
+  next : (fn(self : *(Self)) -> Option(*(BTreeEntry(K, V))))(
+    cond(
+      (self._index >= self._entries.len()) => .None,
+      true =>
+        match(self._entries._ptr,
+          .Some(ptr) => {
+            element_ptr := (ptr &+ self._index);
+            self._index = (self._index + usize(1));
+            .Some(element_ptr)
+          },
+          .None => .None
+        )
+    )
+  )
+));
+
+impl(forall(K : Type, V : Type), BTreeMap(K, V),
+  iter : (fn(self : *(Self)) -> BTreeMapIterPtr(K, V))(
+    BTreeMapIterPtr(K, V)(_entries: self.*._entries, _index: usize(0))
+  )
+);
+
+/**
+ * Keys iterator - wraps BTreeMapIter and yields only keys in sorted order
+ */
+BTreeMapKeys :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
+  struct(
+    _inner : BTreeMapIter(K, V)
+  )
+);
+
+impl(forall(K : Type, V : Type), BTreeMapKeys(K, V), Iterator(
+  Item : K,
+  next : (fn(self : *(Self)) -> Option(K))(
+    match(self._inner.next(),
+      .None => .None,
+      .Some(entry) => .Some(entry.key)
+    )
+  )
+));
+
+impl(forall(K : Type, V : Type), BTreeMap(K, V),
+  keys : (fn(self : Self) -> BTreeMapKeys(K, V))(
+    BTreeMapKeys(K, V)(_inner: BTreeMapIter(K, V)(_entries: self._entries, _index: usize(0)))
+  )
+);
+
+/**
+ * Values iterator - wraps BTreeMapIter and yields only values in sorted key order
+ */
+BTreeMapValues :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
+  struct(
+    _inner : BTreeMapIter(K, V)
+  )
+);
+
+impl(forall(K : Type, V : Type), BTreeMapValues(K, V), Iterator(
+  Item : V,
+  next : (fn(self : *(Self)) -> Option(V))(
+    match(self._inner.next(),
+      .None => .None,
+      .Some(entry) => .Some(entry.value)
+    )
+  )
+));
+
+impl(forall(K : Type, V : Type), BTreeMap(K, V),
+  values : (fn(self : Self) -> BTreeMapValues(K, V))(
+    BTreeMapValues(K, V)(_inner: BTreeMapIter(K, V)(_entries: self._entries, _index: usize(0)))
+  )
 );
 
-export BTreeMap;
+export
+  BTreeMap,
+  BTreeMapIter,
+  BTreeMapIterPtr,
+  BTreeMapKeys,
+  BTreeMapValues
+;

package/std/collections/deque.yo

@@ -57,8 +57,21 @@ impl(forall(T : Type), Deque(T),
     while (i < self._len), (i = (i + usize(1))), {
       idx := ((self._head + i) % self._capacity);
       buf := self._buf.unwrap();
-      (new_buf &+ i).* = (buf &+ idx).*;
+      consume((new_buf &+ i).* = (buf &+ idx).*);
     };
+    // Drop old elements for RC types before freeing old buffer
+    // (the copy above duped each element, so old slots still hold references)
+    cond(
+      Type.contains_rc_type(T) => {
+        j := usize(0);
+        while (j < self._len), (j = (j + usize(1))), {
+          old_idx := ((self._head + j) % self._capacity);
+          old_buf := self._buf.unwrap();
+          unsafe.drop((old_buf &+ old_idx).*);
+        };
+      },
+      true => ()
+    );
     match(self._buf,
       .Some(p) => free(.Some(*(void)(p))),
       .None    => ()
@@ -76,7 +89,7 @@ impl(forall(T : Type), Deque(T),
       true => ()
     );
     buf := self._buf.unwrap();
-    (buf &+ self._tail).* = val;
+    consume((buf &+ self._tail).* = val);
     self._tail = ((self._tail + usize(1)) % self._capacity);
     self._len  = (self._len + usize(1));
   }),
@@ -92,7 +105,7 @@ impl(forall(T : Type), Deque(T),
       true => (self._head - usize(1))
     );
     buf := self._buf.unwrap();
-    (buf &+ self._head).* = val;
+    consume((buf &+ self._head).* = val);
     self._len = (self._len + usize(1));
   }),
 
@@ -102,7 +115,9 @@ impl(forall(T : Type), Deque(T),
       (self._len == usize(0)) => .None,
       true => {
         buf := self._buf.unwrap();
-        val := (buf &+ self._head).*;
+        element_ptr := (buf &+ self._head);
+        val := element_ptr.*;
+        unsafe.drop(element_ptr.*);
         self._head = ((self._head + usize(1)) % self._capacity);
         self._len  = (self._len - usize(1));
         .Some(val)
@@ -120,7 +135,9 @@ impl(forall(T : Type), Deque(T),
           true => (self._tail - usize(1))
         );
         buf := self._buf.unwrap();
-        val := (buf &+ self._tail).*;
+        element_ptr := (buf &+ self._tail);
+        val := element_ptr.*;
+        unsafe.drop(element_ptr.*);
         self._len = (self._len - usize(1));
         .Some(val)
       }
@@ -162,4 +179,79 @@ impl(forall(T : Type), Deque(T), Dispose(
   })
 ));
 
-export Deque;
+/**
+ * Value iterator for Deque - yields elements by value (T)
+ * Traverses the circular buffer in logical order.
+ */
+DequeIter :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _deque     : Deque(T),
+    _pos       : usize,
+    _remaining : usize
+  )
+);
+
+impl(forall(T : Type), DequeIter(T), Iterator(
+  Item : T,
+  next : (fn(self : *(Self)) -> Option(T))(
+    cond(
+      (self._remaining == usize(0)) => .None,
+      true => {
+        idx := ((self._deque._head + self._pos) % self._deque._capacity);
+        buf := self._deque._buf.unwrap();
+        value := (buf &+ idx).*;
+        self._pos = (self._pos + usize(1));
+        self._remaining = (self._remaining - usize(1));
+        .Some(value)
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), Deque(T),
+  into_iter : (fn(self : Self) -> DequeIter(T))(
+    DequeIter(T)(_deque: self, _pos: usize(0), _remaining: self._len)
+  )
+);
+
+/**
+ * Pointer iterator for Deque - yields pointers to elements (*(T))
+ * Yields pointers into the circular buffer. Pointers are valid as long as
+ * the deque is not modified during iteration.
+ */
+DequeIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _deque     : Deque(T),
+    _pos       : usize,
+    _remaining : usize
+  )
+);
+
+impl(forall(T : Type), DequeIterPtr(T), Iterator(
+  Item : *(T),
+  next : (fn(self : *(Self)) -> Option(*(T)))(
+    cond(
+      (self._remaining == usize(0)) => .None,
+      true => {
+        idx := ((self._deque._head + self._pos) % self._deque._capacity);
+        buf := self._deque._buf.unwrap();
+        element_ptr := (buf &+ idx);
+        self._pos = (self._pos + usize(1));
+        self._remaining = (self._remaining - usize(1));
+        .Some(element_ptr)
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), Deque(T),
+  iter : (fn(self : *(Self)) -> DequeIterPtr(T))(
+    DequeIterPtr(T)(_deque: self.*, _pos: usize(0), _remaining: self.*._len)
+  )
+);
+
+export
+  Deque,
+  DequeIter,
+  DequeIterPtr
+;

package/std/collections/hash_map.yo

@@ -565,8 +565,144 @@ impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
     })
   ));
 
+/**
+ * Value iterator for HashMap - yields Bucket(K, V) by value
+ * Scans ctrl bytes to find occupied slots.
+ */
+HashMapIter :: (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)), HashMapIter(K, V), Iterator(
+  Item : Bucket(K, V),
+  next : (fn(self : *(Self)) -> Option(Bucket(K, V)))(
+    cond(
+      (self._map.capacity == usize(0)) => .None,
+      true => {
+        ctrl_ptr := self._map.ctrl.unwrap();
+        data_ptr := self._map.data.unwrap();
+        result := Option(Bucket(K, V)).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((data_ptr &+ self._index).*);
+            },
+            true => ()
+          );
+        };
+        result
+      }
+    )
+  )
+));
+
+impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
+  into_iter : (fn(self : Self) -> HashMapIter(K, V))(
+    HashMapIter(K, V)(_map: self, _index: usize(0))
+  )
+);
+
+/**
+ * Pointer iterator for HashMap - yields pointers to Bucket(K, V)
+ * Pointers are valid as long as the map is not modified during iteration.
+ */
+HashMapIterPtr :: (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)), HashMapIterPtr(K, V), Iterator(
+  Item : *(Bucket(K, V)),
+  next : (fn(self : *(Self)) -> Option(*(Bucket(K, V))))(
+    cond(
+      (self._map.capacity == usize(0)) => .None,
+      true => {
+        ctrl_ptr := self._map.ctrl.unwrap();
+        data_ptr := self._map.data.unwrap();
+        result := Option(*(Bucket(K, V))).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((data_ptr &+ self._index));
+            },
+            true => ()
+          );
+        };
+        result
+      }
+    )
+  )
+));
+
+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))
+  )
+);
+
+/**
+ * Keys iterator - wraps HashMapIter and yields only the keys
+ */
+HashMapKeys :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
+  struct(
+    _inner : HashMapIter(K, V)
+  )
+);
+
+impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMapKeys(K, V), Iterator(
+  Item : K,
+  next : (fn(self : *(Self)) -> Option(K))(
+    match(self._inner.next(),
+      .None => .None,
+      .Some(bucket) => .Some(bucket.key)
+    )
+  )
+));
+
+impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
+  keys : (fn(self : Self) -> HashMapKeys(K, V))(
+    HashMapKeys(K, V)(_inner: HashMapIter(K, V)(_map: self, _index: usize(0)))
+  )
+);
+
+/**
+ * Values iterator - wraps HashMapIter and yields only the values
+ */
+HashMapValues :: (fn(comptime(K) : Type, comptime(V) : Type) -> comptime(Type))(
+  struct(
+    _inner : HashMapIter(K, V)
+  )
+);
+
+impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMapValues(K, V), Iterator(
+  Item : V,
+  next : (fn(self : *(Self)) -> Option(V))(
+    match(self._inner.next(),
+      .None => .None,
+      .Some(bucket) => .Some(bucket.value)
+    )
+  )
+));
+
+impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
+  values : (fn(self : Self) -> HashMapValues(K, V))(
+    HashMapValues(K, V)(_inner: HashMapIter(K, V)(_map: self, _index: usize(0)))
+  )
+);
+
 export
   HashMap,
   HashMapError,
-  Bucket
+  Bucket,
+  HashMapIter,
+  HashMapIterPtr,
+  HashMapKeys,
+  HashMapValues
 ;

package/std/collections/hash_set.yo

@@ -781,7 +781,91 @@ impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSet(T), Dispose(
   )
 ));
 
+/**
+ * Value iterator for HashSet - yields elements by value (T)
+ * Scans ctrl bytes to find occupied slots.
+ */
+HashSetIter :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _set   : HashSet(T),
+    _index : usize
+  )
+);
+
+impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSetIter(T), Iterator(
+  Item : T,
+  next : (fn(self : *(Self)) -> Option(T))(
+    cond(
+      (self._set.capacity == usize(0)) => .None,
+      true => {
+        ctrl_ptr := self._set.ctrl.unwrap();
+        data_ptr := self._set.data.unwrap();
+        result := Option(T).None;
+        while ((self._index < self._set.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((data_ptr &+ self._index).*);
+            },
+            true => ()
+          );
+        };
+        result
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSet(T),
+  into_iter : (fn(self : Self) -> HashSetIter(T))(
+    HashSetIter(T)(_set: self, _index: usize(0))
+  )
+);
+
+/**
+ * Pointer iterator for HashSet - yields pointers to elements (*(T))
+ * Pointers are valid as long as the set is not modified during iteration.
+ */
+HashSetIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _set   : HashSet(T),
+    _index : usize
+  )
+);
+
+impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSetIterPtr(T), Iterator(
+  Item : *(T),
+  next : (fn(self : *(Self)) -> Option(*(T)))(
+    cond(
+      (self._set.capacity == usize(0)) => .None,
+      true => {
+        ctrl_ptr := self._set.ctrl.unwrap();
+        data_ptr := self._set.data.unwrap();
+        result := Option(*(T)).None;
+        while ((self._index < self._set.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((data_ptr &+ self._index));
+            },
+            true => ()
+          );
+        };
+        result
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSet(T),
+  iter : (fn(self : *(Self)) -> HashSetIterPtr(T))(
+    HashSetIterPtr(T)(_set: self.*, _index: usize(0))
+  )
+);
+
 export
   HashSet,
-  HashSetError
+  HashSetError,
+  HashSetIter,
+  HashSetIterPtr
 ;

package/std/collections/linked_list.yo

@@ -438,8 +438,68 @@ impl(forall(T : Type), LinkedList(T), Dispose(
   )
 ));
 
+/**
+ * Value iterator for LinkedList - yields elements by value (T)
+ * Traverses the linked list following node.next pointers.
+ */
+LinkedListIter :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _current : Option(Node(T))
+  )
+);
+
+impl(forall(T : Type), LinkedListIter(T), Iterator(
+  Item : T,
+  next : (fn(self : *(Self)) -> Option(T))(
+    match(self._current,
+      .None => .None,
+      .Some(node) => {
+        self._current = node.next;
+        .Some(node.value)
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), LinkedList(T),
+  into_iter : (fn(self : Self) -> LinkedListIter(T))(
+    LinkedListIter(T)(_current: self.head)
+  )
+);
+
+/**
+ * Pointer iterator for LinkedList - yields pointers to elements (*(T))
+ * Yields &(node.value) for each node. Pointers are valid as long as
+ * the list is not modified during iteration.
+ */
+LinkedListIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _current : Option(Node(T))
+  )
+);
+
+impl(forall(T : Type), LinkedListIterPtr(T), Iterator(
+  Item : *(T),
+  next : (fn(self : *(Self)) -> Option(*(T)))(
+    match(self._current,
+      .None => .None,
+      .Some(node) => {
+        self._current = node.next;
+        .Some(&(node.value))
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), LinkedList(T),
+  iter : (fn(self : *(Self)) -> LinkedListIterPtr(T))(
+    LinkedListIterPtr(T)(_current: self.*.head)
+  )
+);
 
 export
   LinkedList,
-  LinkedListError
+  LinkedListError,
+  LinkedListIter,
+  LinkedListIterPtr
 ;