func TestScoping(t *testing.T) {
env := environment.New(nil)
environment.Define(env, &types.Symbol{"begin"}, &types.Builtin{begin})
environment.Define(env, &types.Symbol{"+"}, &types.Builtin{add})
funcString := "(begin (define a 0) (define get-num ((lambda (a b) (define c 4) (lambda (b) (+ a b c))) 1 2)))"
f, err := parser.Parse(strings.NewReader(funcString))
if err != nil {
t.Error("Parsing funcString failed:", err)
}
if _, err := Eval(env, f); err != nil {
t.Error("Evaluating funcString failed:", err)
}
f, _ = parser.Parse(strings.NewReader("a"))
if a, err := Eval(env, f); err != nil {
t.Error("Evaluating 'a' failed:", err)
} else if !types.Eqv(a, &types.Number{0}) {
t.Error("a != 0", a)
}
f, _ = parser.Parse(strings.NewReader("(get-num 8)"))
if a, err := Eval(env, f); err != nil {
t.Error("Evaluating (get-num) failed:", err)
} else if !types.Eqv(a, &types.Number{13}) {
t.Error("(get-num 8) != 13:", a)
}
}
func TestLambda(t *testing.T) {
env := environment.New(nil)
environment.Define(env, &types.Symbol{"+"}, &types.Builtin{add})
environment.Define(env, &types.Symbol{"begin"}, &types.Builtin{begin})
f, _ := parser.Parse(strings.NewReader("(lambda (n) n)"))
if a, err := Eval(env, f); err != nil {
t.Error("Evaluating lambda failed:", err, f)
} else if !types.IsSFunction(a) {
t.Error("Evaluating lambda didn't return an SFunction:", a)
}
f, _ = parser.Parse(strings.NewReader("(define add1 (lambda (n) (+ 1 n)))"))
if _, err := Eval(env, f); err != nil {
t.Error("Evaluating define lambda failed:", err)
}
if a, err := environment.Get(env, &types.Symbol{"add1"}); err != nil {
t.Error("'Get'ting add1 caused an error: ", err)
} else if !types.IsSFunction(a) {
t.Error("add1 is not an SFunction:", a)
}
f, _ = parser.Parse(strings.NewReader("(add1 1)"))
if a, err := Eval(env, f); err != nil {
t.Error("Evaluating (add1 1) failed:", err)
} else if !types.Eqv(a, &types.Number{2}) {
t.Error("(add1 1) != 2", a)
}
}
func TestEval(t *testing.T) {
env := environment.New(nil)
environment.Define(env, &types.Symbol{"everything"}, &types.Number{42})
environment.Define(env, &types.Symbol{"cows"}, &types.String{"moo"})
environment.Define(env, &types.Symbol{"sheep"}, &types.String{"baa"})
environment.Define(env, &types.Symbol{"+"}, &types.Builtin{add})
if r, _ := Eval(env, &types.Symbol{"everything"}); !types.Eqv(r, &types.Number{42}) {
t.Error("Var 'everything' != 42: ", r)
}
f, _ := parser.Parse(strings.NewReader("(+ 1 1)"))
if r, err := Eval(env, f); err != nil {
t.Error("Evaluating (+ 1 1) caused an error: ", err)
} else if !types.Eqv(r, &types.Number{2}) {
t.Error("(+ 1 1) != 2: ", r)
}
f, _ = parser.Parse(strings.NewReader("(+ 1 (+ 2 3))"))
if r, err := Eval(env, f); err != nil {
t.Error("Evaluating (+ 1 (+ 2 3)) caused an error: ", err)
} else if !types.Eqv(r, &types.Number{6}) {
t.Error("(+ 1 (+ 2 3)) != 6: ", r)
}
}
func BuildEnvironment() (env *e.Environment) {
var defFunc func(string, func(interface{}, t.Type) (t.Type, error))
defFunc = func(name string, fn func(interface{}, t.Type) (t.Type, error)) {
e.Define(env, &t.Symbol{name}, &t.Builtin{fn})
}
env = e.New(nil)
defFunc("begin", begin)
/* Pairs */
defFunc("cons", cons)
defFunc("car", car)
defFunc("cdr", cdr)
/* Arithmetic */
defFunc("+", add)
defFunc("-", sub)
defFunc("=", equal_Number)
/* General */
defFunc("eq?", eq)
defFunc("eqv?", eqv)
return
}
func TestQuote(t *testing.T) {
env := environment.New(nil)
f, _ := parser.Parse(strings.NewReader("(quote moo)"))
if a, err := Eval(env, f); err != nil {
t.Error("Evaluating (quote moo) failed:", err)
} else if !types.Eqv(a, &types.Symbol{"moo"}) {
t.Error("(quote moo) != moo", a)
}
}
func TestDefine(t *testing.T) {
env := environment.New(nil)
f, _ := parser.Parse(strings.NewReader("(define answer 42)"))
if _, err := Eval(env, f); err != nil {
t.Error("Evaluating (define answer 42) failed:", err)
}
if a, err := environment.Get(env, &types.Symbol{"answer"}); err != nil {
t.Error("'Get'ting 'answer' caused an error: ", err)
} else if !types.Eqv(a, &types.Number{42}) {
t.Error("answer != 42", a)
}
}
func TestBegin(t *testing.T) {
env := environment.New(nil)
environment.Define(env, &types.Symbol{"cows"}, &types.String{"moo"})
environment.Define(env, &types.Symbol{"sheep"}, &types.String{"baa"})
environment.Define(env, &types.Symbol{"begin"}, &types.Builtin{begin})
f, _ := parser.Parse(strings.NewReader("(begin cows sheep)"))
if r, err := Eval(env, f); err != nil {
t.Error("Evaluating (begin cows sheep) caused an error: ", err)
} else if !types.Eqv(r, &types.String{"baa"}) {
t.Error("(begin cows sheep) != baa", r)
}
}
func TestIf(t *testing.T) {
env := environment.New(nil)
f, _ := parser.Parse(strings.NewReader("(if #t 'yes 'no)"))
if a, err := Eval(env, f); err != nil {
t.Error("Evaluating (if #t 'yes 'no) failed:", err)
} else if !types.Eqv(a, &types.Symbol{"yes"}) {
t.Error("result != yes", a)
}
f, _ = parser.Parse(strings.NewReader("(if #f 'yes 'no)"))
if a, err := Eval(env, f); err != nil {
t.Error("Evaluating (if #f 'yes 'no) failed:", err)
} else if !types.Eqv(a, &types.Symbol{"no"}) {
t.Error("result != no", a)
}
}
func Apply(env *environment.Environment, f types.Type, args types.Type) (types.Type, error) {
if isSpecialForm(f) {
return applySpecialForm(env, f.(*types.Symbol).Value, args)
}
fn, err := Eval(env, f)
if err != nil {
return nil, fmt.Errorf("%s\nAPPLY: eval: %s", err, f)
}
args, err = evalArgs(env, args)
if err != nil {
return nil, err
}
//fmt.Printf("%s\n", args)
if bfn, ok := fn.(*types.Builtin); ok {
if r, err := bfn.Fn(env, args); err != nil {
return nil, fmt.Errorf("%s\nAPPLY: builtin %s", err, f.(*types.Symbol).Value)
} else {
return r, nil
}
}
if sfn, ok := fn.(*types.SFunction); ok {
sfnEnv := environment.New(sfn.Env.(*environment.Environment))
err = environment.AddArgs(sfnEnv, sfn.Args, args)
if err != nil {
return nil, err
}
if r, err := begin(sfnEnv, sfn.Function); err != nil {
return nil, fmt.Errorf("%s\nAPPLY: function %s", err, f.(*types.Symbol).Value)
} else {
return r, nil
}
}
return nil, fmt.Errorf("APPLY: Unknown function: %s", f.(*types.Symbol).Value)
}