@shd101wyy/yo 0.0.24 → 0.0.25

package/std/prelude.yo

@@ -3607,29 +3607,92 @@ export
 
 // === Traits again ===
 /// === Iterator ===
-Iterator :: (fn(comptime(Item) : Type) -> comptime(Trait)) {
-  return trait(
-    Item := Item,
-    next :
-      fn(self : *(Self)) -> Option(Self.Item)
-  );
-};
+Iterator :: trait(
+  Item : Type,
+  next :
+    fn(self : *(Self)) -> Option(Self.Item)
+);
 export Iterator;
 
 /// === IntoIterator ===
-IntoIterator :: (fn(
-  comptime(Item) : Type,
-  comptime(IntoIter) : Type,
-  where(IntoIter <: Iterator(Item))) -> comptime(Trait)) {
-  return trait(
-    Item := Item,
-    IntoIter := IntoIter,
-    into_iter : 
-      fn(self : Self) -> Self.IntoIter
-  );
-};
+IntoIterator :: trait(
+  Item : Type,
+  IntoIter : Type,
+  into_iter :
+    fn(self : Self) -> Self.IntoIter,
+  where(Self.IntoIter <: Iterator(Item := Self.Item))
+);
 export IntoIterator;
 
+/// === Array Iterator ===
+/**
+ * Pointer iterator for Array(T, N) - yields *(T) pointers to each element
+ * Used by Array.iter()
+ */
+ArrayIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _ptr   : *(T),
+    _index : usize,
+    _len   : usize
+  )
+);
+
+impl(forall(T : Type), ArrayIterPtr(T), Iterator(
+  Item : *(T),
+  next : (fn(self : *(Self)) -> Option(*(T)))(
+    cond(
+      (self._index >= self._len) => .None,
+      true => {
+        element_ptr := (self._ptr &+ self._index);
+        self._index = (self._index + usize(1));
+        .Some(element_ptr)
+      }
+    )
+  )
+));
+
+impl(forall(T : Type, N : usize), Array(T, N),
+  iter : (fn(self : *(Self)) -> ArrayIterPtr(T))(
+    ArrayIterPtr(T)(_ptr: &((self.*)(usize(0))), _index: usize(0), _len: N)
+  )
+);
+
+export ArrayIterPtr;
+
+/// === Slice Iterator ===
+/**
+ * Pointer iterator for Slice(T) - yields *(T) pointers to each element
+ * Used by Slice.iter()
+ */
+SliceIterPtr :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _slice : Slice(T),
+    _index : usize
+  )
+);
+
+impl(forall(T : Type), SliceIterPtr(T), Iterator(
+  Item : *(T),
+  next : (fn(self : *(Self)) -> Option(*(T)))(
+    cond(
+      (self._index >= self._slice.len()) => .None,
+      true => {
+        ptr := &((self._slice)(self._index));
+        self._index = (self._index + usize(1));
+        .Some(ptr)
+      }
+    )
+  )
+));
+
+impl(forall(T : Type), Slice(T),
+  iter : (fn(self : *(Self)) -> SliceIterPtr(T))(
+    SliceIterPtr(T)(_slice: self.*, _index: usize(0))
+  )
+);
+
+export SliceIterPtr;
+
 // === Conversion ===
 TryFrom :: (fn(comptime(From) : Type) -> comptime(Trait))(
   trait(

package/std/string/string.yo

@@ -1356,7 +1356,94 @@ impl(String, Eq(String)(
   })
 ));
 
+// === Iterator support ===
+
+/**
+ * Rune iterator for String - yields decoded Unicode runes
+ * Used by chars() and into_iter()
+ */
+StringChars :: struct(
+  _string     : String,
+  _byte_index : usize
+);
+
+impl(StringChars, Iterator(
+  Item : rune,
+  next : (fn(self : *(Self)) -> Option(rune))(
+    cond(
+      (self._byte_index >= self._string._bytes.len()) => .None,
+      true => {
+        first_byte_opt := self._string._bytes.get(self._byte_index);
+        match(first_byte_opt,
+          .Some(first_byte) => {
+            // Determine byte length of this UTF-8 character
+            (byte_len : usize) = cond(
+              (first_byte < u8(0x80)) => usize(1),
+              ((first_byte >= u8(0xC0)) && (first_byte < u8(0xE0))) => usize(2),
+              ((first_byte >= u8(0xE0)) && (first_byte < u8(0xF0))) => usize(3),
+              ((first_byte >= u8(0xF0)) && (first_byte < u8(0xF8))) => usize(4),
+              true => usize(1)
+            );
+            r := self._string._decode_rune_at(self._byte_index);
+            self._byte_index = (self._byte_index + byte_len);
+            r
+          },
+          .None => .None
+        )
+      }
+    )
+  )
+));
+
+/**
+ * Byte iterator for String - yields raw UTF-8 bytes
+ * Used by bytes()
+ */
+StringBytes :: struct(
+  _string : String,
+  _index  : usize
+);
+
+impl(StringBytes, Iterator(
+  Item : u8,
+  next : (fn(self : *(Self)) -> Option(u8))(
+    cond(
+      (self._index >= self._string._bytes.len()) => .None,
+      true => {
+        byte_opt := self._string._bytes.get(self._index);
+        self._index = (self._index + usize(1));
+        byte_opt
+      }
+    )
+  )
+));
+
+impl(String,
+  /**
+   * Returns a rune iterator over the string's Unicode characters
+   */
+  chars : (fn(self : Self) -> StringChars)(
+    StringChars(_string: self, _byte_index: usize(0))
+  ),
+
+  /**
+   * Returns a byte iterator over the string's raw UTF-8 bytes
+   */
+  bytes : (fn(self : Self) -> StringBytes)(
+    StringBytes(_string: self, _index: usize(0))
+  ),
+
+  /**
+   * Consume the string and return a rune iterator (default iteration)
+   */
+  into_iter : (fn(self : Self) -> StringChars)(
+    StringChars(_string: self, _byte_index: usize(0))
+  )
+);
+
 export
   String,
-  StringError
+  StringError,
+  StringChars,
+  StringBytes
 ;