This commit introduces support for calling functions within expressions.

The key changes are:

- Interpreter:
  - Added a new `NodeFunctionCall` AST node to represent a function call.
  - The interpreter can now execute functions passed in the variables map. It supports
    functions with 0 to 3 parameters of type `any`.
  - Implemented short-circuiting for `AND` and `OR` logical operators.
- Parser:
  - The parser now recognizes function call syntax (`identifier(...)`).
  - It can parse comma-separated arguments in function calls.
- Lexer:
  - Added a `TokenComma` to tokenize function argument lists.
- Conversions:
  - Type conversion functions now handle `func()` types, allowing for lazy evaluation
    of values.
- Testing:
  - Added a comprehensive test suite for the new function call functionality.

Author: vrancurel

conversions.go

@@ -12,6 +12,10 @@ func isNumber(v interface{}) bool {
 		return true
 	case float32, float64:
 		return true
+	case func() int:
+		return true
+	case func() float64:
+		return true
 	}
 	return false
 }
@@ -42,6 +46,10 @@ func toNumber(ast *Node, v interface{}) (float64, Error) {
 		return float64(n), nil
 	case float32:
 		return float64(n), nil
+	case func() int:
+		return float64(n()), nil
+	case func() float64:
+		return n(), nil
 	}
 	return 0, NewError(ast.Offset, ast.Length, "unable to convert to number: %v", v)
 }
@@ -64,6 +72,8 @@ func toString(v interface{}) string {
 		return string(s)
 	case []byte:
 		return string(s)
+	case func() string:
+		return s()
 	}
 	return fmt.Sprintf("%v", v)
 }
@@ -162,6 +172,10 @@ func normalize(v interface{}) interface{} {
 		return float64(n)
 	case []byte:
 		return string(n)
+	case func() int:
+		return float64(n())
+	case func() float64:
+		return n()
 	}
 
 	return v

interpreter.go

@@ -96,24 +96,44 @@ func (i *interpreter) run(ast *Node, value any) (any, Error) {
 			return value, nil
 		case "length":
 			// Special pseudo-property to get the value's length.
+			if s, ok := value.(func() string); ok {
+				return len(s()), nil
+			}
 			if s, ok := value.(string); ok {
 				return len(s), nil
 			}
 			if a, ok := value.([]any); ok {
 				return len(a), nil
 			}
 		case "lower":
+			if s, ok := value.(func() string); ok {
+				return strings.ToLower(s()), nil
+			}
 			if s, ok := value.(string); ok {
 				return strings.ToLower(s), nil
 			}
 		case "upper":
+			if s, ok := value.(func() string); ok {
+				return strings.ToUpper(s()), nil
+			}
 			if s, ok := value.(string); ok {
 				return strings.ToUpper(s), nil
 			}
 		}
 		if m, ok := value.(map[string]any); ok {
 			if v, ok := m[ast.Value.(string)]; ok {
-				return v, nil
+				switch n := v.(type) {
+				case func() int:
+					return n(), nil
+				case func() float64:
+					return n(), nil
+				case func() bool:
+					return n(), nil
+				case func() string:
+					return n(), nil
+				default:
+					return v, nil
+				}
 			}
 		}
 		if m, ok := value.(map[any]any); ok {
@@ -335,11 +355,21 @@ func (i *interpreter) run(ast *Node, value any) (any, Error) {
 		if err != nil {
 			return nil, err
 		}
+		left := toBool(resultLeft)
+		switch ast.Type {
+		case NodeAnd:
+			if !left {
+				return left, nil
+			}
+		case NodeOr:
+			if left {
+				return left, nil
+			}
+		}
 		resultRight, err := i.run(ast.Right, value)
 		if err != nil {
 			return nil, err
 		}
-		left := toBool(resultLeft)
 		right := toBool(resultRight)
 		switch ast.Type {
 		case NodeAnd:
@@ -470,6 +500,75 @@ func (i *interpreter) run(ast *Node, value any) (any, Error) {
 			}
 		}
 		return results, nil
+	case NodeFunctionCall:
+		funcName := ast.Left.Value.(string)
+		if m, ok := value.(map[string]any); ok {
+			if fn, ok := m[funcName]; ok {
+				// Get function parameters
+				params := []any{}
+				for _, param := range ast.Value.([]Node) {
+					paramValue, err := i.run(&param, value)
+					if err != nil {
+						return nil, err
+					}
+					params = append(params, paramValue)
+				}
+
+				// Execute function based on parameter count
+				switch f := fn.(type) {
+				case func() any:
+					if len(params) != 0 {
+						return nil, NewError(ast.Offset, ast.Length, "function %s expects 0 parameter, got %d", funcName, len(params))
+					}
+					result := f()
+					switch result.(type) {
+					case error:
+						return nil, NewError(ast.Offset, ast.Length, "Runtime error: %v", result.(error))
+					default:
+						return result, nil
+					}
+				case func(any) any:
+					if len(params) != 1 {
+						return nil, NewError(ast.Offset, ast.Length, "function %s expects 1 parameter, got %d", funcName, len(params))
+					}
+					result := f(params[0])
+					switch result.(type) {
+					case error:
+						return nil, NewError(ast.Offset, ast.Length, "Runtime error: %v", result.(error))
+					default:
+						return result, nil
+					}
+				case func(any, any) any:
+					if len(params) != 2 {
+						return nil, NewError(ast.Offset, ast.Length, "function %s expects 2 parameters, got %d", funcName, len(params))
+					}
+					result := f(params[0], params[1])
+					switch result.(type) {
+					case error:
+						return nil, NewError(ast.Offset, ast.Length, "Runtime error: %v", result.(error))
+					default:
+						return result, nil
+					}
+				case func(any, any, any) any:
+					if len(params) != 3 {
+						return nil, NewError(ast.Offset, ast.Length, "function %s expects 3 parameters, got %d", funcName, len(params))
+					}
+					result := f(params[0], params[1], params[2])
+					switch result.(type) {
+					case error:
+						return nil, NewError(ast.Offset, ast.Length, "Runtime error: %v", result.(error))
+					default:
+						return result, nil
+					}
+
+				}
+				return nil, NewError(ast.Offset, ast.Length, "unsupported function type for %s", funcName)
+			}
+		}
+		if i.strict {
+			return nil, NewError(ast.Offset, ast.Length, "function %s not found", funcName)
+		}
+		return nil, nil
 	}
 	return nil, nil
 }

interpreter_test.go

@@ -2,6 +2,7 @@ package mexpr
 
 import (
 	"encoding/json"
+	"fmt"
 	"reflect"
 	"strings"
 	"testing"
@@ -232,6 +233,124 @@ func TestInterpreter(t *testing.T) {
 	}
 }
 
+func TestFunctions(t *testing.T) {
+
+	varMap := make(map[string]interface{})
+
+	varMap["func0"] = func() any {
+		return 43.0
+	}
+
+	varMap["func1"] = func(param1 any) any {
+		switch param1.(type) {
+		case float64:
+			return param1.(float64) * 2
+		default:
+			return fmt.Errorf("Invalid type for param1")
+		}
+	}
+
+	varMap["func2"] = func(param1 any, param2 any) any {
+		switch param1.(type) {
+		case float64:
+			switch param2.(type) {
+			case float64:
+				return param1.(float64) * param2.(float64)
+			default:
+				return fmt.Errorf("Invalid type for param2")
+			}
+		default:
+			return fmt.Errorf("Invalid type for param1")
+		}
+	}
+
+	varMap["func3"] = func(param1 any, param2 any, param3 any) any {
+		switch param1.(type) {
+		case float64:
+			switch param2.(type) {
+			case float64:
+				switch param3.(type) {
+				case float64:
+					return param1.(float64) * param2.(float64) * param3.(float64)
+				default:
+					return fmt.Errorf("Invalid type for param3")
+				}
+			default:
+				return fmt.Errorf("Invalid type for param2")
+			}
+		default:
+			return fmt.Errorf("Invalid type for param1")
+		}
+	}
+
+	type test struct {
+		expr   string
+		output interface{}
+		err    string
+	}
+	cases := []test{
+		{expr: "func0()", output: 43.0},
+		{expr: "func1(42)", output: 84.0},
+		{expr: "func2(3,4)", output: 12.0},
+		{expr: "func3(2,3,4)", output: 24.0},
+		{expr: "func0(42)", err: "expects 0 parameter"},
+		{expr: "func1()", err: "expects 1 parameter"},
+		{expr: "func1(1,2)", err: "expects 1 parameter"},
+		{expr: "func2()", err: "expects 2 parameters"},
+		{expr: "func2(1)", err: "expects 2 parameters"},
+		{expr: "func2(1,2,3)", err: "expects 2 parameters"},
+		{expr: "func3()", err: "expects 3 parameters"},
+		{expr: "func3(1)", err: "expects 3 parameters"},
+		{expr: "func3(1,2)", err: "expects 3 parameters"},
+		{expr: "func3(1,2,3,4)", err: "expects 3 parameters"},
+		{expr: "func1(\"foo\")", err: "Invalid type for"},
+		{expr: "func2(\"foo\",\"bar\")", err: "Invalid type for"},
+		{expr: "func3(\"foo\",\"qux\",\"quz\")", err: "Invalid type for"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.expr, func(t *testing.T) {
+
+			ast, err := Parse(tc.expr, nil)
+
+			if ast != nil {
+				t.Log("graph G {\n" + ast.Dot("") + "\n}")
+			}
+
+			if tc.err != "" {
+				if err != nil {
+					if strings.Contains(err.Error(), tc.err) {
+						return
+					}
+					t.Fatal(err.Pretty(tc.expr))
+				}
+			} else {
+				if err != nil {
+					t.Fatal(err.Pretty(tc.expr))
+				}
+			}
+
+			result, err := Run(ast, varMap, StrictMode)
+			if tc.err != "" {
+				if err == nil {
+					t.Fatal("expected error but found none")
+				}
+				if strings.Contains(err.Error(), tc.err) {
+					return
+				}
+				t.Fatal(err.Pretty(tc.expr))
+			} else {
+				if err != nil {
+					t.Fatal(err.Pretty(tc.expr))
+				}
+				if !reflect.DeepEqual(tc.output, result) {
+					t.Fatalf("expected %v but found %v", tc.output, result)
+				}
+			}
+		})
+	}
+}
+
 func FuzzMexpr(f *testing.F) {
 	f.Fuzz(func(t *testing.T, s string) {
 		Eval(s, nil)

lexer.go

@@ -31,6 +31,7 @@ const (
 	TokenStringCompare
 	TokenWhere
 	TokenEOF
+	TokenComma // New token type for separating function parameters
 )
 
 func (t TokenType) String() string {
@@ -73,6 +74,8 @@ func (t TokenType) String() string {
 		return "where"
 	case TokenEOF:
 		return "eof"
+	case TokenComma:
+		return "comma"
 	}
 	return "unknown"
 }
@@ -97,6 +100,8 @@ func basic(input rune) TokenType {
 		return TokenMulDiv
 	case '^':
 		return TokenPower
+	case ',':
+		return TokenComma
 	}
 
 	return TokenUnknown