Add new features and tests

 - negative numbers
 - parse floating point numbers
 - strings
 - more native functions (including car, cdr, and cons (but not a real cons))
 - lots more tests (83% coverage)

Author: rread

lispy.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"errors"
 	"fmt"
+	"io"
 	"log"
 	"math"
 	"os"
@@ -12,12 +13,17 @@ import (
 	"strings"
 )
 
-type Token int
-type Number float64
-type Atom string
+// Item is an Atom, Number, String, or Function
 type Item interface{}
+
+// ItemList is a fundamental data type.
 type ItemList []Item
 
+type Number float64
+type Atom string
+type String string
+type NativeFunc func(...Item) (Item, error)
+
 var ErrorEOF = errors.New("End of File")
 
 func (items ItemList) String() string {
@@ -32,17 +38,23 @@ func (items ItemList) String() string {
 	return s
 }
 
+func (s String) String() string {
+	return fmt.Sprintf("\"%s\"", string(s))
+}
+
 func read(s *Scanner) (Item, error) {
 	tok, lit := s.Scan()
 	if tok == WS {
 		tok, lit = s.Scan()
 	}
-	// fmt.Println("scan:", tok, lit)
+	//log.Println("scan:", tok, lit)
 	switch tok {
 	case LEFT_PAREN:
 		return readList(s)
 	case ATOM:
 		return Atom(lit), nil
+	case QUOTE:
+		return readQuote(s)
 	case NUMBER:
 		v, err := strconv.ParseFloat(lit, 64)
 		if err != nil {
@@ -53,10 +65,21 @@ func read(s *Scanner) (Item, error) {
 		return nil, nil
 	case EOF:
 		return nil, ErrorEOF
+	case STRING:
+		return String(lit), nil
 	}
 	return nil, errors.New("Malformed input")
 }
 
+func readQuote(s *Scanner) (Item, error) {
+	l := ItemList{Atom("quote")}
+	c, err := read(s)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to complete list: %v\n", err)
+	}
+	return append(l, c), nil
+}
+
 func readList(s *Scanner) (Item, error) {
 	var l ItemList
 	for {
@@ -110,6 +133,8 @@ func eval(expr Item, env *Env) (interface{}, error) {
 		}
 	case Number:
 		return e, nil
+	case String:
+		return e, nil
 	case ItemList:
 		switch car, _ := e[0].(Atom); car {
 		case "quote":
@@ -147,14 +172,12 @@ func eval(expr Item, env *Env) (interface{}, error) {
 		default:
 			proc, err := eval(e[0], env)
 			if err != nil {
-				log.Println("Error1", err)
-				return nil, err
+				return nil, fmt.Errorf("undefined-function: %v", err)
 			}
 			args := make(ItemList, len(e)-1)
 			for i, a := range e[1:] {
 				args[i], err = eval(a, env)
 				if err != nil {
-					log.Println("Error2", err)
 					return nil, err
 				}
 			}
@@ -185,7 +208,7 @@ func evalLambda(expr ItemList, env *Env) (interface{}, error) {
 		case Atom:
 			l.params = append(l.params, p)
 		case []interface{}:
-			log.Fatal("combo param not supported:", x)
+			return nil, fmt.Errorf("combo param not supported: %v", x)
 		}
 
 	}
@@ -195,35 +218,39 @@ func evalLambda(expr ItemList, env *Env) (interface{}, error) {
 	return &l, nil
 
 }
+
 func apply(proc Item, args ItemList, env *Env) (Item, error) {
 	//	log.Printf("apply: %v args: %v\n", proc, args)
 	switch f := proc.(type) {
-	case func(...Item) Item:
-		return f(args...), nil
+	case NativeFunc:
+		return f(args...)
 	case *Lambda:
 		if len(f.params) != len(args) {
-			log.Fatalf("parameter mismatch %v != %v", f.params, args)
+			return nil, fmt.Errorf("parameter mismatch %v != %v", f.params, args)
 		}
 		for i, p := range f.params {
 			f.envt.vars[p] = args[i]
 		}
 		return eval(f.body, f.envt)
 	default:
-		log.Fatalf("apply to a non function: %#v", proc)
+		return nil, fmt.Errorf("apply to a non function: %#v", proc)
 	}
 	return nil, nil
 }
 
-func repl(in string, env *Env) (interface{}, error) {
-	s := NewScanner(strings.NewReader(in))
+func replReader(in io.Reader, env *Env) (interface{}, error) {
+	s := NewScanner(in)
 	var result interface{}
 	for {
 		var err error
 		expr, err := read(s)
 		if err != nil {
+			if err == ErrorEOF {
+				return result, nil
+			}
 			return result, err
 		}
-		//fmt.Println(expr)
+		// fmt.Println(expr)
 
 		result, err = eval(expr, env)
 		if err != nil {
@@ -232,38 +259,69 @@ func repl(in string, env *Env) (interface{}, error) {
 	}
 }
 
+func repl(in string, env *Env) (interface{}, error) {
+	return replReader(strings.NewReader(in), env)
+}
+
 func replCLI(env *Env) {
-	reader := (bufio.NewReader(os.Stdin))
+	reader := bufio.NewReader(os.Stdin)
 	for {
-		fmt.Print(">>> ")
+		fmt.Print("* ")
 		text, _ := reader.ReadString('\n')
 		result, err := repl(text, env)
 		if err != nil && err != ErrorEOF {
-			fmt.Println("New Error:", err)
+			fmt.Println("Error:", err)
+		} else {
+			fmt.Println(result)
 		}
-		fmt.Println("===>", result)
 	}
 }
 
-var defaultEnv *Env
-
-func ApplyNumeric(f func(Number, Number) Number) func(a ...Item) Item {
-	return func(a ...Item) Item {
+func ApplyNumeric(f func(Number, Number) Number) NativeFunc {
+	return func(a ...Item) (Item, error) {
 		v, ok := a[0].(Number)
 		if !ok {
-			log.Fatalf("Not a number: %v", a[0])
+			return nil, fmt.Errorf("Not a number: %v", a[0])
 		}
 		for _, n := range a[1:] {
 			i, ok := n.(Number)
 			if !ok {
-				log.Fatalf("Not a number: %v", a[0])
+				return nil, fmt.Errorf("Not a number: %v", n)
 			}
 			v = f(v, i)
 		}
-		return v
+		return v, nil
+	}
+}
+
+func ApplyNumericBool(f func(Number, Number) bool) NativeFunc {
+	return func(a ...Item) (Item, error) {
+		var ret bool
+		v, ok := a[0].(Number)
+		if !ok {
+			return nil, fmt.Errorf("Not a number: %v", a[0])
+		}
+		for _, n := range a[1:] {
+			i, ok := n.(Number)
+			if !ok {
+				return nil, fmt.Errorf("Not a number: %v", n)
+			}
+			ret = f(v, i)
+			v = i
+			if !ret {
+				return ret, nil
+			}
+		}
+		return Item(ret), nil
 	}
 }
 
+func isItemList(i Item) bool {
+	if _, ok := i.(ItemList); ok {
+		return true
+	}
+	return false
+}
 func DefaultEnv() *Env {
 	return &Env{
 		Binding{
@@ -279,40 +337,71 @@ func DefaultEnv() *Env {
 			"-": ApplyNumeric(func(x, y Number) Number {
 				return x - y
 			}),
-			"<=": func(a ...Item) Item {
-				return a[0].(Number) <= a[1].(Number)
-			},
-			"equal?": func(a ...Item) Item {
-				return reflect.DeepEqual(a[0], a[1])
-			},
+			"<": ApplyNumericBool(func(x, y Number) bool {
+				return x < y
+			}),
+			"<=": ApplyNumericBool(func(x, y Number) bool {
+				return x <= y
+			}),
+			">": ApplyNumericBool(func(x, y Number) bool {
+				return x > y
+			}),
+			">=": ApplyNumericBool(func(x, y Number) bool {
+				return x >= y
+			}),
+			"=": ApplyNumericBool(func(x, y Number) bool {
+				return x == y
+			}),
+			"number?": NativeFunc(func(a ...Item) (Item, error) {
+				if len(a) > 1 {
+					return nil, fmt.Errorf("Too many arguments for number?: %v", a)
+				}
+				if _, ok := a[0].(Number); ok {
+					return Item(true), nil
+				}
+				return Item(false), nil
+			}),
+			"car": NativeFunc(func(a ...Item) (Item, error) {
+				if !isItemList(a[0]) {
+					return nil, fmt.Errorf("Not a list: %#v", a[0])
+				}
+				il := a[0].(ItemList)
+				if len(il) == 0 {
+					return []ItemList{}, nil
+				}
+				return a[0].(ItemList)[0], nil
+			}),
+			"cdr": NativeFunc(func(a ...Item) (Item, error) {
+				if !isItemList(a[0]) {
+					return nil, fmt.Errorf("Not a list: %#v", a[0])
+				}
+				il := a[0].(ItemList)
+				if len(il) < 2 {
+					return []ItemList{}, nil
+				}
+				return il[1:], nil
+			}),
+			"cons": NativeFunc(func(a ...Item) (Item, error) {
+				if len(a) != 2 {
+					return nil, fmt.Errorf("wrong number of arguments given to cons")
+				}
+				l := ItemList{a[0]}
+				if il, ok := a[1].(ItemList); ok {
+					l = append(l, il...)
+				} else {
+					l = append(l, a[1])
+				}
+				return l, nil
+			}),
+			"equal?": NativeFunc(func(a ...Item) (Item, error) {
+				return reflect.DeepEqual(a[0], a[1]), nil
+			}),
 			"pi": Number(math.Pi),
 		},
 		nil,
 	}
 }
-func init() {
-	defaultEnv = DefaultEnv()
-}
 
 func main() {
-	env := defaultEnv
-	/*
-		repl("(define r 10)\n(define n 12)", env)
-		repl("(begin (define r 10)\n(define n 12))", env)
-		repl("(define radius (* pi (* r r)))", env)
-		repl("(if (<= 4 2) (* 10 2))", env)
-		repl("(if (<= 4 2) (* 10 2) (+ 1 2))", env)
-		repl("(/ radius 10)", env)
-		repl("(quote (1  1))", env)
-		repl("123", env)
-		repl("(lambda () (+ 1 1))", env)
-		repl("((lambda () (+ 1 1)))", env)
-		repl("((lambda () (+ 1 1)))", env)
-		repl("(define foo (begin (define count 0) (lambda () (set! count (+ count 1)))))", env)
-		repl("(foo) (foo)", env)
-		repl("(foo) (foo)", env)
-		repl("(define plus (lambda (a b) (+ a b)))", env)
-		repl("(define counter (lambda (n) (lambda () (set! n (+ n 1)))))", env)
-	*/
-	replCLI(env)
+	replCLI(DefaultEnv())
 }