Readme + small edits

Author: reilandeubank

README.md

@@ -6,9 +6,9 @@ as outlined by Don Yessick for CS403 at the University of Alabama
 This interpreter is feature complete for the language as defined by Yessick
 Notes on choices made:
 
-```true``` is the truth value
+```true``` for truthy values
 
-```nil``` used for false/nil value
+```nil``` for falsey/nil values
 
 ```=``` used for equality checking
 
@@ -39,6 +39,9 @@ First, move into the ```golisp``` directory that was just created
 
 From here, you can use the ```make``` command to compile the interpreter into the executable ```./main``` in the current directory.
 
+For submission purposes, ```make``` also runs ```/test/tester.lsp```, which tests every implemented feature in the language
+and outputs the checking to the console
+
 Alternatively, you can compile an executable ```./main``` in the current directory. 
 ```
 $ go build cmd/main.go
@@ -55,3 +58,5 @@ $ ./main file.lsp
 ```
 to run ```file.lsp```
 
+# About the project
+This project was my second ever project in Go after writing my Lox interpreter. I have to say I enjoyed the language just as much as I did the first go around, and I was again glad I had chosen a language that was both so simple to pick up and so powerful. My largest problems that I ran into in this implementation mainly revolved around working through the underlying workings of the Lisp language that I had not considered before. Once I figured out that everything in the language was either a list or an atom/symbol, it became much easier to work through the implementation. I'll admit that I may not have done everything the most optimally (see my giant switch statements in interpreter/visitExpr.go) but I worked through most things multiple times in order to make it work as intended. An example would be the functions, which I initially attempted to detect at runtime, meaning I just parsed the definition and calls as lists, and tried to work those into definition or call statements at runtime. This nearly broke my brain and produced some code very reminiscent of spaghetti, but after trashing all of my changes and starting over, I managed to make definitions and calls into special cases in the parser that far simplified the process, as I could borrow a lot of the interpretation logic from the Lox interpreter. Other than functions, most of the project was fairly smooth sailing and I'm pretty proud of my ability to bang out a working interpreter without having to follow the guidance of a textbook.

pkg/interpreter/callable.go

@@ -34,32 +34,4 @@ func (l LispFunction) Call(i *Interpreter, arguments []interface{}) (interface{}
 	}
 
 	return i.evaluateFunction(l.Declaration.Body, env)
-}
-
-// type clock struct{}
-
-// func (c *clock) Arity() int {
-// 	return 0
-// }
-
-// func (c *clock) Call(i *Interpreter, arguments []interface{}) (interface{}, error) {
-// 	return float64(time.Now().UnixMilli()) / 1000, nil
-// }
-
-// func (c clock) String() string {
-// 	return "<native fn>"
-// }
-
-// type toStr struct{}
-
-// func (t *toStr) Arity() int {
-// 	return 1
-// }
-
-// func (t *toStr) Call(i *Interpreter, arguments []interface{}) (interface{}, error) {
-// 	return fmt.Sprintf("%v", arguments[0]), nil
-// }
-
-// func (t toStr) String() string {
-// 	return "<native fn>"
-// }
+}

pkg/interpreter/helpers.go

@@ -41,21 +41,4 @@ func checkNumberOperands(operator scanner.Token, left interface{}, right interfa
 		return nil
 	}
 	return &RuntimeError{Token: operator, Message: "Operators must be numbers"}
-}
-
-// func (i *Interpreter) cdr(k parser.Keyword) (interface{}, error) {
-// 	var elems []parser.Expression
-// 	for _, elem := range k.Args {
-// 		newExpr, err := i.evaluate(elem)
-// 		if err != nil {
-// 			return nil, err
-// 		}
-// 		if expr, ok := newExpr.(parser.Expression); ok {
-// 			elems = append(elems, expr)
-// 		} else {
-// 			return nil, &RuntimeError{Message: "type assertion failed, expected parser.Expression"}
-// 		}
-// 	}
-// 	fmt.Println(elems)
-// 	return parser.ListExpr{Head: elems[1], Tail: elems[2:]}, nil
-// }
+}

pkg/interpreter/visitExpr.go

@@ -134,7 +134,7 @@ func (i *Interpreter) VisitKeywordExpr(k parser.Keyword) (interface{}, error) {
 			return nil, err
 		}
 		result := isTruthy(left) || isTruthy(right)
-		if result == false {
+		if !result {
 			return nil, nil
 		}
 		return result, nil

pkg/parser/grammar.go

@@ -20,12 +20,10 @@ func (p *Parser) list() (Expression, error) {
         }
 
 		if funcName, ok := head.(Symbol); ok {
-			// fmt.Println("function call", funcName.Name.Lexeme)
 			return p.functionCall(funcName)
         }
 
 		if kw, ok := head.(Keyword); ok && kw.Keyword.Type == scanner.DEFINE {
-			// fmt.Println("function definition", kw.Keyword.Lexeme)
             return p.functionDefinition()
         }
 
@@ -130,7 +128,6 @@ func (p *Parser) paramList() ([]scanner.Token, error) {
 func (p *Parser) atom() (Expression, error) {
 	if p.isKeyword() {
 		k := Keyword{Keyword: p.previous()}
-		// fmt.Println("adding keyword:", scanner.KeywordsReverse[k.Keyword.Type])
 		return k, nil
 	}
 
@@ -144,10 +141,8 @@ func (p *Parser) atom() (Expression, error) {
 		var err error
 		switch prevValue.(type) {
 		case string:
-			// fmt.Println("String: " + prevValue.(string))
 			return Atom{Value: prevValue, Type: scanner.STRING}, err
 		case float64:
-			// fmt.Println("Number: " + fmt.Sprintf("%f", prevValue.(float64)))
 			return Atom{Value: prevValue, Type: scanner.NUMBER}, err
 		default:
 			// Handle other types or error
@@ -159,7 +154,6 @@ func (p *Parser) atom() (Expression, error) {
 	}
 
 	if p.match(scanner.SYMBOL) {
-		// fmt.Println("Symbol: " + p.previous().Lexeme)
 		return Symbol{Name: p.previous()}, nil
 	} 
 

pkg/parser/parser.go

@@ -28,10 +28,4 @@ func (p *Parser) Parse() ([]Expression, error) {
 	}
 
 	return expressions, nil
-
-	// expr, err := p.expr()
-	// if err != nil {
-	// 	return Atom{Value: nil}, err
-	// }
-	// return expr, err
 }

pkg/parser/stmt.go

@@ -3,19 +3,9 @@ package parser
 type ExprVisitor interface {
 	VisitListExpr(l ListExpr) (interface{}, error)
 	VisitKeywordExpr(k Keyword) (interface{}, error)
-	// VisitBinaryExpr(b Binary) (interface{}, error)
 	VisitOperatorExpr(o Operator) (interface{}, error)
 	VisitAtomExpr(l Atom) (interface{}, error)
-	// VisitCondExpr(c Cond) (interface{}, error)
-	// VisitUnaryExpr(u Unary) (interface{}, error)
 	VisitSymbolExpr(s Symbol) (interface{}, error)
 	VisitFuncDefinitionExpr(f FuncDefinition) (interface{}, error)
-	// VisitLogicalExpr(l Logical) (interface{}, error)
 	VisitCallExpr(c Call) (interface{}, error)
-}
-
-type StmtVisitor interface {
-	VisitExprStmt(e ExprStmt) (interface{}, error)
-	VisitSetStmt(v SetStmt) (interface{}, error)
-	VisitFunctionStmt(f FunctionStmt) (interface{}, error)
 }

pkg/parser/visitor.go

@@ -0,0 +1,44 @@
+go build -o main cmd/main.go
+./main test/tester.lsp
+expect ok: ok
+expect fail: fail
+ok
+ok
+ok
+ok
+
+test arithmetic operations
+ok
+ok
+ok
+ok
+
+test comparison operations
+ok
+ok
+ok
+
+test car and cdr on lists
+
+assuming (list 1 2 3) creates a list [1, 2, 3]
+ok
+ok
+
+test type checking functions
+ok
+ok
+ok
+ok
+
+logical operations
+ok
+ok
+
+function with multiple arguments
+ok
+
+more complex recursive function - fibonacci
+ok
+
+testing global variable assignment and usage
+ok