naider 1.15.0 → 1.17.0

package/README.md

@@ -1,8 +1,8 @@
 # NAIDE
 
-**Node AI Development Environment** — A programming language designed for AI-speed code generation that transpiles to **15 languages**.
+**Node AI Development Environment** — A programming language simpler than Python, designed for AI-speed code generation, that transpiles to **15 languages**.
 
-NAIDE is built on three principles: one way to write everything (zero ambiguity), keyword-driven intent (the first token decides meaning), and minimal token count (fewer tokens = faster AI generation). Write once, compile to any target. 47 built-in features including servers, databases, authentication, bots, GraphQL, gRPC, WebRTC, blockchain, and more.
+NAIDE is built on four principles: simpler than Python (built-in functions, syntax sugar, zero boilerplate), one way to write everything (zero ambiguity), keyword-driven intent (the first token decides meaning), and minimal token count (fewer tokens = faster AI generation). Write once, compile to any target. 35+ built-in functions, syntax sugar (`unless`, `until`, `repeat`, `swap`, `is`/`isnt`, one-line functions), and 47 built-in features including servers, databases, authentication, bots, GraphQL, gRPC, WebRTC, blockchain, and more.
 
 ### Compilation Targets
 
@@ -885,14 +885,97 @@ env:
 
 Variables become constants. Missing `required` vars exit with an error.
 
+## Syntax Sugar (Simpler than Python)
+
+```python
+# unless — negated if
+unless x > 10:
+  log "small"
+
+# until — negated while
+until done:
+  process()
+
+# repeat — simple counted loop
+repeat 5:
+  log "hi"
+repeat 10 as i:
+  log i
+
+# enum
+enum Color:
+  RED
+  GREEN
+  BLUE
+
+# swap
+swap a, b
+
+# is / isnt — readable equality
+if x is 5: log "five"
+if y isnt null: log "exists"
+
+# one-line functions
+fn double(int x) -> int = x * 2
+
+# print alias
+print "hello world"
+```
+
 ## Built-in Functions
 
 ```python
-str id = uuid()                          # UUID
-str hashed = hash("password")            # scrypt hash
-bool ok = verify("password", hashed)     # timing-safe verify
-str token = sign({id: 1})                # JWT (uses auth secret)
-str token = sign({id: 1}, "my-secret")   # JWT (explicit secret)
+# Security
+str id = uuid()
+str hashed = hash("password")
+bool ok = verify("password", hashed)
+str token = sign({id: 1})
+
+# Type conversions
+str s = str(42)
+int n = int("42")
+num f = float("3.14")
+
+# String ops
+str u = upper("hello")
+str l = lower("HELLO")
+str t = trim("  hi  ")
+list parts = split("a,b,c", ",")
+str joined = join(parts, "-")
+bool has = contains("hello", "ell")
+
+# Collection ops
+int length = len(items)
+list sorted = sort(items)
+list r = range(10)
+list k = keys(obj)
+list v = values(obj)
+list uniq = unique(items)
+list flat_list = flat(nested)
+list zipped = zip(a, b)
+list chunks = chunk(items, 3)
+
+# Math
+num a = abs(-5)
+num r = round(3.7)
+num s = sqrt(16)
+num p = pow(2, 10)
+num total = sum(nums)
+
+# JSON
+any data = json_parse('{"a":1}')
+str json = json_str(data)
+
+# I/O
+str answer = ask("Name?")
+str content = read("file.txt")
+write("out.txt", content)
+
+# Time & misc
+int ts = now()
+str t = time()
+sleep(1000)
+exit(0)
 ```
 
 Auto-imported from the runtime when used.
@@ -1322,6 +1405,76 @@ naide pkg list                  # list installed NAIDE packages
 
 The `naide.pkg.json` manifest tracks NAIDE-specific metadata (main entry, exports, dependencies) while using npm as the underlying registry.
 
+## NAIDE vs Python — Side by Side
+
+**Read a file, process lines, write result:**
+
+```python
+# Python (8 lines)
+with open("input.txt") as f:
+    lines = f.read().strip().split("\n")
+upper_lines = [line.upper() for line in lines]
+result = "\n".join(upper_lines)
+with open("output.txt", "w") as f:
+    f.write(result)
+print(f"Processed {len(upper_lines)} lines")
+```
+
+```python
+# NAIDE (4 lines)
+list lines = split(trim(read("input.txt")), "\n")
+list upper_lines = [upper(line) for line in lines]
+write("output.txt", join(upper_lines, "\n"))
+print "Processed {len(upper_lines)} lines"
+```
+
+**Sort, deduplicate, and swap:**
+
+```python
+# Python (5 lines)
+items = [3, 1, 4, 1, 5]
+items = sorted(set(items))
+a, b = 1, 2
+a, b = b, a
+print(f"a={a}, b={b}")
+```
+
+```python
+# NAIDE (5 lines)
+list items = unique(sort([3, 1, 4, 1, 5]))
+mut int a = 1
+mut int b = 2
+swap a, b
+print "a={a}, b={b}"
+```
+
+**Simple API server:**
+
+```python
+# Python + Flask (12 lines)
+from flask import Flask, jsonify
+app = Flask(__name__)
+
+@app.route("/")
+def index():
+    return jsonify({"message": "Hello"})
+
+@app.route("/health")
+def health():
+    return jsonify({"status": "ok"})
+
+app.run(port=3000)
+```
+
+```python
+# NAIDE (5 lines)
+server app port 3000:
+  get "/":
+    ret {message: "Hello"}
+  get "/health":
+    ret {status: "ok"}
+```
+
 ## Why NAIDE?
 
 AI code generation speed depends on:
@@ -1329,6 +1482,7 @@ AI code generation speed depends on:
 1. **Token count** — fewer output tokens = faster generation
 2. **Predictability** — one way to write everything = better next-token prediction
 3. **Context window** — shorter code = more room for complex projects
+4. **Simplicity** — built-in functions mean zero imports and less boilerplate
 
 NAIDE-X is designed as an **AI-internal representation** — the AI thinks in NAIDE-X, users receive standard JavaScript.
 

package/SPEC.naide

@@ -634,3 +634,105 @@ blockchain "eth":
   contract "0x1234abcd..."
   abi "contract-abi.json"
 # usage: eth.getBalance("0x..."), eth.getBlock(), eth.sendTx(wallet, to, "0.1")
+
+
+# ============================================
+# シンプルシンタックス (Pythonより簡単)
+# ============================================
+
+# ---- unless (ifの逆) ----
+unless x > 10:
+  log "xは10以下"
+
+# ---- until (whileの逆) ----
+mut int i = 0
+until i > 10:
+  i = i + 1
+
+# ---- repeat (簡単ループ) ----
+repeat 5:
+  log "hello"
+
+repeat 10 as i:
+  log i
+
+# ---- enum (列挙型) ----
+enum Color:
+  RED
+  GREEN
+  BLUE
+
+# インライン形式
+enum Status: ACTIVE, INACTIVE, PENDING
+
+# ---- swap (値の交換) ----
+mut int a = 1
+mut int b = 2
+swap a, b
+
+# ---- is / isnt (比較演算子) ----
+if x is 5:
+  log "xは5"
+if y isnt null:
+  log "yはnullじゃない"
+
+# ---- 一行関数 ----
+fn double(int x) -> int = x * 2
+fn greet(str name) -> str = "Hello, {name}!"
+
+# ---- print (logのエイリアス) ----
+print "hello world"
+
+# ---- ビルトイン関数 ----
+# 型変換
+str s = str(42)
+int n = int("42")
+num f = float("3.14")
+
+# 文字列操作
+str u = upper("hello")        # "HELLO"
+str l = lower("HELLO")        # "hello"
+str t = trim("  hi  ")        # "hi"
+list parts = split("a,b,c", ",")  # ["a","b","c"]
+str joined = join(parts, "-")     # "a-b-c"
+str replaced = replace("hello", "l", "r")  # "herro"
+bool has = contains("hello", "ell")  # true
+
+# コレクション操作
+int length = len(items)
+list sorted = sort(items)
+list reversed = reverse(items)
+list uniq = unique([1,1,2,3])  # [1,2,3]
+list k = keys(obj)
+list v = values(obj)
+list e = entries(obj)
+list r = range(10)             # [0,1,...,9]
+list chunks = chunk([1,2,3,4], 2)  # [[1,2],[3,4]]
+list zipped = zip([1,2], ["a","b"])
+list flattened = flat([[1,2],[3,4]])
+
+# 数学
+num a2 = abs(-5)
+num r2 = round(3.7)
+num c = ceil(3.1)
+num fl = floor(3.9)
+num sq = sqrt(16)
+num p = pow(2, 10)
+num total = sum([1,2,3])
+
+# JSON
+any data2 = json_parse('{"a":1}')
+str json = json_str(data2)
+
+# 時間
+int timestamp = now()
+str timestr = time()
+
+# I/O
+str content = read("file.txt")
+write("out.txt", content)
+str answer = ask("名前は？")
+
+# その他
+sleep(1000)
+exit(0)

package/lsp/server.js

@@ -291,6 +291,7 @@ function getCompletions() {
     'page', 'cli', 'mail', 'graphql', 'desktop', 'screen',
     'oauth', 'pay', 'storage', 'pdf', 'i18n', 'push', 'search', 'image',
     'csv', 'logging', 'migrate', 'grpc', 'webrtc', 'blockchain',
+    'unless', 'until', 'repeat', 'enum', 'swap', 'is', 'isnt', 'print',
   ];
   const builtins = [
     { label: 'uuid()', detail: 'Generate UUID v4', insertText: 'uuid()' },
@@ -315,6 +316,45 @@ function getCompletions() {
     { label: 'graphql "/path"', detail: 'GraphQL endpoint', insertText: 'graphql ' },
     { label: 'desktop name:', detail: 'Desktop app', insertText: 'desktop ' },
     { label: 'screen Name:', detail: 'Mobile screen', insertText: 'screen ' },
+    { label: 'len(list)', detail: 'Get length', insertText: 'len(' },
+    { label: 'sort(list)', detail: 'Sort a list', insertText: 'sort(' },
+    { label: 'reverse(list)', detail: 'Reverse a list', insertText: 'reverse(' },
+    { label: 'unique(list)', detail: 'Remove duplicates', insertText: 'unique(' },
+    { label: 'upper(str)', detail: 'Uppercase string', insertText: 'upper(' },
+    { label: 'lower(str)', detail: 'Lowercase string', insertText: 'lower(' },
+    { label: 'trim(str)', detail: 'Trim whitespace', insertText: 'trim(' },
+    { label: 'split(str, sep)', detail: 'Split string', insertText: 'split(' },
+    { label: 'join(list, sep)', detail: 'Join list to string', insertText: 'join(' },
+    { label: 'contains(list, item)', detail: 'Check if contains', insertText: 'contains(' },
+    { label: 'replace(str, old, new)', detail: 'Replace in string', insertText: 'replace(' },
+    { label: 'keys(map)', detail: 'Get map keys', insertText: 'keys(' },
+    { label: 'values(map)', detail: 'Get map values', insertText: 'values(' },
+    { label: 'entries(map)', detail: 'Get key-value pairs', insertText: 'entries(' },
+    { label: 'range(n)', detail: 'Generate 0..n-1', insertText: 'range(' },
+    { label: 'abs(num)', detail: 'Absolute value', insertText: 'abs(' },
+    { label: 'round(num)', detail: 'Round number', insertText: 'round(' },
+    { label: 'ceil(num)', detail: 'Round up', insertText: 'ceil(' },
+    { label: 'floor(num)', detail: 'Round down', insertText: 'floor(' },
+    { label: 'sqrt(num)', detail: 'Square root', insertText: 'sqrt(' },
+    { label: 'pow(base, exp)', detail: 'Power', insertText: 'pow(' },
+    { label: 'sum(list)', detail: 'Sum of list', insertText: 'sum(' },
+    { label: 'flat(list)', detail: 'Flatten nested list', insertText: 'flat(' },
+    { label: 'zip(a, b)', detail: 'Zip two lists', insertText: 'zip(' },
+    { label: 'chunk(list, n)', detail: 'Split into chunks', insertText: 'chunk(' },
+    { label: 'str(val)', detail: 'Convert to string', insertText: 'str(' },
+    { label: 'int(val)', detail: 'Convert to integer', insertText: 'int(' },
+    { label: 'float(val)', detail: 'Convert to float', insertText: 'float(' },
+    { label: 'json_parse(str)', detail: 'Parse JSON string', insertText: 'json_parse(' },
+    { label: 'json_str(val)', detail: 'Stringify to JSON', insertText: 'json_str(' },
+    { label: 'now()', detail: 'Current timestamp ms', insertText: 'now()' },
+    { label: 'time()', detail: 'Current ISO time', insertText: 'time()' },
+    { label: 'ask(prompt)', detail: 'Read user input', insertText: 'ask(' },
+    { label: 'sleep(ms)', detail: 'Wait milliseconds', insertText: 'sleep(' },
+    { label: 'exit(code)', detail: 'Exit process', insertText: 'exit(' },
+    { label: 'read(path)', detail: 'Read file contents', insertText: 'read(' },
+    { label: 'write(path, data)', detail: 'Write to file', insertText: 'write(' },
+    { label: 'fetch_json(url)', detail: 'Fetch JSON from URL', insertText: 'fetch_json(' },
+    { label: 'random(min, max)', detail: 'Random number', insertText: 'random(' },
   ];
 
   return [
@@ -361,6 +401,14 @@ const HOVER_DOCS = {
   'grpc': '**grpc** — gRPC service\n```naide\ngrpc "users" port 50051:\n  rpc getUser(id) -> user\n  rpc createUser(data) -> user\n```',
   'webrtc': '**webrtc** — WebRTC signaling\n```naide\nwebrtc "video":\n  stun "stun:stun.l.google.com:19302"\n  on offer(data):\n    log "offer received"\n```',
   'blockchain': '**blockchain** — Blockchain/Web3\n```naide\nblockchain "eth":\n  network "ethereum"\n  provider env.ETH_RPC\n  contract "0x..."\n```\nUsage: `eth.getBalance(addr)`, `eth.getBlock()`',
+  'unless': '**unless** — Negated if (do X unless condition)\n```naide\nunless x > 10:\n  log "small"\n```',
+  'until': '**until** — Negated while (loop until condition)\n```naide\nuntil done:\n  process()\n```',
+  'repeat': '**repeat** — Simple counted loop\n```naide\nrepeat 5:\n  log "hi"\nrepeat 10 as i:\n  log i\n```',
+  'enum': '**enum** — Enumeration type\n```naide\nenum Color:\n  RED\n  GREEN\n  BLUE\n```\nInline: `enum Status: ACTIVE, INACTIVE`',
+  'swap': '**swap** — Swap two variables\n```naide\nswap a, b\n```',
+  'is': '**is** — Equality comparison (===)\n```naide\nif x is 5: log "five"\n```',
+  'isnt': '**isnt** — Inequality comparison (!==)\n```naide\nif x isnt null: log "exists"\n```',
+  'print': '**print** — Alias for log\n```naide\nprint "hello world"\n```',
 };
 
 function getHover(params) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "naider",
-  "version": "1.15.0",
-  "description": "NAIDE - Node AI Development Environment. AI-specialized language transpiling to 15 targets: Node.js, Python, Bun, TypeScript, C, C++, Java, Go, Rust, PHP, Ruby, Kotlin, Swift, Dart, C#. Built-in server, auth, DB, AI/LLM, bots, GraphQL, gRPC, WebRTC, blockchain, and 47 more features.",
+  "version": "1.17.0",
+  "description": "NAIDE - Simpler than Python, compiles to 15 targets. AI-specialized language with 35+ built-in functions, syntax sugar (unless/until/repeat/swap/is/isnt), and 47 features. Targets: Node.js, Python, TypeScript, C, C++, Java, Go, Rust, PHP, Ruby, Kotlin, Swift, Dart, C#, Bun.",
   "main": "src/index.js",
   "exports": {
     ".": "./src/index.js",

package/src/generator-c.js

@@ -185,6 +185,8 @@ export class CGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -873,6 +875,12 @@ export class CGenerator {
   generateCall(node) {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     if (node.callee.type === 'Identifier') {
       const name = node.callee.name;
       if (name === 'parseInt') return `atoi(${args})`;
@@ -974,6 +982,46 @@ export class CGenerator {
     return result;
   }
 
+  visitEnum(node) {
+    this.emit(`typedef enum {`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`${node.name}_${v} = ${i},`);
+    });
+    this.indent--;
+    this.emit(`} ${node.name};`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    const tmp = `_tmp_${a.replace(/[^a-zA-Z0-9]/g, '')}`;
+    this.emit(`{ typeof(${a}) ${tmp} = ${a}; ${a} = ${b}; ${b} = ${tmp}; }`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `(sizeof(${args[0]}) / sizeof(${args[0]}[0]))`;
+      case 'abs': return `abs(${args[0]})`;
+      case 'sqrt': { this.includes.add('<math.h>'); return `sqrt(${args[0]})`; }
+      case 'pow': { this.includes.add('<math.h>'); return `pow(${args[0]}, ${args[1]})`; }
+      case 'ceil': { this.includes.add('<math.h>'); return `ceil(${args[0]})`; }
+      case 'floor': { this.includes.add('<math.h>'); return `floor(${args[0]})`; }
+      case 'round': { this.includes.add('<math.h>'); return `round(${args[0]})`; }
+      case 'exit': { this.includes.add('<stdlib.h>'); return `exit(${args[0] || '0'})`; }
+      case 'str': return `snprintf(_buf, sizeof(_buf), "%d", ${args[0]})`;
+      case 'int': { this.includes.add('<stdlib.h>'); return `atoi(${args[0]})`; }
+      case 'float': { this.includes.add('<stdlib.h>'); return `atof(${args[0]})`; }
+      case 'upper': { this.includes.add('<ctype.h>'); return `toupper(${args[0]})`; }
+      case 'lower': { this.includes.add('<ctype.h>'); return `tolower(${args[0]})`; }
+      case 'sleep': { this.includes.add('<unistd.h>'); return `usleep(${args[0]} * 1000)`; }
+      case 'now': { this.includes.add('<time.h>'); return `(long long)time(NULL) * 1000`; }
+      case 'random': { this.includes.add('<stdlib.h>'); return args.length >= 2 ? `(rand() % (${args[1]} - ${args[0]} + 1) + ${args[0]})` : `rand()`; }
+      default: return null;
+    }
+  }
+
   rawString(strData) {
     if (!strData) return '';
     if (strData.raw !== null && strData.raw !== undefined) return strData.raw;

package/src/generator-cpp.js

@@ -186,6 +186,8 @@ export class CppGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -983,6 +985,10 @@ export class CppGenerator {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+
       const name = node.callee.name;
       if (name === 'parseInt') return `stoi(${args})`;
       if (name === 'parseFloat') return `stod(${args})`;
@@ -1208,4 +1214,51 @@ export class CppGenerator {
     this.inFunction = saved;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum class ${node.name} {`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`${v} = ${i},`);
+    });
+    this.indent--;
+    this.emit(`};`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    this.includes.add('<utility>');
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`std::swap(${a}, ${b});`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.size()`;
+      case 'sort': { this.includes.add('<algorithm>'); return `([&](){ auto _v = ${args[0]}; std::sort(_v.begin(), _v.end()); return _v; }())`; }
+      case 'reverse': { this.includes.add('<algorithm>'); return `([&](){ auto _v = ${args[0]}; std::reverse(_v.begin(), _v.end()); return _v; }())`; }
+      case 'contains': return `(std::find(${args[0]}.begin(), ${args[0]}.end(), ${args[1]}) != ${args[0]}.end())`;
+      case 'abs': { this.includes.add('<cmath>'); return `std::abs(${args[0]})`; }
+      case 'sqrt': { this.includes.add('<cmath>'); return `std::sqrt(${args[0]})`; }
+      case 'pow': { this.includes.add('<cmath>'); return `std::pow(${args[0]}, ${args[1]})`; }
+      case 'ceil': { this.includes.add('<cmath>'); return `std::ceil(${args[0]})`; }
+      case 'floor': { this.includes.add('<cmath>'); return `std::floor(${args[0]})`; }
+      case 'round': { this.includes.add('<cmath>'); return `std::round(${args[0]})`; }
+      case 'str': return `std::to_string(${args[0]})`;
+      case 'int': return `std::stoi(${args[0]})`;
+      case 'float': return `std::stof(${args[0]})`;
+      case 'upper': { this.includes.add('<algorithm>'); this.includes.add('<cctype>'); return `([&](){ auto _s = ${args[0]}; std::transform(_s.begin(), _s.end(), _s.begin(), ::toupper); return _s; }())`; }
+      case 'lower': { this.includes.add('<algorithm>'); this.includes.add('<cctype>'); return `([&](){ auto _s = ${args[0]}; std::transform(_s.begin(), _s.end(), _s.begin(), ::tolower); return _s; }())`; }
+      case 'trim': return `([&](){ auto _s = ${args[0]}; _s.erase(0, _s.find_first_not_of(" \\t\\n\\r")); _s.erase(_s.find_last_not_of(" \\t\\n\\r") + 1); return _s; }())`;
+      case 'keys': return `([&](){ std::vector<std::string> _k; for (auto& [k,v] : ${args[0]}) _k.push_back(k); return _k; }())`;
+      case 'values': return `([&](){ std::vector<auto> _v; for (auto& [k,v] : ${args[0]}) _v.push_back(v); return _v; }())`;
+      case 'exit': return `exit(${args[0] || '0'})`;
+      case 'sleep': { this.includes.add('<thread>'); this.includes.add('<chrono>'); return `std::this_thread::sleep_for(std::chrono::milliseconds(${args[0]}))`; }
+      case 'now': { this.includes.add('<chrono>'); return `std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count()`; }
+      case 'random': { this.includes.add('<random>'); return args.length >= 2 ? `([](int a, int b){ std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> dis(a,b); return dis(gen); })(${args[0]}, ${args[1]})` : `([]{ std::random_device rd; return rd(); }())`; }
+      case 'sum': return `([&](){ auto _v = ${args[0]}; return std::accumulate(_v.begin(), _v.end(), 0); }())`;
+      default: return null;
+    }
+  }
 }

package/src/generator-csharp.js

@@ -178,6 +178,8 @@ export class CSharpGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1431,6 +1433,12 @@ export class CSharpGenerator {
   generateCall(node) {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     if (node.callee.type === 'Identifier') {
       const name = node.callee.name;
       if (name === 'parseInt') return `int.Parse(${args})`;
@@ -1630,4 +1638,63 @@ export class CSharpGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum ${node.name} {`);
+    this.indent++;
+    this.emit(node.values.join(', '));
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`(${a}, ${b}) = (${b}, ${a});`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.Count`;
+      case 'sort': return `${args[0]}.OrderBy(x => x).ToList()`;
+      case 'reverse': return `${args[0]}.AsEnumerable().Reverse().ToList()`;
+      case 'unique': return `${args[0]}.Distinct().ToList()`;
+      case 'upper': return `${args[0]}.ToUpper()`;
+      case 'lower': return `${args[0]}.ToLower()`;
+      case 'trim': return `${args[0]}.Trim()`;
+      case 'split': return `${args[0]}.Split(${args[1] || '","'}).ToList()`;
+      case 'join': return `string.Join(${args[1] || '","'}, ${args[0]})`;
+      case 'contains': return `${args[0]}.Contains(${args[1]})`;
+      case 'replace': return `${args[0]}.Replace(${args[1]}, ${args[2]})`;
+      case 'keys': return `${args[0]}.Keys.ToList()`;
+      case 'values': return `${args[0]}.Values.ToList()`;
+      case 'entries': return `${args[0]}.ToList()`;
+      case 'range': return args.length >= 2 ? `Enumerable.Range(${args[0]}, ${args[1]} - ${args[0]}).ToList()` : `Enumerable.Range(0, ${args[0]}).ToList()`;
+      case 'abs': return `Math.Abs(${args[0]})`;
+      case 'sqrt': return `Math.Sqrt(${args[0]})`;
+      case 'pow': return `Math.Pow(${args[0]}, ${args[1]})`;
+      case 'ceil': return `Math.Ceiling((double)${args[0]})`;
+      case 'floor': return `Math.Floor((double)${args[0]})`;
+      case 'round': return `Math.Round((double)${args[0]})`;
+      case 'sum': return `${args[0]}.Sum()`;
+      case 'flat': return `${args[0]}.SelectMany(x => x).ToList()`;
+      case 'zip': return `${args[0]}.Zip(${args[1]}).ToList()`;
+      case 'chunk': return `${args[0]}.Chunk(${args[1]}).Select(c => c.ToList()).ToList()`;
+      case 'str': return `${args[0]}.ToString()`;
+      case 'int': return `int.Parse(${args[0]})`;
+      case 'float': return `double.Parse(${args[0]})`;
+      case 'json_parse': return `System.Text.Json.JsonSerializer.Deserialize<object>(${args[0]})`;
+      case 'json_str': return `System.Text.Json.JsonSerializer.Serialize(${args[0]})`;
+      case 'now': return `DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()`;
+      case 'time': return `DateTime.Now.ToString("o")`;
+      case 'exit': return `Environment.Exit(${args[0] || '0'})`;
+      case 'sleep': return `Thread.Sleep(${args[0]})`;
+      case 'random': return args.length >= 2 ? `new Random().Next(${args[0]}, ${args[1]} + 1)` : `new Random().NextDouble()`;
+      case 'read': return `File.ReadAllText(${args[0]})`;
+      case 'write': return `File.WriteAllText(${args[0]}, ${args[1]})`;
+      case 'ask': return `(Console.Write(${args[0] || '""'}), Console.ReadLine() ?? "").Item2`;
+      default: return null;
+    }
+  }
 }