naider 1.17.4 → 1.19.0

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

package/src/generator-kotlin.js

@@ -139,6 +139,8 @@ export class KotlinGenerator {
       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}`);
     }
@@ -1840,6 +1842,60 @@ export class KotlinGenerator {
     this.emit(`${a} = ${b}.also { ${b} = ${a} }`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    const keyword = node.isMut ? 'var' : 'val';
+    if (node.pattern === 'array') {
+      const names = node.names.filter(n => !n.rest).map(n => n.alias || n.name);
+      this.emit(`${keyword} (${names.join(', ')}) = ${val}`);
+    } 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 ? ` : ${node.parent}()` : '';
+    const initParams = node.init ? node.init.params.map(p => `${p.name}: Any`).join(', ') : '';
+    this.emit(`open class ${node.name}(${initParams})${ext} {`);
+    this.indent++;
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`var ${field.name} = ${this.expr(field.defaultValue)}`);
+      }
+    }
+    if (node.init) {
+      this.emit(`init {`);
+      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 => `${p.name}: Any`).join(', ');
+      this.emit(`fun ${method.name}(${params}): Any? {`);
+      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`;
@@ -1880,6 +1936,13 @@ export class KotlinGenerator {
       case 'read': return `java.io.File(${args[0]}).readText()`;
       case 'write': return `java.io.File(${args[0]}).writeText(${args[1]})`;
       case 'ask': return `(print(${args[0] || '""'}); readLine() ?: "")`;
+      case 'map': return `${args[0]}.map { ${args[1]}(it) }`;
+      case 'filter': return `${args[0]}.filter { ${args[1]}(it) }`;
+      case 'reduce': return args.length >= 3 ? `${args[0]}.fold(${args[2]}) { acc, it -> ${args[1]}(acc, it) }` : `${args[0]}.reduce { acc, it -> ${args[1]}(acc, it) }`;
+      case 'find': return `${args[0]}.find { ${args[1]}(it) }`;
+      case 'every': return `${args[0]}.all { ${args[1]}(it) }`;
+      case 'some': return `${args[0]}.any { ${args[1]}(it) }`;
+      case 'foreach': return `${args[0]}.forEach { ${args[1]}(it) }`;
       default: return null;
     }
   }

package/src/generator-php.js

@@ -105,6 +105,8 @@ export class PhpGenerator {
       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} */`);
     }
@@ -1599,6 +1601,58 @@ export class PhpGenerator {
     this.emit(`[$${a.replace('$','')}, $${b.replace('$','')}] = [$${b.replace('$','')}, $${a.replace('$','')}];`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    if (node.pattern === 'array') {
+      const names = node.names.map(n => {
+        if (n.rest) return `...$${n.name}`;
+        return `$${n.alias || n.name}`;
+      });
+      this.emit(`[${names.join(', ')}] = ${val};`);
+    } else {
+      const parts = node.names.filter(n => !n.rest).map(n => {
+        const varName = n.alias || n.name;
+        return `'${n.name}' => $${varName}`;
+      });
+      this.emit(`[${parts.join(', ')}] = ${val};`);
+    }
+  }
+
+  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(`public $${field.name} = ${this.expr(field.defaultValue)};`);
+      }
+    }
+    if (node.init) {
+      const params = node.init.params.map(p => `$${p.name}`).join(', ');
+      this.emit(`public function __construct(${params}) {`);
+      this.indent++;
+      if (node.parent) this.emit('parent::__construct();');
+      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 => `$${p.name}`).join(', ');
+      this.emit(`public function ${method.name}(${params}) {`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('// empty');
+      } 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 `count(${args[0]})`;
@@ -1639,6 +1693,13 @@ export class PhpGenerator {
       case 'ask': return `readline(${args[0] || '""'})`;
       case 'chunk': return `array_chunk(${args[0]}, ${args[1]})`;
       case 'zip': return `array_map(null, ${args[0]}, ${args[1]})`;
+      case 'map': return `array_map(${args[1]}, ${args[0]})`;
+      case 'filter': return `array_values(array_filter(${args[0]}, ${args[1]}))`;
+      case 'reduce': return `array_reduce(${args[0]}, ${args[1]}, ${args[2] || 'null'})`;
+      case 'find': return `current(array_filter(${args[0]}, ${args[1]}))`;
+      case 'every': return `count(array_filter(${args[0]}, ${args[1]})) === count(${args[0]})`;
+      case 'some': return `count(array_filter(${args[0]}, ${args[1]})) > 0`;
+      case 'foreach': return `array_walk(${args[0]}, ${args[1]})`;
       default: return null;
     }
   }