naider 1.17.2 → 1.18.0

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.2",
+  "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;
     }
   }

package/src/generator-dart.js

@@ -164,6 +164,8 @@ export class DartGenerator {
       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}`);
     }
@@ -1592,6 +1594,71 @@ export class DartGenerator {
     this.emit(`{ final _tmp = ${a}; ${a} = ${b}; ${b} = _tmp; }`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    const keyword = node.isMut ? 'var' : 'final';
+    if (node.pattern === 'array') {
+      node.names.forEach((n, i) => {
+        if (!n.rest) {
+          const varName = n.alias || n.name;
+          this.emit(`${keyword} ${varName} = ${val}[${i}];`);
+        } else {
+          this.emit(`${keyword} ${n.name} = ${val}.sublist(${i});`);
+        }
+      });
+    } else {
+      for (const n of node.names) {
+        if (!n.rest) {
+          const varName = n.alias || n.name;
+          if (n.defaultValue) {
+            this.emit(`${keyword} ${varName} = ${val}['${n.name}'] ?? ${this.expr(n.defaultValue)};`);
+          } else {
+            this.emit(`${keyword} ${varName} = ${val}['${n.name}'];`);
+          }
+        }
+      }
+    }
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? ` extends ${node.parent}` : '';
+    this.emit(`class ${node.name}${ext} {`);
+    this.indent++;
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`var ${field.name} = ${this.expr(field.defaultValue)};`);
+      } else {
+        this.emit(`dynamic ${field.name};`);
+      }
+    }
+    if (node.init) {
+      const params = node.init.params.map(p => `dynamic ${p.name}`).join(', ');
+      this.emit(`${node.name}(${params}) {`);
+      this.indent++;
+      if (node.parent) this.emit('super();');
+      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 ? 'Future<dynamic>' : 'dynamic';
+      this.emit(`${returnType} ${method.name}(${params}) ${asyncKw}{`);
+      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]}.length`;
@@ -1632,6 +1699,13 @@ export class DartGenerator {
       case 'read': { this.addImport('dart:io'); return `File(${args[0]}).readAsStringSync()`; }
       case 'write': { this.addImport('dart:io'); return `File(${args[0]}).writeAsStringSync(${args[1]})`; }
       case 'ask': { this.addImport('dart:io'); return `((){stdout.write(${args[0] || '""'}); return stdin.readLineSync() ?? "";}())`; }
+      case 'map': return `${args[0]}.map((e) => ${args[1]}(e)).toList()`;
+      case 'filter': return `${args[0]}.where((e) => ${args[1]}(e)).toList()`;
+      case 'reduce': return `${args[0]}.fold(${args[2] || 'null'}, (acc, e) => ${args[1]}(acc, e))`;
+      case 'find': return `${args[0]}.firstWhere((e) => ${args[1]}(e), orElse: () => null)`;
+      case 'every': return `${args[0]}.every((e) => ${args[1]}(e))`;
+      case 'some': return `${args[0]}.any((e) => ${args[1]}(e))`;
+      case 'foreach': return `${args[0]}.forEach((e) => ${args[1]}(e))`;
       default: return null;
     }
   }

package/src/generator-go.js

@@ -118,6 +118,8 @@ export class GoGenerator {
       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}`);
     }
@@ -1809,6 +1811,59 @@ export class GoGenerator {
     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(`${names.join(', ')} := ${indexedVals.join(', ')}`);
+    } else {
+      for (const n of node.names) {
+        if (!n.rest) {
+          const varName = n.alias || n.name;
+          this.emit(`${varName} := ${val}["${n.name}"]`);
+        }
+      }
+    }
+  }
+
+  visitClassDecl(node) {
+    // Go uses struct + methods
+    this.emit(`type ${node.name} struct {`);
+    this.indent++;
+    if (node.parent) this.emit(`${node.parent}`);
+    for (const field of node.fields) {
+      this.emit(`${field.name.charAt(0).toUpperCase() + field.name.slice(1)} interface{}`);
+    }
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+    if (node.init) {
+      const params = node.init.params.map(p => `${p.name} interface{}`).join(', ');
+      this.emit(`func New${node.name}(${params}) *${node.name} {`);
+      this.indent++;
+      this.emit(`self := &${node.name}{}`);
+      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 = method.params.map(p => `${p.name} interface{}`).join(', ');
+      this.emit(`func (self *${node.name}) ${method.name.charAt(0).toUpperCase() + method.name.slice(1)}(${params}) interface{} {`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('return nil');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emit(`}`);
+      this.emitRaw('');
+    }
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `len(${args[0]})`;
@@ -1837,6 +1892,13 @@ export class GoGenerator {
       case 'random': { this.addImport('math/rand'); return args.length >= 2 ? `rand.Intn(${args[1]}-${args[0]}+1)+${args[0]}` : `rand.Float64()`; }
       case 'sort': { this.addImport('sort'); return `func() []int { s := make([]int, len(${args[0]})); copy(s, ${args[0]}); sort.Ints(s); return s }()`; }
       case 'reverse': return `func() []interface{} { s := make([]interface{}, len(${args[0]})); copy(s, ${args[0]}); for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 { s[i], s[j] = s[j], s[i] }; return s }()`;
+      case 'map': return `func() []interface{} { _r := make([]interface{}, len(${args[0]})); for _i, _v := range ${args[0]} { _r[_i] = ${args[1]}(_v) }; return _r }()`;
+      case 'filter': return `func() []interface{} { var _r []interface{}; for _, _v := range ${args[0]} { if ${args[1]}(_v) { _r = append(_r, _v) } }; return _r }()`;
+      case 'reduce': return `func() interface{} { _acc := ${args[2] || '0'}; for _, _v := range ${args[0]} { _acc = ${args[1]}(_acc, _v) }; return _acc }()`;
+      case 'find': return `func() interface{} { for _, _v := range ${args[0]} { if ${args[1]}(_v) { return _v } }; return nil }()`;
+      case 'every': return `func() bool { for _, _v := range ${args[0]} { if !${args[1]}(_v) { return false } }; return true }()`;
+      case 'some': return `func() bool { for _, _v := range ${args[0]} { if ${args[1]}(_v) { return true } }; return false }()`;
+      case 'foreach': return `func() { for _, _v := range ${args[0]} { ${args[1]}(_v) } }()`;
       default: return null;
     }
   }

package/src/generator-java.js

@@ -228,6 +228,8 @@ export class JavaGenerator {
       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} */`);
     }
@@ -1835,6 +1837,72 @@ export class JavaGenerator {
     this.emit(`{ var _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) {
+          this.emit(`var ${n.name} = ${val}.subList(${i}, ${val}.size());`);
+        } else {
+          const varName = n.alias || n.name;
+          if (n.defaultValue) {
+            this.emit(`var ${varName} = ${i} < ${val}.size() ? ${val}.get(${i}) : ${this.expr(n.defaultValue)};`);
+          } else {
+            this.emit(`var ${varName} = ${val}.get(${i});`);
+          }
+        }
+      });
+    } else {
+      for (const n of node.names) {
+        if (n.rest) {
+          this.emit(`var ${n.name} = new java.util.HashMap<>(${val}); ${node.names.filter(x => !x.rest).forEach(x => `${n.name}.remove(${JSON.stringify(x.name)})`)};`);
+        } else {
+          const varName = n.alias || n.name;
+          if (n.defaultValue) {
+            this.emit(`var ${varName} = ${val}.getOrDefault(${JSON.stringify(n.name)}, ${this.expr(n.defaultValue)});`);
+          } else {
+            this.emit(`var ${varName} = ${val}.get(${JSON.stringify(n.name)});`);
+          }
+        }
+      }
+    }
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? ` extends ${node.parent}` : '';
+    this.emit(`static class ${node.name}${ext} {`);
+    this.indent++;
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`Object ${field.name} = ${this.expr(field.defaultValue)};`);
+      }
+    }
+    if (node.init) {
+      const params = node.init.params.map(p => `Object ${p.name}`).join(', ');
+      this.emit(`${node.name}(${params}) {`);
+      this.indent++;
+      if (node.parent) this.emit('super();');
+      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 => `Object ${p.name}`).join(', ');
+      this.emit(`Object ${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]}.size()`;
@@ -1869,6 +1937,13 @@ export class JavaGenerator {
       case 'json_parse': return `new com.google.gson.Gson().fromJson(${args[0]}, Object.class)`;
       case 'json_str': return `new com.google.gson.Gson().toJson(${args[0]})`;
       case 'range': return args.length >= 2 ? `java.util.stream.IntStream.range(${args[0]}, ${args[1]}).boxed().collect(java.util.stream.Collectors.toList())` : `java.util.stream.IntStream.range(0, ${args[0]}).boxed().collect(java.util.stream.Collectors.toList())`;
+      case 'map': { this.addImport('java.util.stream.Collectors'); return `${args[0]}.stream().map(${args[1]}).collect(Collectors.toList())`; }
+      case 'filter': { this.addImport('java.util.stream.Collectors'); return `${args[0]}.stream().filter(${args[1]}).collect(Collectors.toList())`; }
+      case 'reduce': return args[2] ? `${args[0]}.stream().reduce(${args[2]}, ${args[1]})` : `${args[0]}.stream().reduce(${args[1]}).orElse(null)`;
+      case 'find': return `${args[0]}.stream().filter(${args[1]}).findFirst().orElse(null)`;
+      case 'every': return `${args[0]}.stream().allMatch(${args[1]})`;
+      case 'some': return `${args[0]}.stream().anyMatch(${args[1]})`;
+      case 'foreach': return `${args[0]}.forEach(${args[1]})`;
       default: return null;
     }
   }