Add lambdas (still strings!)

Author: skius

ast/call.go

@@ -1,14 +1,17 @@
 package ast
 
-import "strings"
+import (
+	"fmt"
+	"strings"
+)
 
 type Call struct {
-	Fn   Var
+	Fn   Expr
 	Args CallArgs
 }
 
 func NewCall(f, as Attrib) (Expr, error) {
-	fn := f.(Var)
+	fn := f.(Expr)
 	args := as.(CallArgs)
 	return Call{Fn: fn, Args: args}, nil
 }
@@ -17,27 +20,58 @@ func (ca Call) Eval(c *Context) Val {
 		return ""
 	}
 
-	userFn, ok := c.UserFunctionMap[string(ca.Fn)]
-	if !ok {
-		fn, ok := c.FunctionMap[string(ca.Fn)]
-		if !ok {
-			panic("function '" + string(ca.Fn) + "' not found.")
+	if fnVar, ok := ca.Fn.(Var); ok {
+		userFn, ok := c.UserFunctionMap[string(fnVar)]
+		if ok {
+			vals := make([]Val, 0, len(ca.Args))
+			for _, argExp := range ca.Args {
+				v := argExp.Eval(c)
+				vals = append(vals, v)
+			}
+			res := userFn.Call(c, vals)
+			return res
 		}
-		vals := make([]string, 0, len(ca.Args))
-		for _, argExp := range ca.Args {
-			v := argExp.Eval(c)
-			vals = append(vals, string(v))
+
+		fn, ok := c.FunctionMap[string(fnVar)]
+		if ok {
+			vals := make([]string, 0, len(ca.Args))
+			for _, argExp := range ca.Args {
+				v := argExp.Eval(c)
+				vals = append(vals, string(v))
+			}
+			res := fn(vals)
+			return Val(res)
 		}
-		res := fn(vals)
-		return Val(res)
+		// Treat as expression, fallthrough
+	}
+
+	fnSource := ca.Fn.Eval(c)
+	fnAst, err := c.parseFn([]byte(fnSource))
+	if err != nil {
+		fmt.Println("Error occurred:", err)
+		return ""
+	}
+	fnProg := fnAst.(Program)
+	if len(fnProg.Code) != 1 {
+		// Must consist of exactly one lambda
+		fmt.Println("Length of parsed program is not equal to 1")
+		return ""
+	}
+	fst := fnProg.Code[0]
+	lam, ok := fst.(Lambda)
+	if !ok {
+		// Must be lambda
+		fmt.Println("Parsed program is not a Lambda")
+		return ""
 	}
 
 	vals := make([]Val, 0, len(ca.Args))
 	for _, argExp := range ca.Args {
 		v := argExp.Eval(c)
 		vals = append(vals, v)
 	}
-	res := userFn.Call(c, vals)
+
+	res := lam.Call(c, vals)
 	return res
 }
 func (ca Call) String() string {
@@ -95,6 +129,7 @@ func (f FuncDecl) Call(c *Context, args []Val) Val {
 		MaxStackSize:    c.MaxStackSize - CheckSize(c.VariableMap) - GoStackframeEstimate, // New context needs to account for Go stackframes
 		limitStackSize:  c.limitStackSize,
 		exitChannel:     c.exitChannel,
+		parseFn:         c.parseFn,
 	}
 	return f.Code.Eval(&cNew)
 }

ast/context.go

@@ -1,6 +1,6 @@
 package ast
 
-func NewContext(args []string, funcs map[string]func([]string) string) *Context {
+func NewContext(args []string, funcs map[string]func([]string) string, parseFn func([]byte) (Expr, error)) *Context {
 	return &Context{
 		Args:            args,
 		VariableMap:     make(map[Var]Val),
@@ -9,6 +9,7 @@ func NewContext(args []string, funcs map[string]func([]string) string) *Context
 		MaxStackSize:    -1,
 		limitStackSize:  false,
 		exitChannel:     make(chan int, 1),
+		parseFn:         parseFn,
 	}
 }
 
@@ -20,6 +21,7 @@ type Context struct {
 	MaxStackSize    int64
 	exitChannel     chan int
 	limitStackSize  bool
+	parseFn         func([]byte) (Expr, error) /* Ugly hack to avoid illegal circular imports */
 }
 
 func (c *Context) SetMaxStackSize(sz int64) {

ast/lambda.go

@@ -0,0 +1,42 @@
+package ast
+
+import "strings"
+
+type Lambda struct {
+	Params []string
+	Code   Block
+}
+
+func NewLambda(ps, b Attrib) (Expr, error) {
+	params := ps.([]string)
+	code := b.(Block)
+	return Lambda{Params: params, Code: code}, nil
+}
+
+func (l Lambda) Eval(c *Context) Val {
+	// Closure by value, copy the value of l's body's free vars in the current context into its body
+	fv := FreeVars(l)
+	for v := range fv {
+		l.Code = append([]Expr{Assn{V: Var(v), E: c.VariableMap[Var(v)]}}, l.Code...)
+	}
+	return Val(l.String())
+}
+
+func (l Lambda) String() string {
+	res := "fun(" + strings.Join(l.Params, ", ") + ") {\n\t"
+	codeLines := strings.SplitN(l.Code.String(), "\n", -1)
+	res += strings.Join(codeLines, "\n\t")
+	res += "\n}"
+	//res = strings.ReplaceAll(res, "\"", "\\\"")
+	return res
+}
+
+func (l Lambda) Call(c *Context, args []Val) Val {
+	// Construct corresponding FuncDecl and call that instead
+	fDecl := FuncDecl{
+		Params:     l.Params,
+		Code:       l.Code,
+		Identifier: "temp_lambda",
+	}
+	return fDecl.Call(c, args)
+}

ast/util.go

@@ -56,6 +56,13 @@ func HasSideEffects(e Expr) bool {
 	return false
 }
 
+func FreeVars(e Expr) map[string]struct{} {
+	// I haven't decided yet what the difference should be to UsedVars
+	used := make(map[string]struct{})
+	setUsedVars(e, used)
+	return used
+}
+
 func UsedVars(b Block) map[string]struct{} {
 	used := make(map[string]struct{})
 	setUsedVars(b, used)
@@ -105,38 +112,27 @@ func setUsedVars(expr Expr, used map[string]struct{}) {
 		for _, e := range val.Args {
 			setUsedVars(e, used)
 		}
+		// Because we allow arbitrary sources for a call, we need to take those into account
+		setUsedVars(val.Fn, used)
 	case Index:
 		setUsedVars(val.Source, used)
 		setUsedVars(val.I, used)
+	case Lambda:
+		innerUsed := UsedVars(val.Code)
+		// Lambda's used vars are "used \union (innerUsed \except params)
+		for _, v := range val.Params {
+			delete(innerUsed, v)
+		}
+		for v := range innerUsed {
+			used[v] = struct{}{}
+		}
 	}
 	return
 }
 
 func attribToString(a Attrib) string {
 	return string(a.(*token.Token).Lit)
 }
-func unescape(s string) string {
-	in := []rune(s)
-	out := make([]rune, 0, len(in))
-	var escape bool
-	for _, r := range in {
-		switch {
-		case escape:
-			switch r {
-			case 'n':
-				out = append(out, '\n')
-			default:
-				out = append(out, r)
-			}
-			escape = false
-		case r == '\\':
-			escape = true
-		default:
-			out = append(out, r)
-		}
-	}
-	return string(out)
-}
 
 const (
 	SigExternalExit = iota + 1
@@ -180,6 +176,7 @@ Complete switch of expressions
 	case IfElse:
 	case While:
 	case Call:
+	case Lambda:
 	}
 
 */

ast/val.go

@@ -1,16 +1,20 @@
 package ast
 
+import "strconv"
+
 type Val string
 
 func NewVal(a Attrib) (Expr, error) {
 	quoted := attribToString(a)
-	unquoted := quoted[1 : len(quoted)-1]
-	unescaped := unescape(unquoted)
-	return Val(unescaped), nil
+	res, err := strconv.Unquote(quoted)
+	if err != nil {
+		panic(err)
+	}
+	return Val(res), nil
 }
 func (v Val) Eval(c *Context) Val {
 	return v
 }
 func (v Val) String() string {
-	return "\"" + string(v) + "\""
+	return strconv.Quote(string(v))
 }