@shd101wyy/yo 0.1.33 → 0.1.34

package/std/encoding/base64.yo

@@ -6,7 +6,7 @@
 //! { base64_encode, base64_decode } :: import "std/encoding/base64";
 //!
 //! s := base64_encode(data);
-//! b := base64_decode(s.to_str()).unwrap();
+//! b := base64_decode(s.to_string()).unwrap();
 //! ```
 open(import("../string"));
 { ArrayList } :: import("../collections/array_list");
@@ -76,26 +76,26 @@ _decode_char :: (fn(c : u8, alpha : str, exn : Exception) -> u8)({
   });
   exn.throw(dyn(EncodingError.InvalidChar(c)))
 });
-_decode_with :: (fn(s : str, alpha : str, exn : Exception) -> ArrayList(u8))({
+_decode_with :: (fn(s : String, alpha : str, exn : Exception) -> ArrayList(u8))({
   // Strip trailing padding
-  len := s.len();
-  while((len > usize(0)) && (s.bytes(len - usize(1)) == _PAD), len = (len - usize(1)), ());
+  len := s.bytes_len();
+  while((len > usize(0)) && (s.byte_at(len - usize(1)) == _PAD), len = (len - usize(1)), ());
   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, exn);
+    c0 := _decode_char(s.byte_at(i), alpha, exn);
     c1 := cond(
-      ((i + usize(1)) < len) => _decode_char(s.bytes(i + usize(1)), alpha, exn),
+      ((i + usize(1)) < len) => _decode_char(s.byte_at(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, exn);
+        c2 := _decode_char(s.byte_at(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, exn);
+            c3 := _decode_char(s.byte_at(i + usize(3)), alpha, exn);
             out.push(((c2 & u8(3)) << u8(6)) | c3);
           },
           true => ()
@@ -107,11 +107,11 @@ _decode_with :: (fn(s : str, alpha : str, exn : Exception) -> ArrayList(u8))({
   out
 });
 /// Decode a standard base64 string to bytes. Throws via `Exception` on invalid input.
-base64_decode :: (fn(s : str, exn : Exception) -> ArrayList(u8))(
+base64_decode :: (fn(s : String, exn : Exception) -> ArrayList(u8))(
   _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))(
+base64_decode_url :: (fn(s : String, exn : Exception) -> ArrayList(u8))(
   _decode_with(s, _URL_ALPHA, exn)
 );
 export(base64_decode, base64_decode_url);
@@ -138,11 +138,10 @@ _base64_index :: (fn(c : u8) -> i32)({
 });
 /// Decode a base64 `String`, ignoring whitespace. Returns `Result(String, String)`.
 base64_decode_string :: (fn(input : String) -> Result(String, String))({
-  raw := input.as_str();
   cleaned := ArrayList(u8).new();
   i := usize(0);
-  while(i < raw.len(), i = (i + usize(1)), {
-    ch := raw.bytes(i);
+  while(i < input.bytes_len(), i = (i + usize(1)), {
+    ch := input.byte_at(i);
     cond(
       (((ch == u8(32)) || (ch == u8(9))) || ((ch == u8(10)) || (ch == u8(13)))) => (),
       true => {

package/std/encoding/hex.yo

@@ -76,18 +76,18 @@ _hex_nibble :: (fn(c : u8, exn : Exception) -> u8)(
   )
 );
 /// Decode a hexadecimal string to bytes. Throws via `Exception` on invalid input.
-hex_decode :: (fn(s : str, exn : Exception) -> ArrayList(u8))({
+hex_decode :: (fn(s : String, exn : Exception) -> ArrayList(u8))({
   cond(
-    ((s.len() % usize(2)) != usize(0)) => {
+    ((s.bytes_len() % usize(2)) != usize(0)) => {
       exn.throw(dyn(EncodingError.OddLength));
     },
     true => ()
   );
-  out := ArrayList(u8).with_capacity(s.len() / usize(2));
+  out := ArrayList(u8).with_capacity(s.bytes_len() / usize(2));
   i := usize(0);
-  while(i < s.len(), i = (i + usize(2)), {
-    hi := _hex_nibble(s.bytes(i), exn);
-    lo := _hex_nibble(s.bytes(i + usize(1)), exn);
+  while(i < s.bytes_len(), i = (i + usize(2)), {
+    hi := _hex_nibble(s.byte_at(i), exn);
+    lo := _hex_nibble(s.byte_at(i + usize(1)), exn);
     out.push((hi << u8(4)) | lo);
   });
   out

package/std/encoding/json.yo

@@ -173,9 +173,9 @@ impl(
             if(keys(i) == key, {
               // SAFETY: `i` is bounded by `keys.len()` and the
               // Object variant invariant says `values.len() ==
-              // keys.len()`, so `values.project(i)` yields a valid
-              // ref into the Rc-managed values list.
-              return(unsafe(&(values.project(i))));
+              // keys.len()`, so `&(values(i))` (Index trait) yields a
+              // valid pointer into the Rc-managed values list.
+              return(unsafe(&(values(i))));
             });
           });
           panic("JsonValue: key not found in Object")
@@ -198,8 +198,9 @@ impl(
           assert(idx < items.len(), "JsonValue: Array index out of bounds");
           // SAFETY: assert above bounds `idx`; `items` is the
           // Rc-managed Array list whose storage outlives this call
-          // (ref(self) keeps `self` and therefore `items` alive).
-          return(unsafe(&(items.project(idx))));
+          // (ref(self) keeps `self` and therefore `items` alive);
+          // `&(items(idx))` (Index trait) yields the element pointer.
+          return(unsafe(&(items(idx))));
         },
         _ => panic("JsonValue: index by usize requires .Array variant")
       )

package/std/encoding/utf16.yo

@@ -20,34 +20,34 @@ open(import("../string"));
 /// Convert a UTF-8 string to an `ArrayList(u16)` of UTF-16 code units.
 ///
 /// Handles BMP characters directly and encodes supplementary characters as surrogate pairs.
-utf8_to_utf16 :: (fn(s : str) -> ArrayList(u16))({
+utf8_to_utf16 :: (fn(s : String) -> ArrayList(u16))({
   out := ArrayList(u16).new();
   i := usize(0);
-  while(i < s.len(), {
-    b0 := u32(s.bytes(i));
+  while(i < s.bytes_len(), {
+    b0 := u32(s.byte_at(i));
     cond(
       (b0 < u32(0x80)) => {
         out.push(u16(b0));
         i = (i + usize(1));
       },
       ((b0 & u32(0xE0)) == u32(0xC0)) => {
-        b1 := u32(s.bytes(i + usize(1)));
+        b1 := u32(s.byte_at(i + usize(1)));
         cp := (((b0 & u32(0x1F)) << u32(6)) | (b1 & u32(0x3F)));
         out.push(u16(cp));
         i = (i + usize(2));
       },
       ((b0 & u32(0xF0)) == u32(0xE0)) => {
-        b1 := u32(s.bytes(i + usize(1)));
-        b2 := u32(s.bytes(i + usize(2)));
+        b1 := u32(s.byte_at(i + usize(1)));
+        b2 := u32(s.byte_at(i + usize(2)));
         cp := ((((b0 & u32(0x0F)) << u32(12)) | ((b1 & u32(0x3F)) << u32(6))) | (b2 & u32(0x3F)));
         out.push(u16(cp));
         i = (i + usize(3));
       },
       true => {
         // 4-byte sequence → surrogate pair
-        b1 := u32(s.bytes(i + usize(1)));
-        b2 := u32(s.bytes(i + usize(2)));
-        b3 := u32(s.bytes(i + usize(3)));
+        b1 := u32(s.byte_at(i + usize(1)));
+        b2 := u32(s.byte_at(i + usize(2)));
+        b3 := u32(s.byte_at(i + usize(3)));
         cp := (((((b0 & u32(0x07)) << u32(18)) | ((b1 & u32(0x3F)) << u32(12))) | ((b2 & u32(0x3F)) << u32(6))) | (b3 & u32(0x3F)));
         cp2 := (cp - u32(0x10000));
         hi := u16((cp2 >> u32(10)) + u32(0xD800));

package/std/env.yo

@@ -14,14 +14,14 @@ open(import("./path"));
 extern(
   "Yo",
   __yo_argc : i32,
-  __yo_argv : *(*(u8)),
-  __yo_args : [*(u8)]
+  __yo_argv : *(*(u8))
 );
 // === Raw command-line arguments ===
-/// Get raw command-line arguments as a slice of C strings.
-/// The first element is the program name.
-raw_args :: (fn() -> [*(u8)])({
-  return(__yo_args);
+/// Get raw command-line arguments as a RawSlice of C strings (privileged:
+/// callers must be pragma'd to name RawSlice). The first element is the
+/// program name.
+raw_args :: (fn() -> RawSlice(*(u8)))({
+  return(RawSlice(*(u8))(ptr : __yo_argv, len : usize(__yo_argc)));
 });
 export(raw_args);
 /// Get the number of command-line arguments (including program name).
@@ -38,12 +38,12 @@ export(argv);
 /// Get command-line arguments as an `ArrayList(String)`.
 /// The first element is the program name.
 args :: (fn() -> ArrayList(String))({
-  raw := raw_args();
   i := usize(0);
   len := usize(argc());
   result := ArrayList(String).with_capacity(len);
   while(i < len, {
-    arg_ptr := raw(i);
+    // SAFETY: i < argc; argv is the C runtime's argument vector.
+    arg_ptr := unsafe((__yo_argv &+ i).*);
     arg_str := String.from_cstr(arg_ptr).unwrap();
     result.push(arg_str);
     i = (i + 1);

package/std/fmt/to_string.yo

@@ -252,22 +252,22 @@ impl(
 // TODO: Array to_string implementation?
 // --- derive_rule for ToString ---
 // Local helpers (not exported from prelude, so defined locally)
-__ts_s2 :: (fn(comptime(a) : comptime_string, comptime(b) : comptime_string) -> comptime(comptime_string))(a + b);
-__ts_s3 :: (fn(comptime(a) : comptime_string, comptime(b) : comptime_string, comptime(c) : comptime_string) -> comptime(comptime_string))(
+__ts_s2 :: (fn(comptime(a) : comptime_str, comptime(b) : comptime_str) -> comptime(comptime_str))(a + b);
+__ts_s3 :: (fn(comptime(a) : comptime_str, comptime(b) : comptime_str, comptime(c) : comptime_str) -> comptime(comptime_str))(
   (a + b) + c
 );
-__ts_s4 :: (fn(comptime(a) : comptime_string, comptime(b) : comptime_string, comptime(c) : comptime_string, comptime(d) : comptime_string) -> comptime(comptime_string))(
+__ts_s4 :: (fn(comptime(a) : comptime_str, comptime(b) : comptime_str, comptime(c) : comptime_str, comptime(d) : comptime_str) -> comptime(comptime_str))(
   ((a + b) + c) + d
 );
-__ts_s5 :: (fn(comptime(a) : comptime_string, comptime(b) : comptime_string, comptime(c) : comptime_string, comptime(d) : comptime_string, comptime(e) : comptime_string) -> comptime(comptime_string))(
+__ts_s5 :: (fn(comptime(a) : comptime_str, comptime(b) : comptime_str, comptime(c) : comptime_str, comptime(d) : comptime_str, comptime(e) : comptime_str) -> comptime(comptime_str))(
   (((a + b) + c) + d) + e
 );
 __ts_fold_range :: (
   fn(
     comptime(n) : usize,
-    comptime(init) : comptime_string,
-    comptime(f) : (fn(comptime(acc) : comptime_string, comptime(i) : usize) -> comptime(comptime_string))
-  ) -> comptime(comptime_string)
+    comptime(init) : comptime_str,
+    comptime(f) : (fn(comptime(acc) : comptime_str, comptime(i) : usize) -> comptime(comptime_str))
+  ) -> comptime(comptime_str)
 )(
   cond(
     (n == usize(0)) => init,
@@ -276,7 +276,7 @@ __ts_fold_range :: (
   )
 );
 // Helper: join string parts with + operator, left-to-right parenthesized
-__derive_join_plus :: (fn(comptime(parts) : comptime_string, comptime(new_part) : comptime_string) -> comptime(comptime_string))(
+__derive_join_plus :: (fn(comptime(parts) : comptime_str, comptime(new_part) : comptime_str) -> comptime(comptime_str))(
   cond(
     (parts == "") => new_part,
     true => __ts_s5("(", parts, " + ", new_part, ")")
@@ -304,7 +304,7 @@ __derive_tostring :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comp
           body :: __ts_fold_range(
             fc,
             __ts_s3("String.from(\"", type_name, "(\")"),
-            (fn(comptime(a) : comptime_string, comptime(fi) : usize) -> comptime(comptime_string))({
+            (fn(comptime(a) : comptime_str, comptime(fi) : usize) -> comptime(comptime_str))({
               fname :: fields.get(fi).name;
               with_sep :: cond(
                 (fi == 0) => a,
@@ -330,7 +330,7 @@ __derive_tostring :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comp
       ts_branches :: __ts_fold_range(
         vc,
         "",
-        (fn(comptime(acc) : comptime_string, comptime(vi) : usize) -> comptime(comptime_string))({
+        (fn(comptime(acc) : comptime_str, comptime(vi) : usize) -> comptime(comptime_str))({
           v :: variants.get(vi);
           branch :: cond(
             (v.fields.len() == 0) =>
@@ -339,7 +339,7 @@ __derive_tostring :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comp
               bindings :: __ts_fold_range(
                 v.fields.len(),
                 "",
-                (fn(comptime(a) : comptime_string, comptime(fi) : usize) -> comptime(comptime_string))({
+                (fn(comptime(a) : comptime_str, comptime(fi) : usize) -> comptime(comptime_str))({
                   fname :: v.fields.get(fi).name;
                   cond(
                     (a == "") => __ts_s2("__v_", fname),
@@ -350,7 +350,7 @@ __derive_tostring :: (fn(comptime(T) : Type, comptime(ctx) : DeriveContext, comp
               body :: __ts_fold_range(
                 v.fields.len(),
                 __ts_s5("String.from(\"", type_name, ".", v.name, "(\")"),
-                (fn(comptime(a) : comptime_string, comptime(fi) : usize) -> comptime(comptime_string))({
+                (fn(comptime(a) : comptime_str, comptime(fi) : usize) -> comptime(comptime_str))({
                   fname :: v.fields.get(fi).name;
                   with_sep :: cond(
                     (fi == 0) => a,

package/std/http/client.yo

@@ -248,7 +248,7 @@ fetch_with :: (
 )(
   io.async((e) => {
     // Parse URL
-    url := Url.parse(url_str.as_str(), e.exn);
+    url := Url.parse(url_str, e.exn);
     // Validate scheme
     scheme := url.scheme();
     is_http := (scheme == `http`);

package/std/imm/list.yo

@@ -17,6 +17,7 @@
 //! ```
 pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
+{ ArrayList } :: import("../collections/array_list.yo");
 { malloc, free } :: GlobalAllocator;
 { memcpy } :: import("../libc/string.yo");
 /// Internal cons cell — atomic object for thread-safe structural sharing.
@@ -197,12 +198,12 @@ impl(
     false
   }),
   /// Build a list from a slice. O(n).
-  from_slice : (fn(s : Slice(T)) -> Self)({
+  from_list : (fn(l : ArrayList(T)) -> Self)({
     (result : Self) = Self.new();
-    (i : usize) = s.len();
+    (i : usize) = l.len();
     while(i > usize(0), {
       i = (i - usize(1));
-      result = result.prepend(s(i));
+      result = result.prepend(match(l.get(i),.Some(__e) => __e,.None => panic("from_list: index out of bounds")));
     });
     result
   })

package/std/imm/map.yo

@@ -19,6 +19,7 @@
 //! ```
 pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
+{ ArrayList } :: import("../collections/array_list.yo");
 { malloc, free } :: GlobalAllocator;
 /// Number of bits per HAMT level.
 BITS :: usize(5);
@@ -948,12 +949,12 @@ impl(
     result
   }),
   /// Create a map from a slice of key-value pairs.
-  from_entries : (fn(pairs : Slice(Pair(K, V))) -> Self)({
+  from_entries : (fn(pairs : ArrayList(Pair(K, V))) -> Self)({
     (result : Self) = Self.new();
     i := usize(0);
     plen := pairs.len();
     while(i < plen, i = (i + usize(1)), {
-      p := (pairs.ptr() &+ i).*;
+      p := match(pairs.get(i),.Some(__e) => __e,.None => panic("from_entries: index out of bounds"));
       result = result.insert(p.key, p.value);
     });
     result

package/std/imm/set.yo

@@ -19,6 +19,7 @@
 //! ```
 pragma(Pragma.AllowUnsafe);
 { Map } :: import("./map.yo");
+{ ArrayList } :: import("../collections/array_list.yo");
 { List } :: import("./list.yo");
 /// Persistent immutable hash set backed by a HAMT.
 ///
@@ -152,12 +153,12 @@ impl(
     self._inner.keys()
   ),
   /// Create a set from a slice of elements.
-  from_slice : (fn(s : Slice(T)) -> Self)({
+  from_list : (fn(l : ArrayList(T)) -> Self)({
     (result : Self) = Self.new();
     i := usize(0);
-    slen := s.len();
+    slen := l.len();
     while(i < slen, i = (i + usize(1)), {
-      result = result.insert((s.ptr() &+ i).*);
+      result = result.insert(match(l.get(i),.Some(__e) => __e,.None => panic("from_list: index out of bounds")));
     });
     result
   })

package/std/imm/sorted_map.yo

@@ -19,6 +19,7 @@
 //! ```
 pragma(Pragma.AllowUnsafe);
 { List } :: import("./list.yo");
+{ ArrayList } :: import("../collections/array_list.yo");
 { Pair } :: import("./map.yo");
 /// Color of a red-black tree node.
 Color :: enum(Red, Black);
@@ -614,12 +615,12 @@ impl(
     _collect_values(K, V, self._root, List(V).new())
   ),
   /// Create a sorted map from a slice of key-value pairs.
-  from_entries : (fn(pairs : Slice(Pair(K, V))) -> Self)({
+  from_entries : (fn(pairs : ArrayList(Pair(K, V))) -> Self)({
     (result : Self) = Self.new();
     i := usize(0);
     plen := pairs.len();
     while(i < plen, i = (i + usize(1)), {
-      p := (pairs.ptr() &+ i).*;
+      p := match(pairs.get(i),.Some(__e) => __e,.None => panic("from_entries: index out of bounds"));
       result = result.insert(p.key, p.value);
     });
     result

package/std/imm/sorted_set.yo

@@ -19,6 +19,7 @@
 //! ```
 pragma(Pragma.AllowUnsafe);
 { SortedMap } :: import("./sorted_map.yo");
+{ ArrayList } :: import("../collections/array_list.yo");
 { List } :: import("./list.yo");
 /// Persistent immutable sorted set backed by a left-leaning red-black tree.
 SortedSet :: (fn(comptime(T) : Type, where(T <: (Eq(T), Ord(T), Send))) -> comptime(Type))(
@@ -174,12 +175,12 @@ impl(
     result
   }),
   /// Create a sorted set from a slice of elements.
-  from_slice : (fn(s : Slice(T)) -> Self)({
+  from_list : (fn(l : ArrayList(T)) -> Self)({
     (result : Self) = Self.new();
     i := usize(0);
-    slen := s.len();
+    slen := l.len();
     while(i < slen, i = (i + usize(1)), {
-      result = result.insert((s.ptr() &+ i).*);
+      result = result.insert(match(l.get(i),.Some(__e) => __e,.None => panic("from_list: index out of bounds")));
     });
     result
   })

package/std/imm/string.yo

@@ -4,6 +4,7 @@
 //! All "modification" operations return a new string; the original is unchanged.
 pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
+{ ArrayList } :: import("../collections/array_list.yo");
 { malloc, free } :: GlobalAllocator;
 { memcpy, memcmp } :: import("../libc/string.yo");
 { rune } :: import("../string/rune.yo");
@@ -68,8 +69,8 @@ impl(
       return(Self(_ptr :.None, _len : usize(0), _capacity : usize(0)));
     });
     ptr := _alloc_bytes(slen);
-    (as_str : str) = s.as_str();
-    unsafe(memcpy(*(void)(ptr), *(void)(as_str.ptr()), slen));
+    rb := s.raw_bytes();
+    unsafe(memcpy(*(void)(ptr), *(void)(rb.ptr), slen));
     return(Self(_ptr :.Some(ptr), _len : slen, _capacity : slen));
   }),
   /// Byte length of the string.
@@ -722,9 +723,15 @@ impl(
 impl(
   String,
   ToString(
-    to_string : (fn(ref(self) : Self) -> std_string.String)(
-      std_string.String.from(self.as_str())
-    )
+    to_string : (fn(ref(self) : Self) -> std_string.String)({
+      bytes := ArrayList(u8).new();
+      match(
+        self._ptr,
+        .None => (),
+        .Some(p) => bytes.extend_from_ptr(p, self._len)
+      );
+      std_string.String.from_bytes(bytes)
+    })
   )
 );
 export(String);

package/std/imm/vec.yo

@@ -18,6 +18,7 @@
 //! ```
 pragma(Pragma.AllowUnsafe);
 { GlobalAllocator } :: import("../allocator.yo");
+{ ArrayList } :: import("../collections/array_list.yo");
 { malloc, free } :: GlobalAllocator;
 /// Persistent immutable vector.
 ///
@@ -412,15 +413,19 @@ impl(
     Vec(V)(_ptr : new_ptr, _len : min_len, _cap : min_len)
   }),
   /// Create a vector from a slice, copying all elements.
-  from_slice : (fn(s : Slice(T)) -> Self)({
-    slen := s.len();
+  from_list : (fn(l : ArrayList(T)) -> Self)({
+    slen := l.len();
     cap := cond(
       (slen > usize(0)) => slen,
       true => usize(4)
     );
     new_ptr := Self._raw_alloc(cap);
     if(slen > usize(0), {
-      Self._copy_elems(new_ptr, s.ptr(), usize(0), usize(0), slen);
+      match(
+        l.ptr(),
+        .Some(src) => Self._copy_elems(new_ptr, src, usize(0), usize(0), slen),
+        .None => ()
+      );
     });
     Self(_ptr : new_ptr, _len : slen, _cap : cap)
   })