Merge pull request #2 from anirudhgray/implement-hashmap

Implement hashmap
anirudhgray · Oct 27, 2024 · 2bc2886 · 2bc2886
2 parents f179d4d + 7b39fab
commit 2bc2886
Show file tree

Hide file tree

Showing 8 changed files with 89 additions and 13 deletions.
diff --git a/README.md b/README.md
@@ -42,6 +42,7 @@ print percentage(20, 28);
       - [Contracts (Preconditions, Postconditions and Assertions)](#contracts-preconditions-postconditions-and-assertions)
       - [Unit Tests](#unit-tests)
     - [Arrays](#arrays)
+    - [Maps](#maps)
     - [Conditionals](#conditionals)
     - [Loops](#loops)
     - [Built-in Functions](#built-in-functions)
@@ -60,7 +61,7 @@ Tahini currently implements:
 - [x] **Conditionals**: If-else statements for decision-making.
 - [x] **Functions**: First class citizens of Tahini. Define and call reusable blocks of code, with support for contracts (`precondition`, `postcondition`, and `assertion`).
 - [ ] **Classes**: Object-oriented features to group variables and methods (halted in favour of a lean towards a functional paradigm).
-- [ ] **Advanced Data Structures**: Support for lists, maps, and other data structures (in progress).
+- [x] **Advanced Data Structures**: Basic support for lists, maps, and other data structures.
 - [ ] **Error Handling**: Support for user-defined exceptions and error handling (in progress).
 - [x] **Stack Traces**: Detailed error messages with line numbers and function names.
 - [x] **Unit Tests**: Write test blocks directly in the source file to validate code correctness.
@@ -317,6 +318,15 @@ fun remove(arr, index) {
 }
 ```
 
+### Maps
+
+Maps are implemented as a HashMap. You can create a map via `{...}` syntax, and access elements using the `[]` operator. Maps can contain any object keys or values.
+
+```
+var map = {"key": "value", 1: 2, "fib": fib};
+print map["key"]; // value
+```
+
 ### Conditionals
 
 ```

diff --git a/tahini/app/src/main/java/com/tahini/lang/Expr.java b/tahini/app/src/main/java/com/tahini/lang/Expr.java
@@ -16,6 +16,7 @@ interface Visitor<R> {
     R visitVariableExpr(Variable expr);
     R visitLogicalExpr(Logical expr);
     R visitTahiniListExpr(TahiniList expr);
+    R visitTahiniMapExpr(TahiniMap expr);
   }
   static class Assign extends Expr {
     Assign(Token name, Expr value) {
@@ -191,6 +192,20 @@ <R> R accept(Visitor<R> visitor) {
 
     final List<Expr> elements;
   }
+  static class TahiniMap extends Expr {
+    TahiniMap(List<Expr> keys, List<Expr> values) {
+      this.keys = keys;
+      this.values = values;
+    }
+
+    @Override
+    <R> R accept(Visitor<R> visitor) {
+      return visitor.visitTahiniMapExpr(this);
+    }
+
+    final List<Expr> keys;
+    final List<Expr> values;
+  }
 
   abstract <R> R accept(Visitor<R> visitor);
 }
diff --git a/tahini/app/src/main/java/com/tahini/lang/Interpreter.java b/tahini/app/src/main/java/com/tahini/lang/Interpreter.java
@@ -1,7 +1,9 @@
 package com.tahini.lang;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Stack;
 
 class Interpreter implements Expr.Visitor<Object>, Stmt.Visitor<Void> {
@@ -85,6 +87,17 @@ public Object visitTahiniListExpr(Expr.TahiniList expr) {
         return tahiniList;
     }
 
+    @Override
+    public Object visitTahiniMapExpr(Expr.TahiniMap expr) {
+        Map<Object, Object> tahiniMap = new HashMap<>();
+        for (int i = 0; i < expr.keys.size(); i++) {
+            Object key = evaluate(expr.keys.get(i));
+            Object value = evaluate(expr.values.get(i));
+            tahiniMap.put(key, value);
+        }
+        return tahiniMap;
+    }
+
     @Override
     public Object visitLiteralExpr(Expr.Literal expr) {
         return expr.value;
@@ -376,29 +389,37 @@ public Object visitListAccessExpr(Expr.ListAccess expr) {
         Object collection = evaluate(expr.list);
         Object index = evaluate(expr.index);
 
-        if (!(collection instanceof List || collection instanceof String)) {
-            throw new RuntimeError(expr.paren, "Can only access elements of a list or a string.", new ArrayList<>());
-        }
-
-        if (!(index instanceof Double)) {
-            throw new RuntimeError(expr.paren, "Index must be a number.", new ArrayList<>());
+        if (!(collection instanceof List || collection instanceof String || collection instanceof Map)) {
+            throw new RuntimeError(expr.paren, "Can only access elements of a list, map or a string.", new ArrayList<>());
         }
 
-        int i = ((Double) index).intValue();
-
         return switch (collection) {
             case List<?> list -> {
+                if (!(index instanceof Double)) {
+                    throw new RuntimeError(expr.paren, "Index must be a number for list access.", new ArrayList<>());
+                }
+                int i = ((Double) index).intValue();
                 if (i < 0 || i >= list.size()) {
                     throw new RuntimeError(expr.paren, "Index out of bounds.", new ArrayList<>());
                 }
                 yield list.get(i);
             }
             case String str -> {
+                if (!(index instanceof Double)) {
+                    throw new RuntimeError(expr.paren, "Index must be a number for string access.", new ArrayList<>());
+                }
+                int i = ((Double) index).intValue();
                 if (i < 0 || i >= str.length()) {
                     throw new RuntimeError(expr.paren, "Index out of bounds.", new ArrayList<>());
                 }
                 yield String.valueOf(str.charAt(i));
             }
+            case Map<?, ?> map -> {
+                if (!map.containsKey(index)) {
+                    throw new RuntimeError(expr.paren, "Key not found in map.", new ArrayList<>());
+                }
+                yield map.get(index);
+            }
             default ->
                 throw new RuntimeError(expr.paren, "Unexpected error.", new ArrayList<>());
         };

diff --git a/tahini/app/src/main/java/com/tahini/lang/Parser.java b/tahini/app/src/main/java/com/tahini/lang/Parser.java
@@ -518,10 +518,10 @@ private Expr call() {
                 Expr index = expression();
                 if (match(TokenType.COLON)) {
                     Expr end = expression();
-                    consume(TokenType.RIGHT_SQUARE, "Expect ']' after list slice.");
+                    consume(TokenType.RIGHT_SQUARE, "Expect ']' after slice.");
                     expr = new Expr.ListSlice(expr, paren, index, end);
                 } else {
-                    consume(TokenType.RIGHT_SQUARE, "Expect ']' after list index.");
+                    consume(TokenType.RIGHT_SQUARE, "Expect ']' after index.");
                     expr = new Expr.ListAccess(expr, paren, index);
                 }
             } else {
@@ -565,6 +565,21 @@ private Expr primary() {
             return new Expr.TahiniList(elements);
         }
 
+        // hash map
+        if (match(TokenType.LEFT_BRACE)) {
+            List<Expr> keys = new ArrayList<>();
+            List<Expr> values = new ArrayList<>();
+            if (!check(TokenType.RIGHT_BRACE)) {
+                do {
+                    keys.add(expression());
+                    consume(TokenType.COLON, "Expect ':' after key.");
+                    values.add(expression());
+                } while (match(TokenType.COMMA));
+            }
+            consume(TokenType.RIGHT_BRACE, "Expect '}' after map elements.");
+            return new Expr.TahiniMap(keys, values);
+        }
+
         // Error production for binary operator without left-hand operand
         if (match(TokenType.PLUS, TokenType.MINUS, TokenType.STAR, TokenType.SLASH, TokenType.EQUAL_EQUAL, TokenType.BANG_EQUAL, TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL)) {
             Token operator = previous();

diff --git a/tahini/app/src/main/java/com/tahini/tool/GenerateAst.java b/tahini/app/src/main/java/com/tahini/tool/GenerateAst.java
@@ -26,7 +26,8 @@ public static void main(String[] args) throws IOException {
                 "Ternary  : Expr condition, Expr left, Expr right",
                 "Variable : Token name",
                 "Logical  : Expr left, Token operator, Expr right",
-                "TahiniList     : List<Expr> elements"
+                "TahiniList     : List<Expr> elements",
+                "TahiniMap      : List<Expr> keys, List<Expr> values"
         ));
 
         defineAst(outputDir, "Stmt", Arrays.asList(

diff --git a/tahini/tests/arrays3.tah b/tahini/tests/arrays3.tah
@@ -1,5 +1,5 @@
 var xy = 10;
 print xy[2];
 
-// RuntimeError: Can only access elements of a list or a string.
+// RuntimeError: Can only access elements of a list, map or a string.
 // [line 2]
diff --git a/tahini/tests/map.tah b/tahini/tests/map.tah
@@ -0,0 +1,4 @@
+var map = { "x": 10, "y": 20 };
+print map["x"];
+
+// 10
diff --git a/test.tah b/test.tah
@@ -5,6 +5,16 @@ fun isEven(n) {
   return n == 0;
 }
 
+var dictwithfunc = { "key1": 1, "key2": 2, "key3": 3, true: false, nil:5, "fib": isEven, isEven: isEven };
+print dictwithfunc["key1"];
+print dictwithfunc[true];
+print dictwithfunc[nil];
+print dictwithfunc["fib"](4);
+print dictwithfunc["fib"];
+print dictwithfunc[isEven];
+print dictwithfunc[isEven](5);
+print dictwithfunc["isEven"](4);
+
 print len("Hello");
 var str = "hello";
 print len(str);