@shd101wyy/yo 0.0.24 → 0.0.26

package/package.json

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

package/std/collections/array_list.yo

@@ -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

@@ -179,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
 ;

package/std/collections/priority_queue.yo

@@ -118,4 +118,73 @@ impl(forall(T : Type), PriorityQueue(T),
   })
 );
 
-export PriorityQueue;
+/**
+ * Value iterator for PriorityQueue - yields elements in heap (arbitrary) order
+ * Note: This iterates in internal storage order, NOT sorted order.
+ */
+PriorityQueueIter :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _data  : ArrayList(T),
+    _index : usize
+  )
+);
+
+impl(forall(T : Type), PriorityQueueIter(T), Iterator(
+  Item : T,
+  next : (fn(self : *(Self)) -> Option(T))(
+    cond(
+      (self._index >= self._data.len()) => .None,
+      true => {
+        value := self._data.get(self._index).unwrap();
+        self._index = (self._index + usize(1));
+        .Some(value)
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), PriorityQueue(T),
+  into_iter : (fn(self : Self) -> PriorityQueueIter(T))(
+    PriorityQueueIter(T)(_data: self._data, _index: usize(0))
+  )
+);
+
+/**
+ * Pointer iterator for PriorityQueue - yields pointers to elements in heap order
+ */
+PriorityQueueIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _data  : ArrayList(T),
+    _index : usize
+  )
+);
+
+impl(forall(T : Type), PriorityQueueIterPtr(T), Iterator(
+  Item : *(T),
+  next : (fn(self : *(Self)) -> Option(*(T)))(
+    cond(
+      (self._index >= self._data.len()) => .None,
+      true =>
+        match(self._data._ptr,
+          .Some(ptr) => {
+            element_ptr := (ptr &+ self._index);
+            self._index = (self._index + usize(1));
+            .Some(element_ptr)
+          },
+          .None => .None
+        )
+    )
+  )
+));
+
+impl(forall(T : Type), PriorityQueue(T),
+  iter : (fn(self : *(Self)) -> PriorityQueueIterPtr(T))(
+    PriorityQueueIterPtr(T)(_data: self.*._data, _index: usize(0))
+  )
+);
+
+export
+  PriorityQueue,
+  PriorityQueueIter,
+  PriorityQueueIterPtr
+;