@shd101wyy/yo 0.1.25 → 0.1.27

package/std/string/string_builder.yo

@@ -1,173 +1,163 @@
 //! Mutable UTF-8 string builder for efficient incremental construction.
-
-{ ArrayList } :: import "../collections/array_list.yo";
-{ rune } :: import "./rune.yo";
-{ String } :: import "./string.yo";
-
+{ ArrayList } :: import("../collections/array_list.yo");
+{ rune } :: import("./rune.yo");
+{ String } :: import("./string.yo");
 /**
- * Mutable buffer for building a `String` incrementally.
- *
- * Use `StringBuilder` when you need to construct a string from many parts,
- * appending bytes or strings in a loop, before converting to an immutable
- * `String` with `to_string()`.
- *
- * ## Example
- * ```rust
- * sb := StringBuilder.new();
- * sb.write_str("Hello");
- * sb.write_str(", ");
- * sb.write_string(`world`);
- * sb.write_byte(u8(33));  // '!'
- * result := sb.to_string();
- * assert(result == `Hello, world!`, "built string");
- * ```
- */
+* Mutable buffer for building a `String` incrementally.
+*
+* Use `StringBuilder` when you need to construct a string from many parts,
+* appending bytes or strings in a loop, before converting to an immutable
+* `String` with `to_string()`.
+*
+* ## Example
+* ```rust
+* sb := StringBuilder.new();
+* sb.write_str("Hello");
+* sb.write_str(", ");
+* sb.write_string(`world`);
+* sb.write_byte(u8(33));  // '!'
+* result := sb.to_string();
+* assert(result == `Hello, world!`, "built string");
+* ```
+*/
 StringBuilder :: object(
   _buf : ArrayList(u8)
 );
-
-impl(StringBuilder,
+impl(
+  StringBuilder,
   /**
-   * Create a new, empty `StringBuilder`.
-   */
+  * Create a new, empty `StringBuilder`.
+  */
   new : (fn() -> Self)(
-    Self(_buf: ArrayList(u8).new())
+    Self(_buf : ArrayList(u8).new())
   ),
-
   /**
-   * Create a `StringBuilder` pre-allocated for `capacity` bytes.
-   */
-  with_capacity : (fn(capacity: usize) -> Self)(
-    Self(_buf: ArrayList(u8).with_capacity(capacity))
+  * Create a `StringBuilder` pre-allocated for `capacity` bytes.
+  */
+  with_capacity : (fn(capacity : usize) -> Self)(
+    Self(_buf : ArrayList(u8).with_capacity(capacity))
   ),
-
   /**
-   * Returns the current number of bytes in the buffer.
-   */
-  len : (fn(self: *(Self)) -> usize)(
+  * Returns the current number of bytes in the buffer.
+  */
+  len : (fn(self : *(Self)) -> usize)(
     self._buf.len()
   ),
-
   /**
-   * Returns true if the buffer is empty.
-   */
-  is_empty : (fn(self: *(Self)) -> bool)(
-    (self._buf.len() == usize(0))
+  * Returns true if the buffer is empty.
+  */
+  is_empty : (fn(self : *(Self)) -> bool)(
+    self._buf.len() == usize(0)
   ),
-
   /**
-   * Append a `str` (raw byte slice) to the buffer.
-   */
-  write_str : (fn(self: *(Self), s: str) -> unit)({
+  * Append a `str` (raw byte slice) to the buffer.
+  */
+  write_str : (fn(self : *(Self), s : str) -> unit)({
     byte_len := s.len();
-    if((byte_len > usize(0)), {
+    if(byte_len > usize(0), {
       self._buf.extend_from_ptr(s.ptr(), byte_len);
     });
   }),
-
   /**
-   * Append a `String` to the buffer.
-   */
-  write_string : (fn(self: *(Self), s: String) -> unit)(
-    match(s._bytes,
+  * Append a `String` to the buffer.
+  */
+  write_string : (fn(self : *(Self), s : String) -> unit)(
+    match(
+      s._bytes,
       .None => (),
       .Some(al) => {
         i := usize(0);
         n := al.len();
-        while ((i < n)),
-              (i = (i + usize(1))),
-        {
+        while(i < n, i = (i + usize(1)), {
           byte_opt := al.get(i);
-          match(byte_opt,
-            .Some(b) => { self._buf.push(b); },
+          match(
+            byte_opt,
+            .Some(b) => {
+              self._buf.push(b);
+            },
             .None => ()
           );
-        };
+        });
       }
     )
   ),
-
   /**
-   * Append a single byte to the buffer.
-   */
-  write_byte : (fn(self: *(Self), b: u8) -> unit)({
+  * Append a single byte to the buffer.
+  */
+  write_byte : (fn(self : *(Self), b : u8) -> unit)({
     self._buf.push(b);
   }),
-
   /**
-   * Append a single Unicode code point, encoded as UTF-8.
-   *
-   * ## Example
-   * ```rust
-   * sb := StringBuilder.new();
-   * sb.write_rune(rune(0x1F600));  // 😀
-   * sb.write_rune(rune(0x41));     // 'A'
-   * ```
-   */
-  write_rune : (fn(self: *(Self), r: rune) -> unit)({
+  * Append a single Unicode code point, encoded as UTF-8.
+  *
+  * ## Example
+  * ```rust
+  * sb := StringBuilder.new();
+  * sb.write_rune(rune(0x1F600));  // 😀
+  * sb.write_rune(rune(0x41));     // 'A'
+  * ```
+  */
+  write_rune : (fn(self : *(Self), r : rune) -> unit)({
     cp := r.char;
     cond(
       (cp < u32(0x80)) => {
         self._buf.push(u8(cp));
       },
       (cp < u32(0x800)) => {
-        self._buf.push(u8((u32(0xC0) | (cp >> u32(6)))));
-        self._buf.push(u8((u32(0x80) | (cp & u32(0x3F)))));
+        self._buf.push(u8(u32(0xC0) | (cp >> u32(6))));
+        self._buf.push(u8(u32(0x80) | (cp & u32(0x3F))));
       },
       (cp < u32(0x10000)) => {
-        self._buf.push(u8((u32(0xE0) | (cp >> u32(12)))));
-        self._buf.push(u8((u32(0x80) | ((cp >> u32(6)) & u32(0x3F)))));
-        self._buf.push(u8((u32(0x80) | (cp & u32(0x3F)))));
+        self._buf.push(u8(u32(0xE0) | (cp >> u32(12))));
+        self._buf.push(u8(u32(0x80) | ((cp >> u32(6)) & u32(0x3F))));
+        self._buf.push(u8(u32(0x80) | (cp & u32(0x3F))));
       },
       true => {
-        self._buf.push(u8((u32(0xF0) | (cp >> u32(18)))));
-        self._buf.push(u8((u32(0x80) | ((cp >> u32(12)) & u32(0x3F)))));
-        self._buf.push(u8((u32(0x80) | ((cp >> u32(6)) & u32(0x3F)))));
-        self._buf.push(u8((u32(0x80) | (cp & u32(0x3F)))));
+        self._buf.push(u8(u32(0xF0) | (cp >> u32(18))));
+        self._buf.push(u8(u32(0x80) | ((cp >> u32(12)) & u32(0x3F))));
+        self._buf.push(u8(u32(0x80) | ((cp >> u32(6)) & u32(0x3F))));
+        self._buf.push(u8(u32(0x80) | (cp & u32(0x3F))));
       }
     );
   }),
-
   /**
-   * Append a `String` followed by a newline byte (`\n`).
-   */
-  write_line : (fn(self: *(Self), s: String) -> unit)({
+  * Append a `String` followed by a newline byte (`\n`).
+  */
+  write_line : (fn(self : *(Self), s : String) -> unit)({
     self.write_string(s);
     self._buf.push(u8(10));
   }),
-
   /**
-   * Consume the builder and return the accumulated `String`.
-   * The builder is left empty after this call.
-   */
-  to_string : (fn(self: *(Self)) -> String)({
+  * Consume the builder and return the accumulated `String`.
+  * The builder is left empty after this call.
+  */
+  to_string : (fn(self : *(Self)) -> String)({
     n := self._buf.len();
     cond(
-      (n == usize(0)) => String(_bytes: .None),
+      (n == usize(0)) => String(_bytes :.None),
       true => {
         buf := ArrayList(u8).with_capacity(n);
         i := usize(0);
-        while ((i < n)),
-              (i = (i + usize(1))),
-        {
+        while(i < n, i = (i + usize(1)), {
           byte_opt := self._buf.get(i);
-          match(byte_opt,
-            .Some(b) => { buf.push(b); },
+          match(
+            byte_opt,
+            .Some(b) => {
+              buf.push(b);
+            },
             .None => ()
           );
-        };
+        });
         self._buf = ArrayList(u8).new();
-        String(_bytes: .Some(buf))
+        String(_bytes :.Some(buf))
       }
     )
   }),
-
   /**
-   * Clear the buffer without freeing memory.
-   */
-  clear : (fn(self: *(Self)) -> unit)({
+  * Clear the buffer without freeing memory.
+  */
+  clear : (fn(self : *(Self)) -> unit)({
     self._buf = ArrayList(u8).new();
   })
 );
-
-export StringBuilder;
+export(StringBuilder);

package/std/string/unicode.yo

@@ -8,84 +8,78 @@
 //! lower := unicode_to_lowercase(`HELLO WÖRLD`);  // "hello wörld"
 //! upper := unicode_to_uppercase(`hello wörld`);  // "HELLO WÖRLD"
 //! ```
-
-open import "../string";
-{ ArrayList } :: import "../collections/array_list";
-
+open(import("../string"));
+{ ArrayList } :: import("../collections/array_list");
 // Declare towlower/towupper directly with i32 to avoid wint_t cast issues.
 // On all major platforms, wint_t is compatible with int/i32.
-c_include "<wctype.h>",
+c_include(
+  "<wctype.h>",
   towlower :
     fn(wc : i32) -> i32,
   towupper :
     fn(wc : i32) -> i32
-;
-
+);
 // Result of decoding a single UTF-8 codepoint
 _DecodeResult :: struct(
   codepoint : i32,
   bytes_consumed : usize
 );
-
 // Decode a single UTF-8 codepoint from bytes at position i.
-_decode_utf8 :: (fn(bytes: ArrayList(u8), i: usize) -> _DecodeResult)({
+_decode_utf8 :: (fn(bytes : ArrayList(u8), i : usize) -> _DecodeResult)({
   (b0 : i32) = i32(bytes.get(i).unwrap());
   cond(
     // 1-byte ASCII
-    ((b0 & i32(0x80)) == i32(0)) => 
-      _DecodeResult(codepoint: b0, bytes_consumed: usize(1))
-    ,
+    ((b0 & i32(0x80)) == i32(0)) =>
+      _DecodeResult(codepoint : b0, bytes_consumed : usize(1)),
     // 2-byte
     ((b0 & i32(0xE0)) == i32(0xC0)) => {
-      (b1 : i32) = i32(bytes.get((i + usize(1))).unwrap());
+      (b1 : i32) = i32(bytes.get(i + usize(1)).unwrap());
       (cp : i32) = (((b0 & i32(0x1F)) << i32(6)) | (b1 & i32(0x3F)));
-      _DecodeResult(codepoint: cp, bytes_consumed: usize(2))
+      _DecodeResult(codepoint : cp, bytes_consumed : usize(2))
     },
     // 3-byte
     ((b0 & i32(0xF0)) == i32(0xE0)) => {
-      (b1 : i32) = i32(bytes.get((i + usize(1))).unwrap());
-      (b2 : i32) = i32(bytes.get((i + usize(2))).unwrap());
+      (b1 : i32) = i32(bytes.get(i + usize(1)).unwrap());
+      (b2 : i32) = i32(bytes.get(i + usize(2)).unwrap());
       (cp : i32) = ((((b0 & i32(0x0F)) << i32(12)) | ((b1 & i32(0x3F)) << i32(6))) | (b2 & i32(0x3F)));
-      _DecodeResult(codepoint: cp, bytes_consumed: usize(3))
+      _DecodeResult(codepoint : cp, bytes_consumed : usize(3))
     },
     // 4-byte
     true => {
-      (b1 : i32) = i32(bytes.get((i + usize(1))).unwrap());
-      (b2 : i32) = i32(bytes.get((i + usize(2))).unwrap());
-      (b3 : i32) = i32(bytes.get((i + usize(3))).unwrap());
+      (b1 : i32) = i32(bytes.get(i + usize(1)).unwrap());
+      (b2 : i32) = i32(bytes.get(i + usize(2)).unwrap());
+      (b3 : i32) = i32(bytes.get(i + usize(3)).unwrap());
       (cp : i32) = (((((b0 & i32(0x07)) << i32(18)) | ((b1 & i32(0x3F)) << i32(12))) | ((b2 & i32(0x3F)) << i32(6))) | (b3 & i32(0x3F)));
-      _DecodeResult(codepoint: cp, bytes_consumed: usize(4))
+      _DecodeResult(codepoint : cp, bytes_consumed : usize(4))
     }
   )
 });
-
 // Encode a Unicode codepoint as UTF-8 bytes into an ArrayList.
-_encode_utf8 :: (fn(cp: i32, out: *(ArrayList(u8))) -> unit)({
+_encode_utf8 :: (fn(cp : i32, out : *(ArrayList(u8))) -> unit)({
   cond(
     (cp < i32(0x80)) => {
       out.*.push(u8(cp));
     },
     (cp < i32(0x800)) => {
-      out.*.push(u8((i32(0xC0) | (cp >> i32(6)))));
-      out.*.push(u8((i32(0x80) | (cp & i32(0x3F)))));
+      out.*.push(u8(i32(0xC0) | (cp >> i32(6))));
+      out.*.push(u8(i32(0x80) | (cp & i32(0x3F))));
     },
     (cp < i32(0x10000)) => {
-      out.*.push(u8((i32(0xE0) | (cp >> i32(12)))));
-      out.*.push(u8((i32(0x80) | ((cp >> i32(6)) & i32(0x3F)))));
-      out.*.push(u8((i32(0x80) | (cp & i32(0x3F)))));
+      out.*.push(u8(i32(0xE0) | (cp >> i32(12))));
+      out.*.push(u8(i32(0x80) | ((cp >> i32(6)) & i32(0x3F))));
+      out.*.push(u8(i32(0x80) | (cp & i32(0x3F))));
     },
     true => {
-      out.*.push(u8((i32(0xF0) | (cp >> i32(18)))));
-      out.*.push(u8((i32(0x80) | ((cp >> i32(12)) & i32(0x3F)))));
-      out.*.push(u8((i32(0x80) | ((cp >> i32(6)) & i32(0x3F)))));
-      out.*.push(u8((i32(0x80) | (cp & i32(0x3F)))));
+      out.*.push(u8(i32(0xF0) | (cp >> i32(18))));
+      out.*.push(u8(i32(0x80) | ((cp >> i32(12)) & i32(0x3F))));
+      out.*.push(u8(i32(0x80) | ((cp >> i32(6)) & i32(0x3F))));
+      out.*.push(u8(i32(0x80) | (cp & i32(0x3F))));
     }
   );
 });
-
 // Special case folding: codepoints that expand to multiple codepoints
 // when lowercased. These are Unicode case folding entries of type 'F' (full).
-_special_to_lower :: (fn(cp: i32, out: *(ArrayList(u8))) -> bool)(
+_special_to_lower :: (fn(cp : i32, out : *(ArrayList(u8))) -> bool)(
   cond(
     // ẞ (U+1E9E LATIN CAPITAL LETTER SHARP S) → ss
     (cp == i32(0x1E9E)) => {
@@ -103,10 +97,9 @@ _special_to_lower :: (fn(cp: i32, out: *(ArrayList(u8))) -> bool)(
     true => false
   )
 );
-
 // Special case folding: codepoints that expand to multiple codepoints
 // when uppercased.
-_special_to_upper :: (fn(cp: i32, out: *(ArrayList(u8))) -> bool)(
+_special_to_upper :: (fn(cp : i32, out : *(ArrayList(u8))) -> bool)(
   cond(
     // ß (U+00DF LATIN SMALL LETTER SHARP S) → SS
     (cp == i32(0x00DF)) => {
@@ -161,21 +154,19 @@ _special_to_upper :: (fn(cp: i32, out: *(ArrayList(u8))) -> bool)(
     true => false
   )
 );
-
 // Convert a String to lowercase using Unicode-aware case mapping.
 /// Convert a `String` to lowercase using Unicode case mapping rules.
 /// Handles both ASCII and non-ASCII codepoints, plus special multi-char expansions (e.g., ẞ → ss).
-unicode_to_lowercase :: (fn(input: String) -> String)({
+unicode_to_lowercase :: (fn(input : String) -> String)({
   (bytes : ArrayList(u8)) = input.as_bytes();
   (out : ArrayList(u8)) = ArrayList(u8).with_capacity(bytes.len());
   (i : usize) = usize(0);
-
-  while (i < bytes.len()), {
+  while(i < bytes.len(), {
     (b0 : i32) = i32(bytes.get(i).unwrap());
     // Fast path for ASCII
-    if(((b0 & i32(0x80)) == i32(0)), {
-      if(((b0 >= i32(0x41)) && (b0 <= i32(0x5A))), {
-        out.push(u8((b0 + i32(0x20))));
+    if((b0 & i32(0x80)) == i32(0), {
+      if((b0 >= i32(0x41)) && (b0 <= i32(0x5A)), {
+        out.push(u8(b0 + i32(0x20)));
       }, {
         out.push(u8(b0));
       });
@@ -185,35 +176,30 @@ unicode_to_lowercase :: (fn(input: String) -> String)({
       (result : _DecodeResult) = _decode_utf8(bytes, i);
       (cp : i32) = result.codepoint;
       (len : usize) = result.bytes_consumed;
-
       // Try special case folding first
-      if(!(_special_to_lower(cp, (&out))), {
+      if(!(_special_to_lower(cp, &(out))), {
         // Use C towlower for standard Unicode lowercase
         (lower : i32) = i32(towlower(cp));
-        _encode_utf8(lower, (&out));
+        _encode_utf8(lower, &(out));
       });
-
       i = (i + len);
     });
-  };
-
+  });
   String.from_bytes(out)
 });
-
 // Convert a String to uppercase using Unicode-aware case mapping.
 /// Convert a `String` to uppercase using Unicode case mapping rules.
 /// Handles both ASCII and non-ASCII codepoints, plus special multi-char expansions (e.g., ß → SS).
-unicode_to_uppercase :: (fn(input: String) -> String)({
+unicode_to_uppercase :: (fn(input : String) -> String)({
   (bytes : ArrayList(u8)) = input.as_bytes();
   (out : ArrayList(u8)) = ArrayList(u8).with_capacity(bytes.len());
   (i : usize) = usize(0);
-
-  while (i < bytes.len()), {
+  while(i < bytes.len(), {
     (b0 : i32) = i32(bytes.get(i).unwrap());
     // Fast path for ASCII
-    if(((b0 & i32(0x80)) == i32(0)), {
-      if(((b0 >= i32(0x61)) && (b0 <= i32(0x7A))), {
-        out.push(u8((b0 - i32(0x20))));
+    if((b0 & i32(0x80)) == i32(0), {
+      if((b0 >= i32(0x61)) && (b0 <= i32(0x7A)), {
+        out.push(u8(b0 - i32(0x20)));
       }, {
         out.push(u8(b0));
       });
@@ -223,19 +209,15 @@ unicode_to_uppercase :: (fn(input: String) -> String)({
       (result : _DecodeResult) = _decode_utf8(bytes, i);
       (cp : i32) = result.codepoint;
       (len : usize) = result.bytes_consumed;
-
       // Try special case folding first
-      if(!(_special_to_upper(cp, (&out))), {
+      if(!(_special_to_upper(cp, &(out))), {
         // Use C towupper for standard Unicode uppercase
         (upper : i32) = i32(towupper(cp));
-        _encode_utf8(upper, (&out));
+        _encode_utf8(upper, &(out));
       });
-
       i = (i + len);
     });
-  };
-
+  });
   String.from_bytes(out)
 });
-
-export unicode_to_lowercase, unicode_to_uppercase;
+export(unicode_to_lowercase, unicode_to_uppercase);