naider 1.17.4 → 1.18.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naider",
-  "version": "1.17.4",
+  "version": "1.18.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": {

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;
     }
   }

package/src/generator-cpp.js

@@ -188,6 +188,8 @@ export class CppGenerator {
       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} */`);
     }
@@ -1233,6 +1235,75 @@ export class CppGenerator {
     this.emit(`std::swap(${a}, ${b});`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    if (node.pattern === 'array') {
+      if (node.names.every(n => !n.rest && !n.defaultValue)) {
+        this.includes.add('<tuple>');
+        const names = node.names.map(n => n.alias || n.name).join(', ');
+        this.emit(`auto [${names}] = ${val};`);
+      } else {
+        node.names.forEach((n, i) => {
+          if (!n.rest) {
+            const varName = n.alias || n.name;
+            if (n.defaultValue) {
+              this.emit(`auto ${varName} = (${i} < ${val}.size()) ? ${val}[${i}] : ${this.expr(n.defaultValue)};`);
+            } else {
+              this.emit(`auto ${varName} = ${val}[${i}];`);
+            }
+          }
+        });
+      }
+    } else {
+      for (const n of node.names) {
+        if (!n.rest) {
+          const varName = n.alias || n.name;
+          if (n.defaultValue) {
+            this.emit(`auto ${varName} = ${val}.count("${n.name}") ? ${val}["${n.name}"] : ${this.expr(n.defaultValue)};`);
+          } else {
+            this.emit(`auto ${varName} = ${val}["${n.name}"];`);
+          }
+        }
+      }
+    }
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? ` : public ${node.parent}` : '';
+    this.emit(`class ${node.name}${ext} {`);
+    this.emit(`public:`);
+    this.indent++;
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`auto ${field.name} = ${this.expr(field.defaultValue)};`);
+      }
+    }
+    if (node.init) {
+      const params = node.init.params.map(p => `auto ${p.name}`).join(', ');
+      this.emit(`${node.name}(${params}) {`);
+      this.indent++;
+      if (node.parent) this.emit(`${node.parent}();`);
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit('}');
+    }
+    for (const method of node.methods) {
+      const params = method.params.map(p => `auto ${p.name}`).join(', ');
+      this.emit(`auto ${method.name}(${params}) {`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('return 0;');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emit('}');
+    }
+    this.indent--;
+    this.emit('};');
+    this.emitRaw('');
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `${args[0]}.size()`;
@@ -1258,6 +1329,13 @@ export class CppGenerator {
       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); }())`;
+      case 'map': { this.includes.add('<algorithm>'); return `([&](){ auto _v = ${args[0]}; std::vector<decltype(${args[1]}(_v[0]))> _r; std::transform(_v.begin(), _v.end(), std::back_inserter(_r), ${args[1]}); return _r; }())`; }
+      case 'filter': { this.includes.add('<algorithm>'); return `([&](){ auto _v = ${args[0]}; decltype(_v) _r; std::copy_if(_v.begin(), _v.end(), std::back_inserter(_r), ${args[1]}); return _r; }())`; }
+      case 'reduce': { this.includes.add('<numeric>'); return `std::accumulate(${args[0]}.begin(), ${args[0]}.end(), ${args[2] || '0'}, ${args[1]})`; }
+      case 'find': { this.includes.add('<algorithm>'); return `(*std::find_if(${args[0]}.begin(), ${args[0]}.end(), ${args[1]}))`; }
+      case 'every': { this.includes.add('<algorithm>'); return `std::all_of(${args[0]}.begin(), ${args[0]}.end(), ${args[1]})`; }
+      case 'some': { this.includes.add('<algorithm>'); return `std::any_of(${args[0]}.begin(), ${args[0]}.end(), ${args[1]})`; }
+      case 'foreach': { this.includes.add('<algorithm>'); return `std::for_each(${args[0]}.begin(), ${args[0]}.end(), ${args[1]})`; }
       default: return null;
     }
   }

package/src/generator-csharp.js

@@ -180,6 +180,8 @@ export class CSharpGenerator {
       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}`);
     }
@@ -1654,6 +1656,65 @@ export class CSharpGenerator {
     this.emit(`(${a}, ${b}) = (${b}, ${a});`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    if (node.pattern === 'array') {
+      const names = node.names.filter(n => !n.rest).map(n => n.alias || n.name);
+      const indexedVals = names.map((name, i) => `${val}[${i}]`);
+      this.emit(`var (${names.join(', ')}) = (${indexedVals.join(', ')});`);
+    } else {
+      for (const n of node.names) {
+        if (!n.rest) {
+          const varName = n.alias || n.name;
+          if (n.defaultValue) {
+            this.emit(`var ${varName} = ${val}.ContainsKey("${n.name}") ? ${val}["${n.name}"] : ${this.expr(n.defaultValue)};`);
+          } else {
+            this.emit(`var ${varName} = ${val}["${n.name}"];`);
+          }
+        }
+      }
+    }
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? ` : ${node.parent}` : '';
+    this.emit(`class ${node.name}${ext} {`);
+    this.indent++;
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`public dynamic ${field.name} = ${this.expr(field.defaultValue)};`);
+      } else {
+        this.emit(`public dynamic ${field.name};`);
+      }
+    }
+    if (node.init) {
+      const params = node.init.params.map(p => `dynamic ${p.name}`).join(', ');
+      const baseCall = node.parent ? ' : base()' : '';
+      this.emit(`public ${node.name}(${params})${baseCall} {`);
+      this.indent++;
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit('}');
+    }
+    for (const method of node.methods) {
+      const params = method.params.map(p => `dynamic ${p.name}`).join(', ');
+      const asyncKw = method.isAsync ? 'async ' : '';
+      const returnType = method.isAsync ? 'async Task<dynamic>' : 'dynamic';
+      this.emit(`public ${returnType} ${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.indent--;
+    this.emit('}');
+    this.emitRaw('');
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `${args[0]}.Count`;
@@ -1694,6 +1755,13 @@ export class CSharpGenerator {
       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`;
+      case 'map': return `${args[0]}.Select(x => ${args[1]}(x)).ToList()`;
+      case 'filter': return `${args[0]}.Where(x => ${args[1]}(x)).ToList()`;
+      case 'reduce': return `${args[0]}.Aggregate(${args[2] || '0'}, (acc, x) => ${args[1]}(acc, x))`;
+      case 'find': return `${args[0]}.FirstOrDefault(x => ${args[1]}(x))`;
+      case 'every': return `${args[0]}.All(x => ${args[1]}(x))`;
+      case 'some': return `${args[0]}.Any(x => ${args[1]}(x))`;
+      case 'foreach': return `${args[0]}.ForEach(x => ${args[1]}(x))`;
       default: return null;
     }
   }