@shd101wyy/yo 0.1.26 → 0.1.28

package/std/encoding/hex.yo

@@ -10,93 +10,86 @@
 //! s := hex_encode(data);         // "deadbeef"
 //! b := hex_decode("deadbeef");
 //! ```
-
-open import "../string";
-{ ArrayList } :: import "../collections/array_list";
-{ Error, AnyError, Exception } :: import "../error";
-{ ToString } :: import "../fmt";
-
+open(import("../string"));
+{ ArrayList } :: import("../collections/array_list");
+{ Error, AnyError, Exception } :: import("../error");
+{ ToString } :: import("../fmt");
 // ============================================================================
 // Error type
 // ============================================================================
-
 /// Encoding/decoding error type.
 EncodingError :: enum(
   /// Invalid character encountered during decoding.
-  InvalidChar(ch: u8),
+  InvalidChar(ch : u8),
   /// Input string has odd length (hex requires even length).
   OddLength
 );
-
-impl(EncodingError, ToString(
-  to_string : (self ->
-    match(self,
-      .InvalidChar(ch) => `encoding error: invalid character ${ch}`,
-      .OddLength => `encoding error: odd length`
+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;
-
+export(EncodingError);
 // ============================================================================
 // Encoding
 // ============================================================================
-
 _HEX_CHARS :: "0123456789abcdef";
-
 // Encode bytes as lowercase hexadecimal.
-_hex_encode_impl :: (fn(data: ArrayList(u8), hex_chars: str) -> String)({
-  out := ArrayList(u8).with_capacity((data.len() * usize(2)));
+_hex_encode_impl :: (fn(data : ArrayList(u8), hex_chars : str) -> String)({
+  out := ArrayList(u8).with_capacity(data.len() * usize(2));
   i := usize(0);
-  while (i < data.len()), (i = (i + usize(1))), {
+  while(i < data.len(), i = (i + usize(1)), {
     b := data.get(i).unwrap();
-    hi := usize(((b >> u8(4)) & u8(0xF)));
-    lo := usize((b & u8(0xF)));
+    hi := usize((b >> u8(4)) & u8(0xF));
+    lo := usize(b & u8(0xF));
     out.push(hex_chars.bytes(hi));
     out.push(hex_chars.bytes(lo));
-  };
+  });
   String.from_bytes(out)
 });
-
 /// Encode bytes as a lowercase hexadecimal string.
-hex_encode :: (fn(data: ArrayList(u8)) -> String)(
+hex_encode :: (fn(data : ArrayList(u8)) -> String)(
   _hex_encode_impl(data, _HEX_CHARS)
 );
-
-export hex_encode;
-
+export(hex_encode);
 // ============================================================================
 // Decoding
 // ============================================================================
-
-_hex_nibble :: (fn(c: u8, using(exn : Exception)) -> u8)(
+_hex_nibble :: (fn(c : u8, using(exn : Exception)) -> u8)(
   cond(
-    ((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))
+    ((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 to bytes. Throws via `Exception` on invalid input.
-hex_decode :: (fn(s: str, using(exn : Exception)) -> ArrayList(u8))({
+hex_decode :: (fn(s : str, using(exn : Exception)) -> ArrayList(u8))({
   cond(
-    (((s.len() % usize(2)) != usize(0))) => {
-      exn.throw(dyn EncodingError.OddLength);
+    ((s.len() % usize(2)) != usize(0)) => {
+      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))), {
+  out := ArrayList(u8).with_capacity(s.len() / usize(2));
+  i := usize(0);
+  while(i < s.len(), i = (i + usize(2)), {
     hi := _hex_nibble(s.bytes(i));
-    lo := _hex_nibble(s.bytes((i + usize(1))));
-    out.push(((hi << u8(4)) | lo));
-  };
+    lo := _hex_nibble(s.bytes(i + usize(1)));
+    out.push((hi << u8(4)) | lo);
+  });
   out
 });
-
-export hex_decode;
+export(hex_decode);

package/std/encoding/html.yo

@@ -11,86 +11,74 @@
 //! result := decode_html(`& < & &`);
 //! assert((result == `& < & &`), "decoded entities");
 //! ```
-
-open import "../string";
-{ HashMap } :: import "../collections/hash_map";
-{ HashSet } :: import "../collections/hash_set";
-{ is_valid_entity_code, from_code_point } :: import "./html_char_utils";
-{ _build_entity_map, _build_legacy_set } :: import "./html_entities";
-
+open(import("../string"));
+{ HashMap } :: import("../collections/hash_map");
+{ HashSet } :: import("../collections/hash_set");
+{ is_valid_entity_code, from_code_point } :: import("./html_char_utils");
+{ _build_entity_map, _build_legacy_set } :: import("./html_entities");
 // Module-level state: lazily initialized entity map and legacy set.
 _state_initialized := false;
 _entity_map := HashMap(String, String).new();
 _legacy_set := HashSet(String).new();
-
 _ensure_init :: (fn() -> unit)({
-  if(!((_state_initialized)), {
+  if(!(_state_initialized), {
     _entity_map = _build_entity_map();
     _legacy_set = _build_legacy_set();
     _state_initialized = true;
   });
 });
-
 // Parse a hex string to i32
-_parse_hex :: (fn(s: String) -> i32)({
+_parse_hex :: (fn(s : String) -> i32)({
   (result : i32) = i32(0);
   (i : usize) = usize(0);
-  while ((i < s.len())), {
+  while(i < s.len(), {
     c := s.at(i).unwrap();
     result = (result * i32(16));
-    if(((c >= rune(u32('0'))) && (c <= rune(u32('9')))), {
+    if((c >= rune(u32('0'))) && (c <= rune(u32('9'))), {
       result = (result + (i32(c.to_u32()) - i32(48)));
-    }, if(((c >= rune(u32('a'))) && (c <= rune(u32('f')))), {
+    }, if((c >= rune(u32('a'))) && (c <= rune(u32('f'))), {
       result = (result + ((i32(c.to_u32()) - i32(97)) + i32(10)));
-    }, if(((c >= rune(u32('A'))) && (c <= rune(u32('F')))), {
+    }, if((c >= rune(u32('A'))) && (c <= rune(u32('F'))), {
       result = (result + ((i32(c.to_u32()) - i32(65)) + i32(10)));
     })));
     i = (i + usize(1));
-  };
+  });
   result
 });
-
 // Parse a decimal string to i32
-_parse_dec :: (fn(s: String) -> i32)({
+_parse_dec :: (fn(s : String) -> i32)({
   (result : i32) = i32(0);
   (i : usize) = usize(0);
-  while ((i < s.len())), {
+  while(i < s.len(), {
     c := s.at(i).unwrap();
     result = ((result * i32(10)) + (i32(c.to_u32()) - i32(48)));
     i = (i + usize(1));
-  };
+  });
   result
 });
-
 // Check if a character is an ASCII alphanumeric
-_is_alpha_numeric :: (fn(c: rune) -> bool)(
-  ((((c >= rune(u32('a'))) && (c <= rune(u32('z')))) || ((c >= rune(u32('A'))) && (c <= rune(u32('Z'))))) || ((c >= rune(u32('0'))) && (c <= rune(u32('9')))))
+_is_alpha_numeric :: (fn(c : rune) -> bool)(
+  (((c >= rune(u32('a'))) && (c <= rune(u32('z')))) || ((c >= rune(u32('A'))) && (c <= rune(u32('Z'))))) || ((c >= rune(u32('0'))) && (c <= rune(u32('9'))))
 );
-
 /// Decode HTML entities in a string.
 ///
 /// Supports named (`&amp;`), decimal (`&#38;`), and hexadecimal (`&#x26;`) character
 /// references. Legacy mode — entities without trailing semicolons are also decoded.
-decode_html :: (fn(input: String) -> String)({
+decode_html :: (fn(input : String) -> String)({
   _ensure_init();
-
   (len : usize) = input.len();
-  if(((len == usize(0))), {
-    return input;
+  if(len == usize(0), {
+    return(input);
   });
-
   // Quick check: if no '&', return as-is
   if(!(input.contains(`&`)), {
-    return input;
+    return(input);
   });
-
   (result : String) = ``;
   (i : usize) = usize(0);
-
-  while ((i < len)), {
+  while(i < len, {
     c := input.at(i).unwrap();
-
-    if((c != rune(u32('&'))), {
+    if(c != rune(u32('&')), {
       // Not an entity start, just append the character
       result = `${result}${from_code_point(i32(c.to_u32()))}`;
       i = (i + usize(1));
@@ -98,26 +86,24 @@ decode_html :: (fn(input: String) -> String)({
       // Found '&' — try to decode entity
       (start : usize) = i;
       i = (i + usize(1));
-
-      if(((i >= len)), {
+      if(i >= len, {
         result = `${result}&`;
       }, {
         next := input.at(i).unwrap();
-
-        if(((next == rune(u32('#')))), {
+        if(next == rune(u32('#')), {
           // Numeric entity: &#N; or &#xN;
           i = (i + usize(1));
-          if(((i >= len)), {
+          if(i >= len, {
             result = `${result}&#`;
           }, {
             hex_char := input.at(i).unwrap();
-            if(((hex_char == rune(u32('x'))) || (hex_char == rune(u32('X')))), {
+            if((hex_char == rune(u32('x'))) || (hex_char == rune(u32('X'))), {
               // Hex: &#xHH;
               (digit_start : usize) = (i + usize(1));
               (digit_end : usize) = digit_start;
-              while (((digit_end < len))), {
+              while(digit_end < len, {
                 dc := input.at(digit_end).unwrap();
-                if(((((dc >= rune(u32('0'))) && (dc <= rune(u32('9')))) || (((dc >= rune(u32('a'))) && (dc <= rune(u32('f')))) || ((dc >= rune(u32('A'))) && (dc <= rune(u32('F'))))))), {
+                if(((dc >= rune(u32('0'))) && (dc <= rune(u32('9')))) || (((dc >= rune(u32('a'))) && (dc <= rune(u32('f')))) || ((dc >= rune(u32('A'))) && (dc <= rune(u32('F'))))), {
                   digit_end = (digit_end + usize(1));
                 }, {
                   // Done with hex digits, break out
@@ -127,35 +113,32 @@ decode_html :: (fn(input: String) -> String)({
                   // TODO: proper break
                   digit_end = (len + usize(1));
                 });
-              };
+              });
               // Fix digit_end if it overflowed
-              if(((digit_end > len)), {
+              if(digit_end > len, {
                 // We used the overflow trick - find actual end
                 digit_end = digit_start;
-                while ((digit_end < len)), {
+                while(digit_end < len, {
                   dc2 := input.at(digit_end).unwrap();
-                  if(((((dc2 >= rune(u32('0'))) && (dc2 <= rune(u32('9')))) || (((dc2 >= rune(u32('a'))) && (dc2 <= rune(u32('f')))) || ((dc2 >= rune(u32('A'))) && (dc2 <= rune(u32('F'))))))), {
+                  if(((dc2 >= rune(u32('0'))) && (dc2 <= rune(u32('9')))) || (((dc2 >= rune(u32('a'))) && (dc2 <= rune(u32('f')))) || ((dc2 >= rune(u32('A'))) && (dc2 <= rune(u32('F'))))), {
                     digit_end = (digit_end + usize(1));
                   }, {
                     digit_end = ((len + digit_end) + usize(1));
                   });
-                };
-                if(((digit_end > len)), {
+                });
+                if(digit_end > len, {
                   digit_end = ((digit_end - len) - usize(1));
                 });
               });
-
-              if(((digit_end > digit_start)), {
+              if(digit_end > digit_start, {
                 hex_str := input.substring(digit_start, digit_end);
                 (code : i32) = _parse_hex(hex_str);
-
                 // Check for semicolon
-                if((((digit_end < len) && (input.at(digit_end).unwrap() == rune(u32(';'))))), {
+                if((digit_end < len) && (input.at(digit_end).unwrap() == rune(u32(';'))), {
                   i = (digit_end + usize(1));
                 }, {
                   i = digit_end;
                 });
-
                 if(is_valid_entity_code(code), {
                   result = `${result}${from_code_point(code)}`;
                 }, {
@@ -172,29 +155,26 @@ decode_html :: (fn(input: String) -> String)({
               // Decimal: &#DD;
               (digit_start : usize) = i;
               (digit_end : usize) = digit_start;
-              while ((digit_end < len)), {
+              while(digit_end < len, {
                 dc := input.at(digit_end).unwrap();
-                if((((dc >= rune(u32('0'))) && (dc <= rune(u32('9'))))), {
+                if((dc >= rune(u32('0'))) && (dc <= rune(u32('9'))), {
                   digit_end = (digit_end + usize(1));
                 }, {
                   digit_end = ((len + digit_end) + usize(1));
                 });
-              };
-              if(((digit_end > len)), {
+              });
+              if(digit_end > len, {
                 digit_end = ((digit_end - len) - usize(1));
               });
-
-              if(((digit_end > digit_start)), {
+              if(digit_end > digit_start, {
                 dec_str := input.substring(digit_start, digit_end);
                 (code : i32) = _parse_dec(dec_str);
-
                 // Check for semicolon
-                if((((digit_end < len) && (input.at(digit_end).unwrap() == rune(u32(';'))))), {
+                if((digit_end < len) && (input.at(digit_end).unwrap() == rune(u32(';'))), {
                   i = (digit_end + usize(1));
                 }, {
                   i = digit_end;
                 });
-
                 if(is_valid_entity_code(code), {
                   result = `${result}${from_code_point(code)}`;
                 }, {
@@ -212,9 +192,9 @@ decode_html :: (fn(input: String) -> String)({
           // Named entity: &name; or &name (legacy)
           (name_start : usize) = i;
           (name_end : usize) = name_start;
-          while ((name_end < len)), {
+          while(name_end < len, {
             nc := input.at(name_end).unwrap();
-            if(((nc == rune(u32(';')))), {
+            if(nc == rune(u32(';')), {
               // Found semicolon — end of entity name
               name_end = ((len + name_end) + usize(1));
             }, if(_is_alpha_numeric(nc), {
@@ -223,22 +203,20 @@ decode_html :: (fn(input: String) -> String)({
               // Non-alphanumeric, non-semicolon — end of potential entity
               name_end = ((len + name_end) + usize(1));
             }));
-          };
+          });
           // Decode the overflow trick
           (found_end : bool) = false;
-          if(((name_end > len)), {
+          if(name_end > len, {
             name_end = ((name_end - len) - usize(1));
             found_end = true;
           });
-
           name_str := input.substring(name_start, name_end);
-
           // Check for semicolon at name_end
-          (has_semi : bool) = (((name_end < len) && (input.at(name_end).unwrap() == rune(u32(';')))));
-
+          (has_semi : bool) = ((name_end < len) && (input.at(name_end).unwrap() == rune(u32(';'))));
           if(has_semi, {
             // Try exact match with semicolon
-            match(_entity_map.get(name_str),
+            match(
+              _entity_map.get(name_str),
               .Some(decoded) => {
                 result = `${result}${decoded}`;
                 i = (name_end + usize(1));
@@ -253,11 +231,11 @@ decode_html :: (fn(input: String) -> String)({
             // Legacy mode: try progressively shorter names
             (matched : bool) = false;
             (try_end : usize) = name_end;
-
-            while ((((try_end > name_start) && !(matched)))), {
+            while((try_end > name_start) && !(matched), {
               try_name := input.substring(name_start, try_end);
               if(_legacy_set.contains(try_name), {
-                match(_entity_map.get(try_name),
+                match(
+                  _entity_map.get(try_name),
                   .Some(decoded) => {
                     result = `${result}${decoded}`;
                     i = try_end;
@@ -270,8 +248,7 @@ decode_html :: (fn(input: String) -> String)({
               }, {
                 try_end = (try_end - usize(1));
               });
-            };
-
+            });
             if(!(matched), {
               // No legacy match — output '&' literally and continue
               result = `${result}&`;
@@ -281,9 +258,7 @@ decode_html :: (fn(input: String) -> String)({
         });
       });
     });
-  };
-
+  });
   result
 });
-
-export decode_html, is_valid_entity_code, from_code_point;
+export(decode_html, is_valid_entity_code, from_code_point);

package/std/encoding/html_char_utils.yo

@@ -10,11 +10,9 @@
 //! assert(is_valid_entity_code(i32(65)), "A is valid");
 //! s := from_code_point(i32(65));  // "A"
 //! ```
-
-open import "../string";
-
+open(import("../string"));
 /// Check if a Unicode codepoint is a valid HTML entity value.
-is_valid_entity_code :: (fn(c: i32) -> bool)(
+is_valid_entity_code :: (fn(c : i32) -> bool)(
   cond(
     ((c >= i32(0xD800)) && (c <= i32(0xDFFF))) => false,
     ((c >= i32(0xFDD0)) && (c <= i32(0xFDEF))) => false,
@@ -27,13 +25,9 @@ is_valid_entity_code :: (fn(c: i32) -> bool)(
     true => true
   )
 );
-
 /// Convert a Unicode codepoint to a `String`.
-from_code_point :: (fn(c: i32) -> String)(
-  {
-    (r : rune) = rune(u32(c));
-    `${r}`
-  }
-);
-
-export is_valid_entity_code, from_code_point;
+from_code_point :: (fn(c : i32) -> String)({
+  (r : rune) = rune(u32(c));
+  `${r}`
+});
+export(is_valid_entity_code, from_code_point);