From fff575908cfdef828ba33b8448ecfaa531971968 Mon Sep 17 00:00:00 2001
From: Seviche CC <me@seviche.cc>
Date: Sat, 10 Jun 2023 19:39:28 +0800
Subject: [PATCH] Fix read_from_token and atom

---
 TypeScript/lisp.ts | 43 ++++++++++++++++---------------------------
 1 file changed, 16 insertions(+), 27 deletions(-)

diff --git a/TypeScript/lisp.ts b/TypeScript/lisp.ts
index 7f71d55..387e0a5 100644
--- a/TypeScript/lisp.ts
+++ b/TypeScript/lisp.ts
@@ -1,19 +1,19 @@
 // Lispts: Scheme Interpreter in TypeScript
-const program = '(begin (define r 10) (* pi (* r r)))'
+const program = "(begin (define r 10) (* pi (* r r)))"
 
-type LSymbol = Symbol // A Lisp Symbol(alias TSymbol) is implemented as TypeScript string
+type LSymbol = string // A Lisp Symbol(alias TSymbol) is implemented as TypeScript string
 type LNumber = number // A Lisp Symbol(alias TSymbol) is implemented as TypeScript number
 type Atom = LSymbol | number // A Lisp Atom is a Symbol or Number impl
 type List = Array<any> // A Lisp List is implemented as a TypeScript array
 type Exp = Atom | List // A Lisp expression is an Atom or List
-type Env = Object // A Lisp environment is a mapping of {variable: value}
+interface Env {
+  [key: string | number]: any
+} // A Lisp environment is a mapping of {variable: value}
 
-class ValueError extends Error{
-  constructor(message:string) {
-    super(message)
-    this.name = 'ValueError'
-  }
-}
+/**
+ * Read a Scheme expression from a string.
+ */
+const parse = (program: string): Exp => read_from_tokens(tokenize(program))
 
 /**
  * Convert a string into a list of tokens.
@@ -28,40 +28,29 @@ const tokenize = (char: string): string[] =>
 /**
  * Numbers become numbers; every other token is a symbol(LSymbol).
  */
-const atom = (token: string): Atom => {
-  try {
-    if (Number.isNaN(token)) {
-      throw new ValueError('Value Error')
-    }
-  } catch (error) {
-    if (error === ValueError) {
-      
-    }
-  }
-}
+const atom = (token: string): Atom =>
+  Number.isNaN(token) ? Number(token) : (token as LSymbol)
 
 /**
  * Read an expression from a sequence of tokens
  */
 const read_from_tokens = (tokens: string[]): Exp => {
-  if (tokens.length === 0) {
+  if (tokens.length === 0 || !tokens) {
     throw new Error('unexpected EOF while reading')
   }
-
   const token = tokens.shift()
   if (token === '(') {
     const l = []
-    while (token[0] !== ')') {
+    while (tokens[0] !== ')') {
       l.push(read_from_tokens(tokens))
     }
     tokens.shift()
     return l
   } else if (token === ')') {
-    throw new Error ('unexpected )')
+    throw new Error('unexpected )')
   } else {
-    return atom(token)
+    return atom(token as string)
   }
 }
 
-
-console.log(tokenize(program))
+console.log(parse(program))