@shd101wyy/yo 0.1.33 → 0.1.35

package/package.json

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

package/std/alg/hash.yo

@@ -1,18 +1,20 @@
 //! FNV-1a (Fowler-Noll-Vo) hash function.
 //!
 //! A fast, non-cryptographic hash function with good distribution.
+pragma(Pragma.AllowUnsafe);
 //! Used internally by `HashMap` and `HashSet`.
 /// FNV offset basis constant (0xcbf29ce484222325).
 FNV_OFFSET_BASIS :: u64(14695981039346656037);
 /// FNV prime constant (0x100000001b3).
 FNV_PRIME :: u64(1099511628211);
 /// Hash a byte sequence using FNV-1a.
-fnv1a_hash_bytes :: (fn(bytes : Slice(u8)) -> u64)({
+fnv1a_hash_bytes :: (fn(bytes : RawSlice(u8)) -> u64)({
   hash := FNV_OFFSET_BASIS;
-  length := bytes.len();
+  length := bytes.len;
   i := usize(0);
   while(i < length, i = (i + usize(1)), {
-    byte := bytes(i);
+    // SAFETY: i < len; the RawSlice contract requires ptr to cover len bytes.
+    byte := unsafe((bytes.ptr &+ i).*);
     xor := (hash ^ u64(byte));
     hash = (xor * FNV_PRIME);
   });

package/std/build.yo

@@ -76,11 +76,11 @@ export(target_host);
 /// Configuration for building an executable.
 Executable :: struct(
   /// Artifact name.
-  name : comptime_string,
+  name : comptime_str,
   /// Root source file.
-  root : comptime_string,
+  root : comptime_str,
   /// Compilation target triple (defaults to host).
-  (target : comptime_string) ?= __yo_build_target_host(),
+  (target : comptime_str) ?= __yo_build_target_host(),
   /// Optimization level.
   (optimize : Optimize) ?= Optimize.Debug,
   /// Memory allocator.
@@ -92,11 +92,11 @@ export(Executable);
 /// Configuration for building a static library.
 StaticLibrary :: struct(
   /// Artifact name.
-  name : comptime_string,
+  name : comptime_str,
   /// Root source file.
-  root : comptime_string,
+  root : comptime_str,
   /// Compilation target triple (defaults to host).
-  (target : comptime_string) ?= __yo_build_target_host(),
+  (target : comptime_str) ?= __yo_build_target_host(),
   /// Optimization level.
   (optimize : Optimize) ?= Optimize.Debug
 );
@@ -104,11 +104,11 @@ export(StaticLibrary);
 /// Configuration for building a shared/dynamic library.
 SharedLibrary :: struct(
   /// Artifact name.
-  name : comptime_string,
+  name : comptime_str,
   /// Root source file.
-  root : comptime_string,
+  root : comptime_str,
   /// Compilation target triple (defaults to host).
-  (target : comptime_string) ?= __yo_build_target_host(),
+  (target : comptime_str) ?= __yo_build_target_host(),
   /// Optimization level.
   (optimize : Optimize) ?= Optimize.Debug
 );
@@ -116,11 +116,11 @@ export(SharedLibrary);
 /// Configuration for a test suite.
 TestSuite :: struct(
   /// Suite name.
-  name : comptime_string,
+  name : comptime_str,
   /// Root test file.
-  root : comptime_string,
+  root : comptime_str,
   /// Compilation target triple (defaults to host).
-  (target : comptime_string) ?= __yo_build_target_host()
+  (target : comptime_str) ?= __yo_build_target_host()
 );
 export(TestSuite);
 // ── Build module type ────────────────────────────────────────────────
@@ -128,17 +128,17 @@ export(TestSuite);
 /// Modules are the unit of reuse across Yo dependencies.
 BuildModule :: struct(
   /// Module name.
-  name : comptime_string,
+  name : comptime_str,
   /// Root source file.
-  root : comptime_string,
-  _dep : comptime_string
+  root : comptime_str,
+  _dep : comptime_str
 );
 export(BuildModule);
 // ── Import entry type ────────────────────────────────────────────────
 /// Pairs an import name with a module for use with `add_import`/`add_import_list`.
 ImportEntry :: struct(
   /// Import alias used in source code.
-  name : comptime_string,
+  name : comptime_str,
   /// The module to import.
   module : BuildModule
 );
@@ -148,7 +148,7 @@ export(ImportEntry);
 /// Use `step.depend_on(dep)` to wire dependencies between steps.
 Step :: struct(
   /// Step name.
-  name : comptime_string,
+  name : comptime_str,
   /// Kind of step.
   kind : StepKind
 );
@@ -179,7 +179,7 @@ impl(
     )
   ),
   /// Add extra C compiler flags to this step.
-  add_c_flags : (fn(comptime(self) : Self, comptime(flags) : comptime_string) -> comptime(unit))({
+  add_c_flags : (fn(comptime(self) : Self, comptime(flags) : comptime_str) -> comptime(unit))({
     __yo_build_add_cflags(self.name, flags);
   })
 );
@@ -197,46 +197,46 @@ impl(
 /// User-configurable build option (declared in `build.yo`, set via `yo build -Dname=value`).
 BuildOption :: struct(
   /// Option name (used with `-D`).
-  name : comptime_string,
+  name : comptime_str,
   /// Human-readable description.
-  description : comptime_string,
+  description : comptime_str,
   /// Default value if not provided.
-  (default : comptime_string) ?= ""
+  (default : comptime_str) ?= ""
 );
 export(BuildOption);
 // ── Dependency config types ──────────────────────────────────────────
 /// Git-hosted dependency configuration.
 GitDependency :: struct(
   /// Dependency name.
-  name : comptime_string,
+  name : comptime_str,
   /// Git repository URL.
-  url : comptime_string,
+  url : comptime_str,
   /// Git ref (tag, branch, or commit SHA). Defaults to `"HEAD"`.
-  (ref : comptime_string) ?= "HEAD",
+  (ref : comptime_str) ?= "HEAD",
   /// Subdirectory within the repository.
-  (path : comptime_string) ?= ""
+  (path : comptime_str) ?= ""
 );
 export(GitDependency);
 /// Local path dependency configuration.
 PathDependency :: struct(
   /// Dependency name.
-  name : comptime_string,
+  name : comptime_str,
   /// Filesystem path to the dependency root.
-  path : comptime_string
+  path : comptime_str
 );
 export(PathDependency);
 /// System C library discovered via `pkg-config`.
 SystemLibrary :: struct(
   /// Library name (passed to `pkg-config`).
-  name : comptime_string,
+  name : comptime_str,
   /// Fallback include path if pkg-config fails.
-  (fallback_include : comptime_string) ?= "",
+  (fallback_include : comptime_str) ?= "",
   /// Fallback library path.
-  (fallback_lib : comptime_string) ?= "",
+  (fallback_lib : comptime_str) ?= "",
   /// Fallback link flags.
-  (fallback_link : comptime_string) ?= "",
+  (fallback_link : comptime_str) ?= "",
   /// Extra C preprocessor defines.
-  (defines : comptime_string) ?= ""
+  (defines : comptime_str) ?= ""
 );
 export(SystemLibrary);
 // ── Dependency handle ────────────────────────────────────────────────
@@ -244,20 +244,20 @@ export(SystemLibrary);
 // Provides access to artifacts defined in the dependency's build.yo.
 /// Handle to a registered dependency. Use `.artifact()` or `.module()` to access its exports.
 Dependency :: struct(
-  name : comptime_string
+  name : comptime_str
 );
 export(Dependency);
 impl(
   Dependency,
   /// Access a named artifact from the dependency's `build.yo`.
   /// Returns a `Step` that can be linked to the consumer's artifacts.
-  artifact : (fn(comptime(self) : Self, comptime(artifact_name) : comptime_string) -> comptime(Step))({
+  artifact : (fn(comptime(self) : Self, comptime(artifact_name) : comptime_str) -> comptime(Step))({
     __yo_build_dep_artifact(self.name, artifact_name);
     Step(name : artifact_name, kind : StepKind.StaticLibrary)
   }),
   /// Get a module from the dependency's `build.yo`.
   /// Empty `module_name` defaults to the sole module if exactly one exists.
-  module : (fn(comptime(self) : Self, (comptime(module_name) : comptime_string) ?= "") -> comptime(BuildModule))({
+  module : (fn(comptime(self) : Self, (comptime(module_name) : comptime_str) ?= "") -> comptime(BuildModule))({
     _encoded :: __yo_build_dep_module(self.name, module_name);
     BuildModule(name : module_name, root : "", _dep : self.name)
   })
@@ -331,8 +331,8 @@ export(run);
 /// Register a named build step. Use `step.depend_on(dep)` to add dependencies.
 step :: (
   fn(
-    comptime(name) : comptime_string,
-    comptime(description) : comptime_string
+    comptime(name) : comptime_str,
+    comptime(description) : comptime_str
   ) -> comptime(Step)
 )({
   __yo_build_step(name, description);
@@ -360,9 +360,9 @@ export(system_library);
 /// Module configuration for shared compilation units.
 ModuleConfig :: struct(
   /// Module name.
-  name : comptime_string,
+  name : comptime_str,
   /// Root source file for the module.
-  root : comptime_string
+  root : comptime_str
 );
 export(ModuleConfig);
 /// Register a named module. Returns a `BuildModule` for linking system libraries
@@ -398,11 +398,11 @@ export(DocFormat);
 /// Configuration for documentation generation.
 DocConfig :: struct(
   /// Step name (e.g., "doc").
-  name : comptime_string,
+  name : comptime_str,
   /// Root source file or directory to document.
-  root : comptime_string,
+  root : comptime_str,
   /// Output directory (default: "yo-out/doc").
-  (output : comptime_string) ?= "yo-out/doc",
+  (output : comptime_str) ?= "yo-out/doc",
   /// Output format (default: Html).
   (format : DocFormat) ?= DocFormat.Html,
   /// Document non-exported (private) items.
@@ -410,14 +410,14 @@ DocConfig :: struct(
   /// Document dependencies too.
   (include_deps : bool) ?= false,
   /// Custom site title (default: project name).
-  (title : comptime_string) ?= "",
+  (title : comptime_str) ?= "",
   /// Release version to display (e.g., "v1.0.0").
   /// When empty, auto-detects from git tag or commit hash.
-  (version : comptime_string) ?= "",
+  (version : comptime_str) ?= "",
   /// Path to logo image.
-  (logo : comptime_string) ?= "",
+  (logo : comptime_str) ?= "",
   /// Path to favicon.
-  (favicon : comptime_string) ?= ""
+  (favicon : comptime_str) ?= ""
 );
 export(DocConfig);
 /// Register a documentation generation step. Returns a Step for dependency wiring.

package/std/collections/array_list.yo

@@ -37,19 +37,6 @@ impl(
   ptr : (fn(self : Self) -> ?*(T))(
     self._ptr
   ),
-  /**
-  * Get a slice view of the ArrayList
-  * 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) -> 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
   * Only use when you've manually populated the buffer (e.g., via direct memory writes)
@@ -73,6 +60,55 @@ impl(
     )
   ),
   /**
+  * Create an ArrayList by copying the elements of a fixed-size array.
+  * The owned-copy companion to array range-indexing
+  * (plans/SLICE_REWORK.md).
+  */
+  /**
+  * Owned copy of the elements in `[r.start, r.end)` — JS-style range
+  * slicing with value semantics (plans/SLICE_REWORK.md: `list(a..b)`
+  * lowers to this).
+  */
+  slice_copy : (fn(self : Self, r : Range(usize)) -> Self)({
+    e := cond((r.end > self.len()) => self.len(), true => r.end);
+    out := Self.new();
+    i := r.start;
+    while(i < e, i = (i + usize(1)), {
+      match(
+        self.get(i),
+        .Some(v) => {
+          ___ := out.push(v);
+        },
+        .None => ()
+      );
+    });
+    out
+  }),
+  /// Inclusive-range companion of `slice_copy` (`list(a..=b)`).
+  slice_copy_inclusive : (fn(self : Self, r : RangeInclusive(usize)) -> Self)({
+    last := cond((r.end >= self.len()) => self.len(), true => (r.end + usize(1)));
+    out := Self.new();
+    i := r.start;
+    while(i < last, i = (i + usize(1)), {
+      match(
+        self.get(i),
+        .Some(v) => {
+          ___ := out.push(v);
+        },
+        .None => ()
+      );
+    });
+    out
+  }),
+  from_array : (fn(forall(N : usize), arr : Array(T, N)) -> Self)({
+    out := Self.with_capacity(N);
+    i := usize(0);
+    while(i < N, i = (i + usize(1)), {
+      out.push(arr(i));
+    });
+    out
+  }),
+  /**
   * Create an ArrayList with a specific initial cap
   */
   with_capacity : (fn(cap : usize) -> Self)(
@@ -507,28 +543,6 @@ impl(
     })
   )
 );
-/// Indexable impl — projection-style indexing yielding `ref(T)`.
-/// See plans/ITERATOR_REDESIGN.md. Body wraps the pointer arithmetic
-/// in `unsafe(...)` to pass the flowability check.
-impl(
-  forall(T : Type),
-  ArrayList(T),
-  Indexable(usize)(
-    Element : T,
-    project : (fn(ref(self) : Self, pos : usize) -> ref(T))({
-      assert(pos < self._length, "ArrayList: project out of bounds");
-      match(
-        self._ptr,
-        // SAFETY: assert above bounds `pos < self._length` and the
-        // length invariant guarantees `pos < self._capacity`, so
-        // `_ptr &+ pos` stays inside the Rc-managed heap buffer
-        // for the duration of the borrow.
-        .Some(_ptr) => unsafe(_ptr &+ pos),
-        .None => panic("ArrayList: project on empty list")
-      )
-    })
-  )
-);
 impl(
   forall(T : Type),
   ArrayList(T),
@@ -586,37 +600,6 @@ impl(
     ArrayListIter(T)(_list : self, _index : usize(0))
   )
 );
-/// Position iterator for ArrayList — yields `usize` indices into the
-/// list. Used by `ArrayList.iter()`; the for-macro pairs each yielded
-/// position with `ArrayList.project(pos)` (Indexable from Phase C) to
-/// bind the body's `ref`-name. See plans/ITERATOR_REDESIGN.md.
-_ArrayListPosIter :: struct(
-  _index : usize,
-  _len : usize
-);
-impl(
-  _ArrayListPosIter,
-  Iterator(
-    Item : usize,
-    next : (fn(ref(self) : Self) -> Option(usize))(
-      cond(
-        (self._index >= self._len) =>.None,
-        true => {
-          out := self._index;
-          self._index = (self._index + usize(1));
-          .Some(out)
-        }
-      )
-    )
-  )
-);
-impl(
-  forall(T : Type),
-  ArrayList(T),
-  iter : (fn(ref(self) : Self) -> _ArrayListPosIter)(
-    _ArrayListPosIter(_index : usize(0), _len : self._length)
-  )
-);
 impl(
   forall(T : Type),
   where(T <: Eq(T)),
@@ -859,4 +842,28 @@ array_list :: (fn(...(quote(elems))) -> unquote(Expr))({
     unquote(tmp)
   })
 });
+/// Range slicing on fixed-size arrays returns an OWNED ArrayList copy
+/// (`arr(a..b)` lowers to this — plans/SLICE_REWORK.md).
+impl(
+  forall(T : Type, N : usize),
+  Array(T, N),
+  slice_copy : (fn(self : Array(T, N), r : Range(usize)) -> ArrayList(T))({
+    e := cond((r.end > N) => N, true => r.end);
+    out := ArrayList(T).new();
+    i := r.start;
+    while(i < e, i = (i + usize(1)), {
+      out.push(self(i));
+    });
+    out
+  }),
+  slice_copy_inclusive : (fn(self : Array(T, N), r : RangeInclusive(usize)) -> ArrayList(T))({
+    last := cond((r.end >= N) => N, true => (r.end + usize(1)));
+    out := ArrayList(T).new();
+    i := r.start;
+    while(i < last, i = (i + usize(1)), {
+      out.push(self(i));
+    });
+    out
+  })
+);
 export(array_list);

package/std/collections/hash_map.yo

@@ -565,9 +565,8 @@ impl(
   where(K <: (Eq(K), Hash)),
   HashMap(K, V),
   /// Pointer iterator — yields `*(Bucket(K, V))` for each occupied bucket.
-  /// Kept as a separate method (not `iter()`) so the Phase D for-macro's
-  /// `coll.iter()` call dispatches to the position-iter variant defined
-  /// later in the file, enabling `for(map, ref(b) => body)`.
+  /// For privileged/unsafe internal use; value iteration goes through
+  /// `into_iter()`.
   iter_ptr : (fn(self : Self) -> HashMapIterPtr(K, V))(
     HashMapIterPtr(K, V)(_map : self, _index : usize(0))
   )
@@ -690,84 +689,6 @@ impl(
     })
   )
 );
-/// Position iterator for HashMap that walks occupied buckets and yields
-/// their bucket indices. Pairs with the `Indexable(usize)` impl below to
-/// make `for(map, ref(b) => body)` legal: `b` becomes a `ref(Bucket(K, V))`
-/// and the loop body can destructure `b.key` / `b.value`.
-HashMapPosIter :: (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)),
-  HashMapPosIter(K, V),
-  Iterator(
-    Item : usize,
-    next : (fn(ref(self) : Self) -> Option(usize))(
-      cond(
-        (self._map.capacity == usize(0)) =>.None,
-        true => {
-          ctrl_ptr := self._map.ctrl.unwrap();
-          result := Option(usize).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(self._index);
-              },
-              true => ()
-            );
-          });
-          result
-        }
-      )
-    )
-  )
-);
-/// Indexable(usize) — projects an occupied bucket index back to a
-/// `ref(Bucket(K, V))` so `for(map, ref(b) => ...)` works. The body of
-/// `for` (Phase D) calls `coll.iter()` to obtain a position iter and
-/// then `coll.project(pos)` for each yielded position. We override
-/// `iter` for HashMap to return the position-iter rather than the
-/// `*(Bucket)` iter — the for-macro only cares about which yields
-/// positions consumable by `project`.
-///
-/// See plans/ITERATOR_REDESIGN.md Open Question 3. The choice here is
-/// "projection-returns a single Bucket struct, user destructures
-/// inside the loop" — chosen over the rejected `(ref(K), ref(V))`
-/// tuple-of-inouts shape.
-impl(
-  forall(K : Type, V : Type),
-  where(K <: (Eq(K), Hash)),
-  HashMap(K, V),
-  Indexable(usize)(
-    Element : Bucket(K, V),
-    project : (fn(ref(self) : Self, pos : usize) -> ref(Bucket(K, V)))(
-      cond(
-        (pos >= self.capacity) => panic("HashMap: project out of bounds"),
-        // SAFETY: cond above bounds `pos`; `_data_ptr` returns the
-        // start of the Rc-managed _data buffer, which is alive while
-        // `self` holds the Rc.
-        true => unsafe(Self._data_ptr(self) &+ pos)
-      )
-    )
-  )
-);
-/// Position-iter constructor for HashMap (paired with the Indexable
-/// impl above): `iter()` yields each occupied bucket index, and the
-/// for-macro then calls `coll.project(pos)` to materialize the
-/// `ref(Bucket)` borrow for the body.
-impl(
-  forall(K : Type, V : Type),
-  where(K <: (Eq(K), Hash)),
-  HashMap(K, V),
-  iter : (fn(self : Self) -> HashMapPosIter(K, V))(
-    HashMapPosIter(K, V)(_map : self, _index : usize(0))
-  )
-);
 /// Clone implementation for HashMap — deep-clones all key-value entries.
 impl(
   forall(K : Type, V : Type),

package/std/collections/list_view.yo

@@ -0,0 +1,77 @@
+//! ListView — a SAFE window over an `ArrayList(T)`.
+//!
+//! The safe replacement for borrowed slices (plans/SLICE_REWORK.md §3):
+//! a ListView holds the Rc'd backing list and indexes through the LIVE
+//! handle. By construction it cannot dangle:
+//!   - the view's Rc keeps the backing object alive (reassigning the
+//!     original variable doesn't matter),
+//!   - every access re-reads the CURRENT buffer through the handle, so
+//!     realloc-on-growth cannot leave a stale pointer,
+//!   - shrinkage is caught by bounds checks (a clean `.None`, never UB),
+//!   - alias mutation is VISIBLE (alias semantics, not a snapshot).
+//!
+//! Cost model: copying a view = one Rc incref; access = one extra
+//! indirection + bounds check. No copy-on-write.
+{ ArrayList } :: import("./array_list.yo");
+ListView :: (fn(comptime(T) : Type) -> comptime(Type))(
+  struct(
+    _backing : ArrayList(T),
+    _offset : usize,
+    _len : usize
+  )
+);
+impl(
+  forall(T : Type),
+  ListView(T),
+  /// Create a view of `[offset, offset+len)` over `backing`. The window is
+  /// clamped to the backing's CURRENT length.
+  new : (fn(backing : ArrayList(T), offset : usize, len : usize) -> Self)({
+    blen := backing.len();
+    o := cond((offset > blen) => blen, true => offset);
+    available := (blen - o);
+    l := cond((len > available) => available, true => len);
+    Self(_backing : backing, _offset : o, _len : l)
+  }),
+  /// View of the whole list.
+  of : (fn(backing : ArrayList(T)) -> Self)({
+    n := backing.len();
+    Self(_backing : backing, _offset : usize(0), _len : n)
+  }),
+  /// The view's length (fixed at construction; may exceed what the
+  /// backing currently holds if it shrank — reads past it yield .None).
+  len : (fn(self : Self) -> usize)(self._len),
+  is_empty : (fn(self : Self) -> bool)(self._len == usize(0)),
+  /// Read element `i` THROUGH the live backing. Bounds-checked against
+  /// both the view window and the backing's current length.
+  get : (fn(self : Self, i : usize) -> Option(T))(
+    cond(
+      (i >= self._len) => Option(T).None,
+      true => self._backing.get(self._offset + i)
+    )
+  ),
+  /// A sub-view of this view (still aliasing the same backing).
+  /// (Params avoid the names of sibling methods bound earlier in this
+  /// impl — e.g. `len` — which cannot be shadowed.)
+  view : (fn(self : Self, sub_offset : usize, sub_len : usize) -> Self)({
+    o := cond((sub_offset > self._len) => self._len, true => sub_offset);
+    available := (self._len - o);
+    l := cond((sub_len > available) => available, true => sub_len);
+    Self(_backing : self._backing, _offset : (self._offset + o), _len : l)
+  }),
+  /// Owned copy of the window's CURRENT contents.
+  to_list : (fn(self : Self) -> ArrayList(T))({
+    out := ArrayList(T).new();
+    i := usize(0);
+    while(i < self._len, i = (i + usize(1)), {
+      match(
+        self._backing.get(self._offset + i),
+        .Some(v) => {
+          ___ := out.push(v);
+        },
+        .None => ()
+      );
+    });
+    out
+  })
+);
+export(ListView);

package/std/crypto/random.yo

@@ -55,9 +55,9 @@ extern(
 // ============================================================================
 // Fill a buffer with cryptographically secure random bytes.
 // ============================================================================
-random_bytes :: (fn(buf : Slice(u8), exn : Exception) -> unit)({
-  buf_ptr := buf.ptr();
-  size := buf.len();
+random_bytes :: (fn(buf : RawSlice(u8), exn : Exception) -> unit)({
+  buf_ptr := buf.ptr;
+  size := buf.len;
   cond(
     (platform == Platform.Macos) => {
       __yo_arc4random_buf(buf_ptr, size);
@@ -109,7 +109,7 @@ export(random_bytes);
 // ============================================================================
 random_u32 :: (fn(exn : Exception) -> u32)({
   buf := Array(u8, usize(4)).fill(u8(0));
-  random_bytes(Slice(u8).from_raw_parts(&(buf(usize(0))), usize(4)), exn);
+  random_bytes(RawSlice(u8)(ptr : &(buf(usize(0))), len : usize(4)), exn);
   u32(buf(usize(0))) |
     (u32(buf(usize(1))) << u32(8)) |
       (u32(buf(usize(2))) << u32(16)) |
@@ -142,7 +142,7 @@ export(random_u32, random_u64, random_f64, random_range);
 uuid_v4 :: (fn(exn : Exception) -> String)({
   bytes := ArrayList(u8).with_capacity(usize(16));
   buf := Array(u8, usize(16)).fill(u8(0));
-  random_bytes(Slice(u8).from_raw_parts(&(buf(usize(0))), usize(16)), exn);
+  random_bytes(RawSlice(u8)(ptr : &(buf(usize(0))), len : usize(16)), exn);
   // Set version bits (v4)
   buf(usize(6)) = ((buf(usize(6)) & u8(0x0F)) | u8(0x40));
   // Set variant bits