@shd101wyy/yo 0.1.26 → 0.1.28

package/std/encoding/utf16.yo

@@ -10,23 +10,20 @@
 //! words := utf8_to_utf16("hello");
 //! s := utf16_to_utf8(words);
 //! ```
-
-open import "../string";
-{ ArrayList } :: import "../collections/array_list";
-{ EncodingError } :: import "./hex";
-{ Error, AnyError, Exception } :: import "../error";
-
+open(import("../string"));
+{ ArrayList } :: import("../collections/array_list");
+{ EncodingError } :: import("./hex");
+{ Error, AnyError, Exception } :: import("../error");
 // ============================================================================
 // UTF-8 → UTF-16
 // ============================================================================
-
 /// Convert a UTF-8 string to an `ArrayList(u16)` of UTF-16 code units.
 ///
 /// Handles BMP characters directly and encodes supplementary characters as surrogate pairs.
-utf8_to_utf16 :: (fn(s: str) -> ArrayList(u16))({
+utf8_to_utf16 :: (fn(s : str) -> ArrayList(u16))({
   out := ArrayList(u16).new();
-  i   := usize(0);
-  while (i < s.len()), {
+  i := usize(0);
+  while(i < s.len(), {
     b0 := u32(s.bytes(i));
     cond(
       (b0 < u32(0x80)) => {
@@ -34,73 +31,70 @@ utf8_to_utf16 :: (fn(s: str) -> ArrayList(u16))({
         i = (i + usize(1));
       },
       ((b0 & u32(0xE0)) == u32(0xC0)) => {
-        b1  := u32(s.bytes((i + usize(1))));
-        cp  := (((b0 & u32(0x1F)) << u32(6)) | (b1 & u32(0x3F)));
+        b1 := u32(s.bytes(i + usize(1)));
+        cp := (((b0 & u32(0x1F)) << u32(6)) | (b1 & u32(0x3F)));
         out.push(u16(cp));
         i = (i + usize(2));
       },
       ((b0 & u32(0xF0)) == u32(0xE0)) => {
-        b1 := u32(s.bytes((i + usize(1))));
-        b2 := u32(s.bytes((i + usize(2))));
-        cp  := ((((b0 & u32(0x0F)) << u32(12)) | ((b1 & u32(0x3F)) << u32(6))) | (b2 & u32(0x3F)));
+        b1 := u32(s.bytes(i + usize(1)));
+        b2 := u32(s.bytes(i + usize(2)));
+        cp := ((((b0 & u32(0x0F)) << u32(12)) | ((b1 & u32(0x3F)) << u32(6))) | (b2 & u32(0x3F)));
         out.push(u16(cp));
         i = (i + usize(3));
       },
       true => {
         // 4-byte sequence → surrogate pair
-        b1  := u32(s.bytes((i + usize(1))));
-        b2  := u32(s.bytes((i + usize(2))));
-        b3  := u32(s.bytes((i + usize(3))));
-        cp  := (((((b0 & u32(0x07)) << u32(18)) | ((b1 & u32(0x3F)) << u32(12))) | ((b2 & u32(0x3F)) << u32(6))) | (b3 & u32(0x3F)));
+        b1 := u32(s.bytes(i + usize(1)));
+        b2 := u32(s.bytes(i + usize(2)));
+        b3 := u32(s.bytes(i + usize(3)));
+        cp := (((((b0 & u32(0x07)) << u32(18)) | ((b1 & u32(0x3F)) << u32(12))) | ((b2 & u32(0x3F)) << u32(6))) | (b3 & u32(0x3F)));
         cp2 := (cp - u32(0x10000));
-        hi  := u16(((cp2 >> u32(10)) + u32(0xD800)));
-        lo  := u16(((cp2 & u32(0x3FF)) + u32(0xDC00)));
+        hi := u16((cp2 >> u32(10)) + u32(0xD800));
+        lo := u16((cp2 & u32(0x3FF)) + u32(0xDC00));
         out.push(hi);
         out.push(lo);
         i = (i + usize(4));
       }
     );
-  };
+  });
   out
 });
-
-export utf8_to_utf16;
-
+export(utf8_to_utf16);
 // ============================================================================
 // UTF-16 → UTF-8
 // ============================================================================
-
 /// Convert UTF-16 code units to a UTF-8 `String`.
 ///
 /// Decodes surrogate pairs back into supplementary code points.
 /// Throws via `Exception` on unpaired surrogates.
-utf16_to_utf8 :: (fn(data: ArrayList(u16), using(exn : Exception)) -> String)({
+utf16_to_utf8 :: (fn(data : ArrayList(u16), using(exn : Exception)) -> String)({
   out := ArrayList(u8).new();
-  i   := usize(0);
-  while (i < data.len()), {
+  i := usize(0);
+  while(i < data.len(), {
     w := u32(data.get(i).unwrap());
     cond(
       // Surrogate pair: high surrogate 0xD800-0xDBFF
       ((w >= u32(0xD800)) && (w <= u32(0xDBFF))) => {
         cond(
           ((i + usize(1)) >= data.len()) => {
-            exn.throw(dyn EncodingError.InvalidChar(u8(0)));
+            exn.throw(dyn(EncodingError.InvalidChar(u8(0))));
           },
           true => ()
         );
-        w2 := u32(data.get((i + usize(1))).unwrap());
+        w2 := u32(data.get(i + usize(1)).unwrap());
         cond(
           ((w2 < u32(0xDC00)) || (w2 > u32(0xDFFF))) => {
-            exn.throw(dyn EncodingError.InvalidChar(u8(0)));
+            exn.throw(dyn(EncodingError.InvalidChar(u8(0))));
           },
           true => ()
         );
         cp := ((((w - u32(0xD800)) << u32(10)) + (w2 - u32(0xDC00))) + u32(0x10000));
         // Encode as 4-byte UTF-8
-        out.push(u8((u32(0xF0) | (cp >> u32(18)))));
-        out.push(u8((u32(0x80) | ((cp >> u32(12)) & u32(0x3F)))));
-        out.push(u8((u32(0x80) | ((cp >> u32(6)) & u32(0x3F)))));
-        out.push(u8((u32(0x80) | (cp & u32(0x3F)))));
+        out.push(u8(u32(0xF0) | (cp >> u32(18))));
+        out.push(u8(u32(0x80) | ((cp >> u32(12)) & u32(0x3F))));
+        out.push(u8(u32(0x80) | ((cp >> u32(6)) & u32(0x3F))));
+        out.push(u8(u32(0x80) | (cp & u32(0x3F))));
         i = (i + usize(2));
       },
       (w < u32(0x80)) => {
@@ -108,19 +102,18 @@ utf16_to_utf8 :: (fn(data: ArrayList(u16), using(exn : Exception)) -> String)({
         i = (i + usize(1));
       },
       (w < u32(0x800)) => {
-        out.push(u8((u32(0xC0) | (w >> u32(6)))));
-        out.push(u8((u32(0x80) | (w & u32(0x3F)))));
+        out.push(u8(u32(0xC0) | (w >> u32(6))));
+        out.push(u8(u32(0x80) | (w & u32(0x3F))));
         i = (i + usize(1));
       },
       true => {
-        out.push(u8((u32(0xE0) | (w >> u32(12)))));
-        out.push(u8((u32(0x80) | ((w >> u32(6)) & u32(0x3F)))));
-        out.push(u8((u32(0x80) | (w & u32(0x3F)))));
+        out.push(u8(u32(0xE0) | (w >> u32(12))));
+        out.push(u8(u32(0x80) | ((w >> u32(6)) & u32(0x3F))));
+        out.push(u8(u32(0x80) | (w & u32(0x3F))));
         i = (i + usize(1));
       }
     );
-  };
+  });
   String.from_bytes(out)
 });
-
-export utf16_to_utf8;
+export(utf16_to_utf8);

package/std/env.yo

@@ -3,96 +3,83 @@
 //!
 //! 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";
+open(import("./collections/array_list"));
+open(import("./string"));
+open(import("./path"));
+{ platform, Platform } :: import("./process");
+{ GlobalAllocator } :: import("./allocator");
 { malloc, free } :: GlobalAllocator;
-
 // === Low-level C interface ===
-
-extern "Yo",
+extern(
+  "Yo",
   __yo_argc : i32,
   __yo_argv : *(*(u8)),
   __yo_args : [*(u8)]
-;
-
+);
 // === Raw command-line arguments ===
-
 /// Get raw command-line arguments as a slice of C strings.
 /// The first element is the program name.
-raw_args :: (fn() -> [*(u8)]) {
-  return __yo_args;
-};
-export raw_args;
-
+raw_args :: (fn() -> [*(u8)])({
+  return(__yo_args);
+});
+export(raw_args);
 /// Get the number of command-line arguments (including program name).
-argc :: (fn() -> i32) {
-  return __yo_argc;
-};
-export argc;
-
+argc :: (fn() -> i32)({
+  return(__yo_argc);
+});
+export(argc);
 /// Get the raw `argv` pointer (`*(*(u8))`).
-argv :: (fn() -> *(*(u8))) {
-  return __yo_argv;
-};
-export argv;
-
+argv :: (fn() -> *(*(u8)))({
+  return(__yo_argv);
+});
+export(argv);
 // === Convenient command-line arguments ===
-
 /// 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, {
+  while(i < len, {
     arg_ptr := raw(i);
     arg_str := String.from_cstr(arg_ptr).unwrap();
     result.push(arg_str);
     i = (i + 1);
-  };
-  return result;
-};
-export args;
-
+  });
+  return(result);
+});
+export(args);
 /// Environment variable access and manipulation.
-env :: impl {
-  { getenv, setenv } :: import "./libc/stdlib";
-
+env :: impl({
+  { getenv, setenv } :: import("./libc/stdlib");
   /// 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,
-      .None => .None,
-      .Some(ptr) => .Some(String.from_cstr(*(u8)(ptr)).unwrap())
+    match(
+      val_ptr,
+      .None =>.None,
+      .Some(ptr) =>.Some(String.from_cstr(*(u8)(ptr)).unwrap())
     )
-  };
-  export get;
-
+  });
+  export(get);
   /// Set an environment variable. If `overwrite` is false and the variable
   /// already exists, it is not modified. Returns true on success.
-  set :: (fn(name : String, value : String, (overwrite : bool) ?= true) -> bool) {
+  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) => {
-        { _putenv_s } :: import "./libc/windows";
-
+        { _putenv_s } :: import("./libc/windows");
         cond(
           overwrite =>
             _putenv_s(*(char)(name_cstr), *(char)(value_cstr)),
           true => {
             existing := getenv(*(char)(name_cstr));
-            match(existing,
+            match(
+              existing,
               .Some(_) => int(0),
               .None => _putenv_s(*(char)(name_cstr), *(char)(value_cstr))
             )
@@ -107,28 +94,23 @@ env :: impl {
         setenv(*(char)(name_cstr), *(char)(value_cstr), overwrite_int)
       }
     );
-
-    return result == int(0);
-  };
-  export set;
-};
-export env;
-
+    return(result == int(0));
+  });
+  export(set);
+});
+export(env);
 /// Get the current working directory as a `Path`.
 /// Returns `Err` with a message on failure.
 cwd :: (fn() -> Result(Path, String))(
   cond(
     (platform == Platform.Windows) => {
-      { GetCurrentDirectoryW, WideCharToMultiByte, CP_UTF8, WCHAR, DWORD } :: import "./libc/windows";
-
-      required_size := GetCurrentDirectoryW(ulong(0), .None);
+      { GetCurrentDirectoryW, WideCharToMultiByte, CP_UTF8, WCHAR, DWORD } :: import("./libc/windows");
+      required_size := GetCurrentDirectoryW(ulong(0),.None);
       cond(
-        (required_size == ulong(0)) => .Err(`Failed to get current working directory on Windows`),
+        (required_size == ulong(0)) =>.Err(`Failed to get current working directory on Windows`),
         true => {
-          wbuf := *(WCHAR)(malloc((usize(required_size) * usize(2))).unwrap());
-
-          actual_size := GetCurrentDirectoryW(required_size, .Some(wbuf));
-
+          wbuf := *(WCHAR)(malloc(usize(required_size) * usize(2)).unwrap());
+          actual_size := GetCurrentDirectoryW(required_size,.Some(wbuf));
           cond(
             (actual_size == ulong(0)) => {
               free(.Some(*(void)(wbuf)));
@@ -145,15 +127,13 @@ 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 => {
-                  utf8_buf := *(u8)(malloc((usize(utf8_size) + usize(1))).unwrap());
-
+                  utf8_buf := *(u8)(malloc(usize(utf8_size) + usize(1)).unwrap());
                   result := WideCharToMultiByte(
                     CP_UTF8,
                     ulong(0),
@@ -164,9 +144,7 @@ cwd :: (fn() -> Result(Path, String))(
                     .None,
                     .None
                   );
-
                   free(.Some(*(void)(wbuf)));
-
                   cond(
                     (result <= i32(0)) => {
                       free(.Some(*(void)(utf8_buf)));
@@ -187,14 +165,12 @@ cwd :: (fn() -> Result(Path, String))(
       )
     },
     true => {
-      { getcwd } :: import "./libc/unistd";
-
+      { getcwd } :: import("./libc/unistd");
       buf_size := usize(4096);
       buf := *(char)(malloc(buf_size).unwrap());
-
       result_ptr := getcwd(buf, buf_size);
-
-      match(result_ptr,
+      match(
+        result_ptr,
         .None => {
           free(.Some(*(void)(buf)));
           .Err(`Failed to get current working directory`)
@@ -208,36 +184,31 @@ cwd :: (fn() -> Result(Path, String))(
     }
   )
 );
-export cwd;
-
+export(cwd);
 /// Change the current working directory to `path`.
 /// Returns `Ok(())` on success, or `Err` with a message on failure.
-chdir :: (fn(path: Path) -> Result(unit, String))(
+chdir :: (fn(path : Path) -> Result(unit, String))(
   cond(
     (platform == Platform.Windows) => {
-      { SetCurrentDirectoryA, BOOL } :: import "./libc/windows";
-
+      { 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(())
+        (result == int(0)) =>.Err(`Failed to change directory to: ${path_str}`),
+        true =>.Ok(())
       )
     },
     true => {
-      { chdir : unix_chdir } :: import "./libc/unistd";
-
+      { 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(())
+        (result != int(0)) =>.Err(`Failed to change directory to: ${path_str}`),
+        true =>.Ok(())
       )
     }
   )
 );
-export chdir;
+export(chdir);

package/std/error.yo

@@ -1,32 +1,24 @@
 //! Standard error handling types and traits for Yo.
-
-open import "./string";
-open import "./fmt";
-
+open(import("./string"));
+open(import("./fmt"));
 /// Standard error trait for typed error propagation.
 /// All error types should implement this trait along with `ToString`.
 Error :: trait(
-  (source : (fn(self: *(Self)) -> Option(Dyn(SelfTrait)))) ?= ((self) -> .None),
-
+  (source : (fn(self : *(Self)) -> Option(Dyn(SelfTrait)))) ?= ((self) ->.None),
   where(Self <: ToString)
 );
-export Error;
-
+export(Error);
 /// Type-erased dynamic error type. Wraps any type implementing `Error`.
 AnyError :: Dyn(Error);
-export AnyError;
-
+export(AnyError);
 /// Allows using `String` directly as an error type.
 impl(String, Error());
-
 /// Non-resumable exception handling effect record.
 /// Use `throw` to raise an `AnyError` and abort the current computation.
 Exception :: struct(
   throw : (fn(forall(ResumeType : Type), error : AnyError) -> ResumeType)
 );
-export Exception;
-
-
+export(Exception);
 /// Creates a resumable exception effect record parameterized by the resume type.
 /// Unlike `Exception`, the handler can return a value to resume the computation.
 ResumableException :: (fn(comptime(ResumeType) : Type) -> comptime(Type))(
@@ -34,4 +26,4 @@ ResumableException :: (fn(comptime(ResumeType) : Type) -> comptime(Type))(
     throw : (fn(error : AnyError) -> ResumeType)
   )
 );
-export ResumableException;
+export(ResumableException);

package/std/fmt/display.yo

@@ -9,16 +9,12 @@
 //!   )
 //! ));
 //! ```
-
-{ Writer } :: import "./writer";
-
+{ Writer } :: import("./writer");
 /// Trait for formatting values by writing to a `Writer` rather than allocating a `String`.
 /// Complement to `ToString` for streaming output into an existing buffer.
-
-Display :: (fn(comptime(T) : Type) -> comptime(Trait))
+Display :: (fn(comptime(T) : Type) -> comptime(Trait))(
   trait(
-    display : (fn(self: *(T), writer: Writer) -> Writer)
+    display : (fn(self : *(T), writer : Writer) -> Writer)
   )
-;
-
-export Display;
+);
+export(Display);

package/std/fmt/index.yo

@@ -1,11 +1,8 @@
 //! Formatted output to stdout and stderr.
-
-{ fwrite, stdout, stderr } :: import "../libc/stdio";
-{ String } :: import "../string";
-{ ToString } :: import "./to_string.yo";
-
-export ToString;
-
+{ fwrite, stdout, stderr } :: import("../libc/stdio");
+{ String } :: import("../string");
+{ ToString } :: import("./to_string.yo");
+export(ToString);
 /// Print a value that implements `ToString` to stdout, followed by a newline.
 println :: (fn(forall(T : Type), v : T, where(T <: ToString)) -> unit)({
   s := v.to_string();
@@ -20,8 +17,7 @@ println :: (fn(forall(T : Type), v : T, where(T <: ToString)) -> unit)({
   );
   fwrite(*(void)(*(u8)("\n")), usize(1), usize(1), stdout);
 });
-export println;
-
+export(println);
 /// Print a value that implements `ToString` to stdout, without a trailing newline.
 print :: (fn(forall(T : Type), v : T, where(T <: ToString)) -> unit)({
   s := v.to_string();
@@ -35,8 +31,7 @@ print :: (fn(forall(T : Type), v : T, where(T <: ToString)) -> unit)({
     true => ()
   );
 });
-export print;
-
+export(print);
 /// Print a value that implements `ToString` to stderr, followed by a newline.
 eprintln :: (fn(forall(T : Type), v : T, where(T <: ToString)) -> unit)({
   s := v.to_string();
@@ -51,8 +46,7 @@ eprintln :: (fn(forall(T : Type), v : T, where(T <: ToString)) -> unit)({
   );
   fwrite(*(void)(*(u8)("\n")), usize(1), usize(1), stderr);
 });
-export eprintln;
-
+export(eprintln);
 /// Print a value that implements `ToString` to stderr, without a trailing newline.
 eprint :: (fn(forall(T : Type), v : T, where(T <: ToString)) -> unit)({
   s := v.to_string();
@@ -66,4 +60,4 @@ eprint :: (fn(forall(T : Type), v : T, where(T <: ToString)) -> unit)({
     true => ()
   );
 });
-export eprint;
+export(eprint);