arc-lang 0.5.4 → 0.5.6

package/dist/ast.d.ts

@@ -2,7 +2,7 @@ export interface Loc {
     line: number;
     col: number;
 }
-export type Expr = IntLiteral | FloatLiteral | BoolLiteral | NilLiteral | StringLiteral | StringInterp | Identifier | BinaryExpr | UnaryExpr | CallExpr | MemberExpr | IndexExpr | PipelineExpr | IfExpr | MatchExpr | LambdaExpr | ListLiteral | MapLiteral | ListComprehension | ToolCallExpr | RangeExpr | BlockExpr | AsyncExpr | AwaitExpr | FetchExpr;
+export type Expr = IntLiteral | FloatLiteral | BoolLiteral | NilLiteral | StringLiteral | StringInterp | Identifier | BinaryExpr | UnaryExpr | CallExpr | MemberExpr | IndexExpr | PipelineExpr | IfExpr | MatchExpr | LambdaExpr | ListLiteral | MapLiteral | ListComprehension | ToolCallExpr | RangeExpr | BlockExpr | AsyncExpr | AwaitExpr | FetchExpr | SpreadExpr | OptionalMemberExpr | TryExpr;
 export interface IntLiteral {
     kind: "IntLiteral";
     value: number;
@@ -103,12 +103,19 @@ export interface ListLiteral {
     elements: Expr[];
     loc: Loc;
 }
+export interface SpreadExpr {
+    kind: "SpreadExpr";
+    expr: Expr;
+    loc: Loc;
+}
+export interface MapEntry {
+    key?: string | Expr;
+    value?: Expr;
+    spread?: Expr;
+}
 export interface MapLiteral {
     kind: "MapLiteral";
-    entries: {
-        key: string | Expr;
-        value: Expr;
-    }[];
+    entries: MapEntry[];
     loc: Loc;
 }
 export interface ListComprehension {
@@ -152,7 +159,18 @@ export interface FetchExpr {
     targets: Expr[];
     loc: Loc;
 }
-export type Pattern = WildcardPattern | LiteralPattern | BindingPattern | ArrayPattern | OrPattern;
+export interface OptionalMemberExpr {
+    kind: "OptionalMemberExpr";
+    object: Expr;
+    property: string;
+    loc: Loc;
+}
+export interface TryExpr {
+    kind: "TryExpr";
+    expr: Expr;
+    loc: Loc;
+}
+export type Pattern = WildcardPattern | LiteralPattern | BindingPattern | ArrayPattern | OrPattern | ConstructorPattern;
 export interface WildcardPattern {
     kind: "WildcardPattern";
     loc: Loc;
@@ -177,6 +195,12 @@ export interface OrPattern {
     patterns: Pattern[];
     loc: Loc;
 }
+export interface ConstructorPattern {
+    kind: "ConstructorPattern";
+    name: string;
+    args: Pattern[];
+    loc: Loc;
+}
 export type Stmt = LetStmt | FnStmt | ForStmt | DoStmt | ExprStmt | UseStmt | TypeStmt | AssignStmt | MemberAssignStmt | IndexAssignStmt | RetStmt;
 export interface AssignStmt {
     kind: "AssignStmt";
@@ -215,11 +239,18 @@ export interface DestructureTarget {
     kind: "DestructureTarget";
     type: "object" | "array";
     names: string[];
+    rest?: string;
+}
+export interface Param {
+    name: string;
+    default?: Expr;
+    rest?: boolean;
 }
 export interface FnStmt {
     kind: "FnStmt";
     name: string;
     params: string[];
+    richParams?: Param[];
     body: Expr;
     isAsync: boolean;
     pub: boolean;
@@ -227,7 +258,7 @@ export interface FnStmt {
 }
 export interface ForStmt {
     kind: "ForStmt";
-    variable: string;
+    variable: string | DestructureTarget;
     iterable: Expr;
     body: Expr;
     loc: Loc;

package/dist/codegen-js.js

@@ -11,6 +11,7 @@ export function generateJS(module) {
     lines.push(`  push(arr, v) { arr.push(v); return arr; },`);
     lines.push(`  __toStr(v) { if (v === null) return "nil"; if (typeof v === "boolean") return v ? "true" : "false"; if (typeof v === "number" || typeof v === "string") return String(v); if (Array.isArray(v)) return "[" + v.map(x => this.__toStr(x)).join(", ") + "]"; if (v && v.__map) { const entries = [...v.entries.entries()].map(([k, val]) => k + ": " + this.__toStr(val)); return "{" + entries.join(", ") + "}"; } return String(v); },`);
     lines.push(`  print(v) { console.log(this.__toStr(v)); },`);
+    lines.push(`  println(v) { console.log(this.__toStr(v)); },`);
     lines.push(`  head(a) { return a[0]; },`);
     lines.push(`  tail(a) { return a.slice(1); },`);
     lines.push(`  map(a, f) { return a.map(f); },`);
@@ -223,7 +224,7 @@ function emitUnop(op, operand) {
 }
 function emitCall(fn, args) {
     const builtins = [
-        "len", "str", "push", "print", "head", "tail", "map", "filter", "fold",
+        "len", "str", "push", "print", "println", "head", "tail", "map", "filter", "fold",
         "range", "keys", "values", "type", "abs", "max", "min", "floor", "ceil",
         "round", "sort", "reverse", "contains", "join", "split", "trim", "replace",
         "uppercase", "lowercase", "sum", "flat", "zip", "enumerate", "slice",

package/dist/formatter.js

@@ -204,6 +204,8 @@ export function format(source, options) {
                 if (expr.entries.length === 0)
                     return "{}";
                 const entries = expr.entries.map(e => {
+                    if (e.spread)
+                        return `...${formatExpr(e.spread, depth + 1)}`;
                     const key = typeof e.key === "string" ? e.key : formatExpr(e.key, depth + 1);
                     return `${key}: ${formatExpr(e.value, depth + 1)}`;
                 });
@@ -235,6 +237,10 @@ export function format(source, options) {
                 const targets = expr.targets.map(t => formatExpr(t, depth)).join(", ");
                 return `fetch [${targets}]`;
             }
+            case "SpreadExpr": return `...${formatExpr(expr.expr, depth)}`;
+            case "OptionalMemberExpr": return `${formatExpr(expr.object, depth)}?.${expr.property}`;
+            case "TryExpr": return `${formatExpr(expr.expr, depth)}?`;
+            default: return `/* unknown */`;
         }
     }
     function formatBlockExpr(expr, depth) {
@@ -272,6 +278,8 @@ export function format(source, options) {
             case "BindingPattern": return pat.name;
             case "ArrayPattern": return `[${pat.elements.map(formatPattern).join(", ")}]`;
             case "OrPattern": return pat.patterns.map(formatPattern).join(" | ");
+            case "ConstructorPattern": return `${pat.name}(${pat.args.map(formatPattern).join(", ")})`;
+            default: return "_";
         }
     }
     function formatTypeExpr(t) {

package/dist/index.js

@@ -15,6 +15,8 @@ import { format } from "./formatter.js";
 import { lint, formatDiagnostic } from "./linter.js";
 import { printVersion } from "./version.js";
 import { setPrettyErrors } from "./errors.js";
+import { build, test as buildTest, newProject } from "./build.js";
+import { pkgInit, pkgAdd, pkgRemove, pkgList, pkgInstall } from "./package-manager.js";
 const args = process.argv.slice(2);
 if (args.includes("--no-pretty-errors"))
     setPrettyErrors(false);
@@ -51,6 +53,54 @@ else if (command === "fuzz") {
             process.exit(1);
     });
 }
+else if (command === "build") {
+    const targetArg = args.find(a => a.startsWith("--target="))?.split("=")[1];
+    build({ target: targetArg, dir: process.cwd() });
+}
+else if (command === "test") {
+    buildTest(process.cwd());
+}
+else if (command === "new") {
+    const name = args[1];
+    if (!name) {
+        console.error("Usage: arc new <project-name>");
+        process.exit(1);
+    }
+    newProject(name);
+}
+else if (command === "pkg") {
+    const sub = args[1];
+    if (sub === "init") {
+        pkgInit();
+    }
+    else if (sub === "add") {
+        const pkg = args[2];
+        if (!pkg) {
+            console.error("Usage: arc pkg add <package>");
+            process.exit(1);
+        }
+        const dev = args.includes("--dev");
+        pkgAdd(pkg, { dev });
+    }
+    else if (sub === "remove") {
+        const pkg = args[2];
+        if (!pkg) {
+            console.error("Usage: arc pkg remove <package>");
+            process.exit(1);
+        }
+        pkgRemove(pkg);
+    }
+    else if (sub === "list") {
+        pkgList();
+    }
+    else if (sub === "install") {
+        pkgInstall();
+    }
+    else {
+        console.error("Usage: arc pkg <init|add|remove|list|install>");
+        process.exit(1);
+    }
+}
 else if (!command || !file) {
     console.log("Usage:");
     console.log("  npx tsx src/index.ts run <file.arc>   - Execute an Arc file");

package/dist/interpreter.d.ts

@@ -12,6 +12,7 @@ interface FnValue {
     __fn: true;
     name: string;
     params: string[];
+    richParams?: AST.Param[];
     body: AST.Expr;
     closure: Env;
 }