@shd101wyy/yo 0.1.26 → 0.1.27

package/std/encoding/punycode.yo

@@ -12,10 +12,8 @@
 //! ascii_domain := to_ascii(`münchen.de`);  // "xn--mnchen-3ya.de"
 //! unicode_domain := to_unicode(ascii_domain);  // "münchen.de"
 //! ```
-
-open import "../string";
-{ ArrayList } :: import "../collections/array_list";
-
+open(import("../string"));
+{ ArrayList } :: import("../collections/array_list");
 // Punycode constants (RFC 3492 section 5)
 _BASE :: i32(36);
 _TMIN :: i32(1);
@@ -24,71 +22,66 @@ _SKEW :: i32(38);
 _DAMP :: i32(700);
 _INITIAL_BIAS :: i32(72);
 _INITIAL_N :: i32(128);
-
 // Decode a single punycode digit character to its value.
-_decode_digit :: (fn(cp: i32) -> i32)(
+_decode_digit :: (fn(cp : i32) -> i32)(
   cond(
     ((cp >= i32(0x30)) && (cp <= i32(0x39))) => (cp - i32(22)),
     ((cp >= i32(0x41)) && (cp <= i32(0x5A))) => (cp - i32(0x41)),
     ((cp >= i32(0x61)) && (cp <= i32(0x7A))) => (cp - i32(0x61)),
-    true => i32(-1)
+    true => i32(-(1))
   )
 );
-
 // Encode a digit value to its punycode character.
-_encode_digit :: (fn(d: i32) -> u8)(
+_encode_digit :: (fn(d : i32) -> u8)(
   cond(
-    (d < i32(26)) => u8((d + i32(0x61))),
-    true => u8(((d - i32(26)) + i32(0x30)))
+    (d < i32(26)) => u8(d + i32(0x61)),
+    true => u8((d - i32(26)) + i32(0x30))
   )
 );
-
 // Bias adaptation function (RFC 3492 section 3.4)
-_adapt :: (fn(delta_val: i32, num_points: i32, first_time: bool) -> i32)({
+_adapt :: (fn(delta_val : i32, num_points : i32, first_time : bool) -> i32)({
   (d : i32) = cond(
     first_time => (delta_val / _DAMP),
     true => (delta_val / i32(2))
   );
   d = (d + (d / num_points));
   (k : i32) = i32(0);
-  while (d > (((_BASE - _TMIN) * _TMAX) / i32(2))), {
+  while(d > (((_BASE - _TMIN) * _TMAX) / i32(2)), {
     d = (d / (_BASE - _TMIN));
     k = (k + _BASE);
-  };
-  (k + ((((_BASE - _TMIN) + i32(1)) * d) / (d + _SKEW)))
+  });
+  k + ((((_BASE - _TMIN) + i32(1)) * d) / (d + _SKEW))
 });
-
 // Encode a single Unicode code point as UTF-8 bytes.
-_encode_codepoint :: (fn(cp: i32, out: *(ArrayList(u8))) -> unit)(
+_encode_codepoint :: (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))));
     }
   )
 );
-
 // Decode a UTF-8 string into an array of code points.
-_string_to_codepoints :: (fn(s: String) -> ArrayList(i32))({
+_string_to_codepoints :: (fn(s : String) -> ArrayList(i32))({
   (bytes : ArrayList(u8)) = s.as_bytes();
   (cps : ArrayList(i32)) = ArrayList(i32).new();
   (i : usize) = usize(0);
   (blen : usize) = bytes.len();
-  while (i < blen), {
+  while(i < blen, {
     (b : i32) = i32(bytes.get(i).unwrap());
     (cp : i32) = i32(0);
     (size : usize) = usize(1);
@@ -113,51 +106,46 @@ _string_to_codepoints :: (fn(s: String) -> ArrayList(i32))({
       }
     );
     (j : usize) = usize(1);
-    while (j < size), {
-      if(((i + j) < blen), {
-        cp = ((cp << i32(6)) | (i32(bytes.get((i + j)).unwrap()) & i32(0x3F)));
+    while(j < size, {
+      if((i + j) < blen, {
+        cp = ((cp << i32(6)) | (i32(bytes.get(i + j).unwrap()) & i32(0x3F)));
       });
       j = (j + usize(1));
-    };
+    });
     cps.push(cp);
     i = (i + size);
-  };
+  });
   cps
 });
-
 /// Decode a punycode-encoded string (without the `xn--` prefix).
 ///
 /// Returns `.Some(decoded)` on success, `.None` on invalid input.
-punycode_decode :: (fn(input: String) -> Option(String))({
+punycode_decode :: (fn(input : String) -> Option(String))({
   (bytes : ArrayList(u8)) = input.as_bytes();
   (input_len : i32) = i32(bytes.len());
-
   // Find the last '-' separator
-  (basic_end : i32) = i32(-1);
+  (basic_end : i32) = i32(-(1));
   (j : i32) = (input_len - i32(1));
-  while ((j >= i32(0)) && (basic_end < i32(0))), {
-    if((i32(bytes.get(usize(j)).unwrap()) == i32(0x2D)), {
+  while((j >= i32(0)) && (basic_end < i32(0)), {
+    if(i32(bytes.get(usize(j)).unwrap()) == i32(0x2D), {
       basic_end = j;
     });
     j = (j - i32(1));
-  };
-
+  });
   (output : ArrayList(i32)) = ArrayList(i32).new();
   (basic_length : i32) = cond(
     (basic_end >= i32(0)) => basic_end,
     true => i32(0)
   );
-
   (bi : i32) = i32(0);
-  while (bi < basic_length), {
+  while(bi < basic_length, {
     (cp : i32) = i32(bytes.get(usize(bi)).unwrap());
-    if((cp >= i32(0x80)), {
-      return .None;
+    if(cp >= i32(0x80), {
+      return(.None);
     });
     output.push(cp);
     bi = (bi + i32(1));
-  };
-
+  });
   (idx : i32) = cond(
     (basic_end >= i32(0)) => (basic_end + i32(1)),
     true => i32(0)
@@ -165,161 +153,145 @@ punycode_decode :: (fn(input: String) -> Option(String))({
   (n : i32) = _INITIAL_N;
   (bias : i32) = _INITIAL_BIAS;
   (i_val : i32) = i32(0);
-
-  while (idx < input_len), {
+  while(idx < input_len, {
     (old_i : i32) = i_val;
     (w : i32) = i32(1);
     (k : i32) = _BASE;
     (decode_done : bool) = false;
-
-    while (!(decode_done)), {
-      if((idx >= input_len), {
-        return .None;
+    while(!(decode_done), {
+      if(idx >= input_len, {
+        return(.None);
       });
       (digit : i32) = _decode_digit(i32(bytes.get(usize(idx)).unwrap()));
       idx = (idx + i32(1));
-      if((digit < i32(0)), {
-        return .None;
+      if(digit < i32(0), {
+        return(.None);
       });
-
       i_val = (i_val + (digit * w));
-
       (t : i32) = cond(
         (k <= bias) => _TMIN,
         (k >= (bias + _TMAX)) => _TMAX,
         true => (k - bias)
       );
-
-      if((digit < t), {
+      if(digit < t, {
         decode_done = true;
       }, {
         w = (w * (_BASE - t));
         k = (k + _BASE);
       });
-    };
-
+    });
     (out_len : i32) = (i32(output.len()) + i32(1));
-    bias = _adapt((i_val - old_i), out_len, (old_i == i32(0)));
+    bias = _adapt(i_val - old_i, out_len, old_i == i32(0));
     n = (n + (i_val / out_len));
     i_val = (i_val % out_len);
-
     // Insert code point at position i_val
     output.push(i32(0));
     (shift_idx : i32) = (i32(output.len()) - i32(1));
-    while (shift_idx > i_val), {
-      &(output(usize(shift_idx))).* = output(usize((shift_idx - i32(1))));
+    while(shift_idx > i_val, {
+      &(output(usize(shift_idx))).* = output(usize(shift_idx - i32(1)));
       shift_idx = (shift_idx - i32(1));
-    };
+    });
     &(output(usize(i_val))).* = n;
     i_val = (i_val + i32(1));
-  };
-
+  });
   // Convert code points to UTF-8
   (result_bytes : ArrayList(u8)) = ArrayList(u8).new();
   (ri : usize) = usize(0);
-  while (ri < output.len()), {
-    _encode_codepoint(output.get(ri).unwrap(), (&result_bytes));
+  while(ri < output.len(), {
+    _encode_codepoint(output.get(ri).unwrap(), &(result_bytes));
     ri = (ri + usize(1));
-  };
+  });
   .Some(String.from_bytes(result_bytes))
 });
-
 /// Encode a Unicode string to punycode (without the `xn--` prefix).
-punycode_encode :: (fn(input: String) -> String)({
+punycode_encode :: (fn(input : String) -> String)({
   (cps : ArrayList(i32)) = _string_to_codepoints(input);
   (cp_count : i32) = i32(cps.len());
-
   // Separate basic and non-basic code points
   (out : ArrayList(u8)) = ArrayList(u8).new();
   (basic_count : i32) = i32(0);
   (ci : i32) = i32(0);
-  while (ci < cp_count), {
+  while(ci < cp_count, {
     (cp : i32) = cps.get(usize(ci)).unwrap();
-    if((cp < i32(0x80)), {
+    if(cp < i32(0x80), {
       out.push(u8(cp));
       basic_count = (basic_count + i32(1));
     });
     ci = (ci + i32(1));
-  };
-
-  if((basic_count > i32(0)), {
+  });
+  if(basic_count > i32(0), {
     out.push(u8(0x2D));
   });
-
   (handled : i32) = basic_count;
   (n : i32) = _INITIAL_N;
   (delta : i32) = i32(0);
   (bias : i32) = _INITIAL_BIAS;
-
-  while (handled < cp_count), {
+  while(handled < cp_count, {
     // Find minimum code point >= n
     (m : i32) = i32(0x7FFFFFFF);
     (mi : i32) = i32(0);
-    while (mi < cp_count), {
+    while(mi < cp_count, {
       (cp : i32) = cps.get(usize(mi)).unwrap();
-      if(((cp >= n) && (cp < m)), {
+      if((cp >= n) && (cp < m), {
         m = cp;
       });
       mi = (mi + i32(1));
-    };
-
+    });
     delta = (delta + ((m - n) * (handled + i32(1))));
     n = m;
-
     (ei : i32) = i32(0);
-    while (ei < cp_count), {
+    while(ei < cp_count, {
       (cp : i32) = cps.get(usize(ei)).unwrap();
-      if((cp < n), {
+      if(cp < n, {
         delta = (delta + i32(1));
       });
-      if((cp == n), {
+      if(cp == n, {
         (q : i32) = delta;
         (k : i32) = _BASE;
         (encode_done : bool) = false;
-        while (!(encode_done)), {
+        while(!(encode_done), {
           (t : i32) = cond(
             (k <= bias) => _TMIN,
             (k >= (bias + _TMAX)) => _TMAX,
             true => (k - bias)
           );
-          if((q < t), {
+          if(q < t, {
             out.push(_encode_digit(q));
             encode_done = true;
           }, {
-            out.push(_encode_digit((t + ((q - t) % (_BASE - t)))));
+            out.push(_encode_digit(t + ((q - t) % (_BASE - t))));
             q = ((q - t) / (_BASE - t));
             k = (k + _BASE);
           });
-        };
-        bias = _adapt(delta, (handled + i32(1)), (handled == basic_count));
+        });
+        bias = _adapt(delta, handled + i32(1), handled == basic_count);
         delta = i32(0);
         handled = (handled + i32(1));
       });
       ei = (ei + i32(1));
-    };
+    });
     delta = (delta + i32(1));
     n = (n + i32(1));
-  };
-
+  });
   String.from_bytes(out)
 });
-
 /// Convert an IDN hostname to Unicode display form.
 ///
 /// Splits on `.`, decodes `xn--` labels via punycode, and keeps original labels on failure.
-to_unicode :: (fn(hostname: String) -> String)({
+to_unicode :: (fn(hostname : String) -> String)({
   (parts : ArrayList(String)) = hostname.split(`.`);
   (result : String) = ``;
   (pi : usize) = usize(0);
-  while (pi < parts.len()), {
+  while(pi < parts.len(), {
     (part : String) = parts.get(pi).unwrap();
-    if((pi > usize(0)), {
+    if(pi > usize(0), {
       result = `${result}.`;
     });
     (part_lower : String) = part.to_lowercase();
     if(part_lower.starts_with(`xn--`), {
       (encoded : String) = part.substring(usize(4), part.len());
-      match(punycode_decode(encoded),
+      match(
+        punycode_decode(encoded),
         .Some(decoded) => {
           result = `${result}${decoded}`;
         },
@@ -332,32 +304,31 @@ to_unicode :: (fn(hostname: String) -> String)({
       result = `${result}${part}`;
     });
     pi = (pi + usize(1));
-  };
+  });
   result
 });
-
 /// Convert a Unicode hostname to ASCII-compatible encoding.
 ///
 /// Non-ASCII labels are punycode-encoded with the `xn--` prefix.
-to_ascii :: (fn(hostname: String) -> String)({
+to_ascii :: (fn(hostname : String) -> String)({
   (parts : ArrayList(String)) = hostname.split(`.`);
   (result : String) = ``;
   (pi : usize) = usize(0);
-  while (pi < parts.len()), {
+  while(pi < parts.len(), {
     (part : String) = parts.get(pi).unwrap();
-    if((pi > usize(0)), {
+    if(pi > usize(0), {
       result = `${result}.`;
     });
     // Check if the label has non-ASCII characters
     (has_non_ascii : bool) = false;
     (bytes : ArrayList(u8)) = part.as_bytes();
     (bi : usize) = usize(0);
-    while (bi < bytes.len()), {
-      if((i32(bytes.get(bi).unwrap()) >= i32(0x80)), {
+    while(bi < bytes.len(), {
+      if(i32(bytes.get(bi).unwrap()) >= i32(0x80), {
         has_non_ascii = true;
       });
       bi = (bi + usize(1));
-    };
+    });
     if(has_non_ascii, {
       (encoded : String) = punycode_encode(part);
       result = `${result}xn--${encoded}`;
@@ -365,8 +336,7 @@ to_ascii :: (fn(hostname: String) -> String)({
       result = `${result}${part}`;
     });
     pi = (pi + usize(1));
-  };
+  });
   result
 });
-
-export punycode_decode, punycode_encode, to_unicode, to_ascii;
+export(punycode_decode, punycode_encode, to_unicode, to_ascii);

package/std/encoding/toml.yo

@@ -10,60 +10,57 @@
 //! // Or via the encoding index:
 //! { toml_parse, TomlValue } :: import "std/encoding";
 //! ```
-
-open import "../string";
-{ ArrayList } :: import "../collections/array_list";
-
+open(import("../string"));
+{ ArrayList } :: import("../collections/array_list");
 /// TOML value type — the result of parsing a TOML document.
 TomlValue :: enum(
   /// A TOML string value.
-  Str(value: String),
+  Str(value : String),
   /// A TOML integer value.
-  Int(value: i64),
+  Int(value : i64),
   /// A TOML boolean value.
-  Bool(value: bool),
+  Bool(value : bool),
   /// A TOML table (ordered key-value map).
-  Table(keys: ArrayList(String), values: ArrayList(Self))
+  Table(keys : ArrayList(String), values : ArrayList(Self))
 );
-
-impl(TomlValue,
+impl(
+  TomlValue,
   /// Create a new empty table.
   new_table : (fn() -> Self)(
-    Self.Table(keys: ArrayList(String).new(), values: ArrayList(TomlValue).new())
+    Self.Table(keys : ArrayList(String).new(), values : ArrayList(TomlValue).new())
   ),
-
   /// Look up a value by key in a table. Returns `.None` if not a table or key is missing.
-  get : (fn(self: Self, key: String) -> Option(TomlValue))(
-    match(self,
+  get : (fn(self : Self, key : String) -> Option(TomlValue))(
+    match(
+      self,
       .Table(keys, values) => {
         i := usize(0);
-        while (i < keys.len()), (i = (i + usize(1))), {
+        while(i < keys.len(), i = (i + usize(1)), {
           cond(
             (keys.get(i).unwrap() == key) => {
-              return .Some(values.get(i).unwrap());
+              return(.Some(values.get(i).unwrap()));
             },
             true => ()
           );
-        };
+        });
         .None
       },
-      _ => .None
+      _ =>.None
     )
   ),
-
   /// Check whether the table contains the given key.
-  has_key : (fn(self: Self, key: String) -> bool)(
+  has_key : (fn(self : Self, key : String) -> bool)(
     self.get(key).is_some()
   ),
-
   /// Insert or update a key-value pair in the table.
-  set : (fn(self: Self, key: String, value: TomlValue) -> unit)(
-    match(self,
+  set : (fn(self : Self, key : String, value : TomlValue) -> unit)(
+    match(
+      self,
       .Table(keys, values) => {
         i := usize(0);
         len := keys.len();
         found := false;
-        while (i < len), (i = (i + usize(1))), {
+        while(i < len, i = (i + usize(1)), {
           cond(
             (keys.get(i).unwrap() == key) => {
               &(values(i)).* = value;
@@ -71,7 +68,7 @@ impl(TomlValue,
             },
             true => ()
           );
-        };
+        });
         cond(
           (!(found)) => {
             keys.push(key);
@@ -83,70 +80,72 @@ impl(TomlValue,
       _ => ()
     )
   ),
-
   /// Return the number of keys in the table, or `0` if not a table.
-  table_len : (fn(self: Self) -> usize)(
-    match(self,
+  table_len : (fn(self : Self) -> usize)(
+    match(
+      self,
       .Table(keys, _) => keys.len(),
       _ => usize(0)
     )
   ),
-
   /// Extract the string value, or `.None` if not a `Str`.
-  as_string : (fn(self: Self) -> Option(String))(
-    match(self, .Str(s) => .Some(s), _ => .None)
+  as_string : (fn(self : Self) -> Option(String))(
+    match(self,.Str(s) =>.Some(s), _ =>.None)
   ),
-
   /// Extract the integer value, or `.None` if not an `Int`.
-  as_int : (fn(self: Self) -> Option(i64))(
-    match(self, .Int(n) => .Some(n), _ => .None)
+  as_int : (fn(self : Self) -> Option(i64))(
+    match(self,.Int(n) =>.Some(n), _ =>.None)
   ),
-
   /// Extract the boolean value, or `.None` if not a `Bool`.
-  as_bool : (fn(self: Self) -> Option(bool))(
-    match(self, .Bool(b) => .Some(b), _ => .None)
+  as_bool : (fn(self : Self) -> Option(bool))(
+    match(self,.Bool(b) =>.Some(b), _ =>.None)
   )
 );
-
-_parse_toml_value :: (fn(raw: String) -> Result(TomlValue, String))({
+_parse_toml_value :: (fn(raw : String) -> Result(TomlValue, String))({
   trimmed := raw.trim();
   cond(
-    trimmed.is_empty() => { return .Err(`Empty value`); },
+    trimmed.is_empty() => {
+      return(.Err(`Empty value`));
+    },
     true => ()
   );
-
   // Quoted string: starts and ends with "
   cond(
     (trimmed.starts_with(`"`) && trimmed.ends_with(`"`)) => {
       len := trimmed.len();
       cond(
-        (len < usize(2)) => { return .Err(`Unterminated string`); },
+        (len < usize(2)) => {
+          return(.Err(`Unterminated string`));
+        },
         true => {
-          return .Ok(.Str(trimmed.substring(usize(1), (len - usize(1)))));
+          return(.Ok(.Str(trimmed.substring(usize(1), len - usize(1)))));
         }
       );
     },
     true => ()
   );
-
   // Booleans
   cond(
-    (trimmed == `true`) => { return .Ok(.Bool(true)); },
-    (trimmed == `false`) => { return .Ok(.Bool(false)); },
+    (trimmed == `true`) => {
+      return(.Ok(.Bool(true)));
+    },
+    (trimmed == `false`) => {
+      return(.Ok(.Bool(false)));
+    },
     true => ()
   );
-
   // Integer
-  match(trimmed.parse_i64(),
-    .Some(n) => { return .Ok(.Int(n)); },
+  match(
+    trimmed.parse_i64(),
+    .Some(n) => {
+      return(.Ok(.Int(n)));
+    },
     .None => ()
   );
-
   .Err(`Unknown value: ${trimmed}`)
 });
-
 /// Parse a TOML string into a `TomlValue` tree. Returns `Result(TomlValue, String)`.
-toml_parse :: (fn(input: String) -> Result(TomlValue, String))({
+toml_parse :: (fn(input : String) -> Result(TomlValue, String))({
   root_keys := ArrayList(String).new();
   root_vals := ArrayList(TomlValue).new();
   cur_keys := root_keys;
@@ -154,9 +153,9 @@ toml_parse :: (fn(input: String) -> Result(TomlValue, String))({
   lines := input.split(`\n`);
   i := usize(0);
   line_count := lines.len();
-
-  while (i < line_count), (i = (i + usize(1))), {
-    match(lines.get(i),
+  while(i < line_count, i = (i + usize(1)), {
+    match(
+      lines.get(i),
       .Some(raw_line) => {
         line := raw_line.trim();
         cond(
@@ -164,26 +163,30 @@ toml_parse :: (fn(input: String) -> Result(TomlValue, String))({
           line.starts_with(`#`) => (),
           // Table header: [name]
           (line.starts_with(`[`) && line.ends_with(`]`)) => {
-            table_name := line.substring(usize(1), (line.len() - usize(1))).trim();
+            table_name := line.substring(usize(1), line.len() - usize(1)).trim();
             new_keys := ArrayList(String).new();
             new_vals := ArrayList(TomlValue).new();
             root_keys.push(table_name);
-            root_vals.push(.Table(keys: new_keys, values: new_vals));
+            root_vals.push(.Table(keys : new_keys, values : new_vals));
             cur_keys = new_keys;
             cur_vals = new_vals;
           },
           // Key = value
           true => {
-            match(line.index_of(`=`),
+            match(
+              line.index_of(`=`),
               .Some(pos) => {
                 key := line.substring(usize(0), pos).trim();
-                val_str := line.substring((pos + usize(1)), line.len()).trim();
-                match(_parse_toml_value(val_str),
+                val_str := line.substring(pos + usize(1), line.len()).trim();
+                match(
+                  _parse_toml_value(val_str),
                   .Ok(val) => {
                     cur_keys.push(key);
                     cur_vals.push(val);
                   },
-                  .Err(e) => { return .Err(e); }
+                  .Err(e) => {
+                    return(.Err(e));
+                  }
                 );
               },
               .None => ()
@@ -193,9 +196,7 @@ toml_parse :: (fn(input: String) -> Result(TomlValue, String))({
       },
       .None => ()
     );
-  };
-
-  .Ok(.Table(keys: root_keys, values: root_vals))
+  });
+  .Ok(.Table(keys : root_keys, values : root_vals))
 });
-
-export TomlValue, toml_parse;
+export(TomlValue, toml_parse);