@shd101wyy/yo 0.1.21 → 0.1.23

package/std/collections/hash_map.yo

@@ -673,6 +673,32 @@ impl(forall(K : Type, V : Type), HashMap(K, V), Index(K)(
   })
 ));
 
+/// Clone implementation for HashMap — deep-clones all key-value entries.
+impl(forall(K : Type, V : Type),
+     where(K <: (Clone, Eq(K), Hash), V <: Clone),
+     HashMap(K, V),
+     Clone(
+       clone : (fn(self: *(Self)) -> Self)(
+         {
+           result := Self.new();
+           it := self.iter();
+           running := true;
+           while running, {
+             nxt := it.next();
+             match(nxt,
+               .None => { running = false; },
+               .Some(bucket_ptr) => {
+                 k := (&(bucket_ptr.*.key)).clone();
+                 v := (&(bucket_ptr.*.value)).clone();
+                 result.set(k, v);
+               }
+             );
+           };
+           result
+         }
+       )
+     ));
+
 export
   HashMap,
   HashMapError,
@@ -682,3 +708,64 @@ export
   HashMapKeys,
   HashMapValues
 ;
+
+// =============================================================================
+// hash_map! literal macro
+// =============================================================================
+
+/// Internal helper: build a list of `tmp.set(k, v).unwrap()` statements from
+/// a sequence of `k => v` arrow expressions.
+__hash_map_build_sets :: (fn(comptime(tmp) : Expr, comptime(entries) : ExprList) -> comptime(ExprList))(
+  cond(
+    (entries.len() == usize(0)) => ExprList(),
+    true => {
+      first :: entries.car();
+      rest :: entries.cdr();
+      __ :: comptime_assert(first.is_fn_call(), "hash_map entries must use 'k => v'");
+      callee :: first.get_callee();
+      __1 :: comptime_assert((callee.is_atom() && (callee == quote(=>))), "hash_map entries must use 'k => v'");
+      pair :: first.get_args();
+      __2 :: comptime_assert((pair.len() == usize(2)), "hash_map entries must use 'k => v'");
+      key :: pair.car();
+      val :: pair.cdr().car();
+      stmt :: quote((unquote(tmp).set(unquote(key), unquote(val)).unwrap()));
+      stmt.cons(recur(tmp, rest))
+    }
+  )
+);
+
+/// `hash_map` macro — construct a `HashMap(K, V)` literal.
+///
+/// `K` and `V` are inferred from the first entry's key and value via `typeof`,
+/// so at least one entry is required.
+///
+/// # Example
+/// ```rust
+/// m := hash_map(`a` => i32(1), `b` => i32(2));
+/// ```
+hash_map :: (fn(...(quote(entries))) -> unquote(Expr)) {
+  __ :: comptime_assert((entries.len() > usize(0)),
+    "hash_map requires at least one 'k => v' entry to infer K and V");
+  first :: entries.car();
+  __1 :: comptime_assert(first.is_fn_call(), "hash_map entries must use 'k => v'");
+  callee :: first.get_callee();
+  __2 :: comptime_assert((callee.is_atom() && (callee == quote(=>))), "hash_map entries must use 'k => v'");
+  pair :: first.get_args();
+  __3 :: comptime_assert((pair.len() == usize(2)), "hash_map entries must use 'k => v'");
+  first_key :: pair.car();
+  first_val :: pair.cdr().car();
+  rest :: entries.cdr();
+  tmp :: gensym("hash_map");
+  k_tmp :: gensym("hash_map_k0");
+  v_tmp :: gensym("hash_map_v0");
+  rest_sets :: __hash_map_build_sets(tmp, rest);
+  quote {
+    unquote(k_tmp) := unquote(first_key);
+    unquote(v_tmp) := unquote(first_val);
+    unquote(tmp) := HashMap(typeof(unquote(k_tmp)), typeof(unquote(v_tmp))).new();
+    unquote(tmp).set(unquote(k_tmp), unquote(v_tmp)).unwrap();
+    unquote_splicing(rest_sets);
+    unquote(tmp)
+  }
+};
+export hash_map;

package/std/collections/hash_set.yo

@@ -833,3 +833,47 @@ export
   HashSetIter,
   HashSetIterPtr
 ;
+
+// =============================================================================
+// hash_set! literal macro
+// =============================================================================
+
+/// Internal helper: build a list of `tmp.add(elem).unwrap()` statements from `elems`.
+__hash_set_build_adds :: (fn(comptime(tmp) : Expr, comptime(elems) : ExprList) -> comptime(ExprList))(
+  cond(
+    (elems.len() == usize(0)) => ExprList(),
+    true => {
+      first :: elems.car();
+      rest :: elems.cdr();
+      stmt :: quote((unquote(tmp).add(unquote(first)).unwrap()));
+      stmt.cons(recur(tmp, rest))
+    }
+  )
+);
+
+/// `hash_set` macro — construct a `HashSet(T)` literal.
+///
+/// `T` is inferred from the first element via `typeof`, so at least one
+/// element is required.
+///
+/// # Example
+/// ```rust
+/// s := hash_set(i32(1), i32(2), i32(3));
+/// ```
+hash_set :: (fn(...(quote(elems))) -> unquote(Expr)) {
+  __ :: comptime_assert((elems.len() > usize(0)),
+    "hash_set requires at least one element to infer the element type");
+  first :: elems.car();
+  rest :: elems.cdr();
+  tmp :: gensym("hash_set");
+  first_tmp :: gensym("hash_set_first");
+  rest_adds :: __hash_set_build_adds(tmp, rest);
+  quote {
+    unquote(first_tmp) := unquote(first);
+    unquote(tmp) := HashSet(typeof(unquote(first_tmp))).new();
+    unquote(tmp).add(unquote(first_tmp)).unwrap();
+    unquote_splicing(rest_adds);
+    unquote(tmp)
+  }
+};
+export hash_set;

package/std/collections/ordered_map.yo

@@ -0,0 +1,244 @@
+//! Insertion-ordered map.
+//!
+//! `OrderedMap(K, V)` preserves the order in which keys were first inserted,
+//! similar to JavaScript's `Map` or Python's `dict` (≥ 3.7). Backed by a
+//! `HashMap` for O(1) average-time lookup and an `ArrayList` of keys for
+//! deterministic iteration order.
+//!
+//! # Complexity
+//!
+//! - `set` (new key): O(1) amortized
+//! - `set` (existing key): O(1) — value updated in place, order unchanged
+//! - `get` / `contains_key`: O(1) average
+//! - `remove`: O(n) — must rebuild the key order list to skip the removed key
+//! - `iter` / `keys` / `values`: O(n), in insertion order
+//!
+//! # Example
+//!
+//! ```rust
+//! { OrderedMap } :: import "std/collections/ordered_map";
+//!
+//! m := OrderedMap(String, i32).new();
+//! m.set(`alpha`, i32(1));
+//! m.set(`beta`,  i32(2));
+//! m.set(`gamma`, i32(3));
+//!
+//! // Iteration yields keys in insertion order.
+//! it := m.keys();
+//! while true, {
+//!   match(it.next(),
+//!     .Some(k) => println(k),
+//!     .None => break
+//!   );
+//! };
+//! ```
+
+open import "./array_list";
+open import "./hash_map";
+
+/// Ordered map preserving insertion order of keys.
+/// Keys must implement `Eq` and `Hash`.
+OrderedMap :: (fn(
+  comptime(K) : Type,
+  comptime(V) : Type,
+  where(K <: (Eq(K), Hash))
+) -> comptime(Type))
+  object(
+    _map : HashMap(K, V),
+    _order : ArrayList(K)
+  )
+;
+
+impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMap(K, V),
+  /// Create an empty `OrderedMap`.
+  new : (fn() -> Self)(
+    Self(
+      _map: HashMap(K, V).new(),
+      _order: ArrayList(K).new()
+    )
+  ),
+
+  /// Number of entries.
+  len : (fn(self : Self) -> usize)(self._map.len()),
+
+  /// Whether the map is empty.
+  is_empty : (fn(self : Self) -> bool)(self._map.is_empty()),
+
+  /// Returns `true` if `key` is present.
+  contains_key : (fn(self : Self, key : K) -> bool)(self._map.contains_key(key)),
+
+  /// Returns the value for `key`, or `.None`.
+  get : (fn(self : Self, key : K) -> Option(V))(self._map.get(key)),
+
+  /// Insert or update `key -> value`.
+  ///
+  /// - For a new key, appends `key` to the insertion order.
+  /// - For an existing key, only updates the value; order is preserved.
+  ///
+  /// Returns `Ok(.Some(old_value))` if key already existed, `Ok(.None)` for
+  /// a new key, or `.Err(_)` on allocation failure.
+  set : (fn(self : Self, key : K, value : V) -> Result(Option(V), HashMapError))({
+    is_new := !(self._map.contains_key(key));
+    result := self._map.set(key, value);
+    cond(
+      is_new => match(result,
+        .Ok(_) => { self._order.push(key); },
+        .Err(_) => ()
+      ),
+      true => ()
+    );
+    return result;
+  }),
+
+  /// Remove `key`. Returns the removed value or `.None`.
+  /// O(n) — rebuilds the key order list to drop the removed key.
+  remove : (fn(self : Self, key : K) -> Option(V))({
+    removed := self._map.remove(key);
+    match(removed,
+      .Some(_) => {
+        new_order := ArrayList(K).new();
+        i := usize(0);
+        n := self._order.len();
+        while (i < n), (i = (i + usize(1))), {
+          match(self._order.get(i),
+            .Some(k) => {
+              cond(
+                (k == key) => (),
+                true => { new_order.push(k); }
+              );
+            },
+            .None => ()
+          );
+        };
+        self._order = new_order;
+      },
+      .None => ()
+    );
+    return removed;
+  }),
+
+  /// Remove all entries.
+  clear : (fn(self : Self) -> unit)({
+    self._map.clear();
+    self._order = ArrayList(K).new();
+  })
+);
+
+/// Iterator over the keys of an `OrderedMap` in insertion order.
+OrderedMapKeys :: (fn(
+  comptime(K) : Type,
+  comptime(V) : Type,
+  where(K <: (Eq(K), Hash))
+) -> comptime(Type))
+  object(
+    _map : OrderedMap(K, V),
+    _index : usize
+  )
+;
+
+impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMapKeys(K, V),
+  next : (fn(self : *(Self)) -> Option(K))({
+    cond(
+      (self._index >= self._map._order.len()) => { return .None; },
+      true => ()
+    );
+    k := self._map._order.get(self._index);
+    self._index = (self._index + usize(1));
+    return k;
+  })
+);
+
+/// Iterator over the values of an `OrderedMap` in insertion order.
+OrderedMapValues :: (fn(
+  comptime(K) : Type,
+  comptime(V) : Type,
+  where(K <: (Eq(K), Hash))
+) -> comptime(Type))
+  object(
+    _map : OrderedMap(K, V),
+    _index : usize
+  )
+;
+
+impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMapValues(K, V),
+  next : (fn(self : *(Self)) -> Option(V))({
+    cond(
+      (self._index >= self._map._order.len()) => { return .None; },
+      true => ()
+    );
+    match(self._map._order.get(self._index),
+      .Some(k) => {
+        self._index = (self._index + usize(1));
+        return self._map._map.get(k);
+      },
+      .None => { return .None; }
+    );
+  })
+);
+
+/// Key-value pair yielded by `OrderedMapIter`.
+OrderedMapEntry :: (fn(
+  comptime(K) : Type,
+  comptime(V) : Type
+) -> comptime(Type))
+  struct(
+    key : K,
+    value : V
+  )
+;
+
+/// Iterator over `(key, value)` pairs of an `OrderedMap` in insertion order.
+OrderedMapIter :: (fn(
+  comptime(K) : Type,
+  comptime(V) : Type,
+  where(K <: (Eq(K), Hash))
+) -> comptime(Type))
+  object(
+    _map : OrderedMap(K, V),
+    _index : usize
+  )
+;
+
+impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMapIter(K, V),
+  next : (fn(self : *(Self)) -> Option(OrderedMapEntry(K, V)))({
+    cond(
+      (self._index >= self._map._order.len()) => { return .None; },
+      true => ()
+    );
+    match(self._map._order.get(self._index),
+      .Some(k) => {
+        self._index = (self._index + usize(1));
+        match(self._map._map.get(k),
+          .Some(v) => { return .Some(OrderedMapEntry(K, V)(key: k, value: v)); },
+          .None => { return .None; }
+        );
+      },
+      .None => { return .None; }
+    );
+  })
+);
+
+impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), OrderedMap(K, V),
+  /// Iterator over keys in insertion order.
+  keys : (fn(self : Self) -> OrderedMapKeys(K, V))(
+    OrderedMapKeys(K, V)(_map: self, _index: usize(0))
+  ),
+
+  /// Iterator over values in insertion order.
+  values : (fn(self : Self) -> OrderedMapValues(K, V))(
+    OrderedMapValues(K, V)(_map: self, _index: usize(0))
+  ),
+
+  /// Iterator over `(key, value)` pairs in insertion order.
+  iter : (fn(self : Self) -> OrderedMapIter(K, V))(
+    OrderedMapIter(K, V)(_map: self, _index: usize(0))
+  )
+);
+
+export
+  OrderedMap,
+  OrderedMapEntry,
+  OrderedMapKeys,
+  OrderedMapValues,
+  OrderedMapIter
+;

package/std/{process.yo → env.yo}

@@ -1,43 +1,16 @@
-//! Process information, command-line arguments, environment variables, and platform detection.
+//! Process environment: command-line arguments, environment variables,
+//! and current working directory.
+//!
+//! Mirrors the layout of Rust's `std::env`. Platform/architecture detection
+//! and child-process spawning live in `std/process`.
 
 open import "./collections/array_list";
 open import "./string";
 open import "./path";
+{ platform, Platform } :: import "./process";
 { GlobalAllocator } :: import "./allocator";
 { malloc, free } :: GlobalAllocator;
 
-/// Current target platform as a compile-time string.
-/// One of: "linux", "macos", "windows", "freebsd", "emscripten", "wasi".
-platform :: __yo_process_platform();
-export platform;
-
-/// Platform constants for compile-time platform comparisons.
-Platform :: {
-  Linux : "linux",
-  Macos : "macos",
-  Windows : "windows",
-  FreeBSD : "freebsd",
-  Emscripten : "emscripten",
-  Wasi : "wasi"
-};
-export Platform;
-
-/// Current target architecture as a compile-time string.
-/// One of: "x86_64", "aarch64", "x86", "arm", "wasm32".
-arch :: __yo_process_arch();
-export arch;
-
-/// Architecture constants for compile-time architecture comparisons.
-Arch :: {
-  X86_64 : "x86_64",
-  Aarch64 : "aarch64",
-  X86 : "x86",
-  Arm : "arm",
-  Wasm32 : "wasm32"
-};
-export Arch;
-
-
 // === Low-level C interface ===
 
 extern "Yo",
@@ -71,11 +44,11 @@ export argv;
 
 /// Get command-line arguments as an `ArrayList(String)`.
 /// The first element is the program name.
-args :: (fn() -> ArrayList(String)) {  
+args :: (fn() -> ArrayList(String)) {
   raw := raw_args();
   i := usize(0);
   len := usize(argc());
-  
+
   result := ArrayList(String).with_capacity(len);
 
   while i < len, {
@@ -94,7 +67,7 @@ env :: impl {
 
   /// Get the value of an environment variable by name.
   /// Returns `.None` if the variable is not set.
-  get :: (fn(name : String) -> Option(String)) {  
+  get :: (fn(name : String) -> Option(String)) {
     name_cstr := name.to_cstr().ptr().unwrap();
     val_ptr := getenv(*(char)(name_cstr));
     match(val_ptr,
@@ -109,28 +82,24 @@ env :: impl {
   set :: (fn(name : String, value : String, (overwrite : bool) ?= true) -> bool) {
     name_cstr := name.to_cstr().ptr().unwrap();
     value_cstr := value.to_cstr().ptr().unwrap();
-    
+
     result := cond(
       (platform == Platform.Windows) => {
-        // Windows: use _putenv_s (doesn't have overwrite parameter)
         { _putenv_s } :: import "./libc/windows";
-        
+
         cond(
           overwrite =>
-            // Always set on Windows (no native "don't overwrite" option)
             _putenv_s(*(char)(name_cstr), *(char)(value_cstr)),
           true => {
-            // Check if variable exists first
             existing := getenv(*(char)(name_cstr));
             match(existing,
-              .Some(_) => int(0),  // Variable exists, don't overwrite (return success)
+              .Some(_) => int(0),
               .None => _putenv_s(*(char)(name_cstr), *(char)(value_cstr))
             )
           }
         )
       },
       true => {
-        // Unix: use setenv
         overwrite_int := cond(
           overwrite => int(1),
           true => int(0)
@@ -138,7 +107,7 @@ env :: impl {
         setenv(*(char)(name_cstr), *(char)(value_cstr), overwrite_int)
       }
     );
-    
+
     return result == int(0);
   };
   export set;
@@ -150,28 +119,22 @@ export env;
 cwd :: (fn() -> Result(Path, String))(
   cond(
     (platform == Platform.Windows) => {
-      // Windows implementation using GetCurrentDirectoryW
       { GetCurrentDirectoryW, WideCharToMultiByte, CP_UTF8, WCHAR, DWORD } :: import "./libc/windows";
-      
-      // First, get the required buffer size
+
       required_size := GetCurrentDirectoryW(ulong(0), .None);
       cond(
         (required_size == ulong(0)) => .Err(`Failed to get current working directory on Windows`),
         true => {
-          // Allocate buffer for wide characters
           wbuf := *(WCHAR)(malloc((usize(required_size) * usize(2))).unwrap());
-          
-          // Get the current directory in UTF-16
+
           actual_size := GetCurrentDirectoryW(required_size, .Some(wbuf));
-          
+
           cond(
             (actual_size == ulong(0)) => {
               free(.Some(*(void)(wbuf)));
               .Err(`Failed to get current working directory on Windows`)
             },
             true => {
-              // Convert UTF-16 to UTF-8
-              // First, get the required buffer size for UTF-8
               utf8_size := WideCharToMultiByte(
                 CP_UTF8,
                 ulong(0),
@@ -182,17 +145,15 @@ cwd :: (fn() -> Result(Path, String))(
                 .None,
                 .None
               );
-              
+
               cond(
                 (utf8_size <= i32(0)) => {
                   free(.Some(*(void)(wbuf)));
                   .Err(`Failed to convert directory path to UTF-8`)
                 },
                 true => {
-                  // Allocate buffer for UTF-8 string
                   utf8_buf := *(u8)(malloc((usize(utf8_size) + usize(1))).unwrap());
-                  
-                  // Convert to UTF-8
+
                   result := WideCharToMultiByte(
                     CP_UTF8,
                     ulong(0),
@@ -203,16 +164,15 @@ cwd :: (fn() -> Result(Path, String))(
                     .None,
                     .None
                   );
-                  
+
                   free(.Some(*(void)(wbuf)));
-                  
+
                   cond(
                     (result <= i32(0)) => {
                       free(.Some(*(void)(utf8_buf)));
                       .Err(`Failed to convert directory path to UTF-8`)
                     },
                     true => {
-                      // Add null terminator
                       (utf8_buf &+ usize(result)).* = u8(0);
                       cwd_str := String.from_cstr(utf8_buf).unwrap();
                       free(.Some(*(void)(utf8_buf)));
@@ -227,15 +187,13 @@ cwd :: (fn() -> Result(Path, String))(
       )
     },
     true => {
-      // Unix-like implementation using getcwd
       { getcwd } :: import "./libc/unistd";
-      
-      // Allocate a buffer for the path (PATH_MAX is typically 4096)
+
       buf_size := usize(4096);
       buf := *(char)(malloc(buf_size).unwrap());
-      
+
       result_ptr := getcwd(buf, buf_size);
-      
+
       match(result_ptr,
         .None => {
           free(.Some(*(void)(buf)));
@@ -257,26 +215,24 @@ export cwd;
 chdir :: (fn(path: Path) -> Result(unit, String))(
   cond(
     (platform == Platform.Windows) => {
-      // Windows implementation using SetCurrentDirectoryA
       { SetCurrentDirectoryA, BOOL } :: import "./libc/windows";
-      
+
       path_str := path.to_string();
       path_cstr := path_str.to_cstr().ptr().unwrap();
       result := SetCurrentDirectoryA(*(char)(path_cstr));
-      
+
       cond(
         (result == int(0)) => .Err(`Failed to change directory to: ${path_str}`),
         true => .Ok(())
       )
     },
     true => {
-      // Unix-like implementation using chdir
       { chdir : unix_chdir } :: import "./libc/unistd";
-      
+
       path_str := path.to_string();
       path_cstr := path_str.to_cstr().ptr().unwrap();
       result := unix_chdir(*(char)(path_cstr));
-      
+
       cond(
         (result != int(0)) => .Err(`Failed to change directory to: ${path_str}`),
         true => .Ok(())
@@ -285,10 +241,3 @@ chdir :: (fn(path: Path) -> Result(unit, String))(
   )
 );
 export chdir;
-
-/// Exit the process with the given status code.
-exit :: (fn(code : usize) -> unit) {
-  { exit : _exit } :: import "./libc/stdlib";
-  _exit(int(code));
-};
-export exit;

package/std/fs/temp.yo

@@ -30,7 +30,8 @@ _dir_mod :: import "./dir";
 IO_temp :: import "../sys/temp";
 IO_file :: import "../sys/file";
 { memcpy } :: import "../libc/string";
-{ platform, Platform, env } :: import "../process";
+{ platform, Platform } :: import "../process";
+{ env } :: import "../env";
 
 _default_tmp_dir :: (fn() -> String)(
   cond(

package/std/{glob/index.yo → glob.yo}

@@ -1,7 +1,7 @@
 //! Glob pattern matching for file paths.
 
-open import "../string";
-{ ArrayList } :: import "../collections/array_list";
+open import "./string";
+{ ArrayList } :: import "./collections/array_list";
 
 // Recursive byte-level glob pattern matching
 _glob_match_impl :: (fn(pb: ArrayList(u8), pi: usize, tb: ArrayList(u8), ti: usize) -> bool)({

package/std/{log/index.yo → log.yo}

@@ -1,8 +1,8 @@
 //! Structured logging with configurable level and output destination.
 
-open import "../string";
-{ ToString } :: import "../fmt";
-{ fwrite, stdout, stderr, FILE } :: import "../libc/stdio";
+open import "./string";
+{ ToString } :: import "./fmt";
+{ fwrite, stdout, stderr, FILE } :: import "./libc/stdio";
 
 /// Log severity level.
 Level :: enum(Trace, Debug, Info, Warn, Error);

package/std/os/env.yo

@@ -12,7 +12,8 @@
 //! ```
 
 open import "../string";
-{ platform, Platform, env } :: import "../process";
+{ platform, Platform } :: import "../process";
+{ env } :: import "../env";
 
 // ============================================================================
 // Directory helpers