naider 1.17.4 → 1.18.0

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

package/src/generator-python.js

@@ -164,6 +164,8 @@ export class PythonGenerator {
       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}`);
     }
@@ -2494,6 +2496,83 @@ export class PythonGenerator {
     this.emit(`${a}, ${b} = ${b}, ${a}`);
   }
 
+  // ===== Destructure =====
+  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.name;
+      });
+      this.emit(`${names.join(', ')} = ${val}`);
+      // Handle defaults for array destructuring
+      for (const n of node.names) {
+        if (n.defaultValue && !n.rest) {
+          this.emit(`${n.name} = ${n.name} if ${n.name} is not None else ${this.expr(n.defaultValue)}`);
+        }
+      }
+    } else {
+      // object destructuring — per-field assignment
+      for (const n of node.names) {
+        if (n.rest) {
+          this.emit(`${n.name} = {k: v for k, v in ${val}.items() if k not in {${node.names.filter(x => !x.rest).map(x => JSON.stringify(x.name)).join(', ')}}}`);
+        } else {
+          const varName = n.alias || n.name;
+          if (n.defaultValue) {
+            this.emit(`${varName} = ${val}.get(${JSON.stringify(n.name)}, ${this.expr(n.defaultValue)})`);
+          } else {
+            this.emit(`${varName} = ${val}[${JSON.stringify(n.name)}]`);
+          }
+        }
+      }
+    }
+  }
+
+  // ===== ClassDecl =====
+  visitClassDecl(node) {
+    const ext = node.parent ? `(${node.parent})` : '';
+    this.emit(`class ${node.name}${ext}:`);
+    this.indent++;
+    if (node.init) {
+      const params = node.init.params.map(p => p.name).join(', ');
+      const selfParams = params ? `self, ${params}` : 'self';
+      this.emit(`def __init__(${selfParams}):`);
+      this.indent++;
+      if (node.parent) this.emit('super().__init__()');
+      if (node.init.body.length === 0 && !node.parent) {
+        this.emit('pass');
+      } else {
+        for (const stmt of node.init.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emitRaw('');
+    }
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`${field.name} = ${this.expr(field.defaultValue)}`);
+      }
+    }
+    for (const method of node.methods) {
+      const async = method.isAsync ? 'async ' : '';
+      const params = method.params.map(p => p.name).join(', ');
+      const selfParams = params ? `self, ${params}` : 'self';
+      this.emit(`${async}def ${method.name}(${selfParams}):`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('pass');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emitRaw('');
+    }
+    if (!node.init && node.fields.length === 0 && node.methods.length === 0) {
+      this.emit('pass');
+    }
+    this.indent--;
+    this.emitRaw('');
+  }
+
   // ===== Builtins =====
   generateBuiltin(name, args) {
     switch (name) {
@@ -2536,6 +2615,13 @@ export class PythonGenerator {
       case 'now': { this.addImport('time'); return `int(time.time() * 1000)`; }
       case 'time': { this.addFromImport('datetime', 'datetime'); return `datetime.now().isoformat()`; }
       case 'chunk': return `[${args[0]}[i:i+${args[1]}] for i in range(0, len(${args[0]}), ${args[1]})]`;
+      case 'map': return `list(map(${args[1]}, ${args[0]}))`;
+      case 'filter': return `list(filter(${args[1]}, ${args[0]}))`;
+      case 'reduce': { this.addFromImport('functools', 'reduce'); return args[2] ? `reduce(${args[1]}, ${args[0]}, ${args[2]})` : `reduce(${args[1]}, ${args[0]})`; }
+      case 'find': return `next((x for x in ${args[0]} if ${args[1]}(x)), None)`;
+      case 'every': return `all(${args[1]}(x) for x in ${args[0]})`;
+      case 'some': return `any(${args[1]}(x) for x in ${args[0]})`;
+      case 'foreach': return `[${args[1]}(x) for x in ${args[0]}]`;
       default: return null;
     }
   }

package/src/generator-ruby.js

@@ -113,6 +113,8 @@ export class RubyGenerator {
       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}`);
     }
@@ -1553,6 +1555,51 @@ export class RubyGenerator {
     this.emit(`${a}, ${b} = ${b}, ${a}`);
   }
 
+  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 keys = node.names.filter(n => !n.rest).map(n => `:${n.name}`);
+      const vars = node.names.filter(n => !n.rest).map(n => n.alias || n.name);
+      this.emit(`${vars.join(', ')} = ${val}.values_at(${keys.join(', ')})`);
+    }
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? ` < ${node.parent}` : '';
+    this.emit(`class ${node.name}${ext}`);
+    this.indent++;
+    if (node.init) {
+      const params = node.init.params.map(p => p.name).join(', ');
+      this.emit(`def initialize(${params})`);
+      this.indent++;
+      if (node.parent) this.emit('super()');
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit('end');
+    }
+    for (const method of node.methods) {
+      const params = method.params.map(p => p.name).join(', ');
+      this.emit(`def ${method.name}(${params})`);
+      this.indent++;
+      if (method.body.length === 0) {
+        this.emit('nil');
+      } else {
+        for (const stmt of method.body) this.visitStatement(stmt);
+      }
+      this.indent--;
+      this.emit('end');
+    }
+    this.indent--;
+    this.emit('end');
+    this.emitRaw('');
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `${args[0]}.length`;
@@ -1593,6 +1640,13 @@ export class RubyGenerator {
       case 'read': return `File.read(${args[0]})`;
       case 'write': return `File.write(${args[0]}, ${args[1]})`;
       case 'ask': return `(print(${args[0] || '""'}); gets.chomp)`;
+      case 'map': return `${args[0]}.map { |_x| ${args[1]}.call(_x) }`;
+      case 'filter': return `${args[0]}.select { |_x| ${args[1]}.call(_x) }`;
+      case 'reduce': return args.length >= 3 ? `${args[0]}.reduce(${args[2]}) { |_acc, _x| ${args[1]}.call(_acc, _x) }` : `${args[0]}.reduce { |_acc, _x| ${args[1]}.call(_acc, _x) }`;
+      case 'find': return `${args[0]}.find { |_x| ${args[1]}.call(_x) }`;
+      case 'every': return `${args[0]}.all? { |_x| ${args[1]}.call(_x) }`;
+      case 'some': return `${args[0]}.any? { |_x| ${args[1]}.call(_x) }`;
+      case 'foreach': return `${args[0]}.each { |_x| ${args[1]}.call(_x) }`;
       default: return null;
     }
   }