progress

Author: Eric Hartford

docs/sema_codegen_ownership.md

@@ -5,6 +5,9 @@
 // once up front into an internal Vec for stable ordering and cancellation
 // bookkeeping.
 
+use std.collections
+use std.result
+
 /// Await all tasks. Returns Vec[T] in input order.
 /// Fails fast on first Err.
 pub async fn await_all[T, E](tasks: impl IntoIter[Task[Result[T, E]]]) -> Result[Vec[T], E]:

lib/std/async.w

@@ -0,0 +1,28 @@
+// std.builtins — ambient user-facing names provided by the prelude.
+//
+// These are ordinary std declarations. The compiler may still lower some of
+// them with intrinsic semantics later, but name resolution should happen
+// through imports, not through hardcoded undefined-name allowlists.
+
+extern fn print(s: str) -> void
+extern fn with_println_str(s: str) -> void
+extern fn with_println_i32(n: i32) -> void
+extern fn with_println_i64(n: i64) -> void
+extern fn with_println_bool(v: bool) -> void
+extern fn with_panic(msg: str, file: str, line: i32) -> void
+
+pub fn println(s: str) -> void:
+    with_println_str(s)
+
+pub fn println_i32(n: i32) -> void:
+    with_println_i32(n)
+
+pub fn println_i64(n: i64) -> void:
+    with_println_i64(n)
+
+pub fn println_bool(v: bool) -> void:
+    with_println_bool(v)
+
+pub fn assert(cond: bool) -> void:
+    if not cond:
+        with_panic("assertion failed", "", 0)

lib/std/builtins.w

@@ -1,98 +1,21 @@
-// std.collections — collection conveniences in pure With.
+// std.collections — collection type surface imported by the prelude.
 //
-// Core collection types (Vec, HashMap, HashSet) are language built-ins.
-// This module adds generic helper functions over those built-ins.
-
-pub fn update(map: HashMap[str, i32], key: str, default_value: i32, f: fn(i32) -> i32) -> void:
-    map.update(key, default_value, f)
-
-pub fn increment(map: HashMap[str, i32], key: str) -> void:
-    map.increment(key)
-
-pub fn decrement(map: HashMap[str, i32], key: str) -> void:
-    map.decrement(key)
-
-pub fn append(map: HashMap[str, Vec[i32]], key: str, value: i32) -> void:
-    map.append(key, value)
-
-pub fn sequence_option(xs: Vec[?i32]) -> ?Vec[i32]:
-    xs.sequence()
-
-pub fn sequence_result(xs: Vec[Result[i32, i32]]) -> Result[Vec[i32], i32]:
-    xs.sequence()
-
-// --- Additional collections (concrete scaffolding) ---
-
-extern fn with_i32_to_str(n: i32) -> str
-
-type Handle = {
-    key: str,
-    generation: i32,
+// Keep this module intentionally minimal for selfhost compatibility.
+// The compiler still owns the lowering/runtime behavior for these
+// collection types; this module provides the user-facing names so they
+// resolve through normal imports instead of hardcoded sema allowlists.
+
+type Vec[T] = {
+    ptr: *const T,
+    len: i64,
+    cap: i64,
+    elem_size: i64,
 }
 
-type SlotMap = {
-    generations: HashMap[str, i32],
-    values: HashMap[str, i32],
+type HashMap[K, V] = {
+    ptr: *const i8,
 }
 
-pub fn slotmap_new -> SlotMap:
-    SlotMap {
-        generations: HashMap.new(),
-        values: HashMap.new(),
-    }
-
-pub fn slotmap_insert(map: SlotMap, value: i32) -> (SlotMap, Handle):
-    let key = map.generations.len() as i32 |> with_i32_to_str
-    let generation_value = map.generations.get(key).unwrap_or(0) + 1
-    map.generations.insert(key, generation_value)
-    map.values.insert(key, value)
-    (map, Handle { key: key, generation: generation_value })
-
-pub fn slotmap_get(map: SlotMap, h: Handle) -> ?i32:
-    let g = map.generations.get(h.key)
-    if g.is_none() then map.values.get("__with_slotmap_absent__")
-    else if g.unwrap() != h.generation then map.values.get("__with_slotmap_absent__")
-    else map.values.get(h.key)
-
-pub fn slotmap_contains(map: SlotMap, h: Handle) -> bool:
-    let g = map.generations.get(h.key)
-    if g.is_none() then false
-    else if g.unwrap() != h.generation then false
-    else map.values.get(h.key).is_some()
-
-pub fn slotmap_remove(map: SlotMap, h: Handle) -> (SlotMap, bool):
-    let g = map.generations.get(h.key)
-    if g.is_none() then (map, false)
-    else if g.unwrap() != h.generation then (map, false)
-    else
-        let removed = map.values.remove(h.key)
-        if removed:
-            map.generations.insert(h.key, h.generation + 1)
-        (map, removed)
-
-pub fn slotmap_len(map: SlotMap) -> i32:
-    map.values.len() as i32
-
-type BTreeMap = {
-    inner: HashMap[str, i32],
+type HashSet[T] = {
+    ptr: *const i8,
 }
-
-pub fn btree_new -> BTreeMap:
-    BTreeMap { inner: HashMap.new() }
-
-pub fn btree_insert(map: BTreeMap, key: str, value: i32) -> BTreeMap:
-    map.inner.insert(key, value)
-    map
-
-pub fn btree_get(map: BTreeMap, key: str) -> ?i32:
-    map.inner.get(key)
-
-pub fn btree_contains(map: BTreeMap, key: str) -> bool:
-    map.inner.contains(key)
-
-pub fn btree_remove(map: BTreeMap, key: str) -> (BTreeMap, bool):
-    let removed = map.inner.remove(key)
-    (map, removed)
-
-pub fn btree_len(map: BTreeMap) -> i64:
-    map.inner.len()

lib/std/collections.w

@@ -2,6 +2,8 @@
 //
 // Helper functions for common iterator patterns.
 
+use std.collections
+
 extern fn with_vec_len(v: &Vec[i32]) -> i64
 extern fn with_vec_get_i32(v: &Vec[i32], index: i64) -> i32
 extern fn with_vec_get_str(v: &Vec[str], index: i64) -> str

lib/std/iter.w

@@ -1,34 +1,7 @@
-// std.option — Option wrappers over built-in combinators.
+// std.option — Option type surface imported by the prelude.
 //
-// Note: wrappers are currently concrete for i32 payloads due generic
-// signature limitations in the current Sema path.
+// Keep this module minimal for selfhost compatibility. The compiler owns
+// the lowering/runtime behavior for option methods and constructors; this
+// module provides the user-facing type name so it resolves by import.
 
-pub fn is_some(opt: ?i32) -> bool:
-    opt.is_some()
-
-pub fn is_none(opt: ?i32) -> bool:
-    opt.is_none()
-
-pub fn unwrap_or(opt: ?i32, fallback: i32) -> i32:
-    opt.unwrap_or(fallback)
-
-pub fn map(opt: ?i32, f: fn(i32) -> i32) -> ?i32:
-    opt.map(f)
-
-pub fn and_then(opt: ?i32, f: fn(i32) -> ?i32) -> ?i32:
-    opt.and_then(f)
-
-pub fn or_else(opt: ?i32, f: fn() -> ?i32) -> ?i32:
-    opt.or_else(f)
-
-pub fn filter(opt: ?i32, pred: fn(i32) -> bool) -> ?i32:
-    opt.filter(pred)
-
-pub fn zip(a: ?i32, b: ?i32) -> ?(i32, i32):
-    a.zip(b)
-
-pub fn cloned(opt: ?i32) -> ?i32:
-    opt.cloned()
-
-pub fn transpose(opt: ?Result[i32, str]) -> Result[?i32, str]:
-    opt.transpose()
+type Option[T] = | Some(T) | None

lib/std/option.w

@@ -5,6 +5,10 @@
 
 use std.math
 use std.string
+use std.builtins
+use std.collections
+use std.option
+use std.result
 use std.iter
 use std.fs
 use std.process

lib/std/prelude.w

@@ -2,3 +2,7 @@
 
 use std.string
 use std.math
+use std.builtins
+use std.collections
+use std.option
+use std.result

lib/std/prelude_core.w

@@ -2,6 +2,8 @@
 //
 // Provides process-level operations wrapping C stdlib.
 
+use std.collections
+
 extern fn exit(code: i32) -> void
 extern fn getpid() -> i32
 extern fn system(cmd: *const i8) -> i32

lib/std/process.w

@@ -1,40 +1,12 @@
-// std.result — Result wrappers over built-in combinators.
+// std.result — Result type surface imported by the prelude.
 //
-// Note: wrappers are currently concrete due generic signature limitations
-// in the current Sema path.
+// Keep this module minimal for selfhost compatibility. The compiler owns
+// the lowering/runtime behavior for result methods and constructors; this
+// module provides the user-facing type names so they resolve by import.
 
-pub fn is_ok(r: Result[i32, i32]) -> bool:
-    r.is_ok()
+type Result[T, E] = | Ok(T) | Err(E)
 
-pub fn is_err(r: Result[i32, i32]) -> bool:
-    r.is_err()
-
-pub fn unwrap_or(r: Result[i32, i32], fallback: i32) -> i32:
-    r.unwrap_or(fallback)
-
-pub fn map(r: Result[i32, i32], f: fn(i32) -> i32) -> Result[i32, i32]:
-    r.map(f)
-
-pub fn map_err(r: Result[i32, i32], f: fn(i32) -> i32) -> Result[i32, i32]:
-    r.map_err(f)
-
-pub fn and_then(r: Result[i32, i32], f: fn(i32) -> Result[i32, i32]) -> Result[i32, i32]:
-    r.and_then(f)
-
-pub fn or_else(r: Result[i32, i32], f: fn(i32) -> Result[i32, i64]) -> Result[i32, i64]:
-    r.or_else(f)
-
-pub fn ok(r: Result[i32, i32]) -> ?i32:
-    r.ok()
-
-pub fn err(r: Result[i32, i32]) -> ?i32:
-    r.err()
-
-pub fn transpose(r: Result[?i32, str]) -> ?Result[i32, str]:
-    r.transpose()
-
-pub fn context(r: Result[i32, i32], msg: str) -> Result[i32, ContextError[i32]]:
-    r.context(msg)
-
-pub fn with_context(r: Result[i32, i32], f: fn() -> str) -> Result[i32, ContextError[i32]]:
-    r.with_context(f)
+type ContextError[E] = {
+    msg: str
+    source: E
+}