use evaluated type instead

with some minor testing code refactoring

src/evaluator/environment/index.test.ts

@@ -1,49 +1,52 @@
+import type { Evaluated } from "../evaluated";
 import Environment from "./";
 
 describe("set()", () => {
   it("set name and value", () => {
     const env = new Environment();
+    const varName = "foo";
+    const varValue = {} as Evaluated;
 
-    expect(() => env.set("foo", 42)).not.toThrow();
+    expect(() => env.set(varName, varValue)).not.toThrow();
   });
 });
 
 describe("get()", () => {
   it("get value after setting the value", () => {
     const env = new Environment();
+    const varName = "foo";
+    const varValue = {} as Evaluated;
 
-    env.set("foo", 42);
-    const value = env.get("foo");
+    env.set(varName, varValue);
 
-    expect(value).toBe(42);
+    expect(env.get(varName)).toBe(varValue);
   });
 
   it("get null if not found", () => {
     const env = new Environment();
+    const varNameNotSet = "foo";
 
-    const value = env.get("foo");
-
-    expect(value).toBe(null);
+    expect(env.get(varNameNotSet)).toBe(null);
   });
 });
 
 describe("linked environment", () => {
   it("set super environment and get via sub environment", () => {
+    const varNameInSuper = "foo";
+    const varValueInSuper = {} as Evaluated;
+
     const superEnv = new Environment();
-    superEnv.set("foo", 42);
+    superEnv.set(varNameInSuper, varValueInSuper);
     const subEnv = new Environment(superEnv);
 
-    const value = subEnv.get("foo");
-
-    expect(value).toBe(42);
+    expect(subEnv.get(varNameInSuper)).toBe(varValueInSuper);
   });
 
   it("get null if not found even in super environment", () => {
     const superEnv = new Environment();
     const subEnv = new Environment(superEnv);
 
-    const value = subEnv.get("foo");
-
-    expect(value).toBe(null);
+    const varNameSetNowhere = "foo";
+    expect(subEnv.get(varNameSetNowhere)).toBe(null);
   });
 });

src/evaluator/environment/index.ts

@@ -1,6 +1,8 @@
+import type { Evaluated } from "../evaluated";
+
 export interface EnvironmentType {
-  get: (name: string) => unknown;
-  set: (name: string, value: any) => unknown;
+  get: (name: string) => Evaluated | null;
+  set: (name: string, value: Evaluated) => void;
 }
 
 export default class Environment implements EnvironmentType {
@@ -12,7 +14,7 @@ export default class Environment implements EnvironmentType {
     this.table = new Map<string, any>;
   }
 
-  get(name: string): unknown {
+  get(name: string): Evaluated | null {
     // return if found in current environment
     const fetched = this.table.get(name);
     if (fetched !== undefined) {
@@ -26,9 +28,7 @@ export default class Environment implements EnvironmentType {
     return this.superEnvironment.get(name);
   }
 
-  set(name: string, value: any): unknown {
+  set(name: string, value: Evaluated): void {
     this.table.set(name, value);
-
-    return value;
   }
 }