Object Implementation Complete.

Author: manash

lexer/lexer.ts

@@ -130,6 +130,8 @@ export class Lexer {
             case '[': return Token.create(TOKEN.LBRACK);
 
             case ']': return Token.create(TOKEN.RBRACK);
+
+            case ':': return Token.create(TOKEN.COLON);
 
             default: return this.handleDefaultCase(ch);
         }

lexer/token.ts

@@ -31,6 +31,7 @@ export enum TOKEN {
     ELSE = "else",
     RETURN = "return",
     NULL = "NULL",
+    COLON = ":"
 }
 
 const keywords: Map<string, TOKEN> = new Map<string, TOKEN>();
@@ -109,6 +110,7 @@ export const TokenFactory = {
     BANG: Token.create(TOKEN.BANG),
     COMMA: Token.create(TOKEN.COMMA),
     SEMICOLON: Token.create(TOKEN.SEMICOLON),
+    COLON: Token.create(TOKEN.COLON),
     FUNCTION: Token.create(TOKEN.FUNCTION),
     LET: Token.create(TOKEN.LET),
     TRUE: Token.create(TOKEN.TRUE),

parser/exprs/expr.ts

@@ -19,12 +19,12 @@ function argParsers(start: TOKEN, parsingFn : Function, end: TOKEN) {
             return args;
         }
 
-        while (p.nextTokenIs(TOKEN.COMMA)) {
+        args.push(parsingFn(p));
+        while (p.curTokenIs(TOKEN.COMMA)) {
+            p.readToken();
             const iden = parsingFn(p)
             args.push(iden);
-            p.readToken();
         }
-        args.push(parsingFn(p));
         p.readExpectedToken(end, `Incorrect Function Expression, Missing ${end} for ${start}`);
         return args;
     }

parser/exprs/hashes.ts

@@ -1,17 +1,16 @@
 import {TOKEN} from "../../lexer/token";
 import {Parser} from "../parser";
 import {Expr} from "./expr";
-import {Identifier} from "./identifier";
 import {PRECEDENCE} from "./precedence";
 
 
 export class Hash implements Expr {
-    map: Map<string, Expr>;
+    map: Map<Expr, Expr>;
     isApplicable(token: TOKEN): boolean {
         return token === TOKEN.LBRACE;
     }
     parse(p: Parser): Expr {
-        const mp = new Map<string, Expr>();
+        const mp = new Map<Expr, Expr>();
         p.readExpectedToken(TOKEN.LBRACE);
         if (p.nextTokenIs(TOKEN.RBRACE)) {
             return Hash.empty();
@@ -25,24 +24,24 @@ export class Hash implements Expr {
         return Hash.create(mp);
     }
 
-    parseEntry(p: Parser, mp: Map<string, Expr>): void {
-        const name = new Identifier().parse(p).toString();
-        p.readExpectedToken(TOKEN.ASSIGN);
+    parseEntry(p: Parser, mp: Map<Expr, Expr>): void {
+        const name = p.parseExpr(PRECEDENCE.LOWEST);
+        p.readExpectedToken(TOKEN.COLON);
         const val = p.parseExpr(PRECEDENCE.LOWEST);
         if (mp.has(name)) {
             throw Error(`${name} is already declared in the object`);
         }
         mp.set(name, val);
     }
 
-    static create(mp: Map<string, Expr>) {
+    static create(mp: Map<Expr, Expr>) {
         const h = new Hash();
         h.map = mp;
         return h;
     }
 
     static empty(): Expr {
-        const mp = new Map<string, Expr>();
+        const mp = new Map<Expr, Expr>();
         const h = new Hash();
         h.map = mp;
         return h;
@@ -62,9 +61,9 @@ export class Hash implements Expr {
     }
 
     eval() {
-        const mp: Map<string, any> = new Map<string, any>();
+        const mp: Map<any, any> = new Map<any, any>();
         for(const [k, v] of this.map.entries()) {
-            mp.set(k, v.eval());
+            mp.set(k.eval(), v.eval());
         }
         return mp;
     }

parser/exprs/indexExpr.ts

@@ -16,9 +16,9 @@ export class IndexExpr implements Expr {
         return IndexExpr.create(left, right);
     }
 
-    static create(left: Expr, right: any): Expr {
+    static create(left: Expr, right: Expr): Expr {
         const ex = new IndexExpr();
-        ex.left =left;
+        ex.left = left;
         ex.right = right;
         return ex;
     }
@@ -29,9 +29,23 @@ export class IndexExpr implements Expr {
     eval() {
         const left = this.left.eval();
         const right = this.right.eval();
-        if (!Array.isArray(left)) {
-            throw new Error(`${this.left.toString()} is not an array`);
+        if (Array.isArray(left)) {
+            return this.evalArrayIndex(right, left);
         }
+        if (left instanceof Map) {
+            return this.evalHashIndex(left, right);
+        }
+        throw new Error(this.left.toString() + ' is not an element to be indexed');
+    }
+
+    evalHashIndex(left: Map<any, any>, right: any) {
+        if (!left.has(right)) {
+            return null;
+        }
+        return left.get(right)!;
+    }
+
+    private evalArrayIndex(right: any, left: any[]) {
         if (!Number.isInteger(right)) {
             throw new Error(`${this.right.toString()} doesn't evaluate to an integer for an index`);
         }

tests/eval/evaluator.test.ts

@@ -177,5 +177,28 @@ describe("Evaluation Queries", () => {
             testInput(inp, exp);
         });
     });
+
+    describe('7. Objects', () => {
+        test('1. Evaluation', () => {
+            const inp = `let name = 'hi'; let obj = { name : 'Yo' }; obj['hi'];`
+            const exp = 'Yo';
+            testInput(inp, exp);
+        });
+        test('2. Complex Evaluation', () => {
+            const inp =  `let two = "two";
+                let o = {
+                    "one": 10 - 9,
+                    two: 1 + 1,
+                    "thr" + "ee": 6 / 2,
+                    4: 4,
+                    true: 5,
+                    false: 6
+                }
+                return [o['one'], o[two], o['three'], o[4], o[true], o[false]];
+                `
+            const exp = [1, 2, 3, 4, 5, 6];
+            testInput(inp, exp);
+        });
+    });
 });
 

tests/parser/parser.test.ts

@@ -194,19 +194,21 @@ describe("Expression Statements", () => {
 
     describe('8. Objects', () => {
         test("a. Simple Objects", () => {
-            const inp = `{ name = 'blah', val = 1 }`;
-            const mp = new Map<string, any>();
-            mp.set('name', 'blah');
-            mp.set('val', 1);
-            const actual = Parser.create(inp).parse().eval();
-            expect(actual).toStrictEqual(mp);
+            const inp = `{ 'name' : 'blah', 'val' : 1 }`;
+            const actual = Parser.create(inp).parse().statements;
+            const mp = new Map<any, any>();
+            mp.set(StringExpr.create('name'), StringExpr.create('blah'));
+            mp.set(StringExpr.create('val'), Integer.create(1));
+            const exp = [
+               ExprStatement.create(Hash.create(mp))
+            ];
+            expect(actual).toStrictEqual(exp);
         });
     });
 
     describe('9. Functions', () => {
         test('a. Functions?', () => {
-            const inp = `add(a * b[2], b[1], 2 * [1, 2][1])`;
-            const ac = Parser.create(inp).parse().getString();
+            const inp = `add(a * b[2], b[1], 2 * [1, 2][1])`; const ac = Parser.create(inp).parse().getString();
             const exp = `add((a * (b[2])), (b[1]), (2 * ([1, 2][1])))`;
             expect(ac).toStrictEqual(exp);
         });