arc-lang 0.6.5 → 0.6.7

package/dist/interpreter.js

@@ -215,6 +215,12 @@ function resolveAsync(v) {
 function makePrelude(env) {
     const fns = {
         print: (...args) => { console.log(args.map(toStr).join(" ")); return null; },
+        throw: (msg) => { throw new Error(toStr(msg ?? "error")); },
+        arity: (v) => {
+            if (v && typeof v === "object" && v.__fn)
+                return (v.params || []).length;
+            return null;
+        },
         len: (v) => {
             if (typeof v === "string")
                 return [...v].length; // codepoint count, not UTF-16
@@ -262,6 +268,25 @@ function makePrelude(env) {
                 return String(a).localeCompare(String(b));
             });
         },
+        sort_by: (list, fn) => {
+            if (!Array.isArray(list))
+                throw new Error("sort_by expects a list as first argument");
+            if (!fn || !fn.__fn)
+                throw new Error("sort_by expects a function as second argument");
+            const fnVal = fn;
+            const paramCount = fnVal.params ? fnVal.params.length : 0;
+            if (paramCount !== 1) {
+                throw new ArcRuntimeError(`sort_by takes a key function fn(x) that returns a sort key, not a comparator fn(a, b). ` +
+                    `For example: sort_by(list, fn(x) => x.name) — not sort_by(list, fn(a, b) => a - b)`, { code: ErrorCode.WRONG_ARITY, category: "TypeError" });
+            }
+            return [...list].sort((a, b) => {
+                const ka = callFn(fnVal, [a]);
+                const kb = callFn(fnVal, [b]);
+                if (typeof ka === "number" && typeof kb === "number")
+                    return ka - kb;
+                return String(ka).localeCompare(String(kb));
+            });
+        },
         take: (list, n) => Array.isArray(list) ? list.slice(0, n) : null,
         drop: (list, n) => Array.isArray(list) ? list.slice(n) : null,
         find: (list, fn) => {
@@ -556,21 +581,30 @@ function makePrelude(env) {
             }
         },
         error_throw: (code, message) => {
+            if (message === undefined || message === null) {
+                throw new Error(toStr(code));
+            }
             throw new Error(`[${toStr(code)}] ${toStr(message)}`);
         },
         error_retry: (fn, times) => {
             const n = typeof times === "number" ? times : 1;
             let lastErr = null;
             for (let i = 0; i < n; i++) {
-                const result = typeof fn === "function" ? fn() : callFn(fn, []);
-                if (result && typeof result === "object" && "__map" in result) {
-                    const entries = result.entries;
-                    if (entries.has("kind") && entries.has("message")) {
-                        lastErr = result;
-                        continue;
+                try {
+                    const result = typeof fn === "function" ? fn() : callFn(fn, []);
+                    if (result && typeof result === "object" && "__map" in result) {
+                        const entries = result.entries;
+                        if (entries.has("kind") && entries.has("message")) {
+                            lastErr = result;
+                            continue;
+                        }
                     }
+                    return result;
+                }
+                catch (e) {
+                    lastErr = e instanceof Error ? e.message : String(e);
+                    continue;
                 }
-                return result;
             }
             return lastErr;
         },
@@ -2548,14 +2582,14 @@ function evalExpr(expr, env) {
                     if (typeof left !== "number" || typeof right !== "number")
                         throw new ArcRuntimeError(`TypeError: cannot divide non-numbers`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
                     if (right === 0)
-                        return left === 0 ? null : (left > 0 ? Infinity : -Infinity);
+                        throw new ArcRuntimeError("Division by zero", { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
                     return left / right;
                 }
                 case "%": {
                     if (typeof left !== "number" || typeof right !== "number")
                         throw new ArcRuntimeError(`TypeError: cannot modulo non-numbers`, { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
                     if (right === 0)
-                        return null;
+                        throw new ArcRuntimeError("Division by zero", { code: ErrorCode.INVALID_OPERATOR, loc: expr.loc });
                     return left % right;
                 }
                 case "**": {

package/dist/lexer.js

@@ -150,7 +150,7 @@ export function lex(source) {
                     str += advance();
                     continue;
                 }
-                if (peek() === "{") {
+                if (peek() === "{" && /[a-zA-Z_]/.test(peek(1))) {
                     hasInterp = true;
                     if (str.length > 0 || parts.length === 0) {
                         parts.push(tok(TokenType.String, str, sl, sc));

package/dist/repl.js

@@ -5,6 +5,7 @@ import { lex } from "./lexer.js";
 import { parse } from "./parser.js";
 import { createEnv, interpretWithEnv, toStr } from "./interpreter.js";
 import { createUseHandler } from "./modules.js";
+import { ARC_VERSION } from "./version.js";
 const GREEN = "\x1b[32m";
 const RED = "\x1b[31m";
 const CYAN = "\x1b[36m";
@@ -101,7 +102,7 @@ function main() {
         output: process.stdout,
         prompt: "arc> ",
     });
-    console.log(`${CYAN}Arc REPL v0.6.4${RESET} — Type ${YELLOW}:help${RESET} for commands, ${YELLOW}:builtins${RESET} for functions`);
+    console.log(`${CYAN}Arc REPL v${ARC_VERSION}${RESET} — Type ${YELLOW}:help${RESET} for commands, ${YELLOW}:builtins${RESET} for functions`);
     rl.prompt();
     let buffer = "";
     let braceDepth = 0;
@@ -109,7 +110,7 @@ function main() {
         const trimmed = line.trim();
         // Handle commands (only when not in multi-line mode)
         if (braceDepth === 0) {
-            if (trimmed === ":quit" || trimmed === ":q") {
+            if (trimmed === ":quit" || trimmed === ":q" || trimmed === ":exit") {
                 console.log("Goodbye!");
                 process.exit(0);
             }

package/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const ARC_VERSION = "0.6.5";
+export declare const ARC_VERSION = "0.6.7";
 export declare const ARC_BUILD_DATE: string;
 export declare const ARC_PLATFORM: string;
 /** Print version info */

package/dist/version.js

@@ -1,5 +1,5 @@
 // Arc Version System
-export const ARC_VERSION = "0.6.5";
+export const ARC_VERSION = "0.6.7";
 export const ARC_BUILD_DATE = new Date().toISOString().split("T")[0];
 export const ARC_PLATFORM = `${process.platform}-${process.arch}`;
 /** Print version info */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arc-lang",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Arc ⚡ — A programming language designed by AI agents, for AI agents. 27-63% fewer tokens than JavaScript.",
   "type": "module",
   "bin": {

package/stdlib/collections.arc

@@ -110,7 +110,8 @@ pub fn max_by(list, f) {
 }
 
 pub fn sort_by(list, f) {
-  # Insertion sort by key function
+  # sort_by takes a key function fn(x), not a comparator fn(a, b)
+  assert(arity(f) == 1, "sort_by takes a key function fn(x) that returns a sort key, not a comparator fn(a, b). Example: sort_by(list, fn(x) => x.name)")
   let mut arr = map(list, x => x)
   for i in 1..len(arr) {
     let mut j = i

package/stdlib/json.arc

@@ -41,10 +41,12 @@ fn _quote(s) {
 
 pub fn from_json(s) {
   let trimmed = trim(s)
-  if len(trimmed) == 0 { nil }
+  if len(trimmed) == 0 { error_throw("Invalid JSON: empty string") }
   el {
     let parsed = _parse_value(trimmed)
-    parsed.value
+    if parsed == nil { error_throw("Invalid JSON: " ++ s) }
+    el if len(trim(parsed.rest)) > 0 { error_throw("Invalid JSON: unexpected trailing content") }
+    el { parsed.value }
   }
 }
 

package/stdlib/regex.arc

@@ -19,14 +19,14 @@ pub fn test(pattern, text) {
   regex_test(re, text)
 }
 
-# Replaces all occurrences of `pattern` with `replacement` in `text`
-# (For first-occurrence-only replacement, use replace_first)
+# Replaces the first occurrence of `pattern` with `replacement` in `text`
+# (For global replacement, use replace_all)
 pub fn replace(pattern, replacement, text) {
   let re = regex_new(pattern)
   regex_replace(re, replacement, text)
 }
 
-# Replaces only the first occurrence of `pattern` with `replacement` in `text`
+# Alias for replace — replaces only the first occurrence
 pub fn replace_first(pattern, replacement, text) {
   let re = regex_new(pattern)
   regex_replace(re, replacement, text)