@shd101wyy/yo 0.1.4 → 0.1.6

package/std/prelude.yo

@@ -96,6 +96,8 @@ extern "Yo",
     fn(forall(T: Type), slice: Slice(T)) -> usize,
   __yo_slice_new :
     fn(forall(T: Type), ptr: *(T), length: usize) -> Slice(T),
+  __yo_slice_ptr :
+    fn(forall(T: Type), slice: Slice(T)) -> *(T),
 
   // C macro related
   __yo_c_macro_defined : (fn(comptime(name) : comptime_string) -> comptime(bool)),
@@ -110,13 +112,7 @@ extern "Yo",
 ;
 export __yo_as;
 
-assert :: (fn(flag : bool, (comptime(msg) : comptime_string) ?= "Assertion failed.") -> unit)
-  cond(
-    flag => (),
-    true => panic(msg)
-  )
-;
-export assert;
+
 
 // unsafe module
 unsafe :: impl {
@@ -3202,6 +3198,9 @@ impl(forall(T : Type), Slice(T),
   ),
   len : (fn(self : Self) -> usize)(
     __yo_slice_len(self)
+  ),
+  ptr : (fn(self : Self) -> *(T))(
+    __yo_slice_ptr(self)
   )
 );
 
@@ -3215,6 +3214,9 @@ impl(str,
   ),
   len : (fn(self : Self) -> usize)(
     __yo_slice_len(self.bytes)
+  ),
+  ptr : (fn(self : Self) -> *(u8))(
+    __yo_slice_ptr(self.bytes)
   )
 );
 
@@ -3271,6 +3273,14 @@ impl(str, Ord(str)(
 
 export str;
 
+assert :: (fn(flag : bool, (msg : str) ?= "Assertion failed.") -> unit)
+  cond(
+    flag => (),
+    true => panic(msg)
+  )
+;
+export assert;
+
 
 /// ComptimeList
 impl(forall(T : Type), ComptimeList(T), Comptime());
@@ -3419,6 +3429,85 @@ impl(forall(T : Type), Option(T),
   )
 );
 
+// Functional combinators for Option(T)
+impl(forall(T : Type), Option(T),
+  map : (fn(forall(B : Type), self : Self, f : Impl(Fn(a : T) -> B)) -> Option(B))(
+    match(self,
+      .Some(value) => Option(B).Some(f(value)),
+      .None => Option(B).None
+    )
+  ),
+
+  and_then : (fn(forall(B : Type), self : Self, f : Impl(Fn(a : T) -> Option(B))) -> Option(B))(
+    match(self,
+      .Some(value) => f(value),
+      .None => Option(B).None
+    )
+  ),
+
+  filter : (fn(self : Self, predicate : Impl(Fn(a : T) -> bool)) -> Option(T))(
+    match(self,
+      .Some(value) => cond(
+        predicate(value) => Option(T).Some(value),
+        true => Option(T).None
+      ),
+      .None => Option(T).None
+    )
+  ),
+
+  or_else : (fn(self : Self, f : Impl(Fn() -> Option(T))) -> Option(T))(
+    match(self,
+      .Some(value) => Option(T).Some(value),
+      .None => f()
+    )
+  ),
+
+  map_or : (fn(forall(B : Type), self : Self, default_val : B, f : Impl(Fn(a : T) -> B)) -> B)(
+    match(self,
+      .Some(value) => f(value),
+      .None => default_val
+    )
+  ),
+
+  map_or_else : (fn(forall(B : Type), self : Self, default_fn : Impl(Fn() -> B), f : Impl(Fn(a : T) -> B)) -> B)(
+    match(self,
+      .Some(value) => f(value),
+      .None => default_fn()
+    )
+  ),
+
+  and : (fn(forall(B : Type), self : Self, optb : Option(B)) -> Option(B))(
+    match(self,
+      .Some(_) => optb,
+      .None => Option(B).None
+    )
+  ),
+
+  or : (fn(self : Self, optb : Option(T)) -> Option(T))(
+    match(self,
+      .Some(value) => Option(T).Some(value),
+      .None => optb
+    )
+  ),
+
+  unwrap_or_else : (fn(self : Self, f : Impl(Fn() -> T)) -> T)(
+    match(self,
+      .Some(value) => value,
+      .None => f()
+    )
+  )
+);
+
+// Flatten for nested Option
+impl(forall(T : Type), Option(Option(T)),
+  flatten : (fn(self : Self) -> Option(T))(
+    match(self,
+      .Some(inner) => inner,
+      .None => Option(T).None
+    )
+  )
+);
+
 // Option(T) implements Comptime when T implements Comptime
 impl(forall(T : Type), where(T <: Comptime), Option(T), Comptime());
 
@@ -3503,6 +3592,103 @@ impl(forall(OkType : Type, ErrorType : Type), Result(OkType, ErrorType),
   )
 );
 
+// Functional combinators for Result(OkType, ErrorType)
+impl(forall(OkType : Type, ErrorType : Type), Result(OkType, ErrorType),
+  map : (fn(forall(B : Type), self : Self, f : Impl(Fn(a : OkType) -> B)) -> Result(B, ErrorType))(
+    match(self,
+      .Ok(value) => Result(B, ErrorType).Ok(f(value)),
+      .Err(error) => Result(B, ErrorType).Err(error)
+    )
+  ),
+
+  map_err : (fn(forall(F : Type), self : Self, f : Impl(Fn(a : ErrorType) -> F)) -> Result(OkType, F))(
+    match(self,
+      .Ok(value) => Result(OkType, F).Ok(value),
+      .Err(error) => Result(OkType, F).Err(f(error))
+    )
+  ),
+
+  and_then : (fn(forall(B : Type), self : Self, f : Impl(Fn(a : OkType) -> Result(B, ErrorType))) -> Result(B, ErrorType))(
+    match(self,
+      .Ok(value) => f(value),
+      .Err(error) => Result(B, ErrorType).Err(error)
+    )
+  ),
+
+  or_else : (fn(forall(F : Type), self : Self, f : Impl(Fn(a : ErrorType) -> Result(OkType, F))) -> Result(OkType, F))(
+    match(self,
+      .Ok(value) => Result(OkType, F).Ok(value),
+      .Err(error) => f(error)
+    )
+  ),
+
+  and : (fn(forall(B : Type), self : Self, res : Result(B, ErrorType)) -> Result(B, ErrorType))(
+    match(self,
+      .Ok(_) => res,
+      .Err(error) => Result(B, ErrorType).Err(error)
+    )
+  ),
+
+  or : (fn(forall(F : Type), self : Self, res : Result(OkType, F)) -> Result(OkType, F))(
+    match(self,
+      .Ok(value) => Result(OkType, F).Ok(value),
+      .Err(_) => res
+    )
+  ),
+
+  ok : (fn(self : Self) -> Option(OkType))(
+    match(self,
+      .Ok(value) => Option(OkType).Some(value),
+      .Err(_) => Option(OkType).None
+    )
+  ),
+
+  err : (fn(self : Self) -> Option(ErrorType))(
+    match(self,
+      .Ok(_) => Option(ErrorType).None,
+      .Err(error) => Option(ErrorType).Some(error)
+    )
+  ),
+
+  map_or : (fn(forall(B : Type), self : Self, default_val : B, f : Impl(Fn(a : OkType) -> B)) -> B)(
+    match(self,
+      .Ok(value) => f(value),
+      .Err(_) => default_val
+    )
+  ),
+
+  map_or_else : (fn(forall(B : Type), self : Self, default_fn : Impl(Fn(a : ErrorType) -> B), f : Impl(Fn(a : OkType) -> B)) -> B)(
+    match(self,
+      .Ok(value) => f(value),
+      .Err(error) => default_fn(error)
+    )
+  ),
+
+  unwrap_or_else : (fn(self : Self, f : Impl(Fn(a : ErrorType) -> OkType)) -> OkType)(
+    match(self,
+      .Ok(value) => value,
+      .Err(error) => f(error)
+    )
+  )
+);
+
+// Option -> Result conversion (defined after Result)
+impl(forall(T : Type), Option(T),
+  ok_or : (fn(forall(E : Type), self : Self, err : E) -> Result(T, E))(
+    match(self,
+      .Some(value) => Result(T, E).Ok(value),
+      .None => Result(T, E).Err(err)
+    )
+  ),
+
+  ok_or_else : (fn(forall(E : Type), self : Self, err_fn : Impl(Fn() -> E)) -> Result(T, E))(
+    match(self,
+      .Some(value) => Result(T, E).Ok(value),
+      .None => Result(T, E).Err(err_fn())
+    )
+  )
+);
+
 // Result(OkType, ErrorType) implements Comptime when both types implement Comptime
 impl(forall(OkType : Type, ErrorType : Type), where(OkType <: Comptime, ErrorType <: Comptime), Result(OkType, ErrorType), Comptime());
 

package/std/regex/parser.yo

@@ -189,6 +189,27 @@ impl(RegexParser,
     r
   }),
 
+  // Parse \xHH hex escape — reads exactly 2 hex digits and returns the codepoint.
+  _parse_hex_byte : (fn(self : Self) -> Option(u32))({
+    if(((self._pos + usize(2)) > self._bytes.len()), { return .None; });
+    (h1 : u8) = self._bytes.get(self._pos).unwrap();
+    (h2 : u8) = self._bytes.get((self._pos + usize(1))).unwrap();
+    (v1 : i32) = cond(
+      ((h1 >= u8(48)) && (h1 <= u8(57))) => (i32(h1) - i32(48)),
+      ((h1 >= u8(65)) && (h1 <= u8(70))) => ((i32(h1) - i32(65)) + i32(10)),
+      ((h1 >= u8(97)) && (h1 <= u8(102))) => ((i32(h1) - i32(97)) + i32(10)),
+      true => { return .None; }
+    );
+    (v2 : i32) = cond(
+      ((h2 >= u8(48)) && (h2 <= u8(57))) => (i32(h2) - i32(48)),
+      ((h2 >= u8(65)) && (h2 <= u8(70))) => ((i32(h2) - i32(65)) + i32(10)),
+      ((h2 >= u8(97)) && (h2 <= u8(102))) => ((i32(h2) - i32(97)) + i32(10)),
+      true => { return .None; }
+    );
+    self._pos = (self._pos + usize(2));
+    .Some(u32(((v1 << i32(4)) | v2)))
+  }),
+
   _parse_class_escape : (fn(self : Self) -> Result(ArrayList(CharRange), String))({
     b := self._advance();
     match(b,
@@ -219,6 +240,14 @@ impl(RegexParser,
             r.push(CharRange(low: u32(33), high: u32(0x10FFFF)));
             .Ok(r)
           },
+          (ch == u8(120)) => {
+            r := ArrayList(CharRange).new();
+            match(self._parse_hex_byte(),
+              .Some(v) => r.push(CharRange(low: v, high: v)),
+              .None => r.push(CharRange(low: u32(ch), high: u32(ch)))
+            );
+            .Ok(r)
+          },
           true => {
             r := ArrayList(CharRange).new();
             codepoint := self._escape_char_codepoint(ch);
@@ -246,6 +275,31 @@ impl(RegexParser,
               (end_first == u8(93)) => {
                 ranges.push(CharRange(low: low, high: low));
               },
+              (end_first == u8(92)) => {
+                // High end is an escape sequence (e.g. \x20, \0, \n)
+                self._pos = (self._pos + usize(1));
+                self._pos = (self._pos + usize(1));
+                esc := self._parse_class_escape();
+                match(esc,
+                  .Ok(esc_ranges) => {
+                    if(((esc_ranges.len() == usize(1)) && (esc_ranges.get(usize(0)).unwrap().low == esc_ranges.get(usize(0)).unwrap().high)), {
+                      (high : u32) = esc_ranges.get(usize(0)).unwrap().low;
+                      ranges.push(CharRange(low: low, high: high));
+                    }, {
+                      // Multi-range escape like \d can't be range endpoint; treat dash as literal
+                      ranges.push(CharRange(low: low, high: low));
+                      ranges.push(CharRange(low: u32(45), high: u32(45)));
+                      j := usize(0);
+                      while (j < esc_ranges.len()), (j = (j + usize(1))), {
+                        ranges.push(esc_ranges.get(j).unwrap());
+                      };
+                    });
+                  },
+                  .Err(_e) => {
+                    ranges.push(CharRange(low: low, high: low));
+                  }
+                );
+              },
               true => {
                 // Consume dash
                 self._pos = (self._pos + usize(1));
@@ -284,10 +338,16 @@ impl(RegexParser,
         esc := self._parse_class_escape();
         match(esc,
           .Ok(esc_ranges) => {
-            j := usize(0);
-            while (j < esc_ranges.len()), (j = (j + usize(1))), {
-              ranges.push(esc_ranges.get(j).unwrap());
-            };
+            // If escape produced a single codepoint, check for range (e.g. \0-\x20)
+            if(((esc_ranges.len() == usize(1)) && (esc_ranges.get(usize(0)).unwrap().low == esc_ranges.get(usize(0)).unwrap().high)), {
+              (low : u32) = esc_ranges.get(usize(0)).unwrap().low;
+              self._try_parse_char_range(ranges, low);
+            }, {
+              j := usize(0);
+              while (j < esc_ranges.len()), (j = (j + usize(1))), {
+                ranges.push(esc_ranges.get(j).unwrap());
+              };
+            });
           },
           .Err(e) => { return .Err(e); }
         );
@@ -452,6 +512,11 @@ impl(RegexParser,
           (ch == u8(112)) => self._parse_unicode_property(false),
           // Negated unicode property \P{Name}
           (ch == u8(80)) => self._parse_unicode_property(true),
+          // Hex escape \xHH
+          (ch == u8(120)) => match(self._parse_hex_byte(),
+            .Some(v) => .Ok(RegexNode.literal(v)),
+            .None => .Ok(RegexNode.literal(u32(ch)))
+          ),
           true => .Ok(RegexNode.literal(self._escape_char_codepoint(ch)))
         ),
       .None => .Err(`Unexpected end of pattern after backslash`)

package/std/regex/vm.yo

@@ -22,21 +22,18 @@ NfaThread :: object(
 impl(NfaThread,
   new : (fn(pc : usize, n_slots : usize) -> Self)({
     s := ArrayList(usize).with_capacity(n_slots);
-    i := usize(0);
-    while (i < n_slots), (i = (i + usize(1))), {
-      // usize.MAX signals "unset"
-      s.push(usize.MAX);
-    };
+    // usize.MAX = 0xFF..FF, so memset with 0xFF fills each byte
+    s.resize_with_byte(n_slots, int(255));
     Self(pc: pc, slots: s)
   }),
 
   // Clone a thread with a new PC
   fork : (fn(self : Self, new_pc : usize) -> Self)({
     new_slots := ArrayList(usize).with_capacity(self.slots.len());
-    i := usize(0);
-    while (i < self.slots.len()), (i = (i + usize(1))), {
-      new_slots.push(self.slots.get(i).unwrap());
-    };
+    match(self.slots.ptr(),
+      .Some(src) => new_slots.extend_from_ptr(src, self.slots.len()),
+      .None => ()
+    );
     Self(pc: new_pc, slots: new_slots)
   })
 );
@@ -233,14 +230,15 @@ impl(NfaVm,
       true => ()
     );
 
-    is_seen := seen.*.get(thread.pc).unwrap();
+    // Already checked bounds above: thread.pc < instructions.len()
+    is_seen := seen.*.get_unchecked(thread.pc);
     cond(
       is_seen => { return (); },
       true => ()
     );
-    seen.*.set(thread.pc, true);
+    seen.*.set_unchecked(thread.pc, true);
 
-    instr := self._program.instructions.get(thread.pc).unwrap();
+    instr := self._program.instructions.get_unchecked(thread.pc);
 
     match(instr.kind,
       .Split => {
@@ -326,10 +324,7 @@ impl(NfaVm,
     sub_next := ArrayList(NfaThread).new();
 
     sub_seen := ArrayList(bool).with_capacity(self._program.instructions.len());
-    si := usize(0);
-    while (si < self._program.instructions.len()), (si = (si + usize(1))), {
-      sub_seen.push(false);
-    };
+    sub_seen.resize_with_byte(self._program.instructions.len(), int(0));
 
     initial := NfaThread.new(sub_start_pc, self._n_slots);
     self._add_thread(&(sub_current), initial, start_byte, &(sub_seen));
@@ -376,10 +371,7 @@ impl(NfaVm,
       sub_blen := decoded.byte_len;
 
       // Clear seen
-      sj := usize(0);
-      while (sj < sub_seen.len()), (sj = (sj + usize(1))), {
-        sub_seen.set(sj, false);
-      };
+      sub_seen.fill_with_byte(int(0));
 
       // Process consuming instructions
       st2 := usize(0);
@@ -446,11 +438,9 @@ impl(NfaVm,
 
     seen := ArrayList(bool).with_capacity(self._program.instructions.len());
     next_seen := ArrayList(bool).with_capacity(self._program.instructions.len());
-    i := usize(0);
-    while (i < self._program.instructions.len()), (i = (i + usize(1))), {
-      seen.push(false);
-      next_seen.push(false);
-    };
+    // Fill with false (0x00) using memset
+    seen.resize_with_byte(self._program.instructions.len(), int(0));
+    next_seen.resize_with_byte(self._program.instructions.len(), int(0));
 
     initial := NfaThread.new(usize(0), self._n_slots);
     self._add_thread(&(current), initial, start_byte, &(seen));
@@ -474,12 +464,9 @@ impl(NfaVm,
         true => ()
       );
 
-      // Clear seen flags for this generation
-      j := usize(0);
-      while (j < seen.len()), (j = (j + usize(1))), {
-        seen.set(j, false);
-        next_seen.set(j, false);
-      };
+      // Clear seen flags for this generation using memset
+      seen.fill_with_byte(int(0));
+      next_seen.fill_with_byte(int(0));
 
       // Process deferred threads targeting this byte_pos
       new_deferred := ArrayList(DeferredThread).new();