@shd101wyy/yo 0.1.21 → 0.1.23

package/package.json

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

package/scripts/install.ps1

@@ -0,0 +1,143 @@
+# Yo language installer for Windows (PowerShell).
+#
+# Installs Yo into $env:LOCALAPPDATA\Yo and links the `yo` command into
+# $env:LOCALAPPDATA\Yo\bin (added to user PATH).
+#
+# Usage:
+#   irm https://raw.githubusercontent.com/shd101wyy/yo/main/scripts/install.ps1 | iex
+#   # or, after cloning:
+#   .\scripts\install.ps1
+#
+# Environment variables / parameters:
+#   -InstallDir <path>   Target install dir.   Default: $env:LOCALAPPDATA\Yo
+#   -BinDir     <path>   Wrapper bin dir.      Default: $InstallDir\bin
+#   -Repo       <url>    Git repo URL.         Default: https://github.com/shd101wyy/yo.git
+#   -Ref        <ref>    Git ref (branch/tag). Default: main
+#   -Force               Overwrite existing install dir.
+
+[CmdletBinding()]
+param(
+  [string]$InstallDir = (Join-Path $env:LOCALAPPDATA 'Yo'),
+  [string]$BinDir,
+  [string]$Repo = 'https://github.com/shd101wyy/yo.git',
+  [string]$Ref = 'main',
+  [switch]$Force
+)
+
+$ErrorActionPreference = 'Stop'
+
+if (-not $BinDir) { $BinDir = Join-Path $InstallDir 'bin' }
+
+function Info($msg)  { Write-Host ">> $msg" -ForegroundColor Cyan }
+function Warn($msg)  { Write-Host "!! $msg" -ForegroundColor Yellow }
+function Fail($msg)  { Write-Host "XX $msg" -ForegroundColor Red; exit 1 }
+
+Info "Installing Yo on Windows"
+Info "Install dir: $InstallDir"
+Info "Bin dir:     $BinDir"
+
+# ---------------------------------------------------------------------------
+# Required tools
+# ---------------------------------------------------------------------------
+
+function Test-Cmd($name) {
+  return [bool](Get-Command $name -ErrorAction SilentlyContinue)
+}
+
+if (-not (Test-Cmd 'git')) { Fail "Missing required command: git. Install from https://git-scm.com/" }
+
+# C compiler (zig recommended on Windows; clang/gcc also work)
+if (-not (Test-Cmd 'zig') -and -not (Test-Cmd 'clang') -and -not (Test-Cmd 'gcc')) {
+  Warn "No C compiler found (zig, clang, or gcc). 'yo compile' will not work."
+  Warn "  Recommended on Windows: install zig via 'winget install zig.zig'"
+}
+
+# bun runtime — required to run the current TypeScript-based compiler.
+if (-not (Test-Cmd 'bun')) {
+  Info "bun not found - installing via official PowerShell installer..."
+  Invoke-RestMethod -Uri 'https://bun.sh/install.ps1' -UseBasicParsing | Invoke-Expression
+  $bunBin = Join-Path $env:USERPROFILE '.bun\bin'
+  if (Test-Path (Join-Path $bunBin 'bun.exe')) {
+    $env:PATH = "$bunBin;$env:PATH"
+  }
+  if (-not (Test-Cmd 'bun')) {
+    Fail "bun installation failed - install manually from https://bun.sh"
+  }
+}
+Info "Using bun: $((Get-Command bun).Source) ($(bun --version))"
+
+# ---------------------------------------------------------------------------
+# Download Yo
+# ---------------------------------------------------------------------------
+
+if (Test-Path $InstallDir) {
+  if ($Force) {
+    Info "Removing existing install dir (-Force set)"
+    Remove-Item -Recurse -Force $InstallDir
+  } else {
+    Fail "Install dir already exists: $InstallDir. Use -Force to overwrite."
+  }
+}
+
+Info "Cloning $Repo ($Ref) into $InstallDir"
+$parent = Split-Path -Parent $InstallDir
+if (-not (Test-Path $parent)) { New-Item -ItemType Directory -Path $parent | Out-Null }
+git clone --depth 1 --branch $Ref $Repo $InstallDir
+if ($LASTEXITCODE -ne 0) { Fail "git clone failed" }
+
+# ---------------------------------------------------------------------------
+# Build
+# ---------------------------------------------------------------------------
+
+Push-Location $InstallDir
+try {
+  Info "Installing dependencies (bun install)"
+  bun install --silent
+  if ($LASTEXITCODE -ne 0) { Fail "bun install failed" }
+
+  Info "Building Yo (bun run build)"
+  bun run build
+  if ($LASTEXITCODE -ne 0) { Fail "bun run build failed" }
+} finally {
+  Pop-Location
+}
+
+# ---------------------------------------------------------------------------
+# Wrapper script
+# ---------------------------------------------------------------------------
+
+if (-not (Test-Path $BinDir)) { New-Item -ItemType Directory -Path $BinDir | Out-Null }
+
+# yo.cmd — calls the existing yo-cli.ps1
+$wrapperCmd = Join-Path $BinDir 'yo.cmd'
+$yoCli = Join-Path $InstallDir 'yo-cli.ps1'
+@"
+@echo off
+powershell -NoProfile -ExecutionPolicy Bypass -File `"$yoCli`" %*
+"@ | Set-Content -Path $wrapperCmd -Encoding ASCII
+
+# yo.ps1 — for direct PowerShell invocation
+$wrapperPs1 = Join-Path $BinDir 'yo.ps1'
+@"
+#!/usr/bin/env pwsh
+& `"$yoCli`" @args
+"@ | Set-Content -Path $wrapperPs1 -Encoding UTF8
+
+Info "Installed wrappers: $wrapperCmd, $wrapperPs1"
+
+# ---------------------------------------------------------------------------
+# Add bin to user PATH (persistent)
+# ---------------------------------------------------------------------------
+
+$userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
+if ($null -eq $userPath) { $userPath = '' }
+$pathParts = $userPath -split ';' | Where-Object { $_ -ne '' }
+if ($pathParts -notcontains $BinDir) {
+  $newUserPath = if ($userPath -eq '') { $BinDir } else { "$userPath;$BinDir" }
+  [Environment]::SetEnvironmentVariable('Path', $newUserPath, 'User')
+  Info "Added $BinDir to user PATH (restart your shell to pick up the change)"
+} else {
+  Info "$BinDir already on user PATH"
+}
+
+Info "Done. Open a new shell and try: yo --help"

package/scripts/install.sh

@@ -0,0 +1,139 @@
+#!/usr/bin/env bash
+# Yo language installer for Linux and macOS.
+#
+# Installs Yo into $HOME/.local/Yo and links the `yo` command into
+# $HOME/.local/bin (or a directory of your choice via $YO_BIN_DIR).
+#
+# Usage:
+#   curl -fsSL https://raw.githubusercontent.com/shd101wyy/yo/main/scripts/install.sh | bash
+#   # or, after cloning:
+#   ./scripts/install.sh
+#
+# Environment variables:
+#   YO_INSTALL_DIR   Target install dir.   Default: $HOME/.local/Yo
+#   YO_BIN_DIR       Wrapper bin dir.      Default: $HOME/.local/bin
+#   YO_REPO          Git repo URL.         Default: https://github.com/shd101wyy/yo.git
+#   YO_REF           Git ref (branch/tag). Default: main
+#   YO_FORCE         If set, overwrite existing install dir.
+
+set -euo pipefail
+
+YO_INSTALL_DIR="${YO_INSTALL_DIR:-$HOME/.local/Yo}"
+YO_BIN_DIR="${YO_BIN_DIR:-$HOME/.local/bin}"
+YO_REPO="${YO_REPO:-https://github.com/shd101wyy/yo.git}"
+YO_REF="${YO_REF:-main}"
+
+color() { printf '\033[%sm%s\033[0m' "$1" "$2"; }
+info()  { printf '%s %s\n' "$(color '1;34' '>>')" "$1"; }
+warn()  { printf '%s %s\n' "$(color '1;33' '!!')" "$1" >&2; }
+err()   { printf '%s %s\n' "$(color '1;31' 'XX')" "$1" >&2; exit 1; }
+
+# ---------------------------------------------------------------------------
+# Detect platform
+# ---------------------------------------------------------------------------
+
+OS="$(uname -s)"
+case "$OS" in
+  Linux)  PLATFORM="linux"  ;;
+  Darwin) PLATFORM="macos"  ;;
+  *) err "Unsupported OS: $OS. This installer supports Linux and macOS only." ;;
+esac
+
+info "Installing Yo on $PLATFORM"
+info "Install dir: $YO_INSTALL_DIR"
+info "Bin dir:     $YO_BIN_DIR"
+
+# ---------------------------------------------------------------------------
+# Required tools
+# ---------------------------------------------------------------------------
+
+need() {
+  command -v "$1" >/dev/null 2>&1 || err "Missing required command: $1"
+}
+
+need git
+need curl
+
+# C compiler (clang or gcc) — needed for `yo compile`.
+if ! command -v clang >/dev/null 2>&1 && ! command -v gcc >/dev/null 2>&1; then
+  warn "No C compiler found (clang or gcc). 'yo compile' will not work until you install one."
+  if [ "$PLATFORM" = "macos" ]; then
+    warn "  Install with: xcode-select --install"
+  else
+    warn "  Install with your distro's package manager (e.g. apt install clang)"
+  fi
+fi
+
+# bun runtime — required to run the current TypeScript-based compiler.
+if ! command -v bun >/dev/null 2>&1; then
+  info "bun not found — installing via official installer..."
+  curl -fsSL https://bun.sh/install | bash
+  # Try common bun install locations
+  for candidate in "$HOME/.bun/bin" "$HOME/.local/share/bun/bin"; do
+    if [ -x "$candidate/bun" ]; then
+      export PATH="$candidate:$PATH"
+      break
+    fi
+  done
+  command -v bun >/dev/null 2>&1 || err "bun installation failed — install manually from https://bun.sh"
+fi
+info "Using bun: $(command -v bun) ($(bun --version))"
+
+# ---------------------------------------------------------------------------
+# Download Yo
+# ---------------------------------------------------------------------------
+
+if [ -e "$YO_INSTALL_DIR" ]; then
+  if [ -n "${YO_FORCE:-}" ]; then
+    info "Removing existing install dir (YO_FORCE set)"
+    rm -rf "$YO_INSTALL_DIR"
+  else
+    err "Install dir already exists: $YO_INSTALL_DIR. Set YO_FORCE=1 to overwrite."
+  fi
+fi
+
+info "Cloning $YO_REPO ($YO_REF) into $YO_INSTALL_DIR"
+mkdir -p "$(dirname "$YO_INSTALL_DIR")"
+git clone --depth 1 --branch "$YO_REF" "$YO_REPO" "$YO_INSTALL_DIR"
+
+# ---------------------------------------------------------------------------
+# Build
+# ---------------------------------------------------------------------------
+
+info "Installing dependencies (bun install)"
+( cd "$YO_INSTALL_DIR" && bun install --silent )
+
+info "Building Yo (bun run build)"
+( cd "$YO_INSTALL_DIR" && bun run build )
+
+# ---------------------------------------------------------------------------
+# Wrapper script
+# ---------------------------------------------------------------------------
+
+mkdir -p "$YO_BIN_DIR"
+WRAPPER="$YO_BIN_DIR/yo"
+
+cat > "$WRAPPER" <<EOF
+#!/usr/bin/env bash
+# Yo language CLI — auto-generated by install.sh
+set -euo pipefail
+exec "$YO_INSTALL_DIR/yo-cli" "\$@"
+EOF
+chmod +x "$WRAPPER"
+
+info "Installed wrapper: $WRAPPER"
+
+# ---------------------------------------------------------------------------
+# PATH check
+# ---------------------------------------------------------------------------
+
+case ":$PATH:" in
+  *":$YO_BIN_DIR:"*) ;;
+  *)
+    warn "$YO_BIN_DIR is not on your PATH."
+    warn "Add this to your shell rc file (.bashrc / .zshrc / etc):"
+    warn "    export PATH=\"\$HOME/.local/bin:\$PATH\""
+    ;;
+esac
+
+info "Done. Try: yo --help"

package/std/cli/arg_parser.yo

@@ -49,7 +49,11 @@ ParsedArgs :: object(
   _option_names : ArrayList(String),
   _option_values : ArrayList(String),
   _positionals : ArrayList(String),
-  _positional_names : ArrayList(String)
+  _positional_names : ArrayList(String),
+  /// Name of the chosen subcommand (`.None` if none was used).
+  _subcommand : Option(String),
+  /// Parsed arguments for the chosen subcommand (`.None` if no subcommand).
+  _subcommand_args : Option(Self)
 );
 
 /// Command-line argument parser.
@@ -59,7 +63,13 @@ ArgParser :: object(
   /// Application description shown in help text.
   _description : String,
   /// Registered argument definitions.
-  _args : ArrayList(ArgDef)
+  _args : ArrayList(ArgDef),
+  /// Subcommand names (parallel to `_subcommand_parsers`).
+  _subcommand_names : ArrayList(String),
+  /// Subcommand descriptions (parallel to `_subcommand_parsers`).
+  _subcommand_descriptions : ArrayList(String),
+  /// Subcommand parsers (parallel to `_subcommand_names`).
+  _subcommand_parsers : ArrayList(Self)
 );
 
 impl(ParsedArgs,
@@ -69,10 +79,18 @@ impl(ParsedArgs,
       _option_names: ArrayList(String).new(),
       _option_values: ArrayList(String).new(),
       _positionals: ArrayList(String).new(),
-      _positional_names: ArrayList(String).new()
+      _positional_names: ArrayList(String).new(),
+      _subcommand: .None,
+      _subcommand_args: .None
     )
   ),
 
+  /// Returns the name of the chosen subcommand, if any.
+  get_subcommand : (fn(self: Self) -> Option(String))(self._subcommand),
+
+  /// Returns the parsed arguments of the chosen subcommand, if any.
+  get_subcommand_args : (fn(self: Self) -> Option(Self))(self._subcommand_args),
+
   get_flag : (fn(self: Self, name: String) -> bool)(
     self._set_flags.contains(name)
   ),
@@ -116,10 +134,43 @@ impl(ArgParser,
     Self(
       _name: name,
       _description: description,
-      _args: ArrayList(ArgDef).new()
+      _args: ArrayList(ArgDef).new(),
+      _subcommand_names: ArrayList(String).new(),
+      _subcommand_descriptions: ArrayList(String).new(),
+      _subcommand_parsers: ArrayList(Self).new()
     )
   ),
 
+  /// Registers a subcommand with the given name and description.
+  /// Returns the new sub-parser, which can be configured with its own
+  /// flags, options, positionals, and nested subcommands.
+  add_subcommand : (fn(self: Self, name: String, description: String) -> Self)({
+    sub := Self.new(name, description);
+    self._subcommand_names.push(name);
+    self._subcommand_descriptions.push(description);
+    self._subcommand_parsers.push(sub);
+    return sub;
+  }),
+
+  /// Looks up a subcommand parser by name.
+  _find_subcommand : (fn(self: Self, name: String) -> Option(usize))({
+    i := usize(0);
+    len := self._subcommand_names.len();
+    (result : Option(usize)) = .None;
+    while ((i < len) && result.is_none()), (i = (i + usize(1))), {
+      match(self._subcommand_names.get(i),
+        .Some(n) => {
+          cond(
+            (n == name) => { result = .Some(i); },
+            true => ()
+          );
+        },
+        .None => ()
+      );
+    };
+    return result;
+  }),
+
   add_flag : (fn(self: Self, long_name: String, short_name: String, description: String) -> unit)({
     self._args.push(ArgDef(
       _long_name: long_name,
@@ -265,6 +316,31 @@ impl(ArgParser,
     );
 
     text = text.concat(`  --help, -h\tShow this help message\n`);
+
+    sub_count := self._subcommand_names.len();
+    cond(
+      (sub_count > usize(0)) => {
+        text = text.concat(`\nSubcommands:\n`);
+        s := usize(0);
+        while (s < sub_count), (s = (s + usize(1))), {
+          match(self._subcommand_names.get(s),
+            .Some(sn) => {
+              match(self._subcommand_descriptions.get(s),
+                .Some(sd) => {
+                  text = text.concat(`  ${sn}\t${sd}\n`);
+                },
+                .None => {
+                  text = text.concat(`  ${sn}\n`);
+                }
+              );
+            },
+            .None => ()
+          );
+        };
+      },
+      true => ()
+    );
+
     return text;
   })
 );
@@ -326,30 +402,78 @@ impl(ArgParser,
               );
             },
             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);
+              // Check if this is a subcommand (first non-flag positional only).
+              is_subcmd := false;
+              cond(
+                (self._subcommand_names.len() > usize(0)) => {
+                  match(self._find_subcommand(current_arg),
+                    .Some(sub_idx) => {
+                      match(self._subcommand_parsers.get(sub_idx),
+                        .Some(sub_parser) => {
+                          // Build new args list: [program_name, ...remaining args after subcommand name].
+                          sub_args := ArrayList(String).new();
+                          match(args.get(usize(0)),
+                            .Some(prog) => { sub_args.push(prog); },
+                            .None => { sub_args.push(self._name); }
+                          );
+                          j := (idx + usize(1));
+                          while (j < args_len), (j = (j + usize(1))), {
+                            match(args.get(j),
+                              .Some(a) => { sub_args.push(a); },
+                              .None => ()
+                            );
+                          };
+                          // Recursively parse the subcommand.
+                          match(recur(sub_parser, sub_args),
+                            .Ok(sub_parsed) => {
+                              parsed._subcommand = .Some(current_arg);
+                              parsed._subcommand_args = .Some(sub_parsed);
+                              idx = args_len;
+                              is_subcmd = true;
+                            },
+                            .Err(sub_err) => {
+                              err_msg = .Some(sub_err);
+                              is_subcmd = true;
+                            }
+                          );
+                        },
+                        .None => ()
+                      );
+                    },
+                    .None => ()
+                  );
+                },
+                true => ()
+              );
+              cond(
+                (!is_subcmd) => {
+                  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));
                           },
-                          true => ()
+                          .Flag => (),
+                          .Opt => ()
                         );
-                        p_count = (p_count + usize(1));
                       },
-                      .Flag => (),
-                      .Opt => ()
+                      .None => ()
                     );
-                  },
-                  .None => ()
-                );
-              };
-              positional_idx = (positional_idx + usize(1));
+                  };
+                  positional_idx = (positional_idx + usize(1));
+                },
+                true => ()
+              );
             }
           );
         },

package/std/collections/array_list.yo

@@ -696,9 +696,86 @@ impl(forall(T : Type), where(T <: Ord(T)), ArrayList(T),
   })
 );
 
+/// Clone implementation for ArrayList — deep-clones each element.
+impl(forall(T : Type), where(T <: Clone), ArrayList(T), Clone(
+  clone : (fn(self: *(Self)) -> Self)(
+    {
+      n := self.*.len();
+      result := Self.with_capacity(n);
+      i := usize(0);
+      while (i < n), {
+        item_opt := self.*.get(i);
+        match(item_opt,
+          .Some(item) => { result.push((&item).clone()); },
+          .None => ()
+        );
+        i = (i + usize(1));
+      };
+      result
+    }
+  )
+));
+
 export
   ArrayList,
   ArrayListError,
   ArrayListIter,
   ArrayListIterPtr
 ;
+
+// =============================================================================
+// array_list! literal macro
+// =============================================================================
+
+/// Internal helper: build a list of `tmp.push(elem)` statements from `elems`.
+__array_list_build_pushes :: (fn(comptime(tmp) : Expr, comptime(elems) : ExprList) -> comptime(ExprList))(
+  cond(
+    (elems.len() == usize(0)) => ExprList(),
+    true => {
+      first :: elems.car();
+      rest :: elems.cdr();
+      stmt :: quote((unquote(tmp).push(unquote(first))));
+      stmt.cons(recur(tmp, rest))
+    }
+  )
+);
+
+/// `array_list` macro — construct an `ArrayList(T)` literal.
+///
+/// The element type `T` is inferred from the first element via `typeof`, so
+/// at least one element is required.
+///
+/// # Example
+/// ```rust
+/// xs := array_list(i32(1), i32(2), i32(3));
+/// names := array_list(`alice`, `bob`);
+/// ```
+///
+/// Expands to:
+/// ```rust
+/// {
+///   __first := <first elem>;
+///   __tmp := ArrayList(typeof(__first)).new();
+///   __tmp.push(__first);
+///   __tmp.push(<elem 2>);
+///   ...
+///   __tmp
+/// }
+/// ```
+array_list :: (fn(...(quote(elems))) -> unquote(Expr)) {
+  __ :: comptime_assert((elems.len() > usize(0)),
+    "array_list requires at least one element to infer the element type");
+  first :: elems.car();
+  rest :: elems.cdr();
+  tmp :: gensym("array_list");
+  first_tmp :: gensym("array_list_first");
+  rest_pushes :: __array_list_build_pushes(tmp, rest);
+  quote {
+    unquote(first_tmp) := unquote(first);
+    unquote(tmp) := ArrayList(typeof(unquote(first_tmp))).new();
+    unquote(tmp).push(unquote(first_tmp));
+    unquote_splicing(rest_pushes);
+    unquote(tmp)
+  }
+};
+export array_list;