@shd101wyy/yo 0.0.26 → 0.0.28

package/package.json

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

package/std/build.yo

@@ -0,0 +1,287 @@
+// Build System Module
+//
+// Provides the declarative build API for Yo projects.
+// All functions are compile-time only — they register build artifacts
+// and steps that the build runner uses to orchestrate compilation.
+//
+// Usage in build.yo:
+//   build :: import "std/build";
+//   build.project({ name: "my-app", root: "./src/lib.yo" });
+//   exe :: build.executable({ name: "my-app", root: "./src/main.yo" });
+//   install :: build.step("install", "Build all artifacts");
+//   install.depend_on(exe);
+
+// ── Optimization levels ──────────────────────────────────────────────
+
+Optimize :: enum(
+  Debug,
+  ReleaseSafe,
+  ReleaseFast,
+  ReleaseSmall
+);
+export Optimize;
+
+// ── Memory allocators ────────────────────────────────────────────────
+
+Allocator :: enum(
+  Mimalloc,
+  Libc
+);
+export Allocator;
+
+// ── Sanitizers ───────────────────────────────────────────────────────
+
+Sanitize :: enum(
+  None,
+  Address,
+  Leak
+);
+export Sanitize;
+
+// ── Step kinds ───────────────────────────────────────────────────────
+
+StepKind :: enum(
+  Executable,
+  StaticLibrary,
+  SharedLibrary,
+  SystemLibrary,
+  TestSuite,
+  Run,
+  Custom
+);
+export StepKind;
+
+// ── Target utilities ─────────────────────────────────────────────────
+
+target_host :: __yo_build_target_host();
+export target_host;
+
+// ── Config struct types ──────────────────────────────────────────────
+// Struct types with defaults, like Zig's options structs.
+// Usage: build.executable({ name: "app", root: "./src/main.yo" })
+// Unspecified fields get their default values.
+
+Project :: struct(
+  name : comptime_string,
+  (root : comptime_string) ?= "./src/lib.yo"
+);
+export Project;
+
+Executable :: struct(
+  name : comptime_string,
+  root : comptime_string,
+  (target : comptime_string) ?= __yo_build_target_host(),
+  (optimize : Optimize) ?= Optimize.Debug,
+  (allocator : Allocator) ?= Allocator.Mimalloc,
+  (sanitize : Sanitize) ?= Sanitize.None
+);
+export Executable;
+
+StaticLibrary :: struct(
+  name : comptime_string,
+  root : comptime_string,
+  (target : comptime_string) ?= __yo_build_target_host(),
+  (optimize : Optimize) ?= Optimize.Debug
+);
+export StaticLibrary;
+
+SharedLibrary :: struct(
+  name : comptime_string,
+  root : comptime_string,
+  (target : comptime_string) ?= __yo_build_target_host(),
+  (optimize : Optimize) ?= Optimize.Debug
+);
+export SharedLibrary;
+
+TestSuite :: struct(
+  name : comptime_string,
+  root : comptime_string,
+  (target : comptime_string) ?= __yo_build_target_host()
+);
+export TestSuite;
+
+// ── Step type ────────────────────────────────────────────────────────
+// Returned by all build functions. Used to wire dependencies between steps.
+
+Step :: struct(
+  name : comptime_string,
+  kind : StepKind
+);
+export Step;
+
+// ── Step methods ─────────────────────────────────────────────────────
+// Methods on Step for Zig-like API: step.depend_on(other), exe.link(lib).
+
+impl(Step,
+  depend_on : (fn(comptime(self) : Self, comptime(dep) : Step) -> comptime(unit))({
+    __yo_build_step_depend_on(self.name, dep.name, dep.kind);
+  }),
+  link : (fn(comptime(self) : Self, comptime(library) : Step) -> comptime(unit))({
+    __yo_build_link(self.name, library.name);
+  })
+);
+
+// ── Build option config types ────────────────────────────────────────
+// Like Zig's b.option(), declare user-configurable options.
+// CLI usage: yo build -Dname=value
+
+BuildOption :: struct(
+  name : comptime_string,
+  description : comptime_string,
+  (default : comptime_string) ?= ""
+);
+export BuildOption;
+
+// ── Dependency config types ──────────────────────────────────────────
+
+GitDependency :: struct(
+  name : comptime_string,
+  url : comptime_string,
+  (ref : comptime_string) ?= "HEAD",
+  (path : comptime_string) ?= ""
+);
+export GitDependency;
+
+PathDependency :: struct(
+  name : comptime_string,
+  path : comptime_string
+);
+export PathDependency;
+
+SystemLibrary :: struct(
+  name : comptime_string,
+  pkg_config : comptime_string,
+  (fallback_include : comptime_string) ?= "",
+  (fallback_lib : comptime_string) ?= "",
+  (fallback_link : comptime_string) ?= ""
+);
+export SystemLibrary;
+
+// ── Dependency handle ────────────────────────────────────────────────
+// Returned by build.dependency() and build.path_dependency().
+// Provides access to artifacts defined in the dependency's build.yo.
+
+Dependency :: struct(
+  name : comptime_string
+);
+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))({
+    __yo_build_dep_artifact(self.name, artifact_name);
+    Step(name: artifact_name, kind: StepKind.StaticLibrary)
+  })
+);
+
+// ── Build functions ──────────────────────────────────────────────────
+// All registration functions return a Step value, allowing steps to be
+// wired together as dependencies via step.depend_on(dep).
+
+// Register project metadata.
+project :: (fn(comptime(config) : Project) -> comptime(unit)) {
+  __yo_build_project(config.name, config.root);
+};
+export project;
+
+// Register an executable artifact. Returns a Step for dependency wiring.
+executable :: (fn(comptime(config) : Executable) -> comptime(Step)) {
+  opt_str :: match(config.optimize,
+    .Debug => "debug",
+    .ReleaseSafe => "release-safe",
+    .ReleaseFast => "release-fast",
+    .ReleaseSmall => "release-small"
+  );
+  alloc_str :: match(config.allocator,
+    .Mimalloc => "mimalloc",
+    .Libc => "libc"
+  );
+  san_str :: match(config.sanitize,
+    .None => "none",
+    .Address => "address",
+    .Leak => "leak"
+  );
+  __yo_build_executable(config.name, config.root, config.target, opt_str, alloc_str, san_str);
+  Step(name: config.name, kind: StepKind.Executable)
+};
+export executable;
+
+// Register a static library artifact. Returns a Step for dependency wiring.
+static_library :: (fn(comptime(config) : StaticLibrary) -> comptime(Step)) {
+  opt_str :: match(config.optimize,
+    .Debug => "debug",
+    .ReleaseSafe => "release-safe",
+    .ReleaseFast => "release-fast",
+    .ReleaseSmall => "release-small"
+  );
+  __yo_build_static_library(config.name, config.root, config.target, opt_str);
+  Step(name: config.name, kind: StepKind.StaticLibrary)
+};
+export static_library;
+
+// Register a shared/dynamic library artifact. Returns a Step for dependency wiring.
+shared_library :: (fn(comptime(config) : SharedLibrary) -> comptime(Step)) {
+  opt_str :: match(config.optimize,
+    .Debug => "debug",
+    .ReleaseSafe => "release-safe",
+    .ReleaseFast => "release-fast",
+    .ReleaseSmall => "release-small"
+  );
+  __yo_build_shared_library(config.name, config.root, config.target, opt_str);
+  Step(name: config.name, kind: StepKind.SharedLibrary)
+};
+export shared_library;
+
+// Register a test suite. Returns a Step for dependency wiring.
+test :: (fn(comptime(config) : TestSuite) -> comptime(Step)) {
+  __yo_build_test(config.name, config.root, config.target);
+  Step(name: config.name, kind: StepKind.TestSuite)
+};
+export test;
+
+// Create a run step (compile + execute an artifact). Returns a Step.
+run :: (fn(comptime(artifact) : Step) -> comptime(Step)) {
+  __yo_build_run(artifact.name);
+  Step(name: artifact.name, kind: StepKind.Run)
+};
+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(Step)) {
+  __yo_build_step(name, description);
+  Step(name: name, kind: StepKind.Custom)
+};
+export step;
+
+// Register a git-hosted dependency. Returns a Dependency handle for accessing artifacts.
+dependency :: (fn(comptime(config) : GitDependency) -> comptime(Dependency)) {
+  __yo_build_dependency(config.name, config.url, config.ref, config.path);
+  Dependency(name: config.name)
+};
+export dependency;
+
+// Register a local path dependency. Returns a Dependency handle for accessing artifacts.
+path_dependency :: (fn(comptime(config) : PathDependency) -> comptime(Dependency)) {
+  __yo_build_path_dependency(config.name, config.path);
+  Dependency(name: config.name)
+};
+export path_dependency;
+
+// Register a system C library discovered via pkg-config. Returns a Step for linking.
+system_library :: (fn(comptime(config) : SystemLibrary) -> comptime(Step)) {
+  __yo_build_system_library(config.name, config.pkg_config, config.fallback_include, config.fallback_lib, config.fallback_link);
+  Step(name: config.name, kind: StepKind.SystemLibrary)
+};
+export system_library;
+
+// Declare a user-configurable build option.
+// Returns the option value (from CLI -Dname=value, or the default).
+// Usage: strip :: build.option({ name: "strip", description: "Strip debug symbols", default: "false" });
+option :: (fn(comptime(config) : BuildOption) -> comptime(str))(
+  __yo_build_option(config.name, config.description, config.default)
+);
+export option;

package/std/crypto/random.yo

@@ -15,6 +15,8 @@
 open import "../string";
 { snprintf } :: import "../libc/stdio";
 { hex_encode } :: import "../encoding/hex";
+{ Error, AnyError, Exception } :: import "../error";
+{ ToString } :: import "../fmt";
 
 // ============================================================================
 // Error type
@@ -25,6 +27,17 @@ CryptoError :: enum(
   Other(msg: String)
 );
 
+impl(CryptoError, ToString(
+  to_string : (self ->
+    match(self,
+      .Unavailable => `crypto: platform random unavailable`,
+      .Other(msg) => `crypto error: ${msg}`
+    )
+  )
+));
+
+impl(CryptoError, Error());
+
 export CryptoError;
 
 // ============================================================================
@@ -41,26 +54,25 @@ extern "Yo",
 // Fill a buffer with cryptographically secure random bytes.
 // ============================================================================
 
-random_bytes :: (fn(buf: *(u8), size: usize) -> Result(unit, CryptoError))(
+random_bytes :: (fn(buf: *(u8), size: usize, using(exn : Exception)) -> unit)(
   cond(
-    (platform == Platform.Darwin) => {
+    (platform == Platform.Macos) => {
       __yo_arc4random_buf(buf, size);
-      .Ok(())
     },
-    (platform == Platform.Win32) => {
+    (platform == Platform.Windows) => {
       r := __yo_bcrypt_gen_random(buf, u32(size));
       cond(
-        (r == i32(0)) => .Ok(()),
-        true => .Err(.Unavailable)
-      )
+        (r == i32(0)) => (),
+        true => { exn.throw(dyn CryptoError.Unavailable); }
+      );
     },
     true => {
       // Linux: getrandom syscall
       ret := __yo_getrandom(buf, size, u32(0));
       cond(
-        (ret < isize(0)) => .Err(.Unavailable),
-        true => .Ok(())
-      )
+        (ret < isize(0)) => { exn.throw(dyn CryptoError.Unavailable); },
+        true => ()
+      );
     }
   )
 );
@@ -71,7 +83,7 @@ export random_bytes;
 // Typed helpers
 // ============================================================================
 
-random_u32 :: (fn() -> u32)({
+random_u32 :: (fn(using(exn : Exception)) -> u32)({
   buf := Array(u8, usize(4)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));
   random_bytes(buf_ptr, usize(4));
@@ -81,18 +93,18 @@ random_u32 :: (fn() -> u32)({
    (u32(buf(usize(3))) << u32(24)))
 });
 
-random_u64 :: (fn() -> u64)({
+random_u64 :: (fn(using(exn : Exception)) -> u64)({
   lo := u64(random_u32());
   hi := u64(random_u32());
   (lo | (hi << u64(32)))
 });
 
-random_f64 :: (fn() -> f64)(
+random_f64 :: (fn(using(exn : Exception)) -> f64)(
   (f64(random_u64()) / f64(18446744073709551615.0))
 );
 
 // Return a random integer in the half-open range [min, max).
-random_range :: (fn(min: i64, max: i64) -> i64)({
+random_range :: (fn(min: i64, max: i64, using(exn : Exception)) -> i64)({
   span := (max - min);
   cond(
     (span <= i64(0)) => min,
@@ -110,7 +122,7 @@ export random_u32, random_u64, random_f64, random_range;
 // ============================================================================
 
 // Generate a random UUID v4 string: "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
-uuid_v4 :: (fn() -> String)({
+uuid_v4 :: (fn(using(exn : Exception)) -> String)({
   bytes := ArrayList(u8).with_capacity(usize(16));
   buf := Array(u8, usize(16)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));

package/std/encoding/base64.yo

@@ -11,6 +11,7 @@
 open import "../string";
 { ArrayList } :: import "../collections/array_list";
 { EncodingError } :: import "./hex";
+{ Error, AnyError, Exception } :: import "../error";
 
 // ============================================================================
 // Standard alphabet
@@ -73,81 +74,55 @@ export base64_encode, base64_encode_url;
 // Decoding
 // ============================================================================
 
-_decode_char :: (fn(c: u8, alpha: str) -> Result(u8, EncodingError))({
+_decode_char :: (fn(c: u8, alpha: str, using(exn : Exception)) -> u8)({
   i := usize(0);
   while (i < usize(64)), (i = (i + usize(1))), {
     cond(
-      (alpha.bytes(i) == c) => { return .Ok(u8(i)); },
+      (alpha.bytes(i) == c) => { return u8(i); },
       true => ()
     );
   };
-  .Err(.InvalidChar(c))
+  exn.throw(dyn EncodingError.InvalidChar(c))
 });
 
-_decode_with :: (fn(s: str, alpha: str) -> Result(ArrayList(u8), EncodingError))({
+_decode_with :: (fn(s: str, alpha: str, using(exn : Exception)) -> ArrayList(u8))({
   // Strip trailing padding
   len := s.len();
   while ((len > usize(0)) && (s.bytes((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_r := _decode_char(s.bytes(i), alpha);
-    c1_r := cond(
+    c0 := _decode_char(s.bytes(i), alpha);
+    c1 := cond(
       ((i + usize(1)) < len) => _decode_char(s.bytes((i + usize(1))), alpha),
-      true => Result(u8, EncodingError).Ok(u8(0))
+      true => u8(0)
     );
-    c2_r := cond(
-      ((i + usize(2)) < len) => _decode_char(s.bytes((i + usize(2))), alpha),
-      true => Result(u8, EncodingError).Ok(u8(0))
-    );
-    c3_r := cond(
-      ((i + usize(3)) < len) => _decode_char(s.bytes((i + usize(3))), alpha),
-      true => Result(u8, EncodingError).Ok(u8(0))
-    );
-    match(c0_r,
-      .Err(e) => { return .Err(e); },
-      .Ok(c0) => {
-        match(c1_r,
-          .Err(e) => { return .Err(e); },
-          .Ok(c1) => {
-            out.push(((c0 << u8(2)) | (c1 >> u8(4))));
-            cond(
-              ((i + usize(2)) < len) => {
-                match(c2_r,
-                  .Err(e) => { return .Err(e); },
-                  .Ok(c2) => {
-                    out.push((((c1 & u8(15)) << u8(4)) | (c2 >> u8(2))));
-                    cond(
-                      ((i + usize(3)) < len) => {
-                        match(c3_r,
-                          .Err(e) => { return .Err(e); },
-                          .Ok(c3) => {
-                            out.push((((c2 & u8(3)) << u8(6)) | c3));
-                          }
-                        );
-                      },
-                      true => ()
-                    );
-                  }
-                );
-              },
-              true => ()
-            );
-          }
+    out.push(((c0 << u8(2)) | (c1 >> u8(4))));
+    cond(
+      ((i + usize(2)) < len) => {
+        c2 := _decode_char(s.bytes((i + usize(2))), alpha);
+        out.push((((c1 & u8(15)) << u8(4)) | (c2 >> u8(2))));
+        cond(
+          ((i + usize(3)) < len) => {
+            c3 := _decode_char(s.bytes((i + usize(3))), alpha);
+            out.push((((c2 & u8(3)) << u8(6)) | c3));
+          },
+          true => ()
         );
-      }
+      },
+      true => ()
     );
   };
-  .Ok(out)
+  out
 });
 
 // Decode standard base64.
-base64_decode :: (fn(s: str) -> Result(ArrayList(u8), EncodingError))(
+base64_decode :: (fn(s: str, using(exn : Exception)) -> ArrayList(u8))(
   _decode_with(s, _STD_ALPHA)
 );
 
 // Decode URL-safe base64.
-base64_decode_url :: (fn(s: str) -> Result(ArrayList(u8), EncodingError))(
+base64_decode_url :: (fn(s: str, using(exn : Exception)) -> ArrayList(u8))(
   _decode_with(s, _URL_ALPHA)
 );
 

package/std/encoding/hex.yo

@@ -6,10 +6,12 @@
 //   { hex_encode, hex_decode } :: import "std/encoding/hex";
 //
 //   s := hex_encode(data);         // "deadbeef"
-//   b := hex_decode("deadbeef").unwrap();
+//   b := hex_decode("deadbeef");
 
 open import "../string";
 { ArrayList } :: import "../collections/array_list";
+{ Error, AnyError, Exception } :: import "../error";
+{ ToString } :: import "../fmt";
 
 // ============================================================================
 // Error type
@@ -20,6 +22,17 @@ EncodingError :: enum(
   OddLength
 );
 
+impl(EncodingError, ToString(
+  to_string : (self ->
+    match(self,
+      .InvalidChar(ch) => `encoding error: invalid character ${ch}`,
+      .OddLength => `encoding error: odd length`
+    )
+  )
+));
+
+impl(EncodingError, Error());
+
 export EncodingError;
 
 // ============================================================================
@@ -52,41 +65,31 @@ export hex_encode;
 // Decoding
 // ============================================================================
 
-_hex_nibble :: (fn(c: u8) -> Result(u8, EncodingError))(
+_hex_nibble :: (fn(c: u8, using(exn : Exception)) -> u8)(
   cond(
-    ((c >= u8(48)) && (c <= u8(57)))  => .Ok((c - u8(48))),         // '0'-'9'
-    ((c >= u8(97)) && (c <= u8(102))) => .Ok(((c - u8(97)) + u8(10))), // 'a'-'f'
-    ((c >= u8(65)) && (c <= u8(70)))  => .Ok(((c - u8(65)) + u8(10))), // 'A'-'F'
-    true => .Err(.InvalidChar(c))
+    ((c >= u8(48)) && (c <= u8(57)))  => (c - u8(48)),         // '0'-'9'
+    ((c >= u8(97)) && (c <= u8(102))) => ((c - u8(97)) + u8(10)), // 'a'-'f'
+    ((c >= u8(65)) && (c <= u8(70)))  => ((c - u8(65)) + u8(10)), // 'A'-'F'
+    true => exn.throw(dyn EncodingError.InvalidChar(c))
   )
 );
 
 // Decode a hexadecimal string into bytes.
-hex_decode :: (fn(s: str) -> Result(ArrayList(u8), EncodingError))({
+hex_decode :: (fn(s: str, using(exn : Exception)) -> ArrayList(u8))({
   cond(
     (((s.len() % usize(2)) != usize(0))) => {
-      return .Err(.OddLength);
+      exn.throw(dyn EncodingError.OddLength);
     },
     true => ()
   );
   out := ArrayList(u8).with_capacity((s.len() / usize(2)));
   i   := usize(0);
   while (i < s.len()), (i = (i + usize(2))), {
-    hi_r := _hex_nibble(s.bytes(i));
-    lo_r := _hex_nibble(s.bytes((i + usize(1))));
-    match(hi_r,
-      .Err(e) => { return .Err(e); },
-      .Ok(hi) => {
-        match(lo_r,
-          .Err(e) => { return .Err(e); },
-          .Ok(lo) => {
-            out.push(((hi << u8(4)) | lo));
-          }
-        );
-      }
-    );
+    hi := _hex_nibble(s.bytes(i));
+    lo := _hex_nibble(s.bytes((i + usize(1))));
+    out.push(((hi << u8(4)) | lo));
   };
-  .Ok(out)
+  out
 });
 
 export hex_decode;

package/std/encoding/json.yo

@@ -4,13 +4,17 @@
 //
 // Example:
 //   { json_parse, json_stringify, JsonValue } :: import "std/encoding/json";
+//   { Exception } :: import "std/error";
 //
-//   v := json_parse(`{"x": 1}`).unwrap();
+//   given(exn) := Exception(throw : ((err) -> { escape (); }));
+//   v := json_parse(`{"x": 1}`);
 //   println(json_stringify(v));
 
 open import "../string";
 { ArrayList } :: import "../collections/array_list";
 { snprintf } :: import "../libc/stdio";
+{ Error, AnyError, Exception } :: import "../error";
+{ ToString } :: import "../fmt";
 
 // ============================================================================
 // JsonError
@@ -25,6 +29,21 @@ JsonError :: enum(
   Other(msg: String)
 );
 
+impl(JsonError, ToString(
+  to_string : (self ->
+    match(self,
+      .UnexpectedChar(ch, pos) => `unexpected character at position ${pos}`,
+      .UnexpectedEnd => `unexpected end of input`,
+      .InvalidNumber => `invalid number`,
+      .InvalidEscape => `invalid escape sequence`,
+      .InvalidUnicode => `invalid unicode`,
+      .Other(msg) => `JSON error: ${msg}`
+    )
+  )
+));
+
+impl(JsonError, Error());
+
 export JsonError;
 
 // ============================================================================
@@ -449,9 +468,12 @@ _parse_value :: (fn(p: _Parser) -> Result(JsonValue, JsonError))({
 // Public API
 // ============================================================================
 
-json_parse :: (fn(s: str) -> Result(JsonValue, JsonError))({
+json_parse :: (fn(s: str, using(exn : Exception)) -> JsonValue)({
   p := _Parser.new(s);
-  _parse_value(p)
+  match(_parse_value(p),
+    .Ok(v) => v,
+    .Err(e) => exn.throw(dyn e)
+  )
 });
 
 export json_parse;