@shd101wyy/yo 0.0.25 → 0.0.27

package/package.json

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

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) => {
       __yo_arc4random_buf(buf, size);
-      .Ok(())
     },
     (platform == Platform.Win32) => {
       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;

package/std/encoding/utf16.yo

@@ -6,11 +6,12 @@
 //   { utf8_to_utf16, utf16_to_utf8 } :: import "std/encoding/utf16";
 //
 //   words := utf8_to_utf16("hello");
-//   s := utf16_to_utf8(words).unwrap();
+//   s := utf16_to_utf8(words);
 
 open import "../string";
 { ArrayList } :: import "../collections/array_list";
 { EncodingError } :: import "./hex";
+{ Error, AnyError, Exception } :: import "../error";
 
 // ============================================================================
 // UTF-8 → UTF-16
@@ -63,7 +64,7 @@ export utf8_to_utf16;
 // UTF-16 → UTF-8
 // ============================================================================
 
-utf16_to_utf8 :: (fn(data: ArrayList(u16)) -> Result(String, EncodingError))({
+utf16_to_utf8 :: (fn(data: ArrayList(u16), using(exn : Exception)) -> String)({
   out := ArrayList(u8).new();
   i   := usize(0);
   while (i < data.len()), {
@@ -73,14 +74,14 @@ utf16_to_utf8 :: (fn(data: ArrayList(u16)) -> Result(String, EncodingError))({
       ((w >= u32(0xD800)) && (w <= u32(0xDBFF))) => {
         cond(
           ((i + usize(1)) >= data.len()) => {
-            return .Err(.InvalidChar(u8(0)));
+            exn.throw(dyn EncodingError.InvalidChar(u8(0)));
           },
           true => ()
         );
         w2 := u32(data.get((i + usize(1))).unwrap());
         cond(
           ((w2 < u32(0xDC00)) || (w2 > u32(0xDFFF))) => {
-            return .Err(.InvalidChar(u8(0)));
+            exn.throw(dyn EncodingError.InvalidChar(u8(0)));
           },
           true => ()
         );
@@ -109,7 +110,7 @@ utf16_to_utf8 :: (fn(data: ArrayList(u16)) -> Result(String, EncodingError))({
       }
     );
   };
-  .Ok(String.from_bytes(out))
+  String.from_bytes(out)
 });
 
 export utf16_to_utf8;

package/std/error.yo

@@ -2,33 +2,49 @@
 //
 // Provides a standard Error trait for typed error propagation.
 // All error types in the standard library should implement this trait.
-//
-// Example:
-//   { Error } :: import "std/error";
-//
-//   MyError :: enum(
-//     NotFound(path: String),
-//     PermissionDenied
-//   );
-//   impl(MyError, Error(
-//     message : (self -> {
-//       return match(self,
-//         .NotFound(path) => `file not found: ${path}`,
-//         .PermissionDenied => String.from("permission denied")
-//       );
-//     })
-//   ));
-
 open import "./string";
+open import "./fmt";
 
 // ============================================================================
 // Error trait
 // ============================================================================
 
-Error :: (fn(comptime(T) : Type) -> comptime(Type))
-  trait(
-    message :: (fn(self: *(T)) -> String)
-  )
-;
+Error :: trait(
+  (source : (fn(self: *(Self)) -> Option(Dyn(SelfTrait)))) ?= ((self) -> .None),
+
+  where(Self <: ToString)
+);
+export Error;
+
+AnyError :: Dyn(Error);
+export AnyError;
+
+// ============================================================================
+// Error implementations for standard types
+// ============================================================================
+
+impl(String, Error());
+
+/// === Exception ===
+// This is a non-resumable exception handling.  
+// 
+// Example (function that may throw):
+//
+//   safe_div :: (fn(x: i32, y: i32, using(exn : Exception)) -> i32)(
+//     cond(
+//       (y == i32(0)) => exn.throw(dyn `division by zero`)),
+//       true => (x / y)
+//     )
+//   );
+Exception :: module(
+  throw : (fn(forall(ResumeType : Type), error : AnyError) -> ResumeType)
+);
+export Exception;
 
-export Error;
+
+ResumableException :: (fn(comptime(ResumeType) : Type) -> comptime(Module))(
+  module(
+    throw : (fn(error : AnyError) -> ResumeType)
+  )
+);
+export ResumableException;