naider 1.17.4 → 1.19.0

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

package/src/generator-rust.js

@@ -209,6 +209,8 @@ export class RustGenerator {
       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} */`);
     }
@@ -1911,6 +1913,71 @@ export class RustGenerator {
     this.emit(`std::mem::swap(&mut ${a}, &mut ${b});`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    const keyword = node.isMut ? 'let mut' : 'let';
+    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(`${keyword} (${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(`${keyword} ${varName} = ${val}.get("${n.name}").unwrap_or(&${this.expr(n.defaultValue)});`);
+          } else {
+            this.emit(`${keyword} ${varName} = ${val}["${n.name}"];`);
+          }
+        }
+      }
+    }
+  }
+
+  visitClassDecl(node) {
+    // Rust uses struct + impl
+    this.emit(`struct ${node.name} {`);
+    this.indent++;
+    for (const field of node.fields) {
+      this.emit(`${field.name}: Box<dyn std::any::Any>,`);
+    }
+    if (node.fields.length === 0) this.emit(`_marker: (),`);
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+    this.emit(`impl ${node.name} {`);
+    this.indent++;
+    if (node.init) {
+      const params = node.init.params.map(p => `${p.name}: impl std::any::Any`).join(', ');
+      this.emit(`fn new(${params}) -> Self {`);
+      this.indent++;
+      for (const stmt of node.init.body) this.visitStatement(stmt);
+      if (node.fields.length > 0) {
+        this.emit(`${node.name} { ${node.fields.map(f => f.name).join(', ')} }`);
+      } else {
+        this.emit(`${node.name} { _marker: () }`);
+      }
+      this.indent--;
+      this.emit(`}`);
+    }
+    for (const method of node.methods) {
+      const mutable = method.body.some(s => JSON.stringify(s).includes('"Assignment"')) ? '&mut self' : '&self';
+      const params = method.params.length > 0 ? `, ${method.params.map(p => `${p.name}: impl std::any::Any`).join(', ')}` : '';
+      this.emit(`fn ${method.name}(${mutable}${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 `${args[0]}.len()`;
@@ -1942,6 +2009,13 @@ export class RustGenerator {
       case 'values': return `${args[0]}.values().cloned().collect::<Vec<_>>()`;
       case 'range': return args.length >= 2 ? `(${args[0]}..${args[1]}).collect::<Vec<_>>()` : `(0..${args[0]}).collect::<Vec<_>>()`;
       case 'flat': return `${args[0]}.into_iter().flatten().collect::<Vec<_>>()`;
+      case 'map': return `${args[0]}.iter().map(${args[1]}).collect::<Vec<_>>()`;
+      case 'filter': return `${args[0]}.iter().filter(${args[1]}).collect::<Vec<_>>()`;
+      case 'reduce': return `${args[0]}.iter().fold(${args[2] || '0'}, ${args[1]})`;
+      case 'find': return `${args[0]}.iter().find(${args[1]})`;
+      case 'every': return `${args[0]}.iter().all(${args[1]})`;
+      case 'some': return `${args[0]}.iter().any(${args[1]})`;
+      case 'foreach': return `${args[0]}.iter().for_each(${args[1]})`;
       default: return null;
     }
   }

package/src/generator-swift.js

@@ -141,6 +141,8 @@ export class SwiftGenerator {
       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}`);
     }
@@ -1758,6 +1760,64 @@ export class SwiftGenerator {
     this.emit(`swap(&${a}, &${b})`);
   }
 
+  visitDestructure(node) {
+    const val = this.expr(node.value);
+    const keyword = node.isMut ? 'var' : 'let';
+    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(`${keyword} (${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(`${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}` : '';
+    this.emit(`class ${node.name}${ext ? ' ' + ext : ''} {`);
+    this.indent++;
+    for (const field of node.fields) {
+      if (field.defaultValue) {
+        this.emit(`var ${field.name}: Any = ${this.expr(field.defaultValue)}`);
+      } else {
+        this.emit(`var ${field.name}: Any?`);
+      }
+    }
+    if (node.init) {
+      const params = node.init.params.map(p => `_ ${p.name}: Any`).join(', ');
+      this.emit(`init(${params}) {`);
+      this.indent++;
+      if (node.parent) this.emit('super.init()');
+      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(`func ${method.name}(${params}) -> Any? {`);
+      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.indent--;
+    this.emit('}');
+    this.emitRaw('');
+  }
+
   generateBuiltin(name, args) {
     switch (name) {
       case 'len': return `${args[0]}.count`;
@@ -1796,6 +1856,13 @@ export class SwiftGenerator {
       case 'random': return args.length >= 2 ? `Int.random(in: ${args[0]}...${args[1]})` : `Double.random(in: 0...1)`;
       case 'read': return `try! String(contentsOfFile: ${args[0]})`;
       case 'write': return `try! ${args[1]}.write(toFile: ${args[0]}, atomically: true, encoding: .utf8)`;
+      case 'map': return `${args[0]}.map { ${args[1]}($0) }`;
+      case 'filter': return `${args[0]}.filter { ${args[1]}($0) }`;
+      case 'reduce': return `${args[0]}.reduce(${args[2] || '0'}) { ${args[1]}($0, $1) }`;
+      case 'find': return `${args[0]}.first { ${args[1]}($0) }`;
+      case 'every': return `${args[0]}.allSatisfy { ${args[1]}($0) }`;
+      case 'some': return `${args[0]}.contains { ${args[1]}($0) }`;
+      case 'foreach': return `${args[0]}.forEach { ${args[1]}($0) }`;
       default: return null;
     }
   }

package/src/generator.js

@@ -94,6 +94,8 @@ export class Generator {
       case 'ReturnStatus': return this.visitReturnStatus(node);
       case 'ReturnMethod': return this.visitReturnMethod(node);
       case 'TypedVar': return this.visitTypedVar(node);
+      case 'Destructure': return this.visitDestructure(node);
+      case 'ClassDecl': return this.visitClassDecl(node);
       case 'If': return this.visitIf(node);
       case 'Each': return this.visitEach(node);
       case 'For': return this.visitFor(node);
@@ -244,6 +246,51 @@ export class Generator {
     this.emit(`${exp}${keyword} ${node.name} = ${this.expr(node.value)};`);
   }
 
+  visitDestructure(node) {
+    const keyword = node.isMut ? 'let' : 'const';
+    const parts = node.names.map(n => {
+      if (n.rest) return `...${n.name}`;
+      let s = n.name;
+      if (n.alias) s += `: ${n.alias}`;
+      if (n.defaultValue) s += ` = ${this.expr(n.defaultValue)}`;
+      return s;
+    });
+    const open = node.pattern === 'object' ? '{ ' : '[ ';
+    const close = node.pattern === 'object' ? ' }' : ' ]';
+    this.emit(`${keyword} ${open}${parts.join(', ')}${close} = ${this.expr(node.value)};`);
+  }
+
+  visitClassDecl(node) {
+    const ext = node.parent ? ` extends ${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(`constructor(${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 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(', ');
+      this.emit(`${async}${method.name}(${params}) {`);
+      this.indent++;
+      for (const stmt of method.body) this.visitStatement(stmt);
+      this.indent--;
+      this.emit('}');
+    }
+    this.indent--;
+    this.emit('}');
+  }
+
   visitAssignment(node) {
     const target = this.expr(node.target);
     const value = this.expr(node.value);
@@ -2464,6 +2511,13 @@ export class Generator {
       case 'now': return `Date.now()`;
       case 'time': return `new Date().toISOString()`;
       case 'chunk': return `Array.from({length: Math.ceil(${args[0]}.length / ${args[1]})}, (_, i) => ${args[0]}.slice(i * ${args[1]}, (i + 1) * ${args[1]}))`;
+      case 'map': return `${args[0]}.map(${args[1]})`;
+      case 'filter': return `${args[0]}.filter(${args[1]})`;
+      case 'reduce': return args[2] ? `${args[0]}.reduce(${args[1]}, ${args[2]})` : `${args[0]}.reduce(${args[1]})`;
+      case 'find': return `${args[0]}.find(${args[1]})`;
+      case 'every': return `${args[0]}.every(${args[1]})`;
+      case 'some': return `${args[0]}.some(${args[1]})`;
+      case 'foreach': return `${args[0]}.forEach(${args[1]})`;
       default: return null;
     }
   }

package/src/parser.js

@@ -468,6 +468,12 @@ export class Parser {
 
   parseTypedVariable() {
     const varType = this.advance().value;
+    if (this.at(T.LBRACE)) {
+      return this.parseDestructure(varType, false);
+    }
+    if (this.at(T.LBRACKET)) {
+      return this.parseDestructure(varType, false);
+    }
     const name = this.expectIdentLike();
     this.expect(T.ASSIGN);
     const value = this.parseExpression();
@@ -481,12 +487,47 @@ export class Parser {
       node.isMut = true;
       return node;
     }
+    if (this.at(T.LBRACE) || this.at(T.LBRACKET)) {
+      return this.parseDestructure(null, true);
+    }
     const name = this.expectIdentLike();
     this.expect(T.ASSIGN);
     const value = this.parseExpression();
     return new ASTNode('TypedVar', { varType: null, name, value, isMut: true });
   }
 
+  parseDestructure(varType, isMut) {
+    const pattern = this.at(T.LBRACE) ? 'object' : 'array';
+    this.advance(); // { or [
+    const names = [];
+    const endToken = pattern === 'object' ? T.RBRACE : T.RBRACKET;
+    while (!this.at(endToken) && !this.at(T.EOF)) {
+      this.skipWhitespace();
+      if (this.at(endToken)) break;
+      if (this.match(T.SPREAD)) {
+        const name = this.expectIdentLike();
+        names.push({ name, rest: true });
+      } else {
+        const name = this.expectIdentLike();
+        let alias = null;
+        if (this.match(T.COLON)) {
+          alias = this.expectIdentLike();
+        }
+        let defaultValue = null;
+        if (this.match(T.ASSIGN)) {
+          defaultValue = this.parseExpression();
+        }
+        names.push({ name, alias, defaultValue, rest: false });
+      }
+      this.match(T.COMMA);
+      this.skipWhitespace();
+    }
+    this.expect(endToken);
+    this.expect(T.ASSIGN);
+    const value = this.parseExpression();
+    return new ASTNode('Destructure', { pattern, names, value, varType, isMut });
+  }
+
   parseIf() {
     this.advance(); // if
     const condition = this.parseExpression();
@@ -1394,19 +1435,40 @@ export class Parser {
   parseSchema() {
     this.advance(); // schema
     const name = this.expect(T.IDENT).value;
+    let parent = null;
+    if (this.match(T.EXTENDS)) {
+      parent = this.expect(T.IDENT).value;
+    }
     this.expect(T.COLON);
     this.skipNewlines();
     this.expect(T.INDENT);
 
     const fields = [];
+    const methods = [];
+    let init = null;
     this.skipNewlines();
 
     while (!this.at(T.DEDENT) && !this.at(T.EOF)) {
-      fields.push(this.parseSchemaField());
+      if (this.at(T.FN) || this.at(T.FN_ASYNC)) {
+        methods.push(this.parseFunction(this.at(T.FN_ASYNC), false));
+      } else if (this.at(T.IDENT) && this.peek().value === 'init' && this.peek(1).type === T.LPAREN) {
+        this.advance(); // init
+        this.expect(T.LPAREN);
+        const params = this.parseFnParams();
+        this.expect(T.RPAREN);
+        this.expect(T.COLON);
+        const body = this.parseBlock();
+        init = { params, body };
+      } else {
+        fields.push(this.parseSchemaField());
+      }
       this.skipNewlines();
     }
     this.match(T.DEDENT);
 
+    if (parent || methods.length > 0 || init) {
+      return new ASTNode('ClassDecl', { name, parent, fields, methods, init });
+    }
     return new ASTNode('SchemaDecl', { name, fields });
   }
 

package/src/tokens.js

@@ -114,6 +114,10 @@ export const T = {
   SWAP: 'SWAP',
   IS: 'IS',
   ISNT: 'ISNT',
+  EXTENDS: 'EXTENDS',
+
+  // Types (auto)
+  TYPE_AUTO: 'TYPE_AUTO',
 
   // Operators
   ASSIGN: 'ASSIGN',
@@ -256,7 +260,9 @@ export const KEYWORDS = {
   'swap': T.SWAP,
   'is': T.IS,
   'isnt': T.ISNT,
+  'extends': T.EXTENDS,
   'print': T.LOG,
+  'auto': T.TYPE_AUTO,
   'true': T.BOOL,
   'false': T.BOOL,
   'null': T.NULL,
@@ -274,4 +280,5 @@ export const KEYWORDS = {
 export const TYPE_TOKENS = new Set([
   T.TYPE_STR, T.TYPE_INT, T.TYPE_NUM, T.TYPE_BOOL,
   T.TYPE_LIST, T.TYPE_MAP, T.TYPE_ANY, T.TYPE_JSON, T.TYPE_VOID,
+  T.TYPE_AUTO,
 ]);

package/vscode-naide/syntaxes/naide.tmLanguage.json

@@ -79,7 +79,7 @@
       "name": "storage.modifier.naide"
     },
     "types": {
-      "match": "\\b(str|int|num|bool|list|map|any|json|void)\\b",
+      "match": "\\b(str|int|num|bool|list|map|any|json|void|auto)\\b",
       "name": "support.type.naide"
     },
     "keywords-control": {
@@ -91,7 +91,7 @@
       "name": "keyword.other.naide"
     },
     "keywords-declaration": {
-      "match": "\\b(fn|fn\\.async|use|from|as|model|extends|schema|env|db|every|watch|test|assert|queue|job|new|enum|swap)\\b",
+      "match": "\\b(fn|fn\\.async|use|from|as|model|extends|schema|env|db|every|watch|test|assert|queue|job|new|enum|swap|init)\\b",
       "name": "keyword.declaration.naide"
     },
     "keywords-operator": {
@@ -129,7 +129,7 @@
           "name": "support.function.naide"
         },
         {
-          "match": "\\b(ask|sleep|exit|read|write|fetch_json|random|sort|reverse|unique|len|upper|lower|trim|split|join|contains|replace|keys|values|entries|range|abs|round|ceil|floor|sqrt|pow|sum|flat|zip|chunk|str|int|float|json_parse|json_str|now|time|print)\\b(?=\\s*[\\(])",
+          "match": "\\b(ask|sleep|exit|read|write|fetch_json|random|sort|reverse|unique|len|upper|lower|trim|split|join|contains|replace|keys|values|entries|range|abs|round|ceil|floor|sqrt|pow|sum|flat|zip|chunk|str|int|float|json_parse|json_str|now|time|print|map|filter|reduce|find|every|some|foreach)\\b(?=\\s*[\\(])",
           "name": "support.function.naide"
         }
       ]