naider 1.15.0 → 1.16.0

package/README.md

@@ -1,8 +1,8 @@
 # NAIDE
 
-**Node AI Development Environment** — A programming language designed for AI-speed code generation that transpiles to **15 languages**.
+**Node AI Development Environment** — A programming language simpler than Python, designed for AI-speed code generation, that transpiles to **15 languages**.
 
-NAIDE is built on three principles: one way to write everything (zero ambiguity), keyword-driven intent (the first token decides meaning), and minimal token count (fewer tokens = faster AI generation). Write once, compile to any target. 47 built-in features including servers, databases, authentication, bots, GraphQL, gRPC, WebRTC, blockchain, and more.
+NAIDE is built on four principles: simpler than Python (built-in functions, syntax sugar, zero boilerplate), one way to write everything (zero ambiguity), keyword-driven intent (the first token decides meaning), and minimal token count (fewer tokens = faster AI generation). Write once, compile to any target. 35+ built-in functions, syntax sugar (`unless`, `until`, `repeat`, `swap`, `is`/`isnt`, one-line functions), and 47 built-in features including servers, databases, authentication, bots, GraphQL, gRPC, WebRTC, blockchain, and more.
 
 ### Compilation Targets
 
@@ -885,14 +885,97 @@ env:
 
 Variables become constants. Missing `required` vars exit with an error.
 
+## Syntax Sugar (Simpler than Python)
+
+```python
+# unless — negated if
+unless x > 10:
+  log "small"
+
+# until — negated while
+until done:
+  process()
+
+# repeat — simple counted loop
+repeat 5:
+  log "hi"
+repeat 10 as i:
+  log i
+
+# enum
+enum Color:
+  RED
+  GREEN
+  BLUE
+
+# swap
+swap a, b
+
+# is / isnt — readable equality
+if x is 5: log "five"
+if y isnt null: log "exists"
+
+# one-line functions
+fn double(int x) -> int = x * 2
+
+# print alias
+print "hello world"
+```
+
 ## Built-in Functions
 
 ```python
-str id = uuid()                          # UUID
-str hashed = hash("password")            # scrypt hash
-bool ok = verify("password", hashed)     # timing-safe verify
-str token = sign({id: 1})                # JWT (uses auth secret)
-str token = sign({id: 1}, "my-secret")   # JWT (explicit secret)
+# Security
+str id = uuid()
+str hashed = hash("password")
+bool ok = verify("password", hashed)
+str token = sign({id: 1})
+
+# Type conversions
+str s = str(42)
+int n = int("42")
+num f = float("3.14")
+
+# String ops
+str u = upper("hello")
+str l = lower("HELLO")
+str t = trim("  hi  ")
+list parts = split("a,b,c", ",")
+str joined = join(parts, "-")
+bool has = contains("hello", "ell")
+
+# Collection ops
+int length = len(items)
+list sorted = sort(items)
+list r = range(10)
+list k = keys(obj)
+list v = values(obj)
+list uniq = unique(items)
+list flat_list = flat(nested)
+list zipped = zip(a, b)
+list chunks = chunk(items, 3)
+
+# Math
+num a = abs(-5)
+num r = round(3.7)
+num s = sqrt(16)
+num p = pow(2, 10)
+num total = sum(nums)
+
+# JSON
+any data = json_parse('{"a":1}')
+str json = json_str(data)
+
+# I/O
+str answer = ask("Name?")
+str content = read("file.txt")
+write("out.txt", content)
+
+# Time & misc
+int ts = now()
+str t = time()
+sleep(1000)
+exit(0)
 ```
 
 Auto-imported from the runtime when used.

package/SPEC.naide

@@ -634,3 +634,105 @@ blockchain "eth":
   contract "0x1234abcd..."
   abi "contract-abi.json"
 # usage: eth.getBalance("0x..."), eth.getBlock(), eth.sendTx(wallet, to, "0.1")
+
+
+# ============================================
+# シンプルシンタックス (Pythonより簡単)
+# ============================================
+
+# ---- unless (ifの逆) ----
+unless x > 10:
+  log "xは10以下"
+
+# ---- until (whileの逆) ----
+mut int i = 0
+until i > 10:
+  i = i + 1
+
+# ---- repeat (簡単ループ) ----
+repeat 5:
+  log "hello"
+
+repeat 10 as i:
+  log i
+
+# ---- enum (列挙型) ----
+enum Color:
+  RED
+  GREEN
+  BLUE
+
+# インライン形式
+enum Status: ACTIVE, INACTIVE, PENDING
+
+# ---- swap (値の交換) ----
+mut int a = 1
+mut int b = 2
+swap a, b
+
+# ---- is / isnt (比較演算子) ----
+if x is 5:
+  log "xは5"
+if y isnt null:
+  log "yはnullじゃない"
+
+# ---- 一行関数 ----
+fn double(int x) -> int = x * 2
+fn greet(str name) -> str = "Hello, {name}!"
+
+# ---- print (logのエイリアス) ----
+print "hello world"
+
+# ---- ビルトイン関数 ----
+# 型変換
+str s = str(42)
+int n = int("42")
+num f = float("3.14")
+
+# 文字列操作
+str u = upper("hello")        # "HELLO"
+str l = lower("HELLO")        # "hello"
+str t = trim("  hi  ")        # "hi"
+list parts = split("a,b,c", ",")  # ["a","b","c"]
+str joined = join(parts, "-")     # "a-b-c"
+str replaced = replace("hello", "l", "r")  # "herro"
+bool has = contains("hello", "ell")  # true
+
+# コレクション操作
+int length = len(items)
+list sorted = sort(items)
+list reversed = reverse(items)
+list uniq = unique([1,1,2,3])  # [1,2,3]
+list k = keys(obj)
+list v = values(obj)
+list e = entries(obj)
+list r = range(10)             # [0,1,...,9]
+list chunks = chunk([1,2,3,4], 2)  # [[1,2],[3,4]]
+list zipped = zip([1,2], ["a","b"])
+list flattened = flat([[1,2],[3,4]])
+
+# 数学
+num a2 = abs(-5)
+num r2 = round(3.7)
+num c = ceil(3.1)
+num fl = floor(3.9)
+num sq = sqrt(16)
+num p = pow(2, 10)
+num total = sum([1,2,3])
+
+# JSON
+any data2 = json_parse('{"a":1}')
+str json = json_str(data2)
+
+# 時間
+int timestamp = now()
+str timestr = time()
+
+# I/O
+str content = read("file.txt")
+write("out.txt", content)
+str answer = ask("名前は？")
+
+# その他
+sleep(1000)
+exit(0)

package/lsp/server.js

@@ -291,6 +291,7 @@ function getCompletions() {
     'page', 'cli', 'mail', 'graphql', 'desktop', 'screen',
     'oauth', 'pay', 'storage', 'pdf', 'i18n', 'push', 'search', 'image',
     'csv', 'logging', 'migrate', 'grpc', 'webrtc', 'blockchain',
+    'unless', 'until', 'repeat', 'enum', 'swap', 'is', 'isnt', 'print',
   ];
   const builtins = [
     { label: 'uuid()', detail: 'Generate UUID v4', insertText: 'uuid()' },
@@ -315,6 +316,45 @@ function getCompletions() {
     { label: 'graphql "/path"', detail: 'GraphQL endpoint', insertText: 'graphql ' },
     { label: 'desktop name:', detail: 'Desktop app', insertText: 'desktop ' },
     { label: 'screen Name:', detail: 'Mobile screen', insertText: 'screen ' },
+    { label: 'len(list)', detail: 'Get length', insertText: 'len(' },
+    { label: 'sort(list)', detail: 'Sort a list', insertText: 'sort(' },
+    { label: 'reverse(list)', detail: 'Reverse a list', insertText: 'reverse(' },
+    { label: 'unique(list)', detail: 'Remove duplicates', insertText: 'unique(' },
+    { label: 'upper(str)', detail: 'Uppercase string', insertText: 'upper(' },
+    { label: 'lower(str)', detail: 'Lowercase string', insertText: 'lower(' },
+    { label: 'trim(str)', detail: 'Trim whitespace', insertText: 'trim(' },
+    { label: 'split(str, sep)', detail: 'Split string', insertText: 'split(' },
+    { label: 'join(list, sep)', detail: 'Join list to string', insertText: 'join(' },
+    { label: 'contains(list, item)', detail: 'Check if contains', insertText: 'contains(' },
+    { label: 'replace(str, old, new)', detail: 'Replace in string', insertText: 'replace(' },
+    { label: 'keys(map)', detail: 'Get map keys', insertText: 'keys(' },
+    { label: 'values(map)', detail: 'Get map values', insertText: 'values(' },
+    { label: 'entries(map)', detail: 'Get key-value pairs', insertText: 'entries(' },
+    { label: 'range(n)', detail: 'Generate 0..n-1', insertText: 'range(' },
+    { label: 'abs(num)', detail: 'Absolute value', insertText: 'abs(' },
+    { label: 'round(num)', detail: 'Round number', insertText: 'round(' },
+    { label: 'ceil(num)', detail: 'Round up', insertText: 'ceil(' },
+    { label: 'floor(num)', detail: 'Round down', insertText: 'floor(' },
+    { label: 'sqrt(num)', detail: 'Square root', insertText: 'sqrt(' },
+    { label: 'pow(base, exp)', detail: 'Power', insertText: 'pow(' },
+    { label: 'sum(list)', detail: 'Sum of list', insertText: 'sum(' },
+    { label: 'flat(list)', detail: 'Flatten nested list', insertText: 'flat(' },
+    { label: 'zip(a, b)', detail: 'Zip two lists', insertText: 'zip(' },
+    { label: 'chunk(list, n)', detail: 'Split into chunks', insertText: 'chunk(' },
+    { label: 'str(val)', detail: 'Convert to string', insertText: 'str(' },
+    { label: 'int(val)', detail: 'Convert to integer', insertText: 'int(' },
+    { label: 'float(val)', detail: 'Convert to float', insertText: 'float(' },
+    { label: 'json_parse(str)', detail: 'Parse JSON string', insertText: 'json_parse(' },
+    { label: 'json_str(val)', detail: 'Stringify to JSON', insertText: 'json_str(' },
+    { label: 'now()', detail: 'Current timestamp ms', insertText: 'now()' },
+    { label: 'time()', detail: 'Current ISO time', insertText: 'time()' },
+    { label: 'ask(prompt)', detail: 'Read user input', insertText: 'ask(' },
+    { label: 'sleep(ms)', detail: 'Wait milliseconds', insertText: 'sleep(' },
+    { label: 'exit(code)', detail: 'Exit process', insertText: 'exit(' },
+    { label: 'read(path)', detail: 'Read file contents', insertText: 'read(' },
+    { 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(' },
   ];
 
   return [
@@ -361,6 +401,14 @@ const HOVER_DOCS = {
   'grpc': '**grpc** — gRPC service\n```naide\ngrpc "users" port 50051:\n  rpc getUser(id) -> user\n  rpc createUser(data) -> user\n```',
   'webrtc': '**webrtc** — WebRTC signaling\n```naide\nwebrtc "video":\n  stun "stun:stun.l.google.com:19302"\n  on offer(data):\n    log "offer received"\n```',
   'blockchain': '**blockchain** — Blockchain/Web3\n```naide\nblockchain "eth":\n  network "ethereum"\n  provider env.ETH_RPC\n  contract "0x..."\n```\nUsage: `eth.getBalance(addr)`, `eth.getBlock()`',
+  'unless': '**unless** — Negated if (do X unless condition)\n```naide\nunless x > 10:\n  log "small"\n```',
+  'until': '**until** — Negated while (loop until condition)\n```naide\nuntil done:\n  process()\n```',
+  'repeat': '**repeat** — Simple counted loop\n```naide\nrepeat 5:\n  log "hi"\nrepeat 10 as i:\n  log i\n```',
+  'enum': '**enum** — Enumeration type\n```naide\nenum Color:\n  RED\n  GREEN\n  BLUE\n```\nInline: `enum Status: ACTIVE, INACTIVE`',
+  'swap': '**swap** — Swap two variables\n```naide\nswap a, b\n```',
+  '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```',
 };
 
 function getHover(params) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "naider",
-  "version": "1.15.0",
-  "description": "NAIDE - Node AI Development Environment. AI-specialized language transpiling to 15 targets: Node.js, Python, Bun, TypeScript, C, C++, Java, Go, Rust, PHP, Ruby, Kotlin, Swift, Dart, C#. Built-in server, auth, DB, AI/LLM, bots, GraphQL, gRPC, WebRTC, blockchain, and 47 more features.",
+  "version": "1.16.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": {
     ".": "./src/index.js",

package/src/generator-python.js

@@ -162,6 +162,8 @@ export class PythonGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`# unknown: ${node.type}`);
     }
@@ -1068,6 +1070,12 @@ export class PythonGenerator {
   generateCall(node) {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b !== null) return b;
+    }
+
     // Map common JS global functions to Python
     if (node.callee.type === 'Identifier') {
       const name = node.callee.name;
@@ -2466,4 +2474,69 @@ export class PythonGenerator {
     this.emit(`${name.replace(/\W/g, '_')} = ${name.charAt(0).toUpperCase() + name.slice(1).replace(/\W/g, '_')}()`);
     this.emitRaw('');
   }
+
+  // ===== Enum =====
+  visitEnum(node) {
+    this.addFromImport('enum', 'Enum');
+    this.emit(`class ${node.name}(Enum):`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`${v} = ${i}`);
+    });
+    this.indent--;
+    this.emitRaw('');
+  }
+
+  // ===== Swap =====
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`${a}, ${b} = ${b}, ${a}`);
+  }
+
+  // ===== Builtins =====
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'ask': return `input(${args[0] || '""'})`;
+      case 'sleep': { this.addImport('time'); return `time.sleep(${args[0]} / 1000)`; }
+      case 'exit': { this.addImport('sys'); return `sys.exit(${args[0] || '0'})`; }
+      case 'read': return `open(${args[0]}).read()`;
+      case 'write': return `open(${args[0]}, 'w').write(${args[1]})`;
+      case 'fetch_json': { this.addImport('requests'); return `requests.get(${args[0]}).json()`; }
+      case 'random': { this.addImport('random'); return args.length >= 2 ? `random.randint(${args[0]}, ${args[1]})` : `random.random()`; }
+      case 'sort': return `sorted(${args[0]})`;
+      case 'reverse': return `list(reversed(${args[0]}))`;
+      case 'unique': return `list(set(${args[0]}))`;
+      case 'len': return `len(${args[0]})`;
+      case 'upper': return `${args[0]}.upper()`;
+      case 'lower': return `${args[0]}.lower()`;
+      case 'trim': return `${args[0]}.strip()`;
+      case 'split': return `${args[0]}.split(${args[1] || ''})`;
+      case 'join': return `${args[1] || '","'}.join(${args[0]})`;
+      case 'contains': return `(${args[1]} in ${args[0]})`;
+      case 'replace': return `${args[0]}.replace(${args[1]}, ${args[2]})`;
+      case 'keys': return `list(${args[0]}.keys())`;
+      case 'values': return `list(${args[0]}.values())`;
+      case 'entries': return `list(${args[0]}.items())`;
+      case 'range': return args.length >= 2 ? `list(range(${args[0]}, ${args[1]}))` : `list(range(${args[0]}))`;
+      case 'abs': return `abs(${args[0]})`;
+      case 'round': return `round(${args[0]})`;
+      case 'ceil': { this.addImport('math'); return `math.ceil(${args[0]})`; }
+      case 'floor': { this.addImport('math'); return `math.floor(${args[0]})`; }
+      case 'sqrt': { this.addImport('math'); return `math.sqrt(${args[0]})`; }
+      case 'pow': return `${args[0]} ** ${args[1]}`;
+      case 'sum': return `sum(${args[0]})`;
+      case 'flat': return `[x for sub in ${args[0]} for x in sub]`;
+      case 'zip': return `list(zip(${args[0]}, ${args[1]}))`;
+      case 'str': return `str(${args[0]})`;
+      case 'int': return `int(${args[0]})`;
+      case 'float': return `float(${args[0]})`;
+      case 'json_parse': { this.addImport('json'); return `json.loads(${args[0]})`; }
+      case 'json_str': { this.addImport('json'); return `json.dumps(${args[0]})`; }
+      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]})]`;
+      default: return null;
+    }
+  }
 }

package/src/generator.js

@@ -162,6 +162,8 @@ export class Generator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -1724,6 +1726,12 @@ export class Generator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const args = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, args);
+      if (b !== null) return b;
+    }
+
     const AUTO_IMPORT = { 'hash': 'hash', 'verify': 'verify', 'uuid': 'uuid',
       'createMock': 'createMock', 'createSpy': 'createSpy',
       'registerPlugin': 'registerPlugin', 'usePlugin': 'usePlugin' };
@@ -2394,4 +2402,69 @@ export class Generator {
     this.emit(`};`);
     this.emitRaw('');
   }
+
+  // ===== Enum =====
+  visitEnum(node) {
+    this.emit(`const ${node.name} = Object.freeze({`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`${v}: ${i},`);
+    });
+    this.indent--;
+    this.emit(`});`);
+    this.emitRaw('');
+  }
+
+  // ===== Swap =====
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`[${a}, ${b}] = [${b}, ${a}];`);
+  }
+
+  // ===== Builtins =====
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'ask': return `await new Promise(__r => { const __rl = (await import('readline')).createInterface({input:process.stdin,output:process.stdout}); __rl.question(${args[0] || '""'}, __a => { __rl.close(); __r(__a); }); })`;
+      case 'sleep': return `await new Promise(__r => setTimeout(__r, ${args[0] || '0'}))`;
+      case 'exit': return `process.exit(${args[0] || '0'})`;
+      case 'read': return `(await import('fs')).readFileSync(${args[0]}, 'utf-8')`;
+      case 'write': return `(await import('fs')).writeFileSync(${args[0]}, ${args[1]})`;
+      case 'fetch_json': return `await fetch(${args[0]}).then(r => r.json())`;
+      case 'random': return args.length >= 2 ? `(Math.floor(Math.random() * (${args[1]} - ${args[0]} + 1)) + ${args[0]})` : `Math.random()`;
+      case 'sort': return `[...${args[0]}].sort()`;
+      case 'reverse': return `[...${args[0]}].reverse()`;
+      case 'unique': return `[...new Set(${args[0]})]`;
+      case 'len': return `${args[0]}.length`;
+      case 'upper': return `${args[0]}.toUpperCase()`;
+      case 'lower': return `${args[0]}.toLowerCase()`;
+      case 'trim': return `${args[0]}.trim()`;
+      case 'split': return `${args[0]}.split(${args[1] || '""'})`;
+      case 'join': return `${args[0]}.join(${args[1] || '","'})`;
+      case 'contains': return `${args[0]}.includes(${args[1]})`;
+      case 'replace': return `${args[0]}.replace(${args[1]}, ${args[2]})`;
+      case 'keys': return `Object.keys(${args[0]})`;
+      case 'values': return `Object.values(${args[0]})`;
+      case 'entries': return `Object.entries(${args[0]})`;
+      case 'range': return args.length >= 2 ? `Array.from({length: ${args[1]} - ${args[0]}}, (_, i) => i + ${args[0]})` : `Array.from({length: ${args[0]}}, (_, i) => i)`;
+      case 'abs': return `Math.abs(${args[0]})`;
+      case 'round': return `Math.round(${args[0]})`;
+      case 'ceil': return `Math.ceil(${args[0]})`;
+      case 'floor': return `Math.floor(${args[0]})`;
+      case 'sqrt': return `Math.sqrt(${args[0]})`;
+      case 'pow': return `Math.pow(${args[0]}, ${args[1]})`;
+      case 'sum': return `${args[0]}.reduce((a, b) => a + b, 0)`;
+      case 'flat': return `${args[0]}.flat()`;
+      case 'zip': return `${args[0]}.map((v, i) => [v, ${args[1]}[i]])`;
+      case 'str': return `String(${args[0]})`;
+      case 'int': return `parseInt(${args[0]})`;
+      case 'float': return `parseFloat(${args[0]})`;
+      case 'json_parse': return `JSON.parse(${args[0]})`;
+      case 'json_str': return `JSON.stringify(${args[0]})`;
+      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]}))`;
+      default: return null;
+    }
+  }
 }

package/src/parser.js

@@ -116,7 +116,9 @@ export class Parser {
       type === T.PDF || type === T.I18N ||
       type === T.PUSH || type === T.SEARCH || type === T.IMAGE ||
       type === T.CSV || type === T.LOGGING || type === T.MIGRATE ||
-      type === T.GRPC || type === T.WEBRTC || type === T.BLOCKCHAIN;
+      type === T.GRPC || type === T.WEBRTC || type === T.BLOCKCHAIN ||
+      type === T.UNLESS || type === T.UNTIL || type === T.REPEAT ||
+      type === T.ENUM_DECL || type === T.SWAP || type === T.IS || type === T.ISNT;
   }
 
   expectPropertyName() {
@@ -166,9 +168,14 @@ export class Parser {
       case T.PUB: return this.parsePub();
       case T.RET: return this.parseReturn();
       case T.IF: return this.parseIf();
+      case T.UNLESS: return this.parseUnless();
       case T.EACH: return this.parseEach();
       case T.FOR: return this.parseFor();
       case T.WHILE: return this.parseWhile();
+      case T.UNTIL: return this.parseUntil();
+      case T.REPEAT: return this.parseRepeat();
+      case T.ENUM_DECL: return this.parseEnum();
+      case T.SWAP: return this.parseSwap();
       case T.MATCH: return this.parseMatch();
       case T.TRY: return this.parseTry();
       case T.SERVER: return this.parseServer();
@@ -325,6 +332,11 @@ export class Parser {
       returnType = this.parseTypeAnnotation();
     }
 
+    if (this.match(T.ASSIGN)) {
+      const expr = this.parseExpression();
+      return new ASTNode('Function', { name, params, returnType, body: [new ASTNode('Return', { value: expr })], isAsync, isPublic });
+    }
+
     this.expect(T.COLON);
     const body = this.parseBlock();
 
@@ -1016,11 +1028,15 @@ export class Parser {
 
   parseComparison() {
     let left = this.parseAddition();
-    while (this.atAny(T.EQ, T.NEQ, T.GT, T.LT, T.GTE, T.LTE, T.INSTANCEOF)) {
+    while (this.atAny(T.EQ, T.NEQ, T.GT, T.LT, T.GTE, T.LTE, T.INSTANCEOF, T.IS, T.ISNT)) {
       const tok = this.advance();
       const right = this.parseAddition();
       if (tok.type === T.INSTANCEOF) {
         left = new ASTNode('Binary', { op: 'instanceof', left, right });
+      } else if (tok.type === T.IS) {
+        left = new ASTNode('Binary', { op: '===', left, right });
+      } else if (tok.type === T.ISNT) {
+        left = new ASTNode('Binary', { op: '!==', left, right });
       } else {
         left = new ASTNode('Binary', { op: tok.value === '==' ? '===' : tok.value === '!=' ? '!==' : tok.value, left, right });
       }
@@ -1171,6 +1187,8 @@ export class Parser {
       case T.PUSH: case T.SEARCH: case T.IMAGE:
       case T.CSV: case T.LOGGING: case T.MIGRATE:
       case T.GRPC: case T.WEBRTC: case T.BLOCKCHAIN:
+      case T.UNLESS: case T.UNTIL: case T.REPEAT:
+      case T.ENUM_DECL: case T.SWAP: case T.IS: case T.ISNT:
       case T.FROM: case T.AS: case T.IN:
         this.advance();
         return new ASTNode('Identifier', { name: tok.value });
@@ -1389,7 +1407,7 @@ export class Parser {
 
     if (TYPE_TOKENS.has(this.peek().type)) {
       fieldType = this.advance().value;
-    } else if (this.at(T.IDENT)) {
+    } else if (this.at(T.IDENT) || this.at(T.ENUM_DECL)) {
       fieldType = this.advance().value;
       if (fieldType === 'enum' && this.at(T.LPAREN)) {
         this.advance();
@@ -2357,4 +2375,82 @@ export class Parser {
     if (this.at(T.DEDENT)) this.advance();
     return new ASTNode('BlockchainDecl', { name, network, provider, contract, abi });
   }
+
+  // unless cond:  → desugars to if (!cond)
+  parseUnless() {
+    this.advance();
+    const condition = this.parseExpression();
+    this.expect(T.COLON);
+    const body = this.parseBlock();
+    return new ASTNode('If', {
+      condition: new ASTNode('Unary', { op: '!', expr: condition }),
+      elifs: [], elseBody: null, body
+    });
+  }
+
+  // until cond:  → desugars to while (!cond)
+  parseUntil() {
+    this.advance();
+    const condition = this.parseExpression();
+    this.expect(T.COLON);
+    const body = this.parseBlock();
+    return new ASTNode('While', {
+      condition: new ASTNode('Unary', { op: '!', expr: condition }),
+      body
+    });
+  }
+
+  // repeat 5:  or  repeat 5 as i:
+  parseRepeat() {
+    this.advance();
+    const count = this.parseExpression();
+    let varName = 'it';
+    if (this.peek().value === 'as') {
+      this.advance();
+      varName = this.advance().value;
+    }
+    this.expect(T.COLON);
+    const body = this.parseBlock();
+    return new ASTNode('For', {
+      varName,
+      start: new ASTNode('Number', { value: '0' }),
+      end: count,
+      body
+    });
+  }
+
+  // enum Color: red, green, blue
+  parseEnum() {
+    this.advance();
+    const name = this.advance().value;
+    this.expect(T.COLON);
+    const values = [];
+    if (this.at(T.INDENT) || this.at(T.NEWLINE)) {
+      this.skipNewlines();
+      this.expect(T.INDENT);
+      while (!this.at(T.DEDENT) && !this.at(T.EOF)) {
+        this.skipNewlines();
+        if (this.at(T.DEDENT) || this.at(T.EOF)) break;
+        values.push(this.advance().value);
+        this.match(T.COMMA);
+        this.skipNewlines();
+      }
+      if (this.at(T.DEDENT)) this.advance();
+    } else {
+      while (!this.at(T.NEWLINE) && !this.at(T.EOF)) {
+        values.push(this.advance().value);
+        this.match(T.COMMA);
+      }
+    }
+    return new ASTNode('EnumDecl', { name, values });
+  }
+
+  // swap a, b
+  parseSwap() {
+    this.advance();
+    const a = this.parseExpression();
+    this.expect(T.COMMA);
+    const b = this.parseExpression();
+    return new ASTNode('Swap', { a, b });
+  }
 }

package/src/tokens.js

@@ -107,6 +107,13 @@ export const T = {
   GRPC: 'GRPC',
   WEBRTC: 'WEBRTC',
   BLOCKCHAIN: 'BLOCKCHAIN',
+  UNLESS: 'UNLESS',
+  UNTIL: 'UNTIL',
+  REPEAT: 'REPEAT',
+  ENUM_DECL: 'ENUM_DECL',
+  SWAP: 'SWAP',
+  IS: 'IS',
+  ISNT: 'ISNT',
 
   // Operators
   ASSIGN: 'ASSIGN',
@@ -242,6 +249,14 @@ export const KEYWORDS = {
   'grpc': T.GRPC,
   'webrtc': T.WEBRTC,
   'blockchain': T.BLOCKCHAIN,
+  'unless': T.UNLESS,
+  'until': T.UNTIL,
+  'repeat': T.REPEAT,
+  'enum': T.ENUM_DECL,
+  'swap': T.SWAP,
+  'is': T.IS,
+  'isnt': T.ISNT,
+  'print': T.LOG,
   'true': T.BOOL,
   'false': T.BOOL,
   'null': T.NULL,

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

@@ -83,7 +83,7 @@
       "name": "support.type.naide"
     },
     "keywords-control": {
-      "match": "\\b(if|elif|else|each|for|while|in|match|try|fail|ensure|ret|break|continue|throw|then|not|and|or|typeof|instanceof)\\b",
+      "match": "\\b(if|elif|else|each|for|while|in|match|try|fail|ensure|ret|break|continue|throw|then|not|and|or|typeof|instanceof|unless|until|repeat|is|isnt)\\b",
       "name": "keyword.control.naide"
     },
     "keywords-server": {
@@ -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)\\b",
+      "match": "\\b(fn|fn\\.async|use|from|as|model|extends|schema|env|db|every|watch|test|assert|queue|job|new|enum|swap)\\b",
       "name": "keyword.declaration.naide"
     },
     "keywords-operator": {
@@ -127,6 +127,10 @@
         {
           "match": "\\b(send|broadcast|next)\\b(?=\\s*\\()",
           "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*[\\(])",
+          "name": "support.function.naide"
         }
       ]
     },