naider 1.17.4 → 1.19.0

package/README.md

@@ -2,7 +2,7 @@
 
 **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 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.
+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. 40+ built-in functions, syntax sugar (`unless`, `until`, `repeat`, `swap`, `is`/`isnt`, one-line functions, `auto` type inference, destructuring, pipe operator), and 55+ built-in features including servers, databases, authentication, bots, GraphQL, gRPC, WebRTC, blockchain, and more.
 
 ### Compilation Targets
 
@@ -136,9 +136,29 @@ any data = null
 
 mut int counter = 0          # mutable (let)
 mut str label = "init"
+
+auto x = 42                  # type inferred (const)
+auto msg = "hello"           # compiler infers str
+mut auto counter2 = 0        # type inferred (let)
 ```
 
-Types: `str`, `int`, `num`, `bool`, `list`, `map`, `any`, `json`, `void`
+Types: `str`, `int`, `num`, `bool`, `list`, `map`, `any`, `json`, `void`, `auto` (inferred)
+
+### Destructuring
+
+```python
+# Object destructuring
+auto {name, age} = user
+auto {name, age = 0} = user          # with defaults
+auto {name, ...rest} = user          # with rest
+mut {score, level} = gameState       # mutable
+
+# Array destructuring
+auto [first, second] = items
+auto [head, ...tail] = items         # with rest
+auto [x, y = 0] = coords            # with defaults
+mut [a, b] = pair                    # mutable
+```
 
 ### String Interpolation
 
@@ -257,6 +277,28 @@ model Admin extends User:
     ret ["read", "write", "delete"]
 ```
 
+Schema inheritance with constructors and methods:
+
+```python
+schema Animal:
+  id       auto
+  name     str required
+  species  str required
+
+schema Dog extends Animal:
+  breed    str optional
+  trained  bool default(false)
+
+  init(str name, str breed):
+    self.name = name
+    self.breed = breed
+
+  fn bark() -> str:
+    ret "Woof! I'm {self.name}"
+```
+
+`init(params):` defines a constructor. `fn method():` defines methods. `extends` inherits all fields and methods from the parent.
+
 ### Pipe Operator
 
 ```python
@@ -264,8 +306,37 @@ list result = data
   |> filter((x) => x.active)
   |> map((x) => x.name)
   |> sort()
+
+int total = items
+  |> filter((x) => x > 0)
+  |> map((x) => x * 2)
+  |> reduce((a, b) => a + b, 0)
 ```
 
+Chain operations left to right for readable data transformations.
+
+### Optional Chaining & Null Coalescing
+
+```python
+str name = user?.name                    # safe property access
+any val = data?.nested?.value            # deep safe access
+str display = user?.name ?? "Anonymous"  # fallback on null/undefined
+int port = config?.port ?? 3000
+```
+
+`?.` safely accesses properties (returns `undefined` if the left side is `null`/`undefined`). `??` provides a fallback value when the left side is `null` or `undefined`.
+
+### Spread Operator
+
+```python
+list combined = [...listA, ...listB]
+map merged = {...defaults, ...overrides}
+list withExtra = [...items, 4, 5, 6]
+map withDebug = {...config, debug: true}
+```
+
+Spread arrays and objects with `...`. Works in list literals, map literals, and function arguments.
+
 ### Imports / Exports
 
 ```python
@@ -888,6 +959,15 @@ Variables become constants. Missing `required` vars exit with an error.
 ## Syntax Sugar (Simpler than Python)
 
 ```python
+# auto — type inference
+auto x = 42
+auto msg = "hello"
+mut auto counter = 0
+
+# destructuring
+auto {name, age} = user
+auto [first, ...rest] = items
+
 # unless — negated if
 unless x > 10:
   log "small"
@@ -918,6 +998,16 @@ if y isnt null: log "exists"
 # one-line functions
 fn double(int x) -> int = x * 2
 
+# pipe operator
+list result = items |> filter((x) => x > 0) |> map((x) => x * 2)
+
+# optional chaining + null coalescing
+str name = user?.name ?? "Anonymous"
+
+# spread
+list all = [...a, ...b]
+map merged = {...defaults, ...overrides}
+
 # print alias
 print "hello world"
 ```
@@ -955,6 +1045,15 @@ list flat_list = flat(nested)
 list zipped = zip(a, b)
 list chunks = chunk(items, 3)
 
+# Functional ops (map/filter/reduce)
+list doubled = map(items, (x) => x * 2)
+list big = filter(items, (x) => x > 5)
+int total = reduce(items, (a, b) => a + b, 0)
+any found = find(items, (x) => x > 3)
+bool allPos = every(items, (x) => x > 0)
+bool hasNeg = some(items, (x) => x < 0)
+foreach(items, (x) => log x)
+
 # Math
 num a = abs(-5)
 num r = round(3.7)

package/SPEC.naide

@@ -27,6 +27,26 @@ any data = null
 mut int counter = 0
 mut str label = "initial"
 
+# auto 型推論 (コンパイラが型を推論)
+auto x = 42                  # const x = 42
+auto msg = "hello"           # const msg = "hello"
+auto items = [1, 2, 3]       # const items = [1, 2, 3]
+mut auto counter2 = 0        # let counter2 = 0
+
+
+# ---- 分割代入 (Destructuring) ----
+# オブジェクト分割代入
+auto {name2, age} = user
+auto {name3, age2 = 0} = user         # デフォルト値
+auto {name4, ...rest} = user           # レスト
+mut {score, level} = gameState         # 可変
+
+# 配列分割代入
+auto [first, second] = items
+auto [head, ...tail] = items           # レスト
+auto [x2, y = 0] = coords             # デフォルト値
+mut [a3, b3] = pair                    # 可変
+
 
 # ---- 文字列補間 ----
 # ダブルクォートで {式} が自動展開
@@ -132,12 +152,29 @@ if err instanceof TypeError:
   log "type error occurred"
 
 
+# ---- map/filter/reduce ビルトイン ----
+# コレクション操作の組み込み関数
+list doubled = map(items, (x) => x * 2)
+list big = filter(items, (x) => x > 5)
+int total2 = reduce(items, (a, b) => a + b, 0)
+any found = find(items, (x) => x > 3)
+bool allBig = every(items, (x) => x > 0)
+bool hasBig = some(items, (x) => x > 10)
+foreach(items, (x) => log x)
+
+
 # ---- パイプ演算子 ----
 # データ変換チェーンが読みやすい
 list result = [1, 2, 3, 4, 5]
   |> filter((x) => x > 2)
   |> map((x) => x * 10)
 
+# パイプ + map/filter/reduce の組み合わせ
+list names = users
+  |> filter((u) => u.active)
+  |> map((u) => u.name)
+  |> sort()
+
 
 # ---- クラス (model) ----
 model User:
@@ -159,6 +196,25 @@ model Admin extends User:
     ret ["read", "write", "delete"]
 
 
+# ---- スキーマ継承 (schema extends) ----
+# schema も extends で継承可能
+schema Animal:
+  id       auto
+  name     str required
+  species  str required
+
+schema Dog extends Animal:
+  breed    str optional
+  trained  bool default(false)
+
+  init(str name, str breed):
+    self.name = name
+    self.breed = breed
+
+  fn bark() -> str:
+    ret "Woof! I'm {self.name}"
+
+
 # ---- データベース永続化 ----
 # db ディレクトリパス → スキーマストアがJSONファイルに自動保存
 db "data/"
@@ -436,7 +492,15 @@ pub str VERSION = "1.0.0"
 
 
 # ---- null安全 ----
+# オプショナルチェーニング (?.)
 any val = data?.nested?.value ?? "default"
+str userName = user?.name
+any first = items?.[0]
+any result2 = obj?.method?.()
+
+# Null合体演算子 (??)
+str displayName = user?.name ?? "Anonymous"
+int port = config?.port ?? 3000
 
 
 # ---- await.all (Promise.all) ----
@@ -446,6 +510,8 @@ any val = data?.nested?.value ?? "default"
 # ---- スプレッド ----
 list combined = [...items, 4, 5, 6]
 map merged = {...config, debug: true}
+list all = [...listA, ...listB]
+map full = {...defaults, ...overrides}
 
 
 # ---- ページ生成 (HTML) ----

package/lsp/server.js

@@ -107,7 +107,7 @@ function validateDocument(uri) {
       const line = lines[i].trim();
       if (!line || line.startsWith('#') || line.startsWith('--')) continue;
 
-      const typeMatch = line.match(/^(str|int|num|bool)\s+\w+\s*=\s*(.+)/);
+      const typeMatch = line.match(/^(str|int|num|bool|auto)\s+\w+\s*=\s*(.+)/);
       if (typeMatch) {
         const declType = typeMatch[1];
         const val = typeMatch[2].trim();
@@ -163,7 +163,7 @@ function indexSymbols(uri, text) {
       symbols.definitions.set(name, { line: i, col, kind: 'function' });
     }
 
-    const varMatch = trimmed.match(/^(?:pub\s+)?(?:mut\s+)?(?:str|int|num|bool|list|map|any|json|void)\s+(\w+)\s*=/);
+    const varMatch = trimmed.match(/^(?:pub\s+)?(?:mut\s+)?(?:str|int|num|bool|list|map|any|json|void|auto)\s+(\w+)\s*=/);
     if (varMatch) {
       const name = varMatch[1];
       const col = line.indexOf(name);
@@ -282,9 +282,9 @@ function getCompletions() {
     'try', 'fail', 'ensure', 'server', 'model', 'schema', 'use', 'pub', 'mut',
     'log', 'typeof', 'instanceof', 'not', 'and', 'or', 'break', 'continue',
     'throw', 'new', 'await', 'test', 'assert', 'queue', 'job', 'db', 'env',
-    'get', 'post', 'put', 'del', 'patch', 'every', 'watch',
+    'get', 'post', 'put', 'del', 'patch', 'every', 'watch', 'extends', 'init',
   ];
-  const types = ['str', 'int', 'num', 'bool', 'list', 'map', 'any', 'json', 'void'];
+  const types = ['str', 'int', 'num', 'bool', 'list', 'map', 'any', 'json', 'void', 'auto'];
   const features = [
     'cors', 'auth', 'crud', 'limit', 'cookie', 'session', 'static', 'ws', 'sse',
     'cache', 'view', 'upload', 'group', 'validate', 'openapi', 'error', 'mid', 'prompt',
@@ -355,6 +355,18 @@ function getCompletions() {
     { 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(' },
+    { label: 'map(list, fn)', detail: 'Transform each element', insertText: 'map(' },
+    { label: 'filter(list, fn)', detail: 'Filter elements by condition', insertText: 'filter(' },
+    { label: 'reduce(list, fn, init)', detail: 'Reduce list to single value', insertText: 'reduce(' },
+    { label: 'find(list, fn)', detail: 'Find first matching element', insertText: 'find(' },
+    { label: 'every(list, fn)', detail: 'Check if all match condition', insertText: 'every(' },
+    { label: 'some(list, fn)', detail: 'Check if any match condition', insertText: 'some(' },
+    { label: 'foreach(list, fn)', detail: 'Execute fn for each element', insertText: 'foreach(' },
+    { label: 'auto', detail: 'Type inference (compiler infers type)', insertText: 'auto ' },
+    { label: 'auto {a, b} = obj', detail: 'Object destructuring', insertText: 'auto {' },
+    { label: 'auto [a, b] = list', detail: 'Array destructuring', insertText: 'auto [' },
+    { label: 'extends', detail: 'Inherit from parent schema/model', insertText: 'extends ' },
+    { label: 'init(params):', detail: 'Constructor method', insertText: 'init(' },
   ];
 
   return [
@@ -409,6 +421,16 @@ const HOVER_DOCS = {
   '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```',
+  'auto': '**auto** — Type inference\n```naide\nauto x = 42          # compiler infers int\nauto msg = "hello"   # compiler infers str\nmut auto counter = 0 # mutable, type inferred\n```\nThe compiler infers the type from the assigned value. Emits `const` (or `let` with `mut`).',
+  'extends': '**extends** — Inherit from parent\n```naide\nschema Dog extends Animal:\n  breed str optional\n\nmodel Admin extends User:\n  str role = "admin"\n```\nInherits all fields and methods from the parent schema or model.',
+  'init': '**init** — Constructor method\n```naide\nschema Dog extends Animal:\n  init(str name, str breed):\n    self.name = name\n    self.breed = breed\n```\nDefines a constructor for schema/model classes.',
+  'map': '**map** — Transform each element\n```naide\nlist doubled = map(items, (x) => x * 2)\n```\nApplies a function to every element and returns a new list.',
+  'filter': '**filter** — Filter elements\n```naide\nlist big = filter(items, (x) => x > 5)\n```\nReturns a new list with only elements matching the condition.',
+  'reduce': '**reduce** — Reduce to single value\n```naide\nint total = reduce(items, (a, b) => a + b, 0)\n```\nAccumulates elements into a single value using a function and initial value.',
+  'find': '**find** — Find first match\n```naide\nany item = find(items, (x) => x > 3)\n```\nReturns the first element matching the condition, or `undefined`.',
+  'every': '**every** — Check all match\n```naide\nbool allPositive = every(items, (x) => x > 0)\n```\nReturns `true` if all elements match the condition.',
+  'some': '**some** — Check any match\n```naide\nbool hasNegative = some(items, (x) => x < 0)\n```\nReturns `true` if at least one element matches the condition.',
+  'foreach': '**foreach** — Iterate with side effects\n```naide\nforeach(items, (x) => log x)\n```\nExecutes a function for each element (no return value).',
 };
 
 function getHover(params) {

package/mcp/server.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+import { createInterface } from 'readline';
+import { resolve, dirname } from 'path';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+let compileModule = null;
+async function getCompiler() {
+  if (!compileModule) {
+    compileModule = await import(resolve(__dirname, '..', 'src', 'index.js'));
+  }
+  return compileModule;
+}
+
+function send(msg) {
+  const json = JSON.stringify(msg);
+  const buf = Buffer.from(json, 'utf-8');
+  process.stdout.write(`Content-Length: ${buf.length}\r\n\r\n`);
+  process.stdout.write(buf);
+}
+
+function respond(id, result) {
+  send({ jsonrpc: '2.0', id, result });
+}
+
+function respondError(id, code, message) {
+  send({ jsonrpc: '2.0', id, error: { code, message } });
+}
+
+const TOOLS = [
+  {
+    name: 'naide_compile',
+    description: 'Compile NAIDE code to a target language. NAIDE is an AI-optimized language that transpiles to 15 targets.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'NAIDE source code to compile' },
+        target: {
+          type: 'string',
+          description: 'Target language (default: node)',
+          enum: ['node', 'python', 'bun', 'typescript', 'go', 'java', 'rust', 'cpp', 'c', 'csharp', 'kotlin', 'swift', 'dart', 'php', 'ruby']
+        }
+      },
+      required: ['code']
+    }
+  },
+  {
+    name: 'naide_run',
+    description: 'Compile NAIDE code to JavaScript and execute it. Returns stdout output.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'NAIDE source code to run' }
+      },
+      required: ['code']
+    }
+  },
+  {
+    name: 'naide_targets',
+    description: 'List all available NAIDE compilation targets with details.',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'naide_spec',
+    description: 'Get the NAIDE language specification. Use this to understand NAIDE syntax before writing code.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        section: {
+          type: 'string',
+          description: 'Optional section to retrieve (e.g. "variables", "functions", "server"). Omit for full spec.'
+        }
+      }
+    }
+  }
+];
+
+const TARGETS_INFO = [
+  { name: 'node', language: 'JavaScript (ES Modules)', server: 'Express', flag: 'default' },
+  { name: 'python', language: 'Python', server: 'Flask', flag: '--target python' },
+  { name: 'bun', language: 'JavaScript (Bun)', server: 'Bun.serve', flag: '--target bun' },
+  { name: 'typescript', language: 'TypeScript', server: 'Express', flag: '--target ts' },
+  { name: 'go', language: 'Go', server: 'net/http', flag: '--target go' },
+  { name: 'java', language: 'Java', server: 'HttpServer', flag: '--target java' },
+  { name: 'rust', language: 'Rust', server: 'actix-web', flag: '--target rust' },
+  { name: 'cpp', language: 'C++', server: 'cpp-httplib', flag: '--target cpp' },
+  { name: 'c', language: 'C', server: 'libmicrohttpd', flag: '--target c' },
+  { name: 'csharp', language: 'C#', server: 'ASP.NET', flag: '--target csharp' },
+  { name: 'kotlin', language: 'Kotlin', server: 'Ktor', flag: '--target kotlin' },
+  { name: 'swift', language: 'Swift', server: 'Vapor', flag: '--target swift' },
+  { name: 'dart', language: 'Dart', server: 'shelf', flag: '--target dart' },
+  { name: 'php', language: 'PHP', server: 'Built-in / Laravel', flag: '--target php' },
+  { name: 'ruby', language: 'Ruby', server: 'Sinatra', flag: '--target ruby' },
+];
+
+async function handleToolCall(name, args) {
+  const { compile, compileAsync } = await getCompiler();
+
+  switch (name) {
+    case 'naide_compile': {
+      const target = args.target || 'node';
+      try {
+        if (target === 'node') {
+          const result = compile(args.code);
+          return { content: [{ type: 'text', text: result.js }] };
+        }
+        const result = await compileAsync(args.code, { target });
+        return { content: [{ type: 'text', text: result.code }] };
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Compilation error: ${e.message}` }], isError: true };
+      }
+    }
+
+    case 'naide_run': {
+      try {
+        const result = compile(args.code);
+        const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+        let output = '';
+        const fakeConsole = { log: (...a) => { output += a.map(String).join(' ') + '\n'; }, error: (...a) => { output += a.map(String).join(' ') + '\n'; } };
+        const fn = new AsyncFunction('console', result.js);
+        await fn(fakeConsole);
+        return { content: [{ type: 'text', text: output || '(no output)' }] };
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+      }
+    }
+
+    case 'naide_targets': {
+      const text = TARGETS_INFO.map(t => `${t.name.padEnd(12)} ${t.language.padEnd(25)} ${t.server.padEnd(20)} ${t.flag}`).join('\n');
+      return { content: [{ type: 'text', text: `NAIDE Compilation Targets (15):\n\n${'Target'.padEnd(12)} ${'Language'.padEnd(25)} ${'Server'.padEnd(20)} Flag\n${'─'.repeat(75)}\n${text}` }] };
+    }
+
+    case 'naide_spec': {
+      try {
+        let spec = readFileSync(resolve(__dirname, '..', 'SPEC.naide'), 'utf-8');
+        if (args.section) {
+          const s = args.section.toLowerCase();
+          const lines = spec.split('\n');
+          const chunks = [];
+          let capturing = false;
+          for (const line of lines) {
+            if (line.startsWith('# ---- ') && line.toLowerCase().includes(s)) capturing = true;
+            else if (line.startsWith('# ---- ') && capturing) break;
+            if (capturing) chunks.push(line);
+          }
+          if (chunks.length > 0) spec = chunks.join('\n');
+        }
+        return { content: [{ type: 'text', text: spec }] };
+      } catch (e) {
+        return { content: [{ type: 'text', text: `Error reading spec: ${e.message}` }], isError: true };
+      }
+    }
+
+    default:
+      return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+  }
+}
+
+async function handleMessage(msg) {
+  switch (msg.method) {
+    case 'initialize':
+      respond(msg.id, {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'naide-mcp', version: '1.18.0' }
+      });
+      break;
+
+    case 'notifications/initialized':
+      break;
+
+    case 'tools/list':
+      respond(msg.id, { tools: TOOLS });
+      break;
+
+    case 'tools/call':
+      try {
+        const result = await handleToolCall(msg.params.name, msg.params.arguments || {});
+        respond(msg.id, result);
+      } catch (e) {
+        respondError(msg.id, -32000, e.message);
+      }
+      break;
+
+    case 'ping':
+      respond(msg.id, {});
+      break;
+
+    default:
+      if (msg.id !== undefined) {
+        respondError(msg.id, -32601, `Method not found: ${msg.method}`);
+      }
+  }
+}
+
+let buffer = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk) => {
+  buffer += chunk;
+  while (true) {
+    const headerEnd = buffer.indexOf('\r\n\r\n');
+    if (headerEnd === -1) break;
+    const header = buffer.slice(0, headerEnd);
+    const match = header.match(/Content-Length:\s*(\d+)/i);
+    if (!match) { buffer = buffer.slice(headerEnd + 4); continue; }
+    const len = parseInt(match[1], 10);
+    const bodyStart = headerEnd + 4;
+    if (buffer.length < bodyStart + len) break;
+    const body = buffer.slice(bodyStart, bodyStart + len);
+    buffer = buffer.slice(bodyStart + len);
+    try {
+      handleMessage(JSON.parse(body));
+    } catch (e) {
+      process.stderr.write(`Parse error: ${e.message}\n`);
+    }
+  }
+});
+
+process.stderr.write('NAIDE MCP Server running on stdio\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naider",
-  "version": "1.17.4",
+  "version": "1.19.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": {
@@ -8,13 +8,15 @@
     "./runtime": "./src/runtime.js"
   },
   "bin": {
-    "naide": "bin/naide.js"
+    "naide": "bin/naide.js",
+    "naide-mcp": "mcp/server.js"
   },
   "type": "module",
   "files": [
     "bin/",
     "src/",
     "assets/",
+    "mcp/",
     "lsp/",
     "examples/",
     "vscode-naide/",

package/src/generator-c.js

@@ -187,6 +187,8 @@ export class CGenerator {
       case 'BlockchainDecl': return this.visitBlockchain(node);
       case 'EnumDecl': return this.visitEnum(node);
       case 'Swap': return this.visitSwap(node);
+      case 'Destructure': return this.visitDestructure(node);
+      case 'ClassDecl': return this.visitClassDecl(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -1000,6 +1002,62 @@ export class CGenerator {
     this.emit(`{ typeof(${a}) ${tmp} = ${a}; ${a} = ${b}; ${b} = ${tmp}; }`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    if (node.pattern === 'array') {
+      node.names.forEach((n, i) => {
+        if (!n.rest) {
+          const varName = n.alias || n.name;
+          this.emit(`auto ${varName} = ${val}[${i}];`);
+        }
+      });
+    } else {
+      for (const n of node.names) {
+        if (!n.rest) {
+          const varName = n.alias || n.name;
+          this.emit(`auto ${varName} = ${val}["${n.name}"];`);
+        }
+      }
+    }
+  }
+
+  visitClassDecl(node) {
+    this.emit(`/* C does not support classes; using struct + functions for ${node.name} */`);
+    this.emit(`typedef struct {`);
+    this.indent++;
+    for (const field of node.fields) {
+      this.emit(`void* ${field.name};`);
+    }
+    if (node.fields.length === 0) this.emit(`int __placeholder;`);
+    this.indent--;
+    this.emit(`} ${node.name};`);
+    this.emitRaw('');
+    if (node.init) {
+      const params = node.init.params.map(p => `void* ${p.name}`).join(', ');
+      this.emit(`${node.name} ${node.name}_create(${params || 'void'}) {`);
+      this.indent++;
+      this.emit(`${node.name} self;`);
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      this.emit(`return self;`);
+      this.indent--;
+      this.emit(`}`);
+      this.emitRaw('');
+    }
+    for (const method of node.methods) {
+      const params = [`${node.name}* self`, ...method.params.map(p => `void* ${p.name}`)].join(', ');
+      this.emit(`void* ${node.name}_${method.name}(${params}) {`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('return NULL;');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emit(`}`);
+      this.emitRaw('');
+    }
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `(sizeof(${args[0]}) / sizeof(${args[0]}[0]))`;
@@ -1018,6 +1076,13 @@ export class CGenerator {
       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()`; }
+      case 'map': return `/* C: map requires manual loop over ${args[0]} with ${args[1]} */`;
+      case 'filter': return `/* C: filter requires manual loop over ${args[0]} with ${args[1]} */`;
+      case 'reduce': return `/* C: reduce requires manual loop over ${args[0]} with ${args[1]} */`;
+      case 'find': return `/* C: find requires manual loop over ${args[0]} with ${args[1]} */`;
+      case 'every': return `/* C: every requires manual loop over ${args[0]} with ${args[1]} */`;
+      case 'some': return `/* C: some requires manual loop over ${args[0]} with ${args[1]} */`;
+      case 'foreach': return `for (int _i = 0; _i < sizeof(${args[0]})/sizeof(${args[0]}[0]); _i++) { ${args[1]}(${args[0]}[_i]); }`;
       default: return null;
     }
   }