@shd101wyy/yo 0.0.28 → 0.0.30

package/package.json

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

package/std/cli/arg_parser.yo

@@ -0,0 +1,365 @@
+open import "../collections/array_list";
+open import "../string";
+
+ArgKind :: enum(Flag, Opt, Positional);
+
+ArgDef :: object(
+  _long_name : String,
+  _short_name : String,
+  _description : String,
+  _kind : ArgKind,
+  _default_value : String,
+  _required : bool
+);
+
+ParsedArgs :: object(
+  _set_flags : ArrayList(String),
+  _option_names : ArrayList(String),
+  _option_values : ArrayList(String),
+  _positionals : ArrayList(String),
+  _positional_names : ArrayList(String)
+);
+
+ArgParser :: object(
+  _name : String,
+  _description : String,
+  _args : ArrayList(ArgDef)
+);
+
+impl(ParsedArgs,
+  new : (fn() -> Self)(
+    Self(
+      _set_flags: ArrayList(String).new(),
+      _option_names: ArrayList(String).new(),
+      _option_values: ArrayList(String).new(),
+      _positionals: ArrayList(String).new(),
+      _positional_names: ArrayList(String).new()
+    )
+  ),
+
+  get_flag : (fn(self: Self, name: String) -> bool)(
+    self._set_flags.contains(name)
+  ),
+
+  _lookup : (fn(self: Self, names: ArrayList(String), values: ArrayList(String), name: String) -> Option(String))({
+    i := usize(0);
+    len := names.len();
+    (result : Option(String)) = .None;
+    while (i < len), (i = (i + usize(1))), {
+      match(names.get(i),
+        .Some(n) => {
+          cond(
+            (n == name) => {
+              result = values.get(i);
+              i = len;
+            },
+            true => ()
+          );
+        },
+        .None => ()
+      );
+    };
+    return result;
+  }),
+
+  get_option : (fn(self: Self, name: String) -> Option(String))(
+    self._lookup(self._option_names, self._option_values, name)
+  ),
+
+  get_positional : (fn(self: Self, name: String) -> Option(String))(
+    self._lookup(self._positional_names, self._positionals, name)
+  ),
+
+  get_positional_at : (fn(self: Self, index: usize) -> Option(String))(
+    self._positionals.get(index)
+  )
+);
+
+impl(ArgParser,
+  new : (fn(name: String, description: String) -> Self)(
+    Self(
+      _name: name,
+      _description: description,
+      _args: ArrayList(ArgDef).new()
+    )
+  ),
+
+  add_flag : (fn(self: Self, long_name: String, short_name: String, description: String) -> unit)({
+    self._args.push(ArgDef(
+      _long_name: long_name,
+      _short_name: short_name,
+      _description: description,
+      _kind: .Flag,
+      _default_value: ``,
+      _required: false
+    ));
+  }),
+
+  add_option : (fn(self: Self, long_name: String, short_name: String, description: String, default_value: String) -> unit)({
+    self._args.push(ArgDef(
+      _long_name: long_name,
+      _short_name: short_name,
+      _description: description,
+      _kind: .Opt,
+      _default_value: default_value,
+      _required: false
+    ));
+  }),
+
+  add_positional : (fn(self: Self, name: String, description: String) -> unit)({
+    self._args.push(ArgDef(
+      _long_name: name,
+      _short_name: ``,
+      _description: description,
+      _kind: .Positional,
+      _default_value: ``,
+      _required: true
+    ));
+  }),
+
+  _find_arg_index : (fn(self: Self, name: String) -> Option(usize))({
+    i := usize(0);
+    len := self._args.len();
+    (result : Option(usize)) = .None;
+    while (i < len), (i = (i + usize(1))), {
+      match(self._args.get(i),
+        .Some(arg_def) => {
+          cond(
+            ((arg_def._long_name == name) || (arg_def._short_name == name)) => {
+              result = .Some(i);
+              i = len;
+            },
+            true => ()
+          );
+        },
+        .None => ()
+      );
+    };
+    return result;
+  }),
+
+  help_text : (fn(self: Self) -> String)({
+    text := `Usage: ${self._name}\n${self._description}\n\n`;
+
+    has_positionals := false;
+    has_flags_or_options := false;
+    i := usize(0);
+    len := self._args.len();
+    while (i < len), (i = (i + usize(1))), {
+      match(self._args.get(i),
+        .Some(arg_def) => {
+          match(arg_def._kind,
+            .Flag => { has_flags_or_options = true; },
+            .Opt => { has_flags_or_options = true; },
+            .Positional => { has_positionals = true; }
+          );
+        },
+        .None => ()
+      );
+    };
+
+    cond(
+      has_positionals => {
+        text = text.concat(`Arguments:\n`);
+        j := usize(0);
+        while (j < len), (j = (j + usize(1))), {
+          match(self._args.get(j),
+            .Some(arg_def) => {
+              match(arg_def._kind,
+                .Positional => {
+                  text = text.concat(`  ${arg_def._long_name}\t${arg_def._description}\n`);
+                },
+                .Flag => (),
+                .Opt => ()
+              );
+            },
+            .None => ()
+          );
+        };
+        text = text.concat(`\n`);
+      },
+      true => ()
+    );
+
+    cond(
+      has_flags_or_options => {
+        text = text.concat(`Options:\n`);
+        k := usize(0);
+        while (k < len), (k = (k + usize(1))), {
+          match(self._args.get(k),
+            .Some(arg_def) => {
+              match(arg_def._kind,
+                .Flag => {
+                  line := `  ${arg_def._long_name}`;
+                  cond(
+                    (!(arg_def._short_name.is_empty())) => {
+                      line = line.concat(`, ${arg_def._short_name}`);
+                    },
+                    true => ()
+                  );
+                  line = line.concat(`\t${arg_def._description}\n`);
+                  text = text.concat(line);
+                },
+                .Opt => {
+                  line := `  ${arg_def._long_name}`;
+                  cond(
+                    (!(arg_def._short_name.is_empty())) => {
+                      line = line.concat(`, ${arg_def._short_name}`);
+                    },
+                    true => ()
+                  );
+                  line = line.concat(` <value>\t${arg_def._description}`);
+                  cond(
+                    (!(arg_def._default_value.is_empty())) => {
+                      line = line.concat(` (default: ${arg_def._default_value})`);
+                    },
+                    true => ()
+                  );
+                  line = line.concat(`\n`);
+                  text = text.concat(line);
+                },
+                .Positional => ()
+              );
+            },
+            .None => ()
+          );
+        };
+      },
+      true => ()
+    );
+
+    text = text.concat(`  --help, -h\tShow this help message\n`);
+    return text;
+  })
+);
+
+impl(ArgParser,
+  parse : (fn(self: Self, args: ArrayList(String)) -> Result(ParsedArgs, String))({
+    parsed := ParsedArgs.new();
+    arg_defs_len := self._args.len();
+
+    idx := usize(1);
+    args_len := args.len();
+    positional_idx := usize(0);
+    (err_msg : Option(String)) = .None;
+
+    while ((idx < args_len) && (err_msg.is_none())), {
+      match(args.get(idx),
+        .Some(current_arg) => {
+          cond(
+            ((current_arg == `--help`) || (current_arg == `-h`)) => {
+              err_msg = .Some(self.help_text());
+            },
+            current_arg.starts_with(`-`) => {
+              match(self._find_arg_index(current_arg),
+                .Some(arg_idx) => {
+                  match(self._args.get(arg_idx),
+                    .Some(def) => {
+                      match(def._kind,
+                        .Flag => {
+                          parsed._set_flags.push(def._long_name);
+                        },
+                        .Opt => {
+                          idx = (idx + usize(1));
+                          cond(
+                            (idx < args_len) => {
+                              match(args.get(idx),
+                                .Some(val) => {
+                                  parsed._option_names.push(def._long_name);
+                                  parsed._option_values.push(val);
+                                },
+                                .None => {
+                                  err_msg = .Some(`Missing value for option: ${def._long_name}`);
+                                }
+                              );
+                            },
+                            true => {
+                              err_msg = .Some(`Missing value for option: ${def._long_name}`);
+                            }
+                          );
+                        },
+                        .Positional => ()
+                      );
+                    },
+                    .None => ()
+                  );
+                },
+                .None => {
+                  err_msg = .Some(`Unknown argument: ${current_arg}`);
+                }
+              );
+            },
+            true => {
+              parsed._positionals.push(current_arg);
+              p_idx := usize(0);
+              p_count := usize(0);
+              while (p_idx < arg_defs_len), (p_idx = (p_idx + usize(1))), {
+                match(self._args.get(p_idx),
+                  .Some(p_def) => {
+                    match(p_def._kind,
+                      .Positional => {
+                        cond(
+                          (p_count == positional_idx) => {
+                            parsed._positional_names.push(p_def._long_name);
+                          },
+                          true => ()
+                        );
+                        p_count = (p_count + usize(1));
+                      },
+                      .Flag => (),
+                      .Opt => ()
+                    );
+                  },
+                  .None => ()
+                );
+              };
+              positional_idx = (positional_idx + usize(1));
+            }
+          );
+        },
+        .None => ()
+      );
+      idx = (idx + usize(1));
+    };
+
+    // Check for errors
+    match(err_msg,
+      .Some(msg) => {
+        return .Err(msg);
+      },
+      .None => ()
+    );
+
+    // Apply defaults for options not explicitly set
+    def_i := usize(0);
+    while (def_i < arg_defs_len), (def_i = (def_i + usize(1))), {
+      match(self._args.get(def_i),
+        .Some(def) => {
+          match(def._kind,
+            .Opt => {
+              cond(
+                ((!(parsed._option_names.contains(def._long_name))) && (!(def._default_value.is_empty()))) => {
+                  parsed._option_names.push(def._long_name);
+                  parsed._option_values.push(def._default_value);
+                },
+                true => ()
+              );
+            },
+            .Flag => (),
+            .Positional => ()
+          );
+        },
+        .None => ()
+      );
+    };
+
+    return .Ok(parsed);
+  })
+);
+
+export
+  ArgKind,
+  ArgDef,
+  ParsedArgs,
+  ArgParser
+;

package/std/collections/array_list.yo

@@ -509,6 +509,114 @@ impl(forall(T : Type), ArrayList(T),
   )
 );
 
+impl(forall(T : Type), where(T <: Eq(T)), ArrayList(T),
+  /**
+    * Check if the list contains a value
+    */
+  contains : (fn(self: Self, value: T) -> bool)({
+    found := false;
+    match(self._ptr,
+      .Some(_ptr) => {
+        i := usize(0);
+        while(((i < self._length) && !(found)), i = (i + usize(1)), {
+          cond(
+            ((_ptr &+ i).* == value) => {
+              found = true;
+            },
+            true => ()
+          );
+        });
+      },
+      .None => ()
+    );
+    return found;
+  }),
+
+  /**
+    * Find the first index of a matching value
+    * Returns .Some(index) if found, .None otherwise
+    */
+  index_of : (fn(self: Self, value: T) -> Option(usize))({
+    (result : Option(usize)) = .None;
+    found := false;
+    match(self._ptr,
+      .Some(_ptr) => {
+        i := usize(0);
+        while(((i < self._length) && !(found)), i = (i + usize(1)), {
+          cond(
+            ((_ptr &+ i).* == value) => {
+              result = .Some(i);
+              found = true;
+            },
+            true => ()
+          );
+        });
+      },
+      .None => ()
+    );
+    return result;
+  })
+);
+
+impl(forall(T : Type), ArrayList(T),
+  /**
+    * Reverse elements in place
+    */
+  reverse : (fn(self: Self) -> unit)({
+    cond(
+      (self._length <= usize(1)) => (),
+      true =>
+        match(self._ptr,
+          .Some(_ptr) => {
+            i := usize(0);
+            j := (self._length - usize(1));
+            while((i < j), {i = (i + usize(1)); j = (j - usize(1));}, {
+              tmp := (_ptr &+ i).*;
+              (_ptr &+ i).* = (_ptr &+ j).*;
+              (_ptr &+ j).* = tmp;
+            });
+          },
+          .None => ()
+        )
+    );
+  })
+);
+
+impl(forall(T : Type), where(T <: Ord(T)), ArrayList(T),
+  /**
+    * Sort elements in ascending order using insertion sort
+    */
+  sort : (fn(self: Self) -> unit)({
+    cond(
+      (self._length <= usize(1)) => (),
+      true =>
+        match(self._ptr,
+          .Some(_ptr) => {
+            i := usize(1);
+            while((i < self._length), i = (i + usize(1)), {
+              key := (_ptr &+ i).*;
+              j := i;
+              shifting := cond(
+                (j > usize(0)) => ((_ptr &+ (j - usize(1))).* > key),
+                true => false
+              );
+              while(shifting, (), {
+                (_ptr &+ j).* = (_ptr &+ (j - usize(1))).*;
+                j = (j - usize(1));
+                shifting = cond(
+                  (j > usize(0)) => ((_ptr &+ (j - usize(1))).* > key),
+                  true => false
+                );
+              });
+              (_ptr &+ j).* = key;
+            });
+          },
+          .None => ()
+        )
+    );
+  })
+);
+
 export
   ArrayList,
   ArrayListError,

package/std/collections/hash_map.yo

@@ -427,7 +427,7 @@ impl(forall(K : Type, V : Type), where(K <: (Eq(K), Hash)), HashMap(K, V),
   /**
     * Check if a key exists in the map
     */
-  has : (fn(self: Self, key: K) -> bool)(
+  contains_key : (fn(self: Self, key: K) -> bool)(
     {
       hash := key.hash();
       bucket_opt := Self._find_bucket(self, key, hash);

package/std/collections/hash_set.yo

@@ -377,7 +377,7 @@ impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSet(T),
   /**
     * Check if an element exists in the set
     */
-  has : (fn(self: Self, element: T) -> bool)(
+  contains : (fn(self: Self, element: T) -> bool)(
     {
       hash := element.hash();
       slot_opt := Self._find_slot(self, element, hash);
@@ -485,7 +485,7 @@ impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSet(T),
           cond(
             ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
               element := (data_ptr &+ i).*;
-              contains_result := other.has(element);
+              contains_result := other.contains(element);
               cond(
                 (contains_result == false) => {
                   is_sub = false;
@@ -529,7 +529,7 @@ impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSet(T),
         cond(
           ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
             element := (data_ptr &+ i).*;
-            contains_result := larger.has(element);
+            contains_result := larger.contains(element);
             cond(
               (contains_result == true) => {
                 result = false;
@@ -626,7 +626,7 @@ impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSet(T),
               ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
                 element := (data_ptr &+ i).*;
                 cond(
-                  (larger.has(element)) => {
+                  (larger.contains(element)) => {
                     _ := result_set.add(element);
                   },
                   true => ()
@@ -660,7 +660,7 @@ impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSet(T),
             cond(
               ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
                 element := (data_ptr &+ i).*;
-                contains_result := other.has(element);
+                contains_result := other.contains(element);
                 cond(
                   (contains_result == false) => {
                     _ := result_set.add(element);
@@ -696,7 +696,7 @@ impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSet(T),
             cond(
               ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
                 element := (data_ptr &+ i).*;
-                contains_result := other.has(element);
+                contains_result := other.contains(element);
                 cond(
                   (contains_result == false) => {
                     _ := result_set.add(element);
@@ -716,7 +716,7 @@ impl(forall(T : Type), where(T <: (Eq(T), Hash)), HashSet(T),
             cond(
               ((ctrl_byte != CTRL_EMPTY) && (ctrl_byte != CTRL_DELETED)) => {
                 element := (other_data_ptr &+ j).*;
-                contains_result := self.has(element);
+                contains_result := self.contains(element);
                 cond(
                   (contains_result == false) => {
                     _ := result_set.add(element);

package/std/collections/linked_list.yo

@@ -368,7 +368,7 @@ impl(forall(T : Type), LinkedList(T),
     * Check if the list contains a value
     * O(n) time complexity
     */
-  has : (fn(
+  contains : (fn(
     self: Self, 
     value: T,
     where(T <: Eq(T))

package/std/encoding/base64.yo

@@ -127,3 +127,76 @@ base64_decode_url :: (fn(s: str, using(exn : Exception)) -> ArrayList(u8))(
 );
 
 export base64_decode, base64_decode_url;
+
+// ============================================================================
+// String-level convenience API
+// ============================================================================
+
+// Encode a String to standard base64.
+base64_encode_string :: (fn(input: String) -> String)(
+  _encode_with(input.as_bytes(), _STD_ALPHA, true)
+);
+
+// Reverse lookup: base64 char to 0-63, or -1 for invalid.
+_base64_index :: (fn(c: u8) -> i32)({
+  alpha := _STD_ALPHA;
+  i := usize(0);
+  while (i < usize(64)), (i = (i + usize(1))), {
+    cond(
+      (alpha.bytes(i) == c) => { return i32(i); },
+      true => ()
+    );
+  };
+  i32(-1)
+});
+
+// Decode a base64 String, ignoring whitespace. Returns Result.
+base64_decode_string :: (fn(input: String) -> Result(String, String))({
+  raw := input.as_str();
+  cleaned := ArrayList(u8).new();
+  i := usize(0);
+  while (i < raw.len()), (i = (i + usize(1))), {
+    ch := raw.bytes(i);
+    cond(
+      (((ch == u8(32)) || (ch == u8(9))) || ((ch == u8(10)) || (ch == u8(13)))) => (),
+      true => { cleaned.push(ch); }
+    );
+  };
+  // Strip trailing padding
+  len := cleaned.len();
+  while ((len > usize(0)) && (cleaned.get((len - usize(1))).unwrap() == u8(61))), (len = (len - usize(1))), ();
+  out := ArrayList(u8).new();
+  j := usize(0);
+  while (j < len), (j = (j + usize(4))), {
+    v0 := _base64_index(cleaned.get(j).unwrap());
+    cond((v0 == i32(-1)) => { return .Err(`Invalid base64 input`); }, true => ());
+    v1 := cond(
+      ((j + usize(1)) < len) => {
+        tmp := _base64_index(cleaned.get((j + usize(1))).unwrap());
+        cond((tmp == i32(-1)) => { return .Err(`Invalid base64 input`); }, true => ());
+        tmp
+      },
+      true => i32(0)
+    );
+    out.push(u8(((v0 << i32(2)) | (v1 >> i32(4)))));
+    cond(
+      ((j + usize(2)) < len) => {
+        v2 := _base64_index(cleaned.get((j + usize(2))).unwrap());
+        cond((v2 == i32(-1)) => { return .Err(`Invalid base64 input`); }, true => ());
+        out.push(u8((((v1 & i32(15)) << i32(4)) | (v2 >> i32(2)))));
+        cond(
+          ((j + usize(3)) < len) => {
+            v3 := _base64_index(cleaned.get((j + usize(3))).unwrap());
+            cond((v3 == i32(-1)) => { return .Err(`Invalid base64 input`); }, true => ());
+            out.push(u8((((v2 & i32(3)) << i32(6)) | v3)));
+          },
+          true => ()
+        );
+      },
+      true => ()
+    );
+  };
+  .Ok(String.from_bytes(out))
+});
+
+export base64_encode_string, base64_decode_string;