Added keyword functions

Author: reilandeubank

go.sum

@@ -3,7 +3,7 @@ package interpreter
 import (
 	"fmt"
 
-	"github.com/reilandeubank/golox/pkg/scanner"
+	"github.com/reilandeubank/golisp/pkg/scanner"
 )
 
 var hadErrorFlag bool = false

pkg/interpreter/errorHandler.go

@@ -5,7 +5,7 @@ import (
 	"reflect"
 
 	"github.com/reilandeubank/golisp/pkg/scanner"
-	"github.com/reilandeubank/golsip/pkg/parser"
+	"github.com/reilandeubank/golisp/pkg/parser"
 )
 
 func isTruthy(object interface{}) bool {
@@ -29,11 +29,11 @@ func isEqual(a interface{}, b interface{}) bool {
 	return a == b
 }
 
-func checkNumberOperand(operator scanner.Token, operand interface{}) error {
+func checkNumberOperand(operator scanner.Token, operand interface{}) (bool, error) {
 	if reflect.TypeOf(operand) == reflect.TypeOf(0.0) || reflect.TypeOf(operand) == reflect.TypeOf(0) {
-		return nil
+		return true, nil
 	}
-	return &RuntimeError{Token: operator, Message: "Operator must be a number"}
+	return false, &RuntimeError{Token: operator, Message: "Operator must be a number"}
 }
 
 func checkNumberOperands(operator scanner.Token, left interface{}, right interface{}) error {
@@ -59,9 +59,25 @@ func stringify(object interface{}) string {
 
 func isOperator(expr parser.Expression) bool {
 	switch expr.(type) {
-	case Operator:
+	case parser.Operator:
 		return true
 	default:
 		return false
 	}
 }
+
+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"}
+		}
+	}
+	return parser.ListExpr{Head: elems[1], Tail: elems[2:]}, nil
+}

pkg/interpreter/helpers.go

@@ -1,8 +1,8 @@
 package interpreter
 
 import (
-	"fmt"
-	"github.com/reilandeubank/golisp/parser"
+	// "fmt"
+	"github.com/reilandeubank/golisp/pkg/parser"
 )
 
 type Interpreter struct {

pkg/interpreter/interpreter.go

@@ -13,10 +13,45 @@ func (i *Interpreter) VisitListExpr(l parser.ListExpr) (interface{}, error) {
 		o.Operands = l.Tail
 		return i.evaluate(o)
 	}
+
+	if k, ok := l.Head.(*parser.Keyword); ok {
+		k.Args = l.Tail
+		return i.evaluate(k)
+	}
 	return nil, fmt.Errorf("not implemented")
 }
 
 func (i *Interpreter) VisitKeywordExpr(k parser.Keyword) (interface{}, error) {
+	switch k.Keyword.Type {
+	case scanner.CAR:
+		car, err := i.evaluate(k.Args[0])
+		if err != nil {
+			return nil, err
+		}
+		return parser.Atom{Value: car}, nil
+	case scanner.CDR:
+		return i.cdr(k)
+	case scanner.COND:
+		for j := 0; j < len(k.Args); j += 2 {
+			condition, err := i.evaluate(k.Args[j])
+			if err != nil {
+				return nil, err
+			}
+			if isTruthy(condition) && j+1 < len(k.Args) {
+				return i.evaluate(k.Args[j+1])
+			}
+		}
+		return nil, &RuntimeError{Token: k.Keyword, Message: "Lack of true condition"}
+	case scanner.NUMBERQ:
+		if len(k.Args) != 1 {
+			return nil, &RuntimeError{Token: k.Keyword, Message: "NUMBER? operation must have 1 operand"}
+		}
+		expr, err := i.evaluate(k.Args[0])
+		if err != nil {
+			return nil, err
+		}
+		return checkNumberOperand(k.Keyword, expr)
+	}
 	return nil, fmt.Errorf("not implemented")
 }
 

pkg/interpreter/visitExpr.go

@@ -67,6 +67,7 @@ func (l ListExpr) String() string {
 
 type Keyword struct {
 	Keyword scanner.Token
+	Args    []Expression
 }
 
 func (k Keyword) Accept(v ExprVisitor) (interface{}, error) {