ga-lang 1.2.1 → 1.2.3

package/dist/src/ast.js

@@ -27,6 +27,19 @@ export class CallExpr {
         return visitor.visitCallExpr(this);
     }
 }
+export class BinaryExpr {
+    left;
+    operator;
+    right;
+    constructor(left, operator, right) {
+        this.left = left;
+        this.operator = operator;
+        this.right = right;
+    }
+    accept(visitor) {
+        return visitor.visitBinaryExpr(this);
+    }
+}
 export class PrintStmt {
     expression;
     constructor(expression) {
@@ -78,3 +91,12 @@ export class ExpressionStmt {
         return visitor.visitExpressionStmt(this);
     }
 }
+export class ReturnStmt {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    accept(visitor) {
+        return visitor.visitReturnStmt(this);
+    }
+}

package/dist/src/interpreter.js

@@ -1,4 +1,12 @@
-import { FunctionStmt } from './ast.js';
+import { BinaryExpr, FunctionStmt, ReturnStmt } from './ast.js';
+import { TokenKind } from './token.js';
+class ReturnValue extends Error {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+}
 export class Interpreter {
     environment = new Map();
     interpret(statements) {
@@ -14,7 +22,26 @@ export class Interpreter {
      */
     visitPrintStmt(stmt) {
         const value = this.evaluate(stmt.expression);
-        console.log(value);
+        console.log(this.toDevanagariString(value));
+    }
+    toDevanagariString(value) {
+        if (typeof value === 'number') {
+            return this.numberToDevanagari(value);
+        }
+        return String(value);
+    }
+    numberToDevanagari(num) {
+        const devanagariZero = 0x0966;
+        return num
+            .toString()
+            .split('')
+            .map((char) => {
+            if (char >= '0' && char <= '9') {
+                return String.fromCharCode(devanagariZero + parseInt(char));
+            }
+            return char;
+        })
+            .join('');
     }
     visitVarStmt(stmt) {
         const value = stmt.initializer !== null ? this.evaluate(stmt.initializer) : null;
@@ -31,12 +58,40 @@ export class Interpreter {
     visitExpressionStmt(stmt) {
         this.evaluate(stmt.expression);
     }
+    visitReturnStmt(stmt) {
+        const value = stmt.value !== null ? this.evaluate(stmt.value) : null;
+        throw new ReturnValue(value);
+    }
     visitLiteralExpr(expr) {
         if (typeof expr.value === 'string' && expr.value.startsWith('"')) {
             return expr.value.slice(1, -1);
         }
+        // Check if it's a Devanagari number and convert it
+        if (typeof expr.value === 'string' && this.isDevanagariNumber(expr.value)) {
+            return this.devanagariToNumber(expr.value);
+        }
         return expr.value;
     }
+    isDevanagariNumber(value) {
+        if (value.length === 0)
+            return false;
+        for (const char of value) {
+            const code = char.charCodeAt(0);
+            if (code < 0x0966 || code > 0x096f) {
+                return false;
+            }
+        }
+        return true;
+    }
+    devanagariToNumber(value) {
+        const devanagariZero = 0x0966;
+        let num = 0;
+        for (const char of value) {
+            const code = char.charCodeAt(0);
+            num = num * 10 + (code - devanagariZero);
+        }
+        return num;
+    }
     visitVariableExpr(expr) {
         const value = this.environment.get(expr.name.lexeme);
         if (value === undefined) {
@@ -64,13 +119,85 @@ export class Interpreter {
             this.environment.set(func.params[i].lexeme, value);
         }
         // Execute function body
-        for (const stmt of func.body) {
-            this.execute(stmt);
+        try {
+            for (const stmt of func.body) {
+                this.execute(stmt);
+            }
+        }
+        catch (returnValue) {
+            if (returnValue instanceof ReturnValue) {
+                // Restore previous environment before returning
+                this.environment = prevEnvironment;
+                return returnValue.value;
+            }
+            throw returnValue;
         }
         // Restore previous environment
         this.environment = prevEnvironment;
         return null;
     }
+    visitBinaryExpr(expr) {
+        const left = this.evaluate(expr.left);
+        const right = this.evaluate(expr.right);
+        // Convert Devanagari digits to regular numbers for arithmetic
+        const leftNum = this.toNumber(left);
+        const rightNum = this.toNumber(right);
+        switch (expr.operator.kind) {
+            case TokenKind.Plus:
+                // Handle string concatenation or numeric addition
+                if (typeof left === 'string' && typeof right === 'string') {
+                    return left + right;
+                }
+                return leftNum + rightNum;
+            case TokenKind.Minus:
+                return leftNum - rightNum;
+            case TokenKind.Star:
+                return leftNum * rightNum;
+            case TokenKind.Slash:
+                if (rightNum === 0) {
+                    throw new Error('Division by zero');
+                }
+                return leftNum / rightNum;
+            case TokenKind.Mod:
+                if (rightNum === 0) {
+                    throw new Error('Modulo by zero');
+                }
+                return leftNum % rightNum;
+            default:
+                throw new Error(`Unknown operator: ${expr.operator.kind}`);
+        }
+    }
+    toNumber(value) {
+        if (typeof value === 'number')
+            return value;
+        if (typeof value === 'string') {
+            // Check if it's a Devanagari number
+            const devanagariZero = '\u{0966}'.charCodeAt(0); // ०
+            let isDevanagari = true;
+            let num = 0;
+            for (const char of value) {
+                const code = char.charCodeAt(0);
+                if (code >= devanagariZero && code <= devanagariZero + 9) {
+                    num = num * 10 + (code - devanagariZero);
+                }
+                else if (char >= '0' && char <= '9') {
+                    isDevanagari = false;
+                }
+                else {
+                    throw new Error(`Cannot convert '${value}' to number`);
+                }
+            }
+            if (isDevanagari && value.length > 0)
+                return num;
+            // Otherwise try regular parsing
+            const parsed = parseFloat(value);
+            if (isNaN(parsed)) {
+                throw new Error(`Cannot convert '${value}' to number`);
+            }
+            return parsed;
+        }
+        throw new Error(`Cannot convert '${value}' to number`);
+    }
     /*
      * Evaluate an expression
      */

package/dist/src/parser.js

@@ -1,4 +1,4 @@
-import { CallExpr, ExpressionStmt, FunctionStmt, LiteralExpr, PrintStmt, VarStmt, VariableExpr } from './ast.js';
+import { BinaryExpr, CallExpr, ExpressionStmt, FunctionStmt, LiteralExpr, PrintStmt, ReturnStmt, VarStmt, VariableExpr } from './ast.js';
 import { TokenKind } from './token.js';
 export class Parser {
     tokens;
@@ -28,8 +28,19 @@ export class Parser {
         if (this.match(TokenKind.Function)) {
             return this.parseFunctionStmt();
         }
+        if (this.match(TokenKind.Return)) {
+            return this.parseReturnStmt();
+        }
         return this.parseExpressionStmt();
     }
+    parseReturnStmt() {
+        let value = null;
+        // Check if there's a value to return (not just "फिर्ता" alone)
+        if (!this.check(TokenKind.CloseCurly) && !this.isAtEnd()) {
+            value = this.parseExpression();
+        }
+        return new ReturnStmt(value);
+    }
     parseExpressionStmt() {
         const expr = this.parseExpression();
         return new ExpressionStmt(expr);
@@ -71,7 +82,25 @@ export class Parser {
         return statements;
     }
     parseExpression() {
-        return this.parseCall();
+        return this.parseAddition();
+    }
+    parseAddition() {
+        let expr = this.parseMultiplication();
+        while (this.match(TokenKind.Plus, TokenKind.Minus)) {
+            const operator = this.previous();
+            const right = this.parseMultiplication();
+            expr = new BinaryExpr(expr, operator, right);
+        }
+        return expr;
+    }
+    parseMultiplication() {
+        let expr = this.parseCall();
+        while (this.match(TokenKind.Star, TokenKind.Slash, TokenKind.Mod)) {
+            const operator = this.previous();
+            const right = this.parseCall();
+            expr = new BinaryExpr(expr, operator, right);
+        }
+        return expr;
     }
     parseCall() {
         let expr = this.parsePrimary();
@@ -99,6 +128,11 @@ export class Parser {
         if (this.match(TokenKind.Identifier)) {
             return new VariableExpr(this.previous());
         }
+        if (this.match(TokenKind.OpenParen)) {
+            const expr = this.parseExpression();
+            this.consume(TokenKind.CloseParen, "Expect ')' after expression");
+            return expr;
+        }
         throw this.error(this.peek(), 'Expression expected.');
     }
     match(...kinds) {

package/examples/init.ga

@@ -1,14 +1,6 @@
-कार्य सुरु () {
-    मानौ सन्देश = "सोच्छौ के मेरो बारे?"
-    मानौ एकदुइतिन = १२३
-    छाप(सन्देश)
-    छाप(एकदुइतिन)
+कार्य जोड (अ , आ) {
+  फिर्ता अ + आ 
 }
 
-कार्य जोड( अ, आ) {
- छाप(अ)
- छाप(आ)
-}
-
-सुरु()
-जोड(१,२)
+मानौ जम्मा = जोड(१, २)
+छाप(जम्मा)

package/package.json

@@ -1,12 +1,20 @@
 {
   "name": "ga-lang",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "An interpreted toy programming language",
   "type": "module",
   "main": "dist/main.js",
   "bin": {
     "ga": "./bin/ga.js"
   },
+  "scripts": {
+    "prettier:check": "prettier --check \"./**/*.{js,ts,json}\"",
+    "prettier:fix": "prettier --write \"./**/*.{js,ts,json}\"",
+    "clean": "rm -rf dist",
+    "build": "pnpm run clean && tsc",
+    "test": "pnpm run build && node --test ./dist/tests/**/*.js",
+    "ga": "pnpm run build && node dist/src/main.js"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bvsvntv/ga.git"
@@ -23,6 +31,7 @@
     "url": "https://github.com/bvsvntv/ga/issues"
   },
   "homepage": "https://github.com/bvsvntv/ga#readme",
+  "packageManager": "pnpm@10.25.0",
   "engines": {
     "node": ">=22.x.x",
     "pnpm": ">=10.x.x"
@@ -37,13 +46,5 @@
     "@types/node": "^25.0.3",
     "prettier": "^3.7.4",
     "typescript": "^5.9.3"
-  },
-  "scripts": {
-    "prettier:check": "prettier --check \"./**/*.{js,ts,json}\"",
-    "prettier:fix": "prettier --write \"./**/*.{js,ts,json}\"",
-    "clean": "rm -rf dist",
-    "build": "pnpm run clean && tsc",
-    "test": "pnpm run build && node --test ./dist/tests/**/*.js",
-    "ga": "pnpm run build && node dist/src/main.js"
   }
-}
+}

package/src/ast.ts

@@ -8,6 +8,7 @@ export interface ExprVisitor<T> {
   visitVariableExpr(expr: VariableExpr): T;
   visitLiteralExpr(expr: LiteralExpr): T;
   visitCallExpr(expr: CallExpr): T;
+  visitBinaryExpr(expr: BinaryExpr): T;
 }
 
 export interface Stmt {
@@ -20,6 +21,7 @@ export interface StmtVisitor<T> {
   visitFunctionStmt(stmt: FunctionStmt): T;
   visitBlockStmt(stmt: BlockStmt): T;
   visitExpressionStmt(stmt: ExpressionStmt): T;
+  visitReturnStmt(stmt: ReturnStmt): T;
 }
 
 export class VariableExpr implements Expr {
@@ -60,6 +62,22 @@ export class CallExpr implements Expr {
   }
 }
 
+export class BinaryExpr implements Expr {
+  left: Expr;
+  operator: Token;
+  right: Expr;
+
+  constructor(left: Expr, operator: Token, right: Expr) {
+    this.left = left;
+    this.operator = operator;
+    this.right = right;
+  }
+
+  accept<T>(visitor: ExprVisitor<T>): T {
+    return visitor.visitBinaryExpr(this);
+  }
+}
+
 export class PrintStmt implements Stmt {
   expression: Expr;
 
@@ -125,3 +143,15 @@ export class ExpressionStmt implements Stmt {
     return visitor.visitExpressionStmt(this);
   }
 }
+
+export class ReturnStmt implements Stmt {
+  value: Expr | null;
+
+  constructor(value: Expr | null) {
+    this.value = value;
+  }
+
+  accept<T>(visitor: StmtVisitor<T>): T {
+    return visitor.visitReturnStmt(this);
+  }
+}

package/src/interpreter.ts

@@ -1,5 +1,7 @@
 import {
+  BinaryExpr,
   FunctionStmt,
+  ReturnStmt,
   type BlockStmt,
   type CallExpr,
   type ExpressionStmt,
@@ -12,6 +14,15 @@ import {
   type VariableExpr,
   type VarStmt
 } from './ast.js';
+import { TokenKind } from './token.js';
+
+class ReturnValue extends Error {
+  value: any;
+  constructor(value: any) {
+    super();
+    this.value = value;
+  }
+}
 
 export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
   private environment: Map<string, any> = new Map();
@@ -31,7 +42,28 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
    */
   visitPrintStmt(stmt: PrintStmt): void {
     const value = this.evaluate(stmt.expression);
-    console.log(value);
+    console.log(this.toDevanagariString(value));
+  }
+
+  private toDevanagariString(value: any): string {
+    if (typeof value === 'number') {
+      return this.numberToDevanagari(value);
+    }
+    return String(value);
+  }
+
+  private numberToDevanagari(num: number): string {
+    const devanagariZero = 0x0966;
+    return num
+      .toString()
+      .split('')
+      .map((char) => {
+        if (char >= '0' && char <= '9') {
+          return String.fromCharCode(devanagariZero + parseInt(char));
+        }
+        return char;
+      })
+      .join('');
   }
 
   visitVarStmt(stmt: VarStmt): void {
@@ -54,14 +86,45 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
     this.evaluate(stmt.expression);
   }
 
+  visitReturnStmt(stmt: ReturnStmt): void {
+    const value = stmt.value !== null ? this.evaluate(stmt.value) : null;
+    throw new ReturnValue(value);
+  }
+
   visitLiteralExpr(expr: LiteralExpr): any {
     if (typeof expr.value === 'string' && expr.value.startsWith('"')) {
       return expr.value.slice(1, -1);
     }
 
+    // Check if it's a Devanagari number and convert it
+    if (typeof expr.value === 'string' && this.isDevanagariNumber(expr.value)) {
+      return this.devanagariToNumber(expr.value);
+    }
+
     return expr.value;
   }
 
+  private isDevanagariNumber(value: string): boolean {
+    if (value.length === 0) return false;
+    for (const char of value) {
+      const code = char.charCodeAt(0);
+      if (code < 0x0966 || code > 0x096f) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private devanagariToNumber(value: string): number {
+    const devanagariZero = 0x0966;
+    let num = 0;
+    for (const char of value) {
+      const code = char.charCodeAt(0);
+      num = num * 10 + (code - devanagariZero);
+    }
+    return num;
+  }
+
   visitVariableExpr(expr: VariableExpr): any {
     const value = this.environment.get(expr.name.lexeme);
     if (value === undefined) {
@@ -96,8 +159,17 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
     }
 
     // Execute function body
-    for (const stmt of func.body) {
-      this.execute(stmt);
+    try {
+      for (const stmt of func.body) {
+        this.execute(stmt);
+      }
+    } catch (returnValue) {
+      if (returnValue instanceof ReturnValue) {
+        // Restore previous environment before returning
+        this.environment = prevEnvironment;
+        return returnValue.value;
+      }
+      throw returnValue;
     }
 
     // Restore previous environment
@@ -106,6 +178,68 @@ export class Interpreter implements ExprVisitor<any>, StmtVisitor<void> {
     return null;
   }
 
+  visitBinaryExpr(expr: BinaryExpr): any {
+    const left = this.evaluate(expr.left);
+    const right = this.evaluate(expr.right);
+
+    // Convert Devanagari digits to regular numbers for arithmetic
+    const leftNum = this.toNumber(left);
+    const rightNum = this.toNumber(right);
+
+    switch (expr.operator.kind) {
+      case TokenKind.Plus:
+        // Handle string concatenation or numeric addition
+        if (typeof left === 'string' && typeof right === 'string') {
+          return left + right;
+        }
+        return leftNum + rightNum;
+      case TokenKind.Minus:
+        return leftNum - rightNum;
+      case TokenKind.Star:
+        return leftNum * rightNum;
+      case TokenKind.Slash:
+        if (rightNum === 0) {
+          throw new Error('Division by zero');
+        }
+        return leftNum / rightNum;
+      case TokenKind.Mod:
+        if (rightNum === 0) {
+          throw new Error('Modulo by zero');
+        }
+        return leftNum % rightNum;
+      default:
+        throw new Error(`Unknown operator: ${expr.operator.kind}`);
+    }
+  }
+
+  private toNumber(value: any): number {
+    if (typeof value === 'number') return value;
+    if (typeof value === 'string') {
+      // Check if it's a Devanagari number
+      const devanagariZero = '\u{0966}'.charCodeAt(0); // ०
+      let isDevanagari = true;
+      let num = 0;
+      for (const char of value) {
+        const code = char.charCodeAt(0);
+        if (code >= devanagariZero && code <= devanagariZero + 9) {
+          num = num * 10 + (code - devanagariZero);
+        } else if (char >= '0' && char <= '9') {
+          isDevanagari = false;
+        } else {
+          throw new Error(`Cannot convert '${value}' to number`);
+        }
+      }
+      if (isDevanagari && value.length > 0) return num;
+      // Otherwise try regular parsing
+      const parsed = parseFloat(value);
+      if (isNaN(parsed)) {
+        throw new Error(`Cannot convert '${value}' to number`);
+      }
+      return parsed;
+    }
+    throw new Error(`Cannot convert '${value}' to number`);
+  }
+
   /*
    * Evaluate an expression
    */

package/src/parser.ts

@@ -1,9 +1,11 @@
 import {
+  BinaryExpr,
   CallExpr,
   ExpressionStmt,
   FunctionStmt,
   LiteralExpr,
   PrintStmt,
+  ReturnStmt,
   VarStmt,
   VariableExpr,
   type Expr,
@@ -46,9 +48,22 @@ export class Parser {
       return this.parseFunctionStmt();
     }
 
+    if (this.match(TokenKind.Return)) {
+      return this.parseReturnStmt();
+    }
+
     return this.parseExpressionStmt();
   }
 
+  private parseReturnStmt(): ReturnStmt {
+    let value: Expr | null = null;
+    // Check if there's a value to return (not just "फिर्ता" alone)
+    if (!this.check(TokenKind.CloseCurly) && !this.isAtEnd()) {
+      value = this.parseExpression();
+    }
+    return new ReturnStmt(value);
+  }
+
   private parseExpressionStmt(): ExpressionStmt {
     const expr = this.parseExpression();
     return new ExpressionStmt(expr);
@@ -111,7 +126,31 @@ export class Parser {
   }
 
   private parseExpression(): Expr {
-    return this.parseCall();
+    return this.parseAddition();
+  }
+
+  private parseAddition(): Expr {
+    let expr = this.parseMultiplication();
+
+    while (this.match(TokenKind.Plus, TokenKind.Minus)) {
+      const operator = this.previous();
+      const right = this.parseMultiplication();
+      expr = new BinaryExpr(expr, operator, right);
+    }
+
+    return expr;
+  }
+
+  private parseMultiplication(): Expr {
+    let expr = this.parseCall();
+
+    while (this.match(TokenKind.Star, TokenKind.Slash, TokenKind.Mod)) {
+      const operator = this.previous();
+      const right = this.parseCall();
+      expr = new BinaryExpr(expr, operator, right);
+    }
+
+    return expr;
   }
 
   private parseCall(): Expr {
@@ -145,6 +184,12 @@ export class Parser {
       return new VariableExpr(this.previous());
     }
 
+    if (this.match(TokenKind.OpenParen)) {
+      const expr = this.parseExpression();
+      this.consume(TokenKind.CloseParen, "Expect ')' after expression");
+      return expr;
+    }
+
     throw this.error(this.peek(), 'Expression expected.');
   }
 

package/tests/interpreter.test.ts

@@ -0,0 +1,176 @@
+import test, { describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { Lexer } from '../src/lexer.js';
+import { Parser } from '../src/parser.js';
+import { Interpreter } from '../src/interpreter.js';
+
+describe('Interpreter', () => {
+  function runSource(source: string): string[] {
+    const lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser = new Parser(tokens);
+    const stmts = parser.parse();
+    const interpreter = new Interpreter();
+
+    const outputs: string[] = [];
+    const originalLog = console.log;
+    console.log = (...args: any[]) => {
+      outputs.push(args.join(' '));
+    };
+
+    try {
+      interpreter.interpret(stmts);
+    } finally {
+      console.log = originalLog;
+    }
+
+    return outputs;
+  }
+
+  test('evaluate addition with Devanagari numbers', () => {
+    const source = `मानौ क = ५ + ३
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate subtraction', () => {
+    const source = `मानौ क = १० - २
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate multiplication', () => {
+    const source = `मानौ क = ४ * २
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate division', () => {
+    const source = `मानौ क = १५ / ३
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '५');
+  });
+
+  test('evaluate modulo', () => {
+    const source = `मानौ क = १७ % ५
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२');
+  });
+
+  test('evaluate operator precedence', () => {
+    const source = `मानौ क = २ + ३ * ४
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '१४');
+  });
+
+  test('evaluate parentheses grouping', () => {
+    const source = `मानौ क = (२ + ३) * ४
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२०');
+  });
+
+  test('evaluate chained addition', () => {
+    const source = `मानौ क = १ + २ + ३
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '६');
+  });
+
+  test('evaluate mixed operations', () => {
+    const source = `मानौ क = १० - ३ * २ + ४
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '८');
+  });
+
+  test('evaluate division by zero throws error', () => {
+    const source = `मानौ क = १० / ०
+छाप(क)`;
+    assert.throws(() => {
+      runSource(source);
+    }, /Division by zero/);
+  });
+
+  test('evaluate modulo by zero throws error', () => {
+    const source = `मानौ क = १० % ०
+छाप(क)`;
+    assert.throws(() => {
+      runSource(source);
+    }, /Modulo by zero/);
+  });
+
+  test('evaluate complex expression', () => {
+    const source = `मानौ क = (५ + ५) * (३ - १)
+छाप(क)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२०');
+  });
+
+  test('evaluate multiple print statements', () => {
+    const source = `मानौ क = ५ + ५
+छाप(क)
+मानौ ख = क + ५
+छाप(ख)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 2);
+    assert.equal(outputs[0], '१०');
+    assert.equal(outputs[1], '१५');
+  });
+
+  test('print string literal', () => {
+    const source = `छाप("नमस्ते")`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], 'नमस्ते');
+  });
+
+  test('function returns value', () => {
+    const source = `कार्य जोड(क, ख) {
+  फिर्ता क + ख
+}
+मानौ परिणाम = जोड(२, ३)
+छाप(परिणाम)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '५');
+  });
+
+  test('function returns expression result', () => {
+    const source = `कार्य गुणा(क, ख) {
+  फिर्ता क * ख + १०
+}
+मानौ परिणाम = गुणा(३, ४)
+छाप(परिणाम)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], '२२');
+  });
+
+  test('function returns string', () => {
+    const source = `कार्य नमस्कार() {
+  फिर्ता "नमस्ते संसार"
+}
+मानौ सन्देश = नमस्कार()
+छाप(सन्देश)`;
+    const outputs = runSource(source);
+    assert.equal(outputs.length, 1);
+    assert.equal(outputs[0], 'नमस्ते संसार');
+  });
+});

package/tests/parser.test.ts

@@ -7,7 +7,8 @@ import {
   VarStmt,
   FunctionStmt,
   LiteralExpr,
-  VariableExpr
+  VariableExpr,
+  BinaryExpr
 } from '../src/ast.js';
 
 describe('Parser', () => {
@@ -128,4 +129,91 @@ describe('Parser', () => {
     assert.equal(funcStmt.params[1]!.lexeme, 'ब');
     assert.equal(funcStmt.body.length, 2);
   });
+
+  test('parse binary expression with addition', () => {
+    const source: string = `मानौ क = ५ + ३`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+    const binaryExpr = varStmt.initializer as BinaryExpr;
+    assert.ok(binaryExpr.left instanceof LiteralExpr);
+    assert.ok(binaryExpr.right instanceof LiteralExpr);
+  });
+
+  test('parse binary expression with operator precedence', () => {
+    const source: string = `मानौ क = २ + ३ * ४`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+    const binaryExpr = varStmt.initializer as BinaryExpr;
+    assert.ok(binaryExpr.left instanceof LiteralExpr);
+    assert.ok(binaryExpr.right instanceof BinaryExpr);
+  });
+
+  test('parse binary expression with parentheses', () => {
+    const source: string = `मानौ क = (२ + ३) * ४`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+    const binaryExpr = varStmt.initializer as BinaryExpr;
+    assert.ok(binaryExpr.left instanceof BinaryExpr);
+    assert.ok(binaryExpr.right instanceof LiteralExpr);
+  });
+
+  test('parse binary expression with subtraction', () => {
+    const source: string = `मानौ क = १० - ५`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+  });
+
+  test('parse binary expression with division', () => {
+    const source: string = `मानौ क = १५ / ३`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+  });
+
+  test('parse binary expression with modulo', () => {
+    const source: string = `मानौ क = १७ % ५`;
+    const lexer: Lexer = new Lexer(source.trim());
+    const tokens = lexer.readTokens();
+    const parser: Parser = new Parser(tokens);
+    const stmts = parser.parse();
+
+    assert.equal(stmts.length, 1);
+    assert.ok(stmts[0] instanceof VarStmt);
+    const varStmt = stmts[0] as VarStmt;
+    assert.ok(varStmt.initializer instanceof BinaryExpr);
+  });
 });