go: add stepA_more. try* and more core functions.

9 files changed, 410 insertions, 34 deletions

diff --git a/go/Makefile b/go/Makefile
index dbdfeaf..729d2cc 100644
--- a/go/Makefile
+++ b/go/Makefile
@@ -4,14 +4,14 @@ export GOPATH := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
 
 SOURCES_BASE = src/types/types.go src/reader/reader.go src/printer/printer.go \
 	       src/env/env.go src/core/core.go
-SOURCES_LISP = src/step8_macros/step8_macros.go
+SOURCES_LISP = src/stepA_more/stepA_more.go
 SOURCES = $(SOURCES_BASE) $(SOURCES_LISP)
 
 #####################
 
 SRCS = step0_repl.go step1_read_print.go step2_eval.go step3_env.go \
        step4_if_fn_do.go step5_tco.go step6_file.go step7_quote.go \
-       step8_macros.go
+       step8_macros.go stepA_more.go
 BINS = $(SRCS:%.go=%)
 
 #####################
diff --git a/go/src/core/core.go b/go/src/core/core.go
index 3c6693e..b3961e1 100644
--- a/go/src/core/core.go
+++ b/go/src/core/core.go
@@ -12,6 +12,11 @@ import (
     "printer"
 )
 
+// Errors/Exceptions
+func throw(a []MalType) (MalType, error) {
+    return nil, MalError{a[0]}
+}
+
 
 // String functions
 
@@ -97,11 +102,46 @@ func count(a []MalType) (MalType, error) {
     }
 }
 
+func apply(a []MalType) (MalType, error) {
+    if len(a) < 2 { return nil, errors.New("apply requires at least 2 args") }
+    f := a[0]
+    args := []MalType{}
+    for _, b := range a[1:len(a)-1] {
+        args = append(args, b)
+    }
+    last, e := GetSlice(a[len(a)-1]); if e != nil { return nil, e }
+    args = append(args, last...)
+    return Apply(f, args)
+}
+
+func do_map(a []MalType) (MalType, error) {
+    if len(a) != 2 { return nil, errors.New("map requires 2 args") }
+    f := a[0]
+    results := []MalType{}
+    args, e := GetSlice(a[1]); if e != nil { return nil, e }
+    for _, arg := range args {
+        res, e := Apply(f, []MalType{arg})
+        results = append(results, res)
+        if e != nil { return nil, e }
+    }
+    return List{results}, nil
+}
+
+
 
 // core namespace
 var NS = map[string]MalType{
     "=": func(a []MalType) (MalType, error) {
             return Equal_Q(a[0], a[1]), nil },
+    "throw": throw,
+    "nil?": func(a []MalType) (MalType, error) {
+            return Nil_Q(a[0]), nil },
+    "true?": func(a []MalType) (MalType, error) {
+            return True_Q(a[0]), nil },
+    "false?": func(a []MalType) (MalType, error) {
+            return False_Q(a[0]), nil },
+    "symbol?":  func(a []MalType) (MalType, error) {
+            return Symbol_Q(a[0]), nil },
 
     "pr-str": func(a []MalType) (MalType, error) { return pr_str(a) },
     "str": func(a []MalType) (MalType, error) { return str(a) },
@@ -133,6 +173,8 @@ var NS = map[string]MalType{
     "list?": func(a []MalType) (MalType, error) {
             return List_Q(a[0]), nil },
 
+    "sequential?":  func(a []MalType) (MalType, error) {
+            return Sequential_Q(a[0]), nil },
     "cons": cons,
     "concat": concat,
     "nth": nth,
@@ -140,4 +182,6 @@ var NS = map[string]MalType{
     "rest": rest,
     "empty?": empty_Q,
     "count": count,
+    "apply": apply,
+    "map": do_map,
     }
diff --git a/go/src/step4_if_fn_do/step4_if_fn_do.go b/go/src/step4_if_fn_do/step4_if_fn_do.go
index 86dc10b..7a91a2b 100644
--- a/go/src/step4_if_fn_do/step4_if_fn_do.go
+++ b/go/src/step4_if_fn_do/step4_if_fn_do.go
@@ -121,9 +121,7 @@ func EVAL(ast MalType, env EnvType) (MalType, error) {
         }
     case "fn*":
         return func(arguments []MalType) (MalType, error) {
-            a1s, e := GetSlice(a1)
-            if e != nil { return nil, e }
-            new_env, e := NewEnv(env, a1s, arguments)
+            new_env, e := NewEnv(env, a1, List{arguments})
             if e != nil { return nil, e }
             return EVAL(a2, new_env)
         }, nil
diff --git a/go/src/step5_tco/step5_tco.go b/go/src/step5_tco/step5_tco.go
index ad4b5e2..a15d9e5 100644
--- a/go/src/step5_tco/step5_tco.go
+++ b/go/src/step5_tco/step5_tco.go
@@ -123,9 +123,7 @@ func EVAL(ast MalType, env EnvType) (MalType, error) {
             ast = a2
         }
     case "fn*":
-        fn := MalFunc{EVAL, a2, env, a1, false,
-            func(outer EnvType, binds []MalType, exprs []MalType) (EnvType, error) {
-                return NewEnv(outer, binds, exprs) }}
+        fn := MalFunc{EVAL, a2, env, a1, false, NewEnv}
         return fn, nil
     default:
         el, e := eval_ast(ast, env)
@@ -134,7 +132,7 @@ func EVAL(ast MalType, env EnvType) (MalType, error) {
         if MalFunc_Q(f) {
             fn := f.(MalFunc)
             ast = fn.Exp
-            env, e = NewEnv(fn.Env, fn.Params.(List).Val, el.(List).Val[1:])
+            env, e = NewEnv(fn.Env, fn.Params, List{el.(List).Val[1:]})
             if e != nil { return nil, e }
         } else {
             fn, ok := f.(func([]MalType)(MalType, error))
diff --git a/go/src/step6_file/step6_file.go b/go/src/step6_file/step6_file.go
index 046f24e..205b597 100644
--- a/go/src/step6_file/step6_file.go
+++ b/go/src/step6_file/step6_file.go
@@ -123,9 +123,7 @@ func EVAL(ast MalType, env EnvType) (MalType, error) {
             ast = a2
         }
     case "fn*":
-        fn := MalFunc{EVAL, a2, env, a1, false,
-            func(outer EnvType, binds []MalType, exprs []MalType) (EnvType, error) {
-                return NewEnv(outer, binds, exprs) }}
+        fn := MalFunc{EVAL, a2, env, a1, false, NewEnv}
         return fn, nil
     default:
         el, e := eval_ast(ast, env)
@@ -134,7 +132,7 @@ func EVAL(ast MalType, env EnvType) (MalType, error) {
         if MalFunc_Q(f) {
             fn := f.(MalFunc)
             ast = fn.Exp
-            env, e = NewEnv(fn.Env, fn.Params.(List).Val, el.(List).Val[1:])
+            env, e = NewEnv(fn.Env, fn.Params, List{el.(List).Val[1:]})
             if e != nil { return nil, e }
         } else {
             fn, ok := f.(func([]MalType)(MalType, error))
diff --git a/go/src/step7_quote/step7_quote.go b/go/src/step7_quote/step7_quote.go
index 8642cf0..4083354 100644
--- a/go/src/step7_quote/step7_quote.go
+++ b/go/src/step7_quote/step7_quote.go
@@ -156,9 +156,7 @@ func EVAL(ast MalType, env EnvType) (MalType, error) {
             ast = a2
         }
     case "fn*":
-        fn := MalFunc{EVAL, a2, env, a1, false,
-            func(outer EnvType, binds []MalType, exprs []MalType) (EnvType, error) {
-                return NewEnv(outer, binds, exprs) }}
+        fn := MalFunc{EVAL, a2, env, a1, false, NewEnv}
         return fn, nil
     default:
         el, e := eval_ast(ast, env)
@@ -167,7 +165,7 @@ func EVAL(ast MalType, env EnvType) (MalType, error) {
         if MalFunc_Q(f) {
             fn := f.(MalFunc)
             ast = fn.Exp
-            env, e = NewEnv(fn.Env, fn.Params.(List).Val, el.(List).Val[1:])
+            env, e = NewEnv(fn.Env, fn.Params, List{el.(List).Val[1:]})
             if e != nil { return nil, e }
         } else {
             fn, ok := f.(func([]MalType)(MalType, error))
diff --git a/go/src/step8_macros/step8_macros.go b/go/src/step8_macros/step8_macros.go
index 12f036a..6735275 100644
--- a/go/src/step8_macros/step8_macros.go
+++ b/go/src/step8_macros/step8_macros.go
@@ -75,7 +75,7 @@ func macroexpand(ast MalType, env EnvType)  (MalType, error) {
         a0 := slc[0]
         mac, e = env.Get(a0.(Symbol).Val); if e != nil { return nil, e }
         fn := mac.(MalFunc)
-        ast, e = fn.Apply(slc[1:]); if e != nil { return nil, e }
+        ast, e = Apply(fn, slc[1:]); if e != nil { return nil, e }
     }
     return ast, nil
 }
@@ -195,9 +195,7 @@ func EVAL(ast MalType, env EnvType) (MalType, error) {
             ast = a2
         }
     case "fn*":
-        fn := MalFunc{EVAL, a2, env, a1, false,
-            func(outer EnvType, binds []MalType, exprs []MalType) (EnvType, error) {
-                return NewEnv(outer, binds, exprs) }}
+        fn := MalFunc{EVAL, a2, env, a1, false, NewEnv}
         return fn, nil
     default:
         el, e := eval_ast(ast, env)
@@ -206,7 +204,7 @@ func EVAL(ast MalType, env EnvType) (MalType, error) {
         if MalFunc_Q(f) {
             fn := f.(MalFunc)
             ast = fn.Exp
-            env, e = NewEnv(fn.Env, fn.Params.(List).Val, el.(List).Val[1:])
+            env, e = NewEnv(fn.Env, fn.Params, List{el.(List).Val[1:]})
             if e != nil { return nil, e }
         } else {
             fn, ok := f.(func([]MalType)(MalType, error))
diff --git a/go/src/stepA_more/stepA_more.go b/go/src/stepA_more/stepA_more.go
new file mode 100644
index 0000000..2532cfe
--- /dev/null
+++ b/go/src/stepA_more/stepA_more.go
@@ -0,0 +1,302 @@
+package main
+
+import (
+    "bufio"
+    //"io"
+    "fmt"
+    "os"
+    "strings"
+    "errors"
+)
+
+import (
+    . "types"
+    "reader"
+    "printer"
+    . "env"
+    "core"
+)
+
+// read
+func READ(str string) (MalType, error) {
+    return reader.Read_str(str)
+}
+
+// eval
+func is_pair(x MalType) bool {
+    slc, e := GetSlice(x)
+    if e != nil { return false }
+    return len(slc) > 0
+}
+
+func quasiquote(ast MalType) MalType {
+    if !is_pair(ast) {
+        return List{[]MalType{Symbol{"quote"}, ast}}
+    } else {
+        slc, _ := GetSlice(ast)
+        a0 := slc[0]
+        if Symbol_Q(a0) && (a0.(Symbol).Val == "unquote") {
+            return slc[1]
+        } else if is_pair(a0) {
+            slc0, _ := GetSlice(a0)
+            a00 := slc0[0]
+            if Symbol_Q(a00) && (a00.(Symbol).Val == "splice-unquote") {
+                return List{[]MalType{Symbol{"concat"},
+                                      slc0[1],
+                                      quasiquote(List{slc[1:]})}}
+            }
+        }
+        return List{[]MalType{Symbol{"cons"},
+                              quasiquote(a0),
+                              quasiquote(List{slc[1:]})}}
+    }
+}
+
+func is_macro_call(ast MalType, env EnvType) bool {
+    if List_Q(ast) {
+        slc, _ := GetSlice(ast)
+        a0 := slc[0]
+        if Symbol_Q(a0) && env.Find(a0.(Symbol).Val) != nil {
+            mac, e := env.Get(a0.(Symbol).Val)
+            if e != nil { return false }
+            if MalFunc_Q(mac) {
+                return mac.(MalFunc).GetMacro()
+            }
+        }
+    }
+    return false
+}
+
+func macroexpand(ast MalType, env EnvType)  (MalType, error) {
+    var mac MalType
+    var e error
+    for ; is_macro_call(ast, env) ; {
+        slc, _ := GetSlice(ast)
+        a0 := slc[0]
+        mac, e = env.Get(a0.(Symbol).Val); if e != nil { return nil, e }
+        fn := mac.(MalFunc)
+        ast, e = Apply(fn, slc[1:]); if e != nil { return nil, e }
+    }
+    return ast, nil
+}
+
+func eval_ast(ast MalType, env EnvType) (MalType, error) {
+    //fmt.Printf("eval_ast: %#v\n", ast)
+    if Symbol_Q(ast) {
+        return env.Get(ast.(Symbol).Val)
+    } else if List_Q(ast) {
+        lst := []MalType{}
+        for _, a := range ast.(List).Val {
+            exp, e := EVAL(a, env)
+            if e != nil { return nil, e }
+            lst = append(lst, exp)
+        }
+        return List{lst}, nil
+    } else if Vector_Q(ast) {
+        lst := []MalType{}
+        for _, a := range ast.(Vector).Val {
+            exp, e := EVAL(a, env)
+            if e != nil { return nil, e }
+            lst = append(lst, exp)
+        }
+        return Vector{lst}, nil
+    } else if Hash_Map_Q(ast) {
+        m := ast.(map[string]MalType)
+        new_hm := map[string]MalType{}
+        for k, v := range m {
+            ke, e1 := EVAL(k, env)
+            if e1 != nil { return nil, e1 }
+            if _, ok := ke.(string); !ok {
+                return nil, errors.New("non string hash-map key")
+            }
+            kv, e2 := EVAL(v, env)
+            if e2 != nil { return nil, e2 }
+            new_hm[ke.(string)] = kv
+        }
+        return new_hm, nil
+    } else {
+        return ast, nil
+    }
+}
+
+func EVAL(ast MalType, env EnvType) (MalType, error) {
+    var e error
+    for {
+
+    //fmt.Printf("EVAL: %v\n", printer.Pr_str(ast, true))
+    switch ast.(type) {
+    case List: // continue
+    default:   return eval_ast(ast, env)
+    }
+
+    // apply list
+    ast, e = macroexpand(ast, env); if e != nil { return nil, e }
+    if (!List_Q(ast)) { return ast, nil }
+
+    a0 := ast.(List).Val[0]
+    var a1 MalType = nil; var a2 MalType = nil
+    switch len(ast.(List).Val) {
+    case 1:
+        a1 = nil; a2 = nil
+    case 2:
+        a1 = ast.(List).Val[1]; a2 = nil
+    default:
+        a1 = ast.(List).Val[1]; a2 = ast.(List).Val[2]
+    }
+    a0sym := "__<*fn*>__"
+    if Symbol_Q(a0) { a0sym = a0.(Symbol).Val } 
+    switch a0sym {
+    case "def!":
+        res, e := EVAL(a2, env)
+        if e != nil { return nil, e }
+        return env.Set(a1.(Symbol).Val, res), nil
+    case "let*":
+        let_env, e := NewEnv(env, nil, nil)
+        if e != nil { return nil, e }
+        arr1, e := GetSlice(a1)
+        if e != nil { return nil, e }
+        for i := 0; i < len(arr1); i+=2 {
+            if !Symbol_Q(arr1[i]) {
+                return nil, errors.New("non-symbol bind value")
+            }
+            exp, e := EVAL(arr1[i+1], let_env)
+            if e != nil { return nil, e }
+            let_env.Set(arr1[i].(Symbol).Val, exp)
+        }
+        ast = a2
+        env = let_env
+    case "quote":
+        return a1, nil
+    case "quasiquote":
+        ast = quasiquote(a1)
+    case "defmacro!":
+        fn, e := EVAL(a2, env)
+        fn = fn.(MalFunc).SetMacro()
+        if e != nil { return nil, e }
+        return env.Set(a1.(Symbol).Val, fn), nil
+    case "macroexpand":
+        return macroexpand(a1, env)
+    case "try*":        
+        var exc MalType
+        exp, e := EVAL(a1, env)
+        if e == nil {
+            return exp, nil
+        } else {
+            if a2 != nil && List_Q(a2) {
+                a2s, _ := GetSlice(a2)
+                if Symbol_Q(a2s[0]) && (a2s[0].(Symbol).Val == "catch*") {
+                    switch e.(type) {
+                    case MalError: exc = e.(MalError).Obj
+                    default:       exc = e.Error()
+                    }
+                    binds := NewList(a2s[1])
+                    new_env, e := NewEnv(env, binds, NewList(exc))
+                    if e != nil { return nil, e }
+                    exp, e = EVAL(a2s[2], new_env)
+                    if e == nil { return exp, nil }
+                }
+            }
+            return nil, e
+        }
+    case "do":
+        lst := ast.(List).Val
+        _, e := eval_ast(List{lst[1:len(lst)-1]}, env) 
+        if e != nil { return nil, e }
+        if len(lst) == 1 { return nil, nil }
+        ast = lst[len(lst)-1]
+    case "if":
+        cond, e := EVAL(a1, env)
+        if e != nil { return nil, e }
+        if cond == nil || cond == false {
+            if len(ast.(List).Val) >= 4 {
+                ast = ast.(List).Val[3]
+            } else {
+                return nil, nil
+            }
+        } else {
+            ast = a2
+        }
+    case "fn*":
+        fn := MalFunc{EVAL, a2, env, a1, false, NewEnv}
+        return fn, nil
+    default:
+        el, e := eval_ast(ast, env)
+        if e != nil { return nil, e }
+        f := el.(List).Val[0]
+        if MalFunc_Q(f) {
+            fn := f.(MalFunc)
+            ast = fn.Exp
+            env, e = NewEnv(fn.Env, fn.Params, List{el.(List).Val[1:]})
+            if e != nil { return nil, e }
+        } else {
+            fn, ok := f.(func([]MalType)(MalType, error))
+            if !ok { return nil, errors.New("attempt to call non-function") }
+            return fn(el.(List).Val[1:])
+        }
+    }
+
+    } // TCO loop
+}
+
+// print
+func PRINT(exp MalType) (string, error) {
+    return printer.Pr_str(exp, true), nil
+}
+
+
+var repl_env, _ = NewEnv(nil, nil, nil)
+
+// repl
+func rep(str string) (MalType, error) {
+    var exp MalType
+    var res string
+    var e error
+    if exp, e = READ(str); e != nil { return nil, e }
+    if exp, e = EVAL(exp, repl_env); e != nil { return nil, e }
+    if res, e = PRINT(exp); e != nil { return nil, e }
+    return res, nil
+}
+
+func main() {
+    // core.go: defined using go
+    for k, v := range core.NS {
+        repl_env.Set(k, v)
+    }
+    repl_env.Set("eval", func(a []MalType) (MalType, error) {
+        return EVAL(a[0], repl_env) })
+    repl_env.Set("*ARGV*", List{})
+
+    // core.mal: defined using the language itself
+    rep("(def! not (fn* (a) (if a false true)))")
+    rep("(def! load-file (fn* (f) (eval (read-string (str \"(do \" (slurp f) \")\")))))")
+
+    // called with mal script to load and eval
+    if len(os.Args) > 1 {
+        args := make([]MalType, 0, len(os.Args)-2)
+        for _,a := range os.Args[2:] {
+            args = append(args, a)
+        }
+        repl_env.Set("*ARGV*", List{args})
+        rep("(load-file \"" + os.Args[1] + "\")")
+        os.Exit(0)
+    }
+
+    rdr := bufio.NewReader(os.Stdin);
+    // repl loop
+    for {
+        fmt.Print("user> ");
+        text, err := rdr.ReadString('\n');
+        text = strings.TrimRight(text, "\n");
+        if (err != nil) {
+            return
+        }
+        var out MalType
+        var e error
+        if out, e = rep(text); e != nil {
+            if e.Error() == "<empty line>" { continue }
+            fmt.Printf("Error: %v\n", e)
+            continue
+        }
+        fmt.Printf("%v\n", out)
+    }
+}
diff --git a/go/src/types/types.go b/go/src/types/types.go
index c79810f..a489aa3 100644
--- a/go/src/types/types.go
+++ b/go/src/types/types.go
@@ -3,13 +3,20 @@ package types
 import (
     "reflect"
     "errors"
-    //"fmt"
+    "fmt"
 )
 
-//import (
-//    "env"
-//)
+// Errors/Exceptions
+type MalError struct {
+    Obj MalType
+}
+
+func (e MalError) Error() string {
+    return fmt.Sprintf("%#v", e.Obj)
+}
 
+
+// General types
 type MalType interface {
 }
 
@@ -20,6 +27,28 @@ type EnvType interface {
     Get(key string) (MalType, error)
 }
 
+// Scalars
+func Nil_Q(obj MalType) bool {
+    switch obj.(type) {
+    case nil: return true
+    default:  return false
+    }
+}
+
+func True_Q(obj MalType) bool {
+    switch tobj := obj.(type) {
+    case bool: return tobj == true
+    default:   return false
+    }
+}
+
+func False_Q(obj MalType) bool {
+    switch tobj := obj.(type) {
+    case bool: return tobj == false
+    default:   return false
+    }
+}
+
 // Symbols
 type Symbol struct {
     Val string
@@ -40,7 +69,7 @@ type MalFunc struct {
     Env     EnvType
     Params  MalType
     IsMacro bool
-    GenEnv  func(EnvType, []MalType, []MalType) (EnvType, error)
+    GenEnv  func(EnvType, MalType, MalType) (EnvType, error)
 }
 
 func MalFunc_Q(obj MalType) bool {
@@ -59,12 +88,19 @@ func (f MalFunc) GetMacro() bool {
     return f.IsMacro
 }
 
-func (f MalFunc) Apply(a []MalType) (MalType, error) {
-    slc, e := GetSlice(f.Params)
-    if e != nil { return nil, e }
-    env, e := f.GenEnv(f.Env, slc, a)
-    if e != nil { return nil, e }
-    return f.Eval(f.Exp, env)
+// Take either a MalFunc or regular function and apply it to the
+// arguments
+func Apply(f_mt MalType, a []MalType) (MalType, error) {
+    switch f := f_mt.(type) {
+    case MalFunc:
+        env, e := f.GenEnv(f.Env, f.Params, List{a})
+        if e != nil { return nil, e }
+        return f.Eval(f.Exp, env)
+    case func([]MalType)(MalType, error):
+        return f(a)
+    default:
+        return nil, errors.New("Invalid function to Apply")
+    }
 }
 
 
@@ -73,6 +109,10 @@ type List struct {
     Val []MalType
 }
 
+func NewList(a ...MalType) MalType {
+    return List{a}
+}
+
 func List_Q(obj MalType) bool {
     switch obj.(type) {
     case List: return true
@@ -115,7 +155,7 @@ func _obj_type(obj MalType) string {
 }
 
 func Sequential_Q(seq MalType) bool {
-    //fmt.Printf("here1 %#v\n", reflect.TypeOf(seq).Name())
+    if seq == nil { return false }
     return (reflect.TypeOf(seq).Name() == "List") ||
            (reflect.TypeOf(seq).Name() == "Vector")
 }