new operator 'map' ans general variable access by ${}

Also made a litle change to scanner function moveOn(): now it moves on
the last char passed and only if there are more than one chars.

README.adoc

@@ -0,0 +1,147 @@
+= README
+README about the Expressions calculator
+:authors: Celestino Amoroso
+:docinfo: shared
+:encoding: utf-8
+:toc: right
+:toclevels: 4
+//:toc-title: Indice Generale
+:icons: font
+:icon-set: fi
+:numbered:
+//:table-caption: Tabella
+//:figure-caption: Diagramma
+:docinfo1:
+:sectlinks:
+:sectanchors:
+:source-highlighter: rouge
+// :rouge-style: ThankfulEyes
+:rouge-style: gruvbox
+// :rouge-style: colorful
+//:rouge-style: monokay
+
+toc::[]
+
+== Expr
+_Expr_ is a GO package capable of analysing, interpreting and calculating expressions.
+
+A few examples to get started.
+
+.Examples taken from parser_test.go
+[source,go]
+----
+`1.0 / 2`                      // 0.5
+`435 + 105 * 2 - 1`            // 644
+`4 == (3-1)*(10/5)`            // true
+`"uno" * (2+1)`                // `unounouno`
+`2+3 but 5*2`                  // 10 <1>
+`add(add(1+4),3+2,5*(3-2))`    // 15 <2>
+`a=5; b=2; add(a, b*3)`        // 11 <3>
+`two=func(){2}; two()`         // 2  <4>
+`double=func(x){2*x}; a=4+1; two=func() {2}; (double(3+a) + 1) * two()`  // 34
+`import("./test-funcs.expr"); (double(3+a) + 1) * two()`  // 34 <5>
+`[1,2,"hello"]`                // Mixed types list
+`[1,2]+[3]`                    // append list, result: [1,2,3]
+`add([1,[2,2],3,2])`           // Deep list sum, result: 10 <2>
+`[a=1,b=2,c=3] but a+b+c`      // 6
+----
+
+<1> [blue]`but` operator.
+<2> The _add()_ function definition may be changed in the future.
+<3> Multiple expression. Only the last expression value will returned.
+<4> Simple function definition: _two()_ returns 2.
+<5> _import()_ function imports expressions from the specified files. See file _test-funcs.expr_.
+
+
+=== Usage
+
+
+[source,go]
+----
+package main
+
+import (
+	"fmt"
+	"strings"
+	"git.portale-stac.it/go-pkg/expr"
+)
+
+func main() {
+	ctx := expr.NewSimpleVarStore()
+	ctx.SetVar("var", 4)
+
+	source := `(3-1)*(10/5) == var`
+
+	r := strings.NewReader(source)
+	scanner := expr.NewScanner(r, expr.DefaultTranslations())
+	parser := expr.NewParser(ctx)
+
+	if ast, err := parser.Parse(scanner); err == nil {
+		if result, err := ast.Eval(ctx); err == nil {
+			fmt.Printf("%q -> %v [%T]\n", source, result, result)
+		} else {
+			fmt.Println("Error calculating the expression:", err)
+		}
+	} else {
+		fmt.Println("Error parsing the expression:", err)
+	}
+}
+----
+
+The above program is equivalent to the following one.
+
+[source,go]
+----
+package main
+
+import (
+	"fmt"
+	"git.portale-stac.it/go-pkg/expr"
+)
+
+func main() {
+	ctx := expr.NewSimpleVarStore()
+	ctx.SetVar("var", 4)
+
+	source := `(3-1)*(10/5) == var`
+
+	if result, err := expr.EvalString(ctx, source); err == nil {
+		fmt.Printf("%q -> %v [%T]\n", source, result, result)
+	} else {
+		fmt.Println("Error calculating the expression:", err)
+	}
+}
+----
+
+Here is another equivalent version.
+
+[source,go]
+----
+package main
+
+import (
+	"fmt"
+	"git.portale-stac.it/go-pkg/expr"
+)
+
+func main() {
+	source := `(3-1)*(10/5) == var`
+
+	if result, err := expr.EvalStringA(source, expr.Arg{"var", 4}); err == nil {
+		fmt.Printf("%q -> %v [%T]\n", source, result, result)
+	} else {
+		fmt.Println("Error calculating the expression:", err)
+	}
+}
+----
+
+== Context of evaluation
+Unless helpers functions like _expr.EvalStringA()_ are used, a _context_ is required to compute an expession.
+
+A context is an object that implements the _expr.ExprContext_ interface. This interface specifies a set of function to handle variables and functions.
+
+Variables and functions can be added to a context both programmatically and ad an effect of the expression computation.
+
+== Expressions syntax
+
+See https://cdn.paas.portale-stac.it/howto/go-pkg/expr/doc/Expr.html[Expr documentation] for a complete reference of the expression syntax and available functions.

ast.go

@@ -1,67 +1,89 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // ast.go
 package expr
 
 import (
-	"errors"
-	"fmt"
 	"strings"
 )
 
 //-------- ast
 
 type ast struct {
-	root *term
+	forest []*term
+	root   *term
 }
 
 func NewAst() *ast {
 	return &ast{}
 }
 
-func (self *ast) String() string {
+func (expr *ast) TypeName() string {
+	return "Expression"
+}
+
+func (expr *ast) ToForest() {
+	if expr.root != nil {
+		if expr.forest == nil {
+			expr.forest = make([]*term, 0)
+		}
+		expr.forest = append(expr.forest, expr.root)
+		expr.root = nil
+	}
+}
+
+func (expr *ast) String() string {
 	var sb strings.Builder
-	if self.root == nil {
+	if expr.root == nil {
 		sb.WriteString("(nil)")
 	} else {
-		self.root.toString(&sb)
+		expr.root.toString(&sb)
 	}
 	return sb.String()
 }
 
-func (self *ast) addTokens(tokens ...*Token) (err error) {
+func (expr *ast) addTokens(tokens ...*Token) (err error) {
 	for _, tk := range tokens {
-		if err = self.addToken(tk); err != nil {
+		if _, err = expr.addToken(tk); err != nil {
 			break
 		}
 	}
 	return
 }
 
-func (self *ast) addToken(tk *Token) (err error) {
-	if t := newTerm(tk, nil); t != nil {
-		err = self.addTerm(t)
+// func (expr *ast) addToken(tk *Token) (err error) {
+// 	_, err = expr.addToken2(tk)
+// 	return
+// }
+
+func (expr *ast) addToken(tk *Token) (t *term, err error) {
+	if t = newTerm(tk); t != nil {
+		err = expr.addTerm(t)
 	} else {
-		err = fmt.Errorf("No term constructor for token %q", tk.String())
+		err = tk.Errorf("unexpected token %q", tk.String())
 	}
 	return
 }
 
-func (self *ast) addTerm(node *term) (err error) {
-	if self.root == nil {
-		self.root = node
+func (expr *ast) addTerm(node *term) (err error) {
+	if expr.root == nil {
+		expr.root = node
 	} else {
-		self.root, err = self.insert(self.root, node)
+		expr.root, err = expr.insert(expr.root, node)
 	}
 	return
 }
 
-func (self *ast) insert(tree, node *term) (root *term, err error) {
+func (expr *ast) insert(tree, node *term) (root *term, err error) {
 	if tree.getPriority() < node.getPriority() {
 		root = tree
 		if tree.isComplete() {
 			var subRoot *term
 			last := tree.removeLastChild()
-			subRoot, err = self.insert(last, node)
-			subRoot.setParent(tree)
+			if subRoot, err = expr.insert(last, node); err == nil {
+				subRoot.setParent(tree)
+			}
 		} else {
 			node.setParent(tree)
 		}
@@ -69,16 +91,40 @@ func (self *ast) insert(tree, node *term) (root *term, err error) {
 		root = node
 		tree.setParent(node)
 	} else {
-		err = fmt.Errorf("two adjacent operators: %q and %q", tree, node)
+		err = node.Errorf("two adjacent operators: %q and %q", tree, node)
 	}
 	return
 }
 
-func (self *ast) eval(ctx exprContext) (result any, err error) {
-	if self.root != nil {
-		result, err = self.root.compute(ctx)
-	} else {
-		err = errors.New("empty expression")
+func (expr *ast) Finish() {
+	if expr.root == nil && expr.forest != nil && len(expr.forest) >= 1 {
+		expr.root = expr.forest[len(expr.forest)-1]
+		expr.forest = expr.forest[0 : len(expr.forest)-1]
+	}
+}
+
+func (expr *ast) Eval(ctx ExprContext) (result any, err error) {
+	expr.Finish()
+
+	if expr.root != nil {
+		// initDefaultVars(ctx)
+		if expr.forest != nil {
+			for _, root := range expr.forest {
+				if result, err = root.compute(ctx); err == nil {
+					ctx.UnsafeSetVar(ControlLastResult, result)
+				} else {
+					//err = fmt.Errorf("error in expression nr %d: %v", i+1, err)
+					break
+				}
+			}
+		}
+		if err == nil {
+			if result, err = expr.root.compute(ctx); err == nil {
+				ctx.UnsafeSetVar(ControlLastResult, result)
+			}
+		}
+		// } else {
+		// 	err = errors.New("empty expression")
 	}
 	return
 }

bind-expr-functions.go

@@ -0,0 +1,59 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// function.go
+package expr
+
+// ---- Linking with Expr functions
+type exprFunctor struct {
+	baseFunctor
+	params []ExprFuncParam
+	expr   Expr
+	defCtx ExprContext
+}
+
+func (functor *exprFunctor) GetParams() (params []ExprFuncParam) {
+	return functor.params
+}
+
+func newExprFunctor(e Expr, params []ExprFuncParam, ctx ExprContext) *exprFunctor {
+	var defCtx ExprContext
+	if ctx != nil {
+		defCtx = ctx
+	}
+	return &exprFunctor{expr: e, params: params, defCtx: defCtx}
+}
+
+func (functor *exprFunctor) TypeName() string {
+	return "ExprFunctor"
+}
+
+func (functor *exprFunctor) GetDefinitionContext() ExprContext {
+	return functor.defCtx
+}
+
+func (functor *exprFunctor) InvokeNamed(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var missing []string
+	for _, p := range functor.params {
+		if arg, exists := args[p.Name()]; exists {
+			if funcArg, ok := arg.(Functor); ok {
+				paramSpecs := funcArg.GetParams()
+				ctx.RegisterFunc(p.Name(), funcArg, TypeAny, paramSpecs)
+			} else {
+				ctx.UnsafeSetVar(p.Name(), arg)
+			}
+		} else {
+			if missing == nil {
+				missing = make([]string, 0, 1)
+			}
+			missing = append(missing, p.Name())
+			// ctx.UnsafeSetVar(p.Name(), nil)
+		}
+	}
+	if missing != nil {
+		err = ErrMissingParams(name, missing)
+	} else {
+		result, err = functor.expr.Eval(ctx)
+	}
+	return
+}

bind-go-functions.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// bind-go-function.go
+package expr
+
+// ---- Linking with Go functions
+type golangFunctor struct {
+	baseFunctor
+	f FuncTemplate
+}
+
+func NewGolangFunctor(f FuncTemplate) *golangFunctor {
+	return &golangFunctor{f: f}
+}
+
+func (functor *golangFunctor) TypeName() string {
+	return "GoFunctor"
+}
+
+func (functor *golangFunctor) InvokeNamed(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	return functor.f(ctx, name, args)
+}

builtin-base.go

@@ -0,0 +1,316 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtin-base.go
+package expr
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+)
+
+const (
+	ParamDenominator = "denominator"
+)
+
+func isNilFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	result = args[ParamValue] == nil
+	return
+}
+
+func isIntFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	result = IsInteger(args[ParamValue])
+	return
+}
+
+func isFloatFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	result = IsFloat(args[ParamValue])
+	return
+}
+
+func isBoolFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	result = IsBool(args[ParamValue])
+	return
+}
+
+func isStringFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	result = IsString(args[ParamValue])
+	return
+}
+
+func isFractionFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	result = IsFract(args[ParamValue])
+	return
+}
+
+func isRationalFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	result = IsRational(args[ParamValue])
+	return
+}
+
+func isListFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	result = IsList(args[ParamValue])
+	return
+}
+
+func isDictionaryFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	result = IsDict(args[ParamValue])
+	return
+}
+
+func boolFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	switch v := args[ParamValue].(type) {
+	case int64:
+		result = (v != 0)
+	case *FractionType:
+		result = v.num != 0
+	case float64:
+		result = v != 0.0
+	case bool:
+		result = v
+	case string:
+		result = len(v) > 0
+	case *ListType:
+		result = len(*v) > 0
+	case *DictType:
+		result = len(*v) > 0
+	default:
+		err = ErrCantConvert(name, v, "bool")
+	}
+	return
+}
+
+func intFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	switch v := args[ParamValue].(type) {
+	case int64:
+		result = v
+	case float64:
+		result = int64(math.Trunc(v))
+	case bool:
+		if v {
+			result = int64(1)
+		} else {
+			result = int64(0)
+		}
+	case string:
+		var i int
+		if i, err = strconv.Atoi(v); err == nil {
+			result = int64(i)
+		}
+	case *FractionType:
+		result = int64(v.num / v.den)
+	default:
+		err = ErrCantConvert(name, v, "int")
+	}
+	return
+}
+
+func decFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	switch v := args[ParamValue].(type) {
+	case int64:
+		result = float64(v)
+	case float64:
+		result = v
+	case bool:
+		if v {
+			result = float64(1)
+		} else {
+			result = float64(0)
+		}
+	case string:
+		var f float64
+		if f, err = strconv.ParseFloat(v, 64); err == nil {
+			result = f
+		}
+	case *FractionType:
+		result = v.toFloat()
+	default:
+		err = ErrCantConvert(name, v, "float")
+	}
+	return
+}
+
+func stringFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	switch v := args[ParamValue].(type) {
+	case int64:
+		result = strconv.FormatInt(v, 10)
+	case float64:
+		result = strconv.FormatFloat(v, 'g', -1, 64)
+	case bool:
+		if v {
+			result = "true"
+		} else {
+			result = "false"
+		}
+	case string:
+		result = v
+	case *FractionType:
+		result = v.ToString(0)
+	case Formatter:
+		result = v.ToString(0)
+	case fmt.Stringer:
+		result = v.String()
+	default:
+		err = ErrCantConvert(name, v, "string")
+	}
+	return
+}
+
+func fractFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	switch v := args[ParamValue].(type) {
+	case int64:
+		var den int64 = 1
+
+		var ok bool
+		if den, ok = args[ParamDenominator].(int64); !ok {
+			err = ErrExpectedGot(name, "integer", args[ParamDenominator])
+		} else if den == 0 {
+			err = ErrFuncDivisionByZero(name)
+		}
+
+		if err == nil {
+			result = newFraction(v, den)
+		}
+	case float64:
+		result, err = float64ToFraction(v)
+	case bool:
+		if v {
+			result = newFraction(1, 1)
+		} else {
+			result = newFraction(0, 1)
+		}
+	case string:
+		result, err = makeGeneratingFraction(v)
+	case *FractionType:
+		result = v
+	default:
+		err = ErrCantConvert(name, v, "float")
+	}
+	return
+}
+
+// func iteratorFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+// 	return
+// }
+
+func evalFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	if source, ok := args[ParamSource].(string); ok {
+		var expr Expr
+
+		parser := NewParser()
+		if ctx == nil {
+			ctx = NewSimpleStore()
+		}
+
+		r := strings.NewReader(source)
+		scanner := NewScanner(r, DefaultTranslations())
+
+		if expr, err = parser.Parse(scanner); err == nil {
+			CtrlEnable(ctx, control_export_all)
+			result, err = expr.Eval(ctx)
+		}
+	} else {
+		err = ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+	}
+	return
+}
+
+func varFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var varName string
+	var ok bool
+
+	if varName, ok = args[ParamName].(string); !ok {
+		return nil, ErrWrongParamType(name, ParamName, TypeString, args[ParamName])
+	}
+
+	if result, ok = args[ParamValue]; ok && result != nil {
+		ctx.GetParent().UnsafeSetVar(varName, result)
+		// } else {
+		// 	err = ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+		// }
+	} else if result, ok = ctx.GetVar(varName); !ok {
+		err = ErrUnknownVar(name, varName)
+	}
+	return
+}
+
+func setFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var varName string
+	var ok bool
+
+	if varName, ok = args[ParamName].(string); !ok {
+		return nil, ErrWrongParamType(name, ParamName, TypeString, args[ParamName])
+	}
+
+	if result, ok = args[ParamValue]; ok {
+		ctx.GetParent().UnsafeSetVar(varName, result)
+	} else {
+		err = ErrWrongParamType(name, ParamValue, TypeAny, args[ParamValue])
+	}
+	return
+}
+
+func unsetFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var varName string
+	var ok bool
+
+	if varName, ok = args[ParamName].(string); !ok {
+		return nil, ErrWrongParamType(name, ParamName, TypeString, args[ParamName])
+	} else {
+		ctx.GetParent().DeleteVar(varName)
+		result = nil
+	}
+	return
+}
+
+//// import
+
+func ImportBuiltinsFuncs(ctx ExprContext) {
+	anyParams := []ExprFuncParam{
+		NewFuncParam(ParamValue),
+	}
+
+	ctx.RegisterFunc("isNil", NewGolangFunctor(isNilFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isInt", NewGolangFunctor(isIntFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isFloat", NewGolangFunctor(isFloatFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isBool", NewGolangFunctor(isBoolFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isString", NewGolangFunctor(isStringFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isFract", NewGolangFunctor(isFractionFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isRational", NewGolangFunctor(isRationalFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isList", NewGolangFunctor(isListFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("isDict", NewGolangFunctor(isDictionaryFunc), TypeBoolean, anyParams)
+
+	ctx.RegisterFunc("bool", NewGolangFunctor(boolFunc), TypeBoolean, anyParams)
+	ctx.RegisterFunc("int", NewGolangFunctor(intFunc), TypeInt, anyParams)
+	ctx.RegisterFunc("dec", NewGolangFunctor(decFunc), TypeFloat, anyParams)
+	ctx.RegisterFunc("string", NewGolangFunctor(stringFunc), TypeString, anyParams)
+	ctx.RegisterFunc("fract", NewGolangFunctor(fractFunc), TypeFraction, []ExprFuncParam{
+		NewFuncParam(ParamValue),
+		NewFuncParamFlagDef(ParamDenominator, PfDefault, int64(1)),
+	})
+
+	ctx.RegisterFunc("eval", NewGolangFunctor(evalFunc), TypeAny, []ExprFuncParam{
+		NewFuncParam(ParamSource),
+	})
+
+	ctx.RegisterFunc("var", NewGolangFunctor(varFunc), TypeAny, []ExprFuncParam{
+		NewFuncParam(ParamName),
+		NewFuncParamFlagDef(ParamValue, PfDefault, nil),
+	})
+
+	ctx.RegisterFunc("set", NewGolangFunctor(setFunc), TypeAny, []ExprFuncParam{
+		NewFuncParam(ParamName),
+		NewFuncParam(ParamValue),
+	})
+
+	ctx.RegisterFunc("unset", NewGolangFunctor(unsetFunc), TypeAny, []ExprFuncParam{
+		NewFuncParam(ParamName),
+		NewFuncParam(ParamValue),
+	})
+}
+
+func init() {
+	RegisterBuiltinModule("base", ImportBuiltinsFuncs, "Base expression tools like isNil(), int(), etc.")
+}

builtin-fmt.go

@@ -0,0 +1,57 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtin-fmt.go
+package expr
+
+import (
+	"fmt"
+	"io"
+	"os"
+)
+
+func getStdout(ctx ExprContext) io.Writer {
+	var w io.Writer
+	if wany, exists := ctx.GetVar(ControlStdout); exists && wany != nil {
+		w, _ = wany.(io.Writer)
+	}
+	if w == nil {
+		w = os.Stdout
+	}
+	return w
+}
+
+func printFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var n int = 0
+	if v, exists := args[ParamItem]; exists && v != nil {
+		argv := v.([]any)
+		n, err = fmt.Fprint(getStdout(ctx), argv...)
+	}
+	result = int64(n)
+	return
+}
+
+func printLnFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var n int = 0
+	if v, exists := args[ParamItem]; exists && v != nil {
+		argv := v.([]any)
+		n, err = fmt.Fprintln(getStdout(ctx), argv...)
+	} else {
+		n, err = fmt.Fprintln(getStdout(ctx))
+	}
+	result = int64(n)
+	return
+}
+
+func ImportFmtFuncs(ctx ExprContext) {
+	ctx.RegisterFunc("print", NewGolangFunctor(printFunc), TypeInt, []ExprFuncParam{
+		NewFuncParamFlag(ParamItem, PfRepeat),
+	})
+	ctx.RegisterFunc("println", NewGolangFunctor(printLnFunc), TypeInt, []ExprFuncParam{
+		NewFuncParamFlag(ParamItem, PfRepeat),
+	})
+}
+
+func init() {
+	RegisterBuiltinModule("fmt", ImportFmtFuncs, "String and console formatting functions")
+}

builtin-import.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtin-import.go
+package expr
+
+import (
+	"io"
+	"os"
+)
+
+func importFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	return importGeneral(ctx, name, args)
+}
+
+func importAllFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	CtrlEnable(ctx, control_export_all)
+	return importGeneral(ctx, name, args)
+}
+
+func importGeneral(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	dirList := buildSearchDirList("sources", ENV_EXPR_SOURCE_PATH)
+	if v, exists := args[ParamFilepath]; exists && v != nil {
+		argv := v.([]any)
+		result, err = doImport(ctx, name, dirList, NewArrayIterator(argv))
+	}
+	return
+}
+
+func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (result any, err error) {
+	var v any
+	var sourceFilepath string
+
+	for v, err = it.Next(); err == nil; v, err = it.Next() {
+		if err = checkStringParamExpected(name, v, it.Index()); err != nil {
+			break
+		}
+		if sourceFilepath, err = makeFilepath(v.(string), dirList); err != nil {
+			break
+		}
+		var file *os.File
+		if file, err = os.Open(sourceFilepath); err == nil {
+			defer file.Close()
+			var expr *ast
+			scanner := NewScanner(file, DefaultTranslations())
+			parser := NewParser()
+			if expr, err = parser.parseGeneral(scanner, allowMultiExpr|allowVarRef, SymEos); err == nil {
+				result, err = expr.Eval(ctx)
+			}
+			if err != nil {
+				break
+			}
+		} else {
+			break
+		}
+	}
+	if err != nil {
+		if err == io.EOF {
+			err = nil
+		} else {
+			result = nil
+		}
+	}
+	return
+}
+
+func ImportImportFuncs(ctx ExprContext) {
+	ctx.RegisterFunc("import", NewGolangFunctor(importFunc), TypeAny, []ExprFuncParam{
+		NewFuncParamFlag(ParamFilepath, PfRepeat),
+	})
+	ctx.RegisterFunc("importAll", NewGolangFunctor(importAllFunc), TypeAny, []ExprFuncParam{
+		NewFuncParamFlag(ParamFilepath, PfRepeat),
+	})
+}
+
+func init() {
+	RegisterBuiltinModule("import", ImportImportFuncs, "Functions import() and include()")
+}

builtin-iterator.go

@@ -0,0 +1,112 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtin-iterator.go
+package expr
+
+import (
+	"fmt"
+	"io"
+)
+
+const (
+	iterParamOperator = "operator"
+	iterParamVars     = "vars"
+	iterVarStatus     = "status"
+)
+
+func parseRunArgs(localCtx ExprContext, args map[string]any) (it Iterator, op Functor, err error) {
+	var ok bool
+
+	if it, ok = args[ParamIterator].(Iterator); !ok {
+		err = fmt.Errorf("paramter %q must be an iterator, passed %v [%s]", ParamIterator, args[ParamIterator], TypeName(args[ParamIterator]))
+		return
+	}
+
+	if args[iterParamOperator] != nil {
+		if op, ok = args[iterParamOperator].(Functor); !ok || op == nil {
+			err = fmt.Errorf("paramter %q must be a function, passed %v [%s]", iterParamOperator, args[iterParamOperator], TypeName(args[iterParamOperator]))
+			return
+		}
+	}
+
+	var vars *DictType
+	if vars, ok = args[iterParamVars].(*DictType); !ok && args[iterParamVars] != nil {
+		err = fmt.Errorf("paramter %q must be a dictionary, passed %v [%s]", iterParamVars, args[iterParamVars], TypeName(args[iterParamVars]))
+		return
+	}
+
+	if vars != nil {
+		for key, value := range *vars {
+			var varName string
+			if varName, ok = key.(string); ok {
+				localCtx.UnsafeSetVar(varName, value)
+			}
+		}
+	}
+
+	return
+}
+
+func runFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var it Iterator
+	var ok bool
+	var op Functor
+	var v any
+	// var usingDefaultOp = false
+	var params map[string]any
+	var item any
+
+	localCtx := ctx.Clone()
+	localCtx.UnsafeSetVar(iterVarStatus, nil)
+
+	if it, op, err = parseRunArgs(localCtx, args); err != nil {
+		return
+		// } else if op == nil {
+		// 	op = NewGolangFunctor(printLnFunc)
+		// 	usingDefaultOp = true
+	}
+
+	for item, err = it.Next(); err == nil; item, err = it.Next() {
+		// if usingDefaultOp {
+		// 	params = map[string]any{ParamItem: []any{item}}
+		// } else {
+		// params = map[string]any{ParamIndex: it.Index(), ParamItem: item}
+		// }
+
+		if op != nil {
+			params = map[string]any{ParamIndex: it.Index(), ParamItem: item}
+			if v, err = op.InvokeNamed(localCtx, iterParamOperator, params); err != nil {
+				break
+			} else {
+				var success bool
+				if success, ok = ToBool(v); !success || !ok {
+					break
+				}
+			}
+		}
+	}
+
+	if err == io.EOF {
+		err = nil
+	}
+	if err == nil {
+		if op == nil {
+			ctx.UnsafeSetVar(iterVarStatus, it.Count())
+		}
+		result, _ = localCtx.GetVar(iterVarStatus)
+	}
+	return
+}
+
+func ImportIterFuncs(ctx ExprContext) {
+	ctx.RegisterFunc("run", NewGolangFunctor(runFunc), TypeAny, []ExprFuncParam{
+		NewFuncParam(ParamIterator),
+		NewFuncParamFlag(iterParamOperator, PfOptional),
+		NewFuncParamFlag(iterParamVars, PfOptional),
+	})
+}
+
+func init() {
+	RegisterBuiltinModule("iterator", ImportIterFuncs, "Iterator helper functions")
+}

builtin-math-arith.go

@@ -0,0 +1,183 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtin-math-arith.go
+package expr
+
+import (
+	"fmt"
+	"io"
+)
+
+func checkNumberParamExpected(funcName string, paramValue any, paramPos, level, subPos int) (err error) {
+	if !(IsNumber(paramValue) || isFraction(paramValue)) /*|| isList(paramValue)*/ {
+		err = fmt.Errorf("%s(): param nr %d (%d in %d) has wrong type %T, number expected",
+			funcName, paramPos+1, subPos+1, level, paramValue)
+	}
+	return
+}
+
+func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result any, err error) {
+	var sumAsFloat, sumAsFract bool
+	var floatSum float64 = 0.0
+	var intSum int64 = 0
+	var fractSum *FractionType
+	var v any
+
+	level++
+
+	for v, err = it.Next(); err == nil; v, err = it.Next() {
+		if list, ok := v.(*ListType); ok {
+			v = NewListIterator(list, nil)
+		}
+		if subIter, ok := v.(Iterator); ok {
+			if v, err = doAdd(ctx, name, subIter, count, level); err != nil {
+				break
+			}
+			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(CleanName) {
+				if _, err = extIter.CallOperation(CleanName, nil); err != nil {
+					return
+				}
+			}
+		} else if err = checkNumberParamExpected(name, v, count, level, it.Index()); err != nil {
+			break
+		}
+		count++
+
+		if !sumAsFloat {
+			if IsFloat(v) {
+				sumAsFloat = true
+				if sumAsFract {
+					floatSum = fractSum.toFloat()
+				} else {
+					floatSum = float64(intSum)
+				}
+			} else if !sumAsFract && isFraction(v) {
+				fractSum = newFraction(intSum, 1)
+				sumAsFract = true
+			}
+		}
+
+		if sumAsFloat {
+			floatSum += numAsFloat(v)
+		} else if sumAsFract {
+			var item *FractionType
+			var ok bool
+			if item, ok = v.(*FractionType); !ok {
+				iv, _ := v.(int64)
+				item = newFraction(iv, 1)
+			}
+			fractSum = sumFract(fractSum, item)
+		} else {
+			iv, _ := v.(int64)
+			intSum += iv
+		}
+	}
+	if err == nil || err == io.EOF {
+		err = nil
+		if sumAsFloat {
+			result = floatSum
+		} else if sumAsFract {
+			result = fractSum
+		} else {
+			result = intSum
+		}
+	}
+	return
+}
+
+func addFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	argv := args[ParamValue].([]any)
+	result, err = doAdd(ctx, name, NewArrayIterator(argv), 0, -1)
+	return
+}
+
+func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result any, err error) {
+	var mulAsFloat, mulAsFract bool
+	var floatProd float64 = 1.0
+	var intProd int64 = 1
+	var fractProd *FractionType
+	var v any
+
+	level++
+	for v, err = it.Next(); err == nil; v, err = it.Next() {
+		if list, ok := v.(*ListType); ok {
+			v = NewListIterator(list, nil)
+		}
+		if subIter, ok := v.(Iterator); ok {
+			if v, err = doMul(ctx, name, subIter, count, level); err != nil {
+				break
+			}
+			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(CleanName) {
+				if _, err = extIter.CallOperation(CleanName, nil); err != nil {
+					return
+				}
+			}
+		} else {
+			if err = checkNumberParamExpected(name, v, count, level, it.Index()); err != nil {
+				break
+			}
+		}
+		count++
+
+		if !mulAsFloat {
+			if IsFloat(v) {
+				mulAsFloat = true
+				if mulAsFract {
+					floatProd = fractProd.toFloat()
+				} else {
+					floatProd = float64(intProd)
+				}
+			} else if !mulAsFract && isFraction(v) {
+				fractProd = newFraction(intProd, 1)
+				mulAsFract = true
+			}
+		}
+
+		if mulAsFloat {
+			floatProd *= numAsFloat(v)
+		} else if mulAsFract {
+			var item *FractionType
+			var ok bool
+			if item, ok = v.(*FractionType); !ok {
+				iv, _ := v.(int64)
+				item = newFraction(iv, 1)
+			}
+			fractProd = mulFract(fractProd, item)
+		} else {
+			iv, _ := v.(int64)
+			intProd *= iv
+		}
+	}
+	if err == nil || err == io.EOF {
+		err = nil
+		if mulAsFloat {
+			result = floatProd
+		} else if mulAsFract {
+			result = fractProd
+		} else {
+			result = intProd
+		}
+	}
+	return
+}
+
+func mulFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	argv := args[ParamValue].([]any)
+	result, err = doMul(ctx, name, NewArrayIterator(argv), 0, -1)
+	return
+}
+
+func ImportMathFuncs(ctx ExprContext) {
+	ctx.RegisterFunc("add", NewGolangFunctor(addFunc), TypeNumber, []ExprFuncParam{
+		NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(0)),
+	})
+
+	ctx.RegisterFunc("mul", NewGolangFunctor(mulFunc), TypeNumber, []ExprFuncParam{
+		NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(1)),
+	})
+}
+
+func init() {
+	RegisterBuiltinModule("math.arith", ImportMathFuncs, "Functions add() and mul()")
+}

builtin-os-file-iter.go

@@ -0,0 +1,149 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtin-os-file.go
+package expr
+
+import (
+	"fmt"
+	"io"
+	"slices"
+)
+
+const paramHandleOrPath = "handle-or-path"
+const fileReadTextIteratorType = "fileReadTextIterator"
+
+type fileReadTextIterator struct {
+	osReader  *osReader
+	index     int
+	count     int
+	line      string
+	autoClose bool
+}
+
+func newReadTextIterator(r *osReader, autoClose bool) *fileReadTextIterator {
+	return &fileReadTextIterator{osReader: r, index: -1, autoClose: autoClose}
+}
+
+func (it *fileReadTextIterator) TypeName() string {
+	return fileReadTextIteratorType
+}
+
+func (it *fileReadTextIterator) String() string {
+	if it.osReader != nil && it.osReader.fh != nil {
+		return fmt.Sprintf("$(%s@%q)", fileReadTextIteratorType, it.osReader.fh.Name())
+	}
+	return fmt.Sprintf("$(%s@<nil>)", fileReadTextIteratorType)
+}
+
+func (it *fileReadTextIterator) Count() int {
+	return it.count
+}
+
+func (it *fileReadTextIterator) Next() (item any, err error) { // must return io.EOF after the last item
+	if it.osReader.fh != nil {
+		if it.line, err = it.osReader.reader.ReadString('\n'); err == nil {
+			it.index++
+			it.count++
+			item = it.line[0 : len(it.line)-1]
+		} else if it.autoClose {
+			it.Clean()
+		}
+	}
+	return
+}
+
+func (it *fileReadTextIterator) Current() (item any, err error) {
+	if len(it.line) > 0 {
+		item = it.line[0 : len(it.line)-1]
+	}
+	return
+}
+
+func (it *fileReadTextIterator) Index() int {
+	return it.index
+}
+
+func (it *fileReadTextIterator) Reset() (err error) {
+	if _, err = it.osReader.fh.Seek(0, io.SeekStart); err == nil {
+		it.index = -1
+		it.count = 0
+		it.line = ""
+	}
+	return
+}
+
+func (it *fileReadTextIterator) HasOperation(name string) bool {
+	return slices.Contains([]string{NextName, ResetName, IndexName, CountName, CurrentName, CleanName}, name)
+}
+
+func (it *fileReadTextIterator) Clean() (err error) {
+	if it.osReader.fh != nil {
+		if err = it.osReader.fh.Close(); err == nil {
+			it.osReader = nil
+		}
+	}
+	return nil
+}
+
+func (it *fileReadTextIterator) CallOperation(name string, args map[string]any) (v any, err error) {
+	switch name {
+	case NextName:
+		v, err = it.Next()
+	case ResetName:
+		err = it.Reset()
+	case CleanName:
+		err = it.Clean()
+	case IndexName:
+		v = int64(it.Index())
+	case CurrentName:
+		v, err = it.Current()
+	case CountName:
+		v = it.count
+	default:
+		err = errNoOperation(name)
+	}
+	return
+}
+
+func fileReadIteratorFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var handle *osReader
+	var invalidFileHandle any
+	var ok, autoClose bool
+
+	result = nil
+	if handle, ok = args[paramHandleOrPath].(*osReader); !ok {
+		if fileName, ok := args[paramHandleOrPath].(string); ok && len(fileName) > 0 {
+			var handleAny any
+			if handleAny, err = openFileFunc(ctx, name, map[string]any{ParamFilepath: fileName}); err != nil {
+				return
+			}
+			if handleAny != nil {
+				handle = handleAny.(*osReader)
+				autoClose = true
+			}
+		} else {
+			invalidFileHandle = args[paramHandleOrPath]
+		}
+	}
+
+	if handle != nil {
+		result = newReadTextIterator(handle, autoClose)
+
+	}
+
+	if err == nil && (handle == nil || invalidFileHandle != nil) {
+		err = errInvalidFileHandle(name, invalidFileHandle)
+	}
+	return
+}
+
+// func ImportOsIterFuncs(ctx ExprContext) {
+// 	ctx.RegisterFunc("fileReadIterator", NewGolangFunctor(fileReadIteratorFunc), TypeIterator, []ExprFuncParam{
+// 		NewFuncParam(paramHandleOrPath),
+// 	})
+// }
+
+// func init() {
+// 	RegisterBuiltinModule("os.file", ImportOsIterFuncs, "Operating system file iterator functions")
+// }

builtin-os-file.go

@@ -0,0 +1,261 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtin-os-file.go
+package expr
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+)
+
+const (
+	osLimitCh = "limitCh"
+)
+
+type osHandle interface {
+	getFile() *os.File
+}
+
+type osWriter struct {
+	fh     *os.File
+	writer *bufio.Writer
+}
+
+func (h *osWriter) TypeName() string {
+	return "osWriter"
+}
+
+func (h *osWriter) String() string {
+	return "writer"
+}
+
+func (h *osWriter) getFile() *os.File {
+	return h.fh
+}
+
+type osReader struct {
+	fh     *os.File
+	reader *bufio.Reader
+}
+
+func (h *osReader) TypeName() string {
+	return "osReader"
+}
+
+func (h *osReader) String() string {
+	return "reader"
+}
+
+func (h *osReader) getFile() *os.File {
+	return h.fh
+}
+
+func errMissingFilePath(funcName string) error {
+	return fmt.Errorf("%s(): missing or invalid file path", funcName)
+}
+
+func errInvalidFileHandle(funcName string, v any) error {
+	if v != nil {
+		return fmt.Errorf("%s(): invalid file handle %v [%T]", funcName, v, v)
+	} else {
+		return fmt.Errorf("%s(): invalid file handle", funcName)
+	}
+}
+
+func createFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 {
+		var fh *os.File
+		if fh, err = os.Create(filePath); err == nil {
+			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
+		}
+	} else {
+		err = errMissingFilePath(name)
+	}
+	return
+}
+
+func openFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 {
+		var fh *os.File
+		if fh, err = os.Open(filePath); err == nil {
+			result = &osReader{fh: fh, reader: bufio.NewReader(fh)}
+		}
+	} else {
+		err = errMissingFilePath(name)
+	}
+	return
+}
+
+func appendFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 {
+		var fh *os.File
+		if fh, err = os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0660); err == nil {
+			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
+		}
+	} else {
+		err = errMissingFilePath(name)
+	}
+	return
+}
+
+func closeFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var handle osHandle
+	var invalidFileHandle any
+	var ok bool
+
+	if handle, ok = args[ParamHandle].(osHandle); !ok {
+		invalidFileHandle = args[ParamHandle]
+	}
+
+	if handle != nil {
+		if fh := handle.getFile(); fh != nil {
+			if w, ok := handle.(*osWriter); ok {
+				err = w.writer.Flush()
+			}
+
+			if err == nil {
+				err = fh.Close()
+			}
+		}
+	}
+	if err == nil && (handle == nil || invalidFileHandle != nil) {
+		err = errInvalidFileHandle(name, handle)
+	}
+	result = err == nil
+	return
+}
+
+func fileWriteTextFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var handle osHandle
+	var invalidFileHandle any
+	var ok bool
+
+	if handle, ok = args[ParamHandle].(osHandle); !ok {
+		invalidFileHandle = args[ParamHandle]
+	}
+
+	if handle != nil {
+		if w, ok := handle.(*osWriter); ok {
+			if v, exists := args[ParamItem]; exists {
+				argv := v.([]any)
+				result, err = fmt.Fprint(w.writer, argv...)
+			}
+		} else {
+			invalidFileHandle = handle
+		}
+	}
+
+	if err == nil && (handle == nil || invalidFileHandle != nil) {
+		err = errInvalidFileHandle(name, invalidFileHandle)
+	}
+	return
+}
+
+func fileReadTextFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var handle osHandle
+	var invalidFileHandle any
+	var ok bool
+
+	result = nil
+	if handle, ok = args[ParamHandle].(osHandle); !ok || args[ParamHandle] == nil {
+		invalidFileHandle = args[ParamHandle]
+	}
+
+	if handle != nil {
+		if r, ok := handle.(*osReader); ok {
+			var limit byte = '\n'
+			var v string
+			if s, ok := args[osLimitCh].(string); ok && len(s) > 0 {
+				limit = s[0]
+			}
+
+			v, err = r.reader.ReadString(limit)
+			if err == io.EOF {
+				err = nil
+			}
+			if len(v) > 0 {
+				if v[len(v)-1] == limit {
+					result = v[0 : len(v)-1]
+				} else {
+					result = v
+				}
+			}
+		} else {
+			invalidFileHandle = handle
+		}
+	}
+
+	if err == nil && (handle == nil || invalidFileHandle != nil) {
+		err = errInvalidFileHandle(name, invalidFileHandle)
+	}
+	return
+}
+
+func fileReadTextAllFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var handle osHandle
+	var invalidFileHandle any
+	var ok bool
+
+	result = nil
+	if handle, ok = args[ParamHandle].(osHandle); !ok || args[ParamHandle] == nil {
+		invalidFileHandle = args[ParamHandle]
+	}
+
+	if handle != nil {
+		if r, ok := handle.(*osReader); ok {
+			var b []byte
+			b, err = io.ReadAll(r.reader)
+			result = string(b)
+		} else {
+			invalidFileHandle = handle
+		}
+	}
+
+	if err == nil && (handle == nil || invalidFileHandle != nil) {
+		err = errInvalidFileHandle(name, invalidFileHandle)
+	}
+	return
+}
+
+func ImportOsFuncs(ctx ExprContext) {
+	ctx.RegisterFunc("fileOpen", NewGolangFunctor(openFileFunc), TypeFileHandle, []ExprFuncParam{
+		NewFuncParam(ParamFilepath),
+	})
+
+	ctx.RegisterFunc("fileAppend", NewGolangFunctor(appendFileFunc), TypeFileHandle, []ExprFuncParam{
+		NewFuncParam(ParamFilepath),
+	})
+
+	ctx.RegisterFunc("fileCreate", NewGolangFunctor(createFileFunc), TypeFileHandle, []ExprFuncParam{
+		NewFuncParam(ParamFilepath),
+	})
+
+	ctx.RegisterFunc("fileClose", NewGolangFunctor(closeFileFunc), TypeBoolean, []ExprFuncParam{
+		NewFuncParam(ParamHandle),
+	})
+
+	ctx.RegisterFunc("fileWriteText", NewGolangFunctor(fileWriteTextFunc), TypeInt, []ExprFuncParam{
+		NewFuncParam(ParamHandle),
+		NewFuncParamFlagDef(ParamItem, PfDefault|PfRepeat, ""),
+	})
+
+	ctx.RegisterFunc("fileReadText", NewGolangFunctor(fileReadTextFunc), TypeString, []ExprFuncParam{
+		NewFuncParam(ParamHandle),
+		NewFuncParamFlagDef(osLimitCh, PfDefault, "\n"),
+	})
+
+	ctx.RegisterFunc("fileReadTextAll", NewGolangFunctor(fileReadTextAllFunc), TypeString, []ExprFuncParam{
+		NewFuncParam(ParamHandle),
+	})
+
+	ctx.RegisterFunc("fileReadIterator", NewGolangFunctor(fileReadIteratorFunc), TypeIterator, []ExprFuncParam{
+		NewFuncParam(paramHandleOrPath),
+	})
+}
+
+func init() {
+	RegisterBuiltinModule("os.file", ImportOsFuncs, "Operating system file functions")
+}

builtin-string.go

@@ -0,0 +1,271 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtin-string.go
+package expr
+
+import (
+	"fmt"
+	"io"
+	"strings"
+)
+
+const (
+	strParamOther = "other"
+)
+
+// --- Start of function definitions
+func doJoinStr(funcName string, sep string, it Iterator) (result any, err error) {
+	var sb strings.Builder
+	var v any
+	for v, err = it.Next(); err == nil; v, err = it.Next() {
+		if it.Index() > 0 {
+			sb.WriteString(sep)
+		}
+		if s, ok := v.(string); ok {
+			sb.WriteString(s)
+		} else {
+			err = ErrExpectedGot(funcName, TypeString, v)
+			return
+		}
+	}
+	if err == io.EOF {
+		err = nil
+		result = sb.String()
+	}
+	return
+}
+
+func joinStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	if sep, ok := args[ParamSeparator].(string); ok {
+		if v, exists := args[ParamItem]; exists {
+			argv := v.([]any)
+			if len(argv) == 1 {
+				if ls, ok := argv[0].(*ListType); ok {
+					result, err = doJoinStr(name, sep, NewListIterator(ls, nil))
+				} else if it, ok := argv[0].(Iterator); ok {
+					result, err = doJoinStr(name, sep, it)
+				} else if s, ok := argv[0].(string); ok {
+					result = s
+				} else {
+					err = ErrInvalidParameterValue(name, ParamItem, v)
+				}
+			} else {
+				result, err = doJoinStr(name, sep, NewArrayIterator(argv))
+			}
+		}
+	} else {
+		err = ErrWrongParamType(name, ParamSeparator, TypeString, args[ParamSeparator])
+	}
+	return
+}
+
+func subStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var start = 0
+	var count = -1
+	var source string
+	var ok bool
+
+	if source, ok = args[ParamSource].(string); !ok {
+		return nil, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+	}
+
+	if start, err = ToGoInt(args[ParamStart], name+"()"); err != nil {
+		return
+	}
+
+	if count, err = ToGoInt(args[ParamCount], name+"()"); err != nil {
+		return
+	}
+
+	if start < 0 {
+		start = len(source) + start
+	}
+
+	if count < 0 {
+		count = len(source) - start
+	}
+	end := min(start+count, len(source))
+	result = source[start:end]
+	return
+}
+
+func trimStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var source string
+	var ok bool
+
+	if source, ok = args[ParamSource].(string); !ok {
+		return nil, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+	}
+	result = strings.TrimSpace(source)
+	return
+}
+
+func startsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var source, prefix string
+	var ok bool
+
+	result = false
+
+	if source, ok = args[ParamSource].(string); !ok {
+		return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+	}
+
+	if prefix, ok = args[ParamPrefix].(string); !ok {
+		return result, ErrWrongParamType(name, ParamPrefix, TypeString, args[ParamPrefix])
+	}
+	if strings.HasPrefix(source, prefix) {
+		result = true
+	} else if v, exists := args[strParamOther]; exists {
+		argv := v.([]any)
+		for i, targetSpec := range argv {
+			if target, ok := targetSpec.(string); ok {
+				if strings.HasPrefix(source, target) {
+					result = true
+					break
+				}
+			} else {
+				err = fmt.Errorf("target item nr %d is %s, string expected", i+1, TypeName(targetSpec))
+				break
+			}
+		}
+	}
+	return
+}
+
+func endsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var source, suffix string
+	var ok bool
+
+	result = false
+
+	if source, ok = args[ParamSource].(string); !ok {
+		return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+	}
+
+	if suffix, ok = args[ParamSuffix].(string); !ok {
+		return result, ErrWrongParamType(name, ParamSuffix, TypeString, args[ParamSuffix])
+	}
+	if strings.HasPrefix(source, suffix) {
+		result = true
+	} else if v, exists := args[strParamOther]; exists {
+		argv := v.([]any)
+		for i, targetSpec := range argv {
+			if target, ok := targetSpec.(string); ok {
+				if strings.HasSuffix(source, target) {
+					result = true
+					break
+				}
+			} else {
+				err = fmt.Errorf("target item nr %d is %s, string expected", i+1, TypeName(targetSpec))
+				break
+			}
+		}
+	}
+	return
+}
+
+func splitStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	var source, sep string
+	var count int = -1
+	var parts []string
+	var ok bool
+
+	if source, ok = args[ParamSource].(string); !ok {
+		return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+	}
+
+	if sep, ok = args[ParamSeparator].(string); !ok {
+		return nil, fmt.Errorf("separator param must be string, got %s (%v)", TypeName(args[ParamSeparator]), args[ParamSeparator])
+	}
+
+	if count64, ok := args[ParamCount].(int64); ok { // TODO replace type assertion with toInt()
+		count = int(count64)
+	} else {
+		return nil, fmt.Errorf("part count must be integer, got %s (%v)", TypeName(args[ParamCount]), args[ParamCount])
+	}
+
+	if count > 0 {
+		parts = strings.SplitN(source, sep, count)
+	} else if count < 0 {
+		parts = strings.Split(source, sep)
+	} else {
+		parts = []string{}
+	}
+	list := make(ListType, len(parts))
+	for i, part := range parts {
+		list[i] = part
+	}
+	result = &list
+	return
+}
+
+func upperStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	if source, ok := args[ParamSource].(string); ok {
+		result = strings.ToUpper(source)
+	} else {
+		err = ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+	}
+	return
+}
+
+func lowerStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	if source, ok := args[ParamSource].(string); ok {
+		result = strings.ToLower(source)
+	} else {
+		err = ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+	}
+	return
+}
+
+// --- End of function definitions
+
+// Import above functions in the context
+func ImportStringFuncs(ctx ExprContext) {
+	ctx.RegisterFunc("strJoin", NewGolangFunctor(joinStrFunc), TypeString, []ExprFuncParam{
+		NewFuncParam(ParamSeparator),
+		NewFuncParamFlag(ParamItem, PfRepeat),
+	})
+
+	ctx.RegisterFunc("strSub", NewGolangFunctor(subStrFunc), TypeString, []ExprFuncParam{
+		NewFuncParam(ParamSource),
+		NewFuncParamFlagDef(ParamStart, PfDefault, int64(0)),
+		NewFuncParamFlagDef(ParamCount, PfDefault, int64(-1)),
+	})
+
+	ctx.RegisterFunc("strSplit", NewGolangFunctor(splitStrFunc), "list of "+TypeString, []ExprFuncParam{
+		NewFuncParam(ParamSource),
+		NewFuncParamFlagDef(ParamSeparator, PfDefault, ""),
+		NewFuncParamFlagDef(ParamCount, PfDefault, int64(-1)),
+	})
+
+	ctx.RegisterFunc("strTrim", NewGolangFunctor(trimStrFunc), TypeString, []ExprFuncParam{
+		NewFuncParam(ParamSource),
+	})
+
+	ctx.RegisterFunc("strStartsWith", NewGolangFunctor(startsWithStrFunc), TypeBoolean, []ExprFuncParam{
+		NewFuncParam(ParamSource),
+		NewFuncParam(ParamPrefix),
+		NewFuncParamFlag(strParamOther, PfRepeat),
+	})
+
+	ctx.RegisterFunc("strEndsWith", NewGolangFunctor(endsWithStrFunc), TypeBoolean, []ExprFuncParam{
+		NewFuncParam(ParamSource),
+		NewFuncParam(ParamSuffix),
+		NewFuncParamFlag(strParamOther, PfRepeat),
+	})
+
+	ctx.RegisterFunc("strUpper", NewGolangFunctor(upperStrFunc), TypeString, []ExprFuncParam{
+		NewFuncParam(ParamSource),
+	})
+
+	ctx.RegisterFunc("strLower", NewGolangFunctor(lowerStrFunc), TypeString, []ExprFuncParam{
+		NewFuncParam(ParamSource),
+	})
+}
+
+// Register the import function in the import-register.
+// That will allow to import all function of this module by the "builtin" operator."
+func init() {
+	RegisterBuiltinModule("string", ImportStringFuncs, "string utilities")
+}

builtins-register.go

@@ -0,0 +1,48 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// builtins-register.go
+package expr
+
+import (
+	"fmt"
+)
+
+type builtinModule struct {
+	importFunc  func(ExprContext)
+	description string
+	imported    bool
+}
+
+func newBuiltinModule(importFunc func(ExprContext), description string) *builtinModule {
+	return &builtinModule{importFunc, description, false}
+}
+
+var builtinModuleRegister map[string]*builtinModule
+
+func RegisterBuiltinModule(name string, importFunc func(ExprContext), description string) {
+	if builtinModuleRegister == nil {
+		builtinModuleRegister = make(map[string]*builtinModule)
+	}
+	if _, exists := builtinModuleRegister[name]; exists {
+		panic(fmt.Errorf("module %q already registered", name))
+	}
+	builtinModuleRegister[name] = newBuiltinModule(importFunc, description)
+}
+
+func IterateBuiltinModules(op func(name, description string, imported bool) bool) {
+	if op != nil {
+		for name, mod := range builtinModuleRegister {
+			if !op(name, mod.description, mod.imported) {
+				break
+			}
+		}
+	}
+}
+
+// ----
+func init() {
+	if builtinModuleRegister == nil {
+		builtinModuleRegister = make(map[string]*builtinModule)
+	}
+}

byte-ring.go

@@ -1,31 +0,0 @@
-// byte-slider.go
-package expr
-
-import "bytes"
-
-type ByteSlider struct {
-	buf    []byte
-	length int
-}
-
-func NewByteSlider(size int) *ByteSlider {
-	return &ByteSlider{
-		buf:    make([]byte, max(1, size)),
-		length: 0,
-	}
-}
-
-func (self *ByteSlider) PushEnd(b byte) {
-	if self.length == cap(self.buf) {
-		self.length--
-		for i := 0; i < self.length; i++ {
-			self.buf[i] = self.buf[i+1]
-		}
-	}
-	self.buf[self.length] = b
-	self.length++
-}
-
-func (self *ByteSlider) Equal(target []byte) bool {
-	return target != nil && bytes.Equal(self.buf, target)
-}

byte-slider.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// byte-slider.go
+package expr
+
+import "bytes"
+
+type ByteSlider struct {
+	buf    []byte
+	length int
+}
+
+func NewByteSlider(size int) *ByteSlider {
+	return &ByteSlider{
+		buf:    make([]byte, max(1, size)),
+		length: 0,
+	}
+}
+
+func (slider *ByteSlider) PushEnd(b byte) {
+	if slider.length == cap(slider.buf) {
+		slider.length--
+		for i := 0; i < slider.length; i++ {
+			slider.buf[i] = slider.buf[i+1]
+		}
+	}
+	slider.buf[slider.length] = b
+	slider.length++
+}
+
+func (slider *ByteSlider) Equal(target []byte) bool {
+	return target != nil && bytes.Equal(slider.buf, target)
+}

common-errors.go

@@ -0,0 +1,91 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// common-errors.go
+package expr
+
+import (
+	"fmt"
+	"strings"
+)
+
+func ErrMissingParams(funcName string, missing []string) (err error) {
+	return fmt.Errorf("%s(): missing params -- %s", funcName, strings.Join(missing, ", "))
+}
+
+func ErrTooFewParams(funcName string, minArgs, maxArgs, argCount int) (err error) {
+	if maxArgs < 0 {
+		err = fmt.Errorf("%s(): too few params -- expected %d or more, got %d", funcName, minArgs, argCount)
+	} else {
+		err = fmt.Errorf("%s(): too few params -- expected %d, got %d", funcName, minArgs, argCount)
+	}
+	return
+}
+
+func ErrTooManyParams(funcName string, maxArgs, argCount int) (err error) {
+	err = fmt.Errorf("%s(): too many params -- expected %d, got %d", funcName, maxArgs, argCount)
+	return
+}
+
+// --- General errors
+
+func ErrCantConvert(funcName string, value any, kind string) error {
+	return fmt.Errorf("%s(): can't convert %s to %s", funcName, TypeName(value), kind)
+}
+
+func ErrExpectedGot(funcName string, kind string, value any) error {
+	return fmt.Errorf("%s(): expected %s, got %s (%v)", funcName, kind, TypeName(value), value)
+}
+
+func ErrFuncDivisionByZero(funcName string) error {
+	return fmt.Errorf("%s(): division by zero", funcName)
+}
+
+// func ErrDivisionByZero() error {
+// 	return fmt.Errorf("division by zero")
+// }
+
+// --- Parameter errors
+
+// func ErrMissingRequiredParameter(funcName, paramName string) error {
+// 	return fmt.Errorf("%s(): missing required parameter %q", funcName, paramName)
+// }
+
+func ErrInvalidParameterValue(funcName, paramName string, paramValue any) error {
+	return fmt.Errorf("%s(): invalid value %s (%v) for parameter %q", funcName, TypeName(paramValue), paramValue, paramName)
+}
+
+func undefArticle(s string) (article string) {
+	if len(s) > 0 && strings.Contains("aeiou", s[0:1]) {
+		article = "an"
+	} else {
+		article = "a"
+	}
+	return
+}
+
+func prependUndefArticle(s string) (result string) {
+	return undefArticle(s) + " " + s
+}
+
+func ErrWrongParamType(funcName, paramName, paramType string, paramValue any) error {
+	var artWantType, artGotType string
+	gotType := TypeName(paramValue)
+	artGotType = prependUndefArticle(gotType)
+	artWantType = prependUndefArticle(paramType)
+	return fmt.Errorf("%s(): the %q parameter must be %s, got %s (%v)", funcName, paramName, artWantType, artGotType, paramValue)
+}
+
+func ErrUnknownParam(funcName, paramName string) error {
+	return fmt.Errorf("%s(): unknown parameter %q", funcName, paramName)
+}
+
+func ErrUnknownVar(funcName, varName string) error {
+	return fmt.Errorf("%s(): unknown variable %q", funcName, varName)
+}
+
+// --- Operator errors
+
+func ErrLeftOperandMustBeVariable(leftTerm, opTerm *term) error {
+	return leftTerm.Errorf("left operand of %q must be a variable", opTerm.source())
+}

common-params.go

@@ -0,0 +1,32 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// common-params.go
+package expr
+
+const (
+	ParamArgs      = "args"
+	ParamCount     = "count"
+	ParamItem      = "item"
+	ParamIndex     = "index"
+	ParamParts     = "parts"
+	ParamSeparator = "separator"
+	ParamSource    = "source"
+	ParamSuffix    = "suffix"
+	ParamPrefix    = "prefix"
+	ParamStart     = "start"
+	ParamEnd       = "end"
+	ParamValue     = "value"
+	ParamName      = "name"
+	ParamEllipsis  = "..."
+	ParamFilepath  = "filepath"
+	ParamDirpath   = "dirpath"
+	ParamHandle    = "handle"
+	ParamResource  = "resource"
+	ParamIterator  = "iterator"
+)
+
+// to be moved in its own source file
+const (
+	ConstLastIndex = 0xFFFF_FFFF
+)

common-type-names.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// common-type-names.go
+package expr
+
+const (
+	TypeAny           = "any"
+	TypeNil           = "nil"
+	TypeBoolean       = "boolean"
+	TypeFloat         = "float"
+	TypeFraction      = "fraction"
+	TypeFileHandle    = "file-handle"
+	TypeInt           = "integer"
+	TypeItem          = "item"
+	TypeIterator      = "iterator"
+	TypeNumber        = "number"
+	TypePair          = "pair"
+	TypeString        = "string"
+	TypeDict          = "dict"
+	TypeListOf        = "list-of-"
+	TypeListOfStrings = "list-of-strings"
+)

context-helpers.go

@@ -0,0 +1,49 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// context-helpers.go
+package expr
+
+func cloneContext(sourceCtx ExprContext) (clonedCtx ExprContext) {
+	if sourceCtx != nil {
+		clonedCtx = sourceCtx.Clone()
+	}
+	return
+}
+
+func exportVar(ctx ExprContext, name string, value any) {
+	if name[0] == '@' {
+		name = name[1:]
+	}
+	ctx.UnsafeSetVar(name, value)
+}
+
+func exportFunc(ctx ExprContext, name string, info ExprFunc) {
+	if name[0] == '@' {
+		name = name[1:]
+	}
+	ctx.RegisterFunc(name, info.Functor(), info.ReturnType(), info.Params())
+}
+
+func exportObjects(destCtx, sourceCtx ExprContext) {
+	exportAll := CtrlIsEnabled(sourceCtx, control_export_all)
+	// fmt.Printf("Exporting from sourceCtx [%p] to destCtx [%p] -- exportAll=%t\n", sourceCtx, destCtx, exportAll)
+	// Export variables
+	for _, refName := range sourceCtx.EnumVars(func(name string) bool { return (exportAll || name[0] == '@') && !(name[0] == '_') }) {
+		// fmt.Printf("\tExporting %q\n", refName)
+		refValue, _ := sourceCtx.GetVar(refName)
+		exportVar(destCtx, refName, refValue)
+	}
+	// Export functions
+	for _, refName := range sourceCtx.EnumFuncs(func(name string) bool { return exportAll || name[0] == '@' }) {
+		if info, _ := sourceCtx.GetFuncInfo(refName); info != nil {
+			exportFunc(destCtx, refName, info)
+		}
+	}
+}
+
+func exportObjectsToParent(sourceCtx ExprContext) {
+	if parentCtx := sourceCtx.GetParent(); parentCtx != nil {
+		exportObjects(parentCtx, sourceCtx)
+	}
+}

context.go

@@ -1,15 +0,0 @@
-// context.go
-package expr
-
-type exprFunc interface {
-	Name() string
-	MinArgs() int
-	MaxArgs() int
-}
-
-type exprContext interface {
-	GetValue(varName string) (value any, exists bool)
-	SetValue(varName string, value any)
-	GetFuncInfo(name string) exprFunc
-	Call(name string, args []any) (result any, err error)
-}

control.go

@@ -0,0 +1,40 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// control.go
+package expr
+
+// Preset control variables
+const (
+	ControlPreset        = "_preset"
+	ControlLastResult    = "last"
+	ControlBoolShortcut  = "_bool_shortcut"
+	ControlSearchPath    = "_search_path"
+	ControlParentContext = "_parent_context"
+	ControlStdout        = "_stdout"
+)
+
+// Other control variables
+const (
+	control_export_all = "_export_all"
+)
+
+// Initial values
+const (
+	init_search_path = "~/.local/lib/go-pkg/expr:/usr/local/lib/go-pkg/expr:/usr/lib/go-pkg/expr"
+)
+
+func SetCtrl(ctx ExprContext, name string, value any) (current any) {
+	current, _ = ctx.GetVar(name)
+	ctx.UnsafeSetVar(name, value)
+	return
+}
+
+func initDefaultVars(ctx ExprContext) {
+	if _, exists := ctx.GetVar(ControlPreset); exists {
+		return
+	}
+	ctx.UnsafeSetVar(ControlPreset, true)
+	ctx.UnsafeSetVar(ControlBoolShortcut, true)
+	ctx.UnsafeSetVar(ControlSearchPath, init_search_path)
+}

data-cursor.go

@@ -0,0 +1,305 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// data-cursors.go
+package expr
+
+import (
+	"io"
+	"slices"
+)
+
+type dataCursor struct {
+	ds        map[string]Functor
+	ctx       ExprContext
+	initState bool // true if no item has produced yet (this replace di initial Next() call in the contructor)
+	// cursorValid bool // true if resource is nil or if clean has not yet been called
+	index     int
+	count     int
+	current   any
+	lastErr   error
+	resource  any
+	nextFunc  Functor
+	cleanFunc Functor
+	resetFunc Functor
+}
+
+func NewDataCursor(ctx ExprContext, ds map[string]Functor, resource any) (dc *dataCursor) {
+	dc = &dataCursor{
+		ds:        ds,
+		initState: true,
+		// cursorValid: true,
+		index:     -1,
+		count:     0,
+		current:   nil,
+		lastErr:   nil,
+		resource:  resource,
+		ctx:       ctx.Clone(),
+		nextFunc:  ds[NextName],
+		cleanFunc: ds[CleanName],
+		resetFunc: ds[ResetName],
+	}
+	return
+}
+
+func (dc *dataCursor) Context() ExprContext {
+	return dc.ctx
+}
+
+func (dc *dataCursor) TypeName() string {
+	return "DataCursor"
+}
+
+// func mapToString(m map[string]Functor) string {
+// 	var sb strings.Builder
+// 	sb.WriteByte('{')
+// 	for key, _ := range m {
+// 		if sb.Len() > 1 {
+// 			sb.WriteString(fmt.Sprintf(", %q: func(){}", key))
+// 		} else {
+// 			sb.WriteString(fmt.Sprintf("%q: func(){}", key))
+// 		}
+// 	}
+// 	sb.WriteByte('}')
+// 	return sb.String()
+// }
+
+func (dc *dataCursor) String() string {
+	return "$()"
+	/*
+	   var sb strings.Builder
+	   sb.WriteString(fmt.Sprintf(`$(
+	   index: %d,
+	   ds:    %s,
+	   ctx:   `, dc.index, mapToString(dc.ds)))
+	   CtxToBuilder(&sb, dc.ctx, 1)
+	   sb.WriteByte(')')
+	   return sb.String()
+	*/
+}
+
+func (dc *dataCursor) HasOperation(name string) (exists bool) {
+	exists = slices.Contains([]string{CleanName, ResetName, CurrentName, IndexName}, name)
+	if !exists {
+		f, ok := dc.ds[name]
+		exists = ok && isFunctor(f)
+	}
+	return
+}
+
+func (dc *dataCursor) CallOperation(name string, args map[string]any) (value any, err error) {
+	if name == IndexName {
+		value = int64(dc.Index())
+	} else if name == CleanName {
+		err = dc.Clean()
+	} else if name == ResetName {
+		err = dc.Reset()
+	} else if functor, ok := dc.ds[name]; ok && isFunctor(functor) {
+		ctx := cloneContext(dc.ctx)
+		value, err = functor.InvokeNamed(ctx, name, args)
+		exportObjects(dc.ctx, ctx)
+	} else {
+		err = errNoOperation(name)
+	}
+	return
+}
+
+// func (dc *dataCursor) Reset() (err error) {
+// 	if dc.resetFunc != nil {
+// 		if dc.resource != nil {
+// 			ctx := cloneContext(dc.ctx)
+// 			actualParams := bindActualParams(dc.resetFunc, []any{dc.resource})
+// 			_, err = dc.resetFunc.InvokeNamed(ctx, ResetName, actualParams)
+// 			exportObjects(dc.ctx, ctx)
+// 			dc.index = -1
+// 			dc.count = 0
+// 			dc.initState = true
+// 			dc.current = nil
+// 			dc.lastErr = nil
+// 		} else {
+// 			err = errInvalidDataSource()
+// 		}
+// 	} else {
+// 		err = errNoOperation(ResetName)
+// 	}
+// 	return
+// }
+
+func (dc *dataCursor) Reset() (err error) {
+	if dc.resetFunc != nil {
+		ctx := cloneContext(dc.ctx)
+		actualParams := bindActualParams(dc.resetFunc, []any{dc.resource})
+		_, err = dc.resetFunc.InvokeNamed(ctx, ResetName, actualParams)
+		exportObjects(dc.ctx, ctx)
+	}
+	dc.index = -1
+	dc.count = 0
+	dc.initState = true
+	dc.current = nil
+	dc.lastErr = nil
+	return
+}
+
+func (dc *dataCursor) Clean() (err error) {
+	if dc.cleanFunc != nil {
+		ctx := cloneContext(dc.ctx)
+		actualParams := bindActualParams(dc.cleanFunc, []any{dc.resource})
+		_, err = dc.cleanFunc.InvokeNamed(ctx, CleanName, actualParams)
+		exportObjects(dc.ctx, ctx)
+	}
+	dc.lastErr = io.EOF
+	return
+}
+
+// func (dc *dataCursor) Clean() (err error) {
+// 	if dc.cleanFunc != nil {
+// 		if dc.resource != nil {
+// 			ctx := cloneContext(dc.ctx)
+// 			actualParams := bindActualParams(dc.cleanFunc, []any{dc.resource})
+// 			_, err = dc.cleanFunc.InvokeNamed(ctx, CleanName, actualParams)
+// 			exportObjects(dc.ctx, ctx)
+// 		} else {
+// 			err = errInvalidDataSource()
+// 		}
+// 	} else {
+// 		err = errNoOperation(CleanName)
+// 	}
+// 	return
+// }
+
+func (dc *dataCursor) Current() (item any, err error) { // must return io.EOF at the last item
+	dc.init()
+
+	if dc.current != nil {
+		item = dc.current
+	} else {
+		err = io.EOF
+	}
+	return
+}
+
+func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err error) {
+	var v any
+	var ok bool
+	ctx := cloneContext(dc.ctx)
+
+	actualParams := bindActualParams(filter, []any{item, dc.index})
+	if v, err = filter.InvokeNamed(ctx, FilterName, actualParams); err == nil && v != nil {
+		if accepted, ok = v.(bool); !ok {
+			accepted = true // NOTE: A non-boolean value that is not nil means the item has been accepted
+		}
+	}
+	return
+}
+
+func (dc *dataCursor) mapItem(mapper Functor, item any) (mappedItem any, err error) {
+	ctx := cloneContext(dc.ctx)
+	actualParams := bindActualParams(mapper, []any{item, dc.index})
+	mappedItem, err = mapper.InvokeNamed(ctx, MapName, actualParams)
+	return
+}
+
+func (dc *dataCursor) init() {
+	if dc.initState {
+		dc.initState = false
+		dc.Next()
+	}
+}
+
+func (dc *dataCursor) Next() (current any, err error) { // must return io.EOF after the last item
+	if dc.initState {
+		dc.init()
+	} else if err = dc.lastErr; err != nil {
+		return
+	}
+	current = dc.current
+	filter := dc.ds[FilterName]
+	mapper := dc.ds[MapName]
+	var item any
+	for item == nil && dc.lastErr == nil {
+		ctx := cloneContext(dc.ctx)
+		dc.index++
+
+		actualParams := bindActualParams(dc.nextFunc, []any{dc.resource, dc.index})
+		if item, dc.lastErr = dc.nextFunc.InvokeNamed(ctx, NextName, actualParams); dc.lastErr == nil {
+			if item == nil {
+				dc.lastErr = io.EOF
+			} else {
+				accepted := true
+				if filter != nil {
+					if accepted, dc.lastErr = dc.checkFilter(filter, item); dc.lastErr != nil || !accepted {
+						item = nil
+					}
+				}
+				if accepted {
+					dc.count++
+				}
+				if item != nil && mapper != nil {
+					item, dc.lastErr = dc.mapItem(mapper, item)
+				}
+			}
+		}
+		exportObjects(dc.ctx, ctx)
+	}
+	dc.current = item
+	if dc.lastErr != nil {
+		dc.index--
+		dc.Clean()
+	}
+	return
+}
+
+// func (dc *dataCursor) Next() (current any, err error) { // must return io.EOF after the last item
+// 	if dc.initState {
+// 		dc.init()
+// 	} else if err = dc.lastErr; err != nil {
+// 		return
+// 	}
+// 	current = dc.current
+// 	if dc.resource != nil {
+// 		filter := dc.ds[FilterName]
+// 		mapper := dc.ds[MapName]
+// 		var item any
+// 		for item == nil && dc.lastErr == nil {
+// 			ctx := cloneContext(dc.ctx)
+// 			dc.index++
+
+// 			actualParams := bindActualParams(dc.nextFunc, []any{dc.resource, dc.index})
+// 			if item, dc.lastErr = dc.nextFunc.InvokeNamed(ctx, NextName, actualParams); dc.lastErr == nil {
+// 				if item == nil {
+// 					dc.lastErr = io.EOF
+// 				} else {
+// 					accepted := true
+// 					if filter != nil {
+// 						if accepted, dc.lastErr = dc.checkFilter(filter, item); dc.lastErr != nil || !accepted {
+// 							item = nil
+// 						}
+// 					}
+// 					if accepted {
+// 						dc.count++
+// 					}
+// 					if item != nil && mapper != nil {
+// 						item, dc.lastErr = dc.mapItem(mapper, item)
+// 					}
+// 				}
+// 			}
+// 			exportObjects(dc.ctx, ctx)
+// 		}
+// 		dc.current = item
+// 		if dc.lastErr != nil {
+// 			dc.index--
+// 			dc.Clean()
+// 		}
+// 	} else {
+// 		dc.lastErr = errInvalidDataSource()
+// 	}
+// 	return
+// }
+
+func (dc *dataCursor) Index() int {
+	return dc.index - 1
+}
+
+func (dc *dataCursor) Count() int {
+	return dc.count
+}

dict-iterator.go

@@ -0,0 +1,221 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// dict-iterator.go
+package expr
+
+import (
+	"fmt"
+	"io"
+	"slices"
+	"strings"
+)
+
+type dictIterMode int
+
+const (
+	dictIterModeKeys dictIterMode = iota
+	dictIterModeValues
+	dictIterModeItems
+)
+
+type DictIterator struct {
+	a        *DictType
+	count    int
+	index    int
+	keys     []any
+	iterMode dictIterMode
+}
+
+type sortType int
+
+const (
+	sortTypeNone sortType = iota
+	sortTypeAsc
+	sortTypeDesc
+	sortTypeDefault = sortTypeAsc
+)
+
+func (it *DictIterator) makeKeys(m map[any]any, sort sortType) {
+	it.keys = make([]any, 0, len(m))
+
+	if sort == sortTypeNone {
+		for keyAny := range m {
+			it.keys = append(it.keys, keyAny)
+		}
+	} else {
+		scalarMap := make(map[string]any, len(m))
+		scalerKeys := make([]string, 0, len(m))
+		for keyAny := range m {
+			keyStr := fmt.Sprint(keyAny)
+			scalarMap[keyStr] = keyAny
+			scalerKeys = append(scalerKeys, keyStr)
+		}
+
+		switch sort {
+		case sortTypeAsc:
+			slices.Sort(scalerKeys)
+		case sortTypeDesc:
+			slices.Sort(scalerKeys)
+			slices.Reverse(scalerKeys)
+		}
+		for _, keyStr := range scalerKeys {
+			it.keys = append(it.keys, scalarMap[keyStr])
+		}
+	}
+}
+
+func NewDictIterator(dict *DictType, args []any) (it *DictIterator, err error) {
+	var sortType = sortTypeNone
+	var s string
+	var argAny any
+
+	dictIt := &DictIterator{a: dict, count: 0, index: -1, keys: nil, iterMode: dictIterModeKeys}
+	if len(args) > 0 {
+		argAny = args[0]
+	} else {
+		argAny = "default"
+	}
+	if s, err = ToGoString(argAny, "sort type"); err == nil {
+		switch strings.ToLower(s) {
+		case "a", "asc":
+			sortType = sortTypeAsc
+		case "d", "desc":
+			sortType = sortTypeDesc
+		case "n", "none", "nosort", "no-sort":
+			sortType = sortTypeNone
+		case "", "default":
+			sortType = sortTypeDefault
+		default:
+			err = fmt.Errorf("invalid sort type %q", s)
+		}
+
+		if err == nil {
+			if len(args) > 1 {
+				argAny = args[1]
+			} else {
+				argAny = "default"
+			}
+
+			if s, err = ToGoString(argAny, "iteration mode"); err == nil {
+				switch strings.ToLower(s) {
+				case "k", "key", "keys":
+					dictIt.iterMode = dictIterModeKeys
+				case "v", "value", "values":
+					dictIt.iterMode = dictIterModeValues
+				case "i", "item", "items":
+					dictIt.iterMode = dictIterModeItems
+				case "", "default":
+					dictIt.iterMode = dictIterModeKeys
+				default:
+					err = fmt.Errorf("invalid iteration mode %q", s)
+				}
+			}
+		}
+	}
+
+	dictIt.makeKeys(*dict, sortType)
+	return dictIt, err
+}
+
+func NewMapIterator(m map[any]any) (it *DictIterator) {
+	it = &DictIterator{a: (*DictType)(&m), count: 0, index: -1, keys: nil}
+	it.makeKeys(m, sortTypeNone)
+	return
+}
+
+func (it *DictIterator) String() string {
+	var l = 0
+	if it.a != nil {
+		l = len(*it.a)
+	}
+	return fmt.Sprintf("$({#%d})", l)
+}
+
+func (it *DictIterator) TypeName() string {
+	return "DictIterator"
+}
+
+func (it *DictIterator) HasOperation(name string) bool {
+	// yes := name == NextName || name == ResetName || name == IndexName || name == CountName || name == CurrentName
+	yes := slices.Contains([]string{NextName, ResetName, IndexName, CountName, CurrentName, CleanName, KeyName, ValueName}, name)
+	return yes
+}
+
+func (it *DictIterator) CallOperation(name string, args map[string]any) (v any, err error) {
+	switch name {
+	case NextName:
+		v, err = it.Next()
+	case ResetName:
+		err = it.Reset()
+	case CleanName:
+		err = it.Clean()
+	case IndexName:
+		v = int64(it.Index())
+	case CurrentName:
+		v, err = it.Current()
+	case CountName:
+		v = it.count
+	case KeyName:
+		if it.index >= 0 && it.index < len(it.keys) {
+			v = it.keys[it.index]
+		} else {
+			err = io.EOF
+		}
+	case ValueName:
+		if it.index >= 0 && it.index < len(it.keys) {
+			a := *(it.a)
+			v = a[it.keys[it.index]]
+		} else {
+			err = io.EOF
+		}
+	default:
+		err = errNoOperation(name)
+	}
+	return
+}
+
+func (it *DictIterator) Current() (item any, err error) {
+	if it.index >= 0 && it.index < len(it.keys) {
+		switch it.iterMode {
+		case dictIterModeKeys:
+			item = it.keys[it.index]
+		case dictIterModeValues:
+			a := *(it.a)
+			item = a[it.keys[it.index]]
+		case dictIterModeItems:
+			a := *(it.a)
+			pair := []any{it.keys[it.index], a[it.keys[it.index]]}
+			item = newList(pair)
+		}
+	} else {
+		err = io.EOF
+	}
+	return
+}
+
+func (it *DictIterator) Next() (item any, err error) {
+	it.index++
+	if item, err = it.Current(); err != io.EOF {
+		it.count++
+	}
+	return
+}
+
+func (it *DictIterator) Index() int {
+	return it.index
+}
+
+func (it *DictIterator) Count() int {
+	return it.count
+}
+
+func (it *DictIterator) Reset() error {
+	it.index = -1
+	it.count = 0
+	return nil
+}
+
+func (it *DictIterator) Clean() error {
+	return nil
+}

dict-type.go

@@ -0,0 +1,166 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// dict-type.go
+package expr
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type DictType map[any]any
+
+func MakeDict() (dict *DictType) {
+	d := make(DictType)
+	dict = &d
+	return
+}
+
+func NewDict(dictAny map[any]any) (dict *DictType) {
+	var d DictType
+	if dictAny != nil {
+		d = make(DictType, len(dictAny))
+		for i, item := range dictAny {
+			d[i] = item
+		}
+	} else {
+		d = make(DictType)
+	}
+	dict = &d
+	return
+}
+
+func newDict(dictAny map[any]*term) (dict *DictType) {
+	// TODO Change with a call to NewDict()
+	var d DictType
+	if dictAny != nil {
+		d = make(DictType, len(dictAny))
+		for i, item := range dictAny {
+			d[i] = item
+		}
+	} else {
+		d = make(DictType)
+	}
+	dict = &d
+	return
+}
+
+func (dict *DictType) toMultiLine(sb *strings.Builder, opt FmtOpt) {
+	indent := GetFormatIndent(opt)
+	flags := GetFormatFlags(opt)
+	//sb.WriteString(strings.Repeat("  ", indent))
+	sb.WriteByte('{')
+
+	if len(*dict) > 0 {
+		innerOpt := MakeFormatOptions(flags, indent+1)
+		nest := strings.Repeat("  ", indent+1)
+		sb.WriteByte('\n')
+
+		first := true
+		for name, value := range *dict {
+			if first {
+				first = false
+			} else {
+				sb.WriteByte(',')
+				sb.WriteByte('\n')
+			}
+
+			sb.WriteString(nest)
+			if key, ok := name.(string); ok {
+				sb.WriteString(string('"') + key + string('"'))
+			} else {
+				sb.WriteString(fmt.Sprintf("%v", name))
+			}
+			sb.WriteString(": ")
+			if f, ok := value.(Formatter); ok {
+				sb.WriteString(f.ToString(innerOpt))
+			} else if _, ok = value.(Functor); ok {
+				sb.WriteString("func(){}")
+			} else {
+				sb.WriteString(fmt.Sprintf("%v", value))
+			}
+		}
+		sb.WriteByte('\n')
+		sb.WriteString(strings.Repeat("  ", indent))
+	}
+	sb.WriteString("}")
+}
+
+func (dict *DictType) ToString(opt FmtOpt) string {
+	var sb strings.Builder
+	flags := GetFormatFlags(opt)
+	if flags&MultiLine != 0 {
+		dict.toMultiLine(&sb, opt)
+	} else {
+		sb.WriteByte('{')
+		first := true
+		for key, value := range *dict {
+			if first {
+				first = false
+			} else {
+				sb.WriteString(", ")
+			}
+			if s, ok := key.(string); ok {
+				sb.WriteString(string('"') + s + string('"'))
+			} else {
+				sb.WriteString(fmt.Sprintf("%v", key))
+			}
+			sb.WriteString(": ")
+			if formatter, ok := value.(Formatter); ok {
+				sb.WriteString(formatter.ToString(opt))
+			} else if t, ok := value.(*term); ok {
+				sb.WriteString(t.String())
+			} else {
+				sb.WriteString(fmt.Sprintf("%#v", value))
+			}
+		}
+		sb.WriteByte('}')
+	}
+	return sb.String()
+}
+
+func (dict *DictType) String() string {
+	return dict.ToString(0)
+}
+
+func (dict *DictType) TypeName() string {
+	return "dict"
+}
+
+func (dict *DictType) hasKey(target any) (ok bool) {
+	for key := range *dict {
+		if ok = reflect.DeepEqual(key, target); ok {
+			break
+		}
+	}
+	return
+}
+
+func (dict *DictType) clone() (c *DictType) {
+	c = newDict(nil)
+	for k, v := range *dict {
+		(*c)[k] = v
+	}
+	return
+}
+
+func (dict *DictType) merge(second *DictType) {
+	if second != nil {
+		for k, v := range *second {
+			(*dict)[k] = v
+		}
+	}
+}
+
+func (dict *DictType) setItem(key any, value any) (err error) {
+	(*dict)[key] = value
+	return
+}
+
+////////////////
+
+type DictFormat interface {
+	ToDict() *DictType
+}

doc/expression-diagram.drawio

@@ -0,0 +1,94 @@
+<mxfile host="app.diagrams.net" modified="2024-04-03T13:08:06.112Z" agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:124.0) Gecko/20100101 Firefox/124.0" etag="aiwjz2Mg7uovMJtfXvHm" version="24.2.1" type="device">
+  <diagram id="C5RBs43oDa-KdzZeNtuy" name="Page-1">
+    <mxGraphModel dx="989" dy="570" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="827" pageHeight="1169" math="0" shadow="0">
+      <root>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-0" />
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-1" parent="WIyWlLk6GJQsqaUBKTNV-0" />
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-9" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;endArrow=classic;endFill=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-3" target="WIyWlLk6GJQsqaUBKTNV-7">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-3" value="scanner" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="180" y="39" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-14" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.13;entryY=0.475;entryDx=0;entryDy=0;endArrow=classic;endFill=0;entryPerimeter=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-7" target="q_7kt0Q1lEUOPZf56y0L-15">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="WIyWlLk6GJQsqaUBKTNV-7" value="" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#dae8fc;strokeColor=#6c8ebf;" parent="WIyWlLk6GJQsqaUBKTNV-1" vertex="1">
+          <mxGeometry x="320" y="14" width="286" height="90" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-5" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=classic;endFill=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="q_7kt0Q1lEUOPZf56y0L-0" target="WIyWlLk6GJQsqaUBKTNV-3">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-0" value="input stream" style="shape=step;perimeter=stepPerimeter;whiteSpace=wrap;html=1;fixedSize=1;fillColor=#e1d5e7;strokeColor=#9673a6;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
+          <mxGeometry x="30" y="39" width="110" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-11" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=classic;endFill=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="q_7kt0Q1lEUOPZf56y0L-2" target="q_7kt0Q1lEUOPZf56y0L-3">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-2" value="&lt;div&gt;syntax&lt;/div&gt;&lt;div&gt;analyzer&lt;br&gt;&lt;/div&gt;" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
+          <mxGeometry x="356" y="39" width="90" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-3" value="&lt;div&gt;static semanthic&lt;/div&gt;&lt;div&gt;analyzer&lt;br&gt;&lt;/div&gt;" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
+          <mxGeometry x="477" y="39" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-4" value="Parser" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
+          <mxGeometry x="433" y="10" width="60" height="30" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-10" value="" style="endArrow=classic;html=1;rounded=0;exitX=0;exitY=0.5;exitDx=0;exitDy=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;endFill=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="WIyWlLk6GJQsqaUBKTNV-7" target="q_7kt0Q1lEUOPZf56y0L-2">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="356" y="80" as="sourcePoint" />
+            <mxPoint x="406" y="30" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-12" value="" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;endFill=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="q_7kt0Q1lEUOPZf56y0L-3" target="WIyWlLk6GJQsqaUBKTNV-7">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="356" y="80" as="sourcePoint" />
+            <mxPoint x="406" y="30" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-30" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=classic;endFill=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="q_7kt0Q1lEUOPZf56y0L-13" target="q_7kt0Q1lEUOPZf56y0L-29">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-13" value="" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#dae8fc;strokeColor=#6c8ebf;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
+          <mxGeometry x="785" y="12" width="255" height="95" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-16" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=classic;endFill=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="q_7kt0Q1lEUOPZf56y0L-15" target="q_7kt0Q1lEUOPZf56y0L-13">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-15" value="AST" style="shape=step;perimeter=stepPerimeter;whiteSpace=wrap;html=1;fixedSize=1;fillColor=#e1d5e7;strokeColor=#9673a6;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
+          <mxGeometry x="634" y="40" width="110" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-18" value="&lt;div&gt;semanthic&lt;/div&gt;&lt;div&gt;analyzer&lt;br&gt;&lt;/div&gt;" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
+          <mxGeometry x="814" y="40.5" width="100" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-19" value="Eval" style="rounded=1;whiteSpace=wrap;html=1;fontSize=12;glass=0;strokeWidth=1;shadow=0;fillColor=#1ba1e2;fontColor=#ffffff;strokeColor=#006EAF;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
+          <mxGeometry x="946" y="40.5" width="60" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-22" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=classic;endFill=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" target="q_7kt0Q1lEUOPZf56y0L-18">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="781" y="60" as="sourcePoint" />
+            <mxPoint x="790" y="70" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-24" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;endArrow=classic;endFill=0;entryX=0;entryY=0.5;entryDx=0;entryDy=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="q_7kt0Q1lEUOPZf56y0L-18" target="q_7kt0Q1lEUOPZf56y0L-19">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="750" y="70" as="sourcePoint" />
+            <mxPoint x="790" y="70" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-27" value="" style="endArrow=classic;html=1;rounded=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;entryX=1;entryY=0.5;entryDx=0;entryDy=0;endFill=0;" edge="1" parent="WIyWlLk6GJQsqaUBKTNV-1" source="q_7kt0Q1lEUOPZf56y0L-19" target="q_7kt0Q1lEUOPZf56y0L-13">
+          <mxGeometry width="50" height="50" relative="1" as="geometry">
+            <mxPoint x="1020" y="62" as="sourcePoint" />
+            <mxPoint x="1070" y="12" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-29" value="&lt;div&gt;Computed&lt;/div&gt;&lt;div&gt;Value&lt;/div&gt;" style="shape=step;perimeter=stepPerimeter;whiteSpace=wrap;html=1;fixedSize=1;fillColor=#e1d5e7;strokeColor=#9673a6;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
+          <mxGeometry x="1060" y="39.5" width="110" height="40" as="geometry" />
+        </mxCell>
+        <mxCell id="q_7kt0Q1lEUOPZf56y0L-31" value="Excecuter" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;" vertex="1" parent="WIyWlLk6GJQsqaUBKTNV-1">
+          <mxGeometry x="872.5" y="9" width="80" height="30" as="geometry" />
+        </mxCell>
+      </root>
+    </mxGraphModel>
+  </diagram>
+</mxfile>

expr-context.go

@@ -0,0 +1,29 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// expr-context.go
+package expr
+
+// ----Expression Context
+type ExprContext interface {
+	Clone() ExprContext
+	SetParent(ctx ExprContext)
+	GetParent() (ctx ExprContext)
+	GetVar(varName string) (value any, exists bool)
+	GetLast() any
+	SetVar(varName string, value any)
+	UnsafeSetVar(varName string, value any)
+
+	EnumVars(func(name string) (accept bool)) (varNames []string)
+	VarCount() int
+	DeleteVar(varName string)
+
+	EnumFuncs(func(name string) (accept bool)) (funcNames []string)
+	FuncCount() int
+	DeleteFunc(funcName string)
+
+	GetFuncInfo(name string) (item ExprFunc, exists bool)
+	Call(name string, args map[string]any) (result any, err error)
+	RegisterFuncInfo(info ExprFunc)
+	RegisterFunc(name string, f Functor, returnType string, param []ExprFuncParam) (funcInfo ExprFunc, err error)
+}

expr-function.go

@@ -0,0 +1,39 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// expr-function.go
+package expr
+
+// ---- Functor interface
+type Functor interface {
+	Typer
+	InvokeNamed(ctx ExprContext, name string, args map[string]any) (result any, err error)
+	SetFunc(info ExprFunc)
+	GetFunc() ExprFunc
+	GetParams() []ExprFuncParam
+	GetDefinitionContext() ExprContext
+}
+
+// ---- Function Param Info
+type ExprFuncParam interface {
+	Name() string
+	Type() string
+	IsDefault() bool
+	IsOptional() bool
+	IsRepeat() bool
+	DefaultValue() any
+}
+
+// ---- Function Info
+type ExprFunc interface {
+	Formatter
+	Name() string
+	MinArgs() int
+	MaxArgs() int
+	Functor() Functor
+	Params() []ExprFuncParam
+	ParamSpec(paramName string) ExprFuncParam
+	ReturnType() string
+	PrepareCall(name string, actualParams map[string]any) (err error)
+	AllocContext(parentCtx ExprContext) (ctx ExprContext)
+}

expr.go

@@ -0,0 +1,12 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// expr.go
+package expr
+
+// ----Expression interface
+type Expr interface {
+	Typer
+	Eval(ctx ExprContext) (result any, err error)
+	String() string
+}

formatter.go

@@ -0,0 +1,79 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// formatter.go
+package expr
+
+import "fmt"
+
+type FmtOpt uint32 // lower 16 bits hold a bit-mask, higher 16 bits hold an indentation number
+
+const (
+	TTY FmtOpt = 1 << iota
+	MultiLine
+	Truncate
+	Base2
+	Base8
+	Base10
+	Base16
+)
+
+const (
+	TruncateEllipsis = "(...)"
+	MinTruncateSize  = 10
+	TruncateSize     = MinTruncateSize + 15
+)
+
+func TruncateString(s string) (trunc string) {
+	finalPart := len(s) - (MinTruncateSize - len(TruncateEllipsis))
+	trunc = s[0:len(s)-MinTruncateSize] + TruncateEllipsis + s[finalPart:]
+	return
+}
+
+func MakeFormatOptions(flags FmtOpt, indent int) FmtOpt {
+	return FmtOpt(indent<<16) | flags
+}
+
+func GetFormatFlags(opt FmtOpt) FmtOpt {
+	return opt & 0xFFFF
+}
+
+func GetFormatIndent(opt FmtOpt) int {
+	return int(opt >> 16)
+}
+
+type Formatter interface {
+	ToString(options FmtOpt) string
+}
+
+func getFormatted(v any, opt FmtOpt) (text string) {
+	if v == nil {
+		text = "(nil)"
+	} else if s, ok := v.(string); ok {
+		text = s
+	} else if formatter, ok := v.(Formatter); ok {
+		text = formatter.ToString(opt)
+	} else {
+		text = fmt.Sprintf("%v", v)
+	}
+	return
+}
+
+type Typer interface {
+	TypeName() string
+}
+
+func TypeName(v any) (name string) {
+	if v == nil {
+		name = "nil"
+	} else if typer, ok := v.(Typer); ok {
+		name = typer.TypeName()
+	} else if IsInteger(v) {
+		name = "integer"
+	} else if IsFloat(v) {
+		name = "float"
+	} else {
+		name = fmt.Sprintf("%T", v)
+	}
+	return
+}

fraction-type.go

@@ -0,0 +1,361 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// fraction-type.go
+package expr
+
+//https://www.youmath.it/lezioni/algebra-elementare/lezioni-di-algebra-e-aritmetica-per-scuole-medie/553-dalle-frazioni-a-numeri-decimali.html
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+)
+
+type FractionType struct {
+	num, den int64
+}
+
+func newFraction(num, den int64) *FractionType {
+	num, den = simplifyIntegers(num, den)
+	return &FractionType{num, den}
+}
+
+func float64ToFraction(f float64) (fract *FractionType, err error) {
+	var sign string
+	intPart, decPart := math.Modf(f)
+	if decPart < 0.0 {
+		sign = "-"
+		intPart = -intPart
+		decPart = -decPart
+	}
+	dec := fmt.Sprintf("%.12f", decPart)
+	s := fmt.Sprintf("%s%.f%s", sign, intPart, dec[1:])
+	return makeGeneratingFraction(s)
+}
+
+// Based on https://cs.opensource.google/go/go/+/refs/tags/go1.22.3:src/math/big/rat.go;l=39
+func makeGeneratingFraction(s string) (f *FractionType, err error) {
+	var num, den int64
+	var sign int64 = 1
+	var parts []string
+	if len(s) == 0 {
+		goto exit
+	}
+	if s[0] == '-' {
+		sign = int64(-1)
+		s = s[1:]
+	} else if s[0] == '+' {
+		s = s[1:]
+	}
+	//	if strings.HasSuffix(s, "()") {
+	//		s = s[0 : len(s)-2]
+	//	}
+	s = strings.TrimSuffix(s, "()")
+	parts = strings.SplitN(s, ".", 2)
+	if num, err = strconv.ParseInt(parts[0], 10, 64); err != nil {
+		return
+	}
+	if len(parts) == 1 {
+		f = newFraction(sign*num, 1)
+	} else if len(parts) == 2 {
+		subParts := strings.SplitN(parts[1], "(", 2)
+		if len(subParts) == 1 {
+			den = 1
+			dec := parts[1]
+			lsd := len(dec)
+			for i := lsd - 1; i >= 0 && dec[i] == '0'; i-- {
+				lsd--
+			}
+			for _, c := range dec[0:lsd] {
+				if c < '0' || c > '9' {
+					return nil, ErrExpectedGot("fract", "digit", c)
+				}
+				num = num*10 + int64(c-'0')
+				den = den * 10
+			}
+			f = newFraction(sign*num, den)
+		} else if len(subParts) == 2 {
+			sub := num
+			mul := int64(1)
+			for _, c := range subParts[0] {
+				if c < '0' || c > '9' {
+					return nil, ErrExpectedGot("fract", "digit", c)
+				}
+				num = num*10 + int64(c-'0')
+				sub = sub*10 + int64(c-'0')
+				mul *= 10
+			}
+			if len(subParts) == 2 {
+				if s[len(s)-1] != ')' {
+					goto exit
+				}
+				p := subParts[1][0 : len(subParts[1])-1]
+				for _, c := range p {
+					if c < '0' || c > '9' {
+						return nil, ErrExpectedGot("fract", "digit", c)
+					}
+					num = num*10 + int64(c-'0')
+					den = den*10 + 9
+				}
+				den *= mul
+			}
+			num -= sub
+			f = newFraction(sign*num, den)
+		}
+	}
+exit:
+	if f == nil {
+		err = errors.New("bad syntax")
+	}
+	return
+}
+
+func (f *FractionType) toFloat() float64 {
+	return float64(f.num) / float64(f.den)
+}
+
+func (f *FractionType) String() string {
+	return f.ToString(0)
+}
+
+func (f *FractionType) ToString(opt FmtOpt) string {
+	var sb strings.Builder
+	if opt&MultiLine == 0 {
+		sb.WriteString(fmt.Sprintf("%d:%d", f.num, f.den))
+	} else {
+		var sign, num string
+		if f.num < 0 && opt&TTY == 0 {
+			num = strconv.FormatInt(-f.num, 10)
+			sign = "-"
+		} else {
+			num = strconv.FormatInt(f.num, 10)
+		}
+		den := strconv.FormatInt(f.den, 10)
+		size := max(len(num), len(den))
+		if opt&TTY != 0 {
+			sNum := fmt.Sprintf("\x1b[4m%[1]*s\x1b[0m\n", -size, fmt.Sprintf("%[1]*s", (size+len(num))/2, sign+num))
+			sb.WriteString(sNum)
+		} else {
+			if len(sign) > 0 {
+				sb.WriteString("  ")
+			}
+			sb.WriteString(fmt.Sprintf("%[1]*s", -size, fmt.Sprintf("%[1]*s", (size+len(num))/2, num)))
+			sb.WriteByte('\n')
+			if len(sign) > 0 {
+				sb.WriteString(sign)
+				sb.WriteByte(' ')
+			}
+			sb.WriteString(strings.Repeat("-", size))
+			sb.WriteByte('\n')
+			if len(sign) > 0 {
+				sb.WriteString("  ")
+			}
+		}
+		sDen := fmt.Sprintf("%[1]*s", size, fmt.Sprintf("%[1]*s", (size+len(den))/2, den))
+		sb.WriteString(sDen)
+	}
+
+	return sb.String()
+}
+
+func (f *FractionType) TypeName() string {
+	return "fraction"
+}
+
+// -------- fraction utility functions
+
+// greatest common divider
+func gcd(a, b int64) (g int64) {
+	if a < 0 {
+		a = -a
+	}
+	if b < 0 {
+		b = -b
+	}
+	if a < b {
+		a, b = b, a
+	}
+	r := a % b
+	for r > 0 {
+		a, b = b, r
+		r = a % b
+	}
+	g = b
+	return
+}
+
+// lower common multiple
+func lcm(a, b int64) (l int64) {
+	g := gcd(a, b)
+	l = a * b / g
+	return
+}
+
+// Sum two fractions
+func sumFract(f1, f2 *FractionType) (sum *FractionType) {
+	m := lcm(f1.den, f2.den)
+	sum = newFraction(f1.num*(m/f1.den)+f2.num*(m/f2.den), m)
+	return
+}
+
+// Multiply two fractions
+func mulFract(f1, f2 *FractionType) (prod *FractionType) {
+	prod = newFraction(f1.num*f2.num, f1.den*f2.den)
+	return
+}
+
+func anyToFract(v any) (f *FractionType, err error) {
+	var ok bool
+	if f, ok = v.(*FractionType); !ok {
+		if n, ok := v.(int64); ok {
+			f = intToFraction(n)
+		}
+	}
+	if f == nil {
+		err = ErrExpectedGot("fract", TypeFraction, v)
+	}
+	return
+}
+
+func anyPairToFract(v1, v2 any) (f1, f2 *FractionType, err error) {
+	if f1, err = anyToFract(v1); err != nil {
+		return
+	}
+	if f2, err = anyToFract(v2); err != nil {
+		return
+	}
+	return
+}
+
+func sumAnyFract(af1, af2 any) (sum any, err error) {
+	var f1, f2 *FractionType
+	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
+		return
+	}
+	f := sumFract(f1, f2)
+	if f.num == 0 {
+		sum = 0
+	} else {
+		sum = simplifyFraction(f)
+	}
+	return
+}
+
+// Returns
+//
+//		 <0 if af1 < af2
+//		 =0 if af1 == af2
+//		 >0 if af1 > af2
+//	 err if af1 or af2 is not convertible to fraction
+func cmpAnyFract(af1, af2 any) (result int, err error) {
+	var f1, f2 *FractionType
+	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
+		return
+	}
+	result = cmpFract(f1, f2)
+	return
+}
+
+// Returns
+//
+//	<0 if af1 < af2
+//	=0 if af1 == af2
+//	>0 if af1 > af2
+func cmpFract(f1, f2 *FractionType) (result int) {
+	f2.num = -f2.num
+	f := sumFract(f1, f2)
+	if f.num < 0 {
+		result = -1
+	} else if f.num > 0 {
+		result = 1
+	} else {
+		result = 0
+	}
+	return
+}
+
+func subAnyFract(af1, af2 any) (sum any, err error) {
+	var f1, f2 *FractionType
+	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
+		return
+	}
+	f2.num = -f2.num
+	f := sumFract(f1, f2)
+	if f.num == 0 {
+		sum = 0
+	} else {
+		sum = simplifyFraction(f)
+	}
+	return
+}
+
+func mulAnyFract(af1, af2 any) (prod any, err error) {
+	var f1, f2 *FractionType
+	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
+		return
+	}
+	if f1.num == 0 || f2.num == 0 {
+		prod = 0
+	} else {
+		f := &FractionType{f1.num * f2.num, f1.den * f2.den}
+		prod = simplifyFraction(f)
+	}
+	return
+}
+
+func divAnyFract(af1, af2 any) (quot any, err error) {
+	var f1, f2 *FractionType
+	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
+		return
+	}
+	if f2.num == 0 {
+		err = errors.New("division by zero")
+		return
+	}
+	if f1.num == 0 || f2.den == 0 {
+		quot = 0
+	} else {
+		f := &FractionType{f1.num * f2.den, f1.den * f2.num}
+		quot = simplifyFraction(f)
+	}
+	return
+}
+
+func simplifyFraction(f *FractionType) (v any) {
+	f.num, f.den = simplifyIntegers(f.num, f.den)
+	if f.den == 1 {
+		v = f.num
+	} else {
+		v = &FractionType{f.num, f.den}
+	}
+	return v
+}
+
+func simplifyIntegers(num, den int64) (a, b int64) {
+	if num == 0 {
+		return 0, 1
+	}
+	if den == 0 {
+		panic("fraction with denominator == 0")
+	}
+	if den < 0 {
+		den = -den
+		num = -num
+	}
+	g := gcd(num, den)
+	a = num / g
+	b = den / g
+	return
+}
+
+func intToFraction(n int64) *FractionType {
+	return &FractionType{n, 1}
+}
+
+func isFraction(v any) (ok bool) {
+	_, ok = v.(*FractionType)
+	return ok
+}

function.go

@@ -0,0 +1,386 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// function.go
+package expr
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// ---- Function template
+type FuncTemplate func(ctx ExprContext, name string, args map[string]any) (result any, err error)
+
+// ---- Common functor definition
+type baseFunctor struct {
+	info ExprFunc
+}
+
+func (functor *baseFunctor) ToString(opt FmtOpt) (s string) {
+	if functor.info != nil {
+		s = functor.info.ToString(opt)
+	} else {
+		s = "func(){}"
+	}
+	return s
+}
+
+func (functor *baseFunctor) GetParams() (params []ExprFuncParam) {
+	if functor.info != nil {
+		return functor.info.Params()
+	} else {
+		return []ExprFuncParam{}
+	}
+}
+
+func (functor *baseFunctor) SetFunc(info ExprFunc) {
+	functor.info = info
+}
+
+func (functor *baseFunctor) GetFunc() ExprFunc {
+	return functor.info
+}
+
+func (functor *baseFunctor) GetDefinitionContext() ExprContext {
+	return nil
+}
+
+// ---- Function Parameters
+type paramFlags uint16
+
+const (
+	PfDefault paramFlags = 1 << iota
+	PfOptional
+	PfRepeat
+)
+
+type funcParamInfo struct {
+	name         string
+	flags        paramFlags
+	defaultValue any
+}
+
+func NewFuncParam(name string) ExprFuncParam {
+	return &funcParamInfo{name: name}
+}
+
+func NewFuncParamFlag(name string, flags paramFlags) ExprFuncParam {
+	return &funcParamInfo{name: name, flags: flags}
+}
+
+func NewFuncParamFlagDef(name string, flags paramFlags, defValue any) *funcParamInfo {
+	return &funcParamInfo{name: name, flags: flags, defaultValue: defValue}
+}
+
+func (param *funcParamInfo) Name() string {
+	return param.name
+}
+
+func (param *funcParamInfo) Type() string {
+	return TypeAny
+}
+
+func (param *funcParamInfo) IsDefault() bool {
+	return (param.flags & PfDefault) != 0
+}
+
+func (param *funcParamInfo) IsOptional() bool {
+	return (param.flags & PfOptional) != 0
+}
+
+func (param *funcParamInfo) IsRepeat() bool {
+	return (param.flags & PfRepeat) != 0
+}
+
+func (param *funcParamInfo) DefaultValue() any {
+	return param.defaultValue
+}
+
+// --- Functions
+
+// funcInfo implements ExprFunc
+type funcInfo struct {
+	name         string
+	minArgs      int
+	maxArgs      int
+	functor      Functor
+	formalParams []ExprFuncParam
+	returnType   string
+}
+
+func newFuncInfo(name string, functor Functor, returnType string, params []ExprFuncParam) (info *funcInfo, err error) {
+	var minArgs = 0
+	var maxArgs = 0
+	for _, p := range params {
+		if maxArgs == -1 {
+			return nil, fmt.Errorf("no more params can be specified after the ellipsis symbol: %q", p.Name())
+		}
+		if p.IsDefault() || p.IsOptional() {
+			maxArgs++
+		} else if maxArgs == minArgs {
+			minArgs++
+			maxArgs++
+		} else {
+			return nil, fmt.Errorf("can't specify non-optional param after optional ones: %q", p.Name())
+		}
+		if p.IsRepeat() {
+			minArgs--
+			maxArgs = -1
+		}
+	}
+
+	info = &funcInfo{
+		name: name, minArgs: minArgs, maxArgs: maxArgs, functor: functor, returnType: returnType, formalParams: params,
+	}
+	functor.SetFunc(info)
+	return info, nil
+}
+
+func (info *funcInfo) Params() []ExprFuncParam {
+	return info.formalParams
+}
+
+func (info *funcInfo) ReturnType() string {
+	return info.returnType
+}
+
+func (info *funcInfo) ToString(opt FmtOpt) string {
+	var sb strings.Builder
+	if len(info.Name()) == 0 {
+		sb.WriteString("func")
+	} else {
+		sb.WriteString(info.Name())
+	}
+	sb.WriteByte('(')
+	if info.formalParams != nil {
+		for i, p := range info.formalParams {
+			if i > 0 {
+				sb.WriteString(", ")
+			}
+			sb.WriteString(p.Name())
+
+			if p.IsDefault() {
+				sb.WriteByte('=')
+				if s, ok := p.DefaultValue().(string); ok {
+					sb.WriteByte('"')
+					sb.WriteString(s)
+					sb.WriteByte('"')
+				} else {
+					sb.WriteString(fmt.Sprintf("%v", p.DefaultValue()))
+				}
+			}
+		}
+	}
+	if info.maxArgs < 0 {
+		sb.WriteString(" ...")
+	}
+	sb.WriteString("):")
+	if len(info.returnType) > 0 {
+		sb.WriteString(info.returnType)
+	} else {
+		sb.WriteString(TypeAny)
+	}
+	sb.WriteString("{}")
+	return sb.String()
+}
+
+func (info *funcInfo) Name() string {
+	return info.name
+}
+
+func (info *funcInfo) MinArgs() int {
+	return info.minArgs
+}
+
+func (info *funcInfo) MaxArgs() int {
+	return info.maxArgs
+}
+
+func (info *funcInfo) Functor() Functor {
+	return info.functor
+}
+
+func (info *funcInfo) AllocContext(parentCtx ExprContext) (ctx ExprContext) {
+	if defCtx := info.functor.GetDefinitionContext(); defCtx != nil {
+		ctx = defCtx.Clone()
+		ctx.SetParent(defCtx)
+	} else {
+		ctx = parentCtx.Clone()
+		ctx.SetParent(parentCtx)
+	}
+	return
+}
+
+func (info *funcInfo) ParamSpec(paramName string) ExprFuncParam {
+	for _, spec := range info.formalParams {
+		if spec.Name() == paramName {
+			return spec
+		}
+	}
+	return nil
+}
+
+func initActualParams(ctx ExprContext, info ExprFunc, callTerm *term) (actualParams map[string]any, err error) {
+	var varArgs []any
+	var varName string
+
+	namedParamsStarted := false
+
+	formalParams := info.Params()
+	actualParams = make(map[string]any, len(formalParams))
+	if callTerm == nil {
+		return
+	}
+
+	for i, tree := range callTerm.children {
+		var paramValue any
+		paramCtx := ctx.Clone()
+		if paramValue, err = tree.compute(paramCtx); err != nil {
+			break
+		}
+		if paramName, namedParam := getAssignVarName(tree); namedParam {
+			if info.ParamSpec(paramName) == nil {
+				err = fmt.Errorf("%s(): unknown param %q", info.Name(), paramName)
+				break
+			}
+			actualParams[paramName] = paramValue
+			namedParamsStarted = true
+		} else if !namedParamsStarted {
+			if varArgs != nil {
+				varArgs = append(varArgs, paramValue)
+			} else if i < len(formalParams) {
+				spec := formalParams[i]
+				if spec.IsRepeat() {
+					varArgs = make([]any, 0, len(callTerm.children)-i)
+					varArgs = append(varArgs, paramValue)
+					varName = spec.Name()
+				} else {
+					actualParams[spec.Name()] = paramValue
+				}
+			} else {
+				err = ErrTooManyParams(info.Name(), len(formalParams), len(callTerm.children))
+				break
+			}
+		} else {
+			err = fmt.Errorf("%s(): positional param nr %d not allowed after named params", info.Name(), i+1)
+			break
+		}
+	}
+	if err == nil {
+		if varArgs != nil {
+			actualParams[varName] = varArgs
+		}
+	}
+	return
+}
+
+func (info *funcInfo) PrepareCall(name string, actualParams map[string]any) (err error) {
+	passedCount := len(actualParams)
+	if info.MinArgs() > passedCount {
+		err = ErrTooFewParams(name, info.MinArgs(), info.MaxArgs(), passedCount)
+		return
+	}
+
+	if passedCount < len(info.formalParams) {
+		for _, p := range info.formalParams {
+			if _, exists := actualParams[p.Name()]; !exists {
+				if !p.IsDefault() {
+					break
+				}
+				if p.IsRepeat() {
+					varArgs := make([]any, 1)
+					varArgs[0] = p.DefaultValue()
+					actualParams[p.Name()] = varArgs
+				} else {
+					actualParams[p.Name()] = p.DefaultValue()
+				}
+			}
+		}
+	}
+
+	if info.MaxArgs() >= 0 && info.MaxArgs() < len(actualParams) {
+		err = ErrTooManyParams(name, info.MaxArgs(), len(actualParams))
+	}
+	return
+}
+
+// ----- Call a function ---
+
+func getAssignVarName(t *term) (name string, ok bool) {
+	if ok = t.symbol() == SymEqual; ok {
+		name = t.children[0].source()
+	}
+	return
+}
+
+func CallFunctionByTerm(parentCtx ExprContext, name string, callTerm *term) (result any, err error) {
+	var actualParams map[string]any
+	if info, exists := GetFuncInfo(parentCtx, name); exists {
+		if actualParams, err = initActualParams(parentCtx, info, callTerm); err == nil {
+			ctx := info.AllocContext(parentCtx)
+			if err = info.PrepareCall(name, actualParams); err == nil {
+				functor := info.Functor()
+				result, err = functor.InvokeNamed(ctx, name, actualParams)
+				exportObjectsToParent(ctx)
+			}
+		}
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}
+
+func CallFunctionByArgs(parentCtx ExprContext, name string, args []any) (result any, err error) {
+	var actualParams map[string]any
+	if info, exists := GetFuncInfo(parentCtx, name); exists {
+		functor := info.Functor()
+		actualParams = bindActualParams(functor, args)
+		ctx := info.AllocContext(parentCtx)
+		if err = info.PrepareCall(name, actualParams); err == nil {
+			result, err = functor.InvokeNamed(ctx, name, actualParams)
+			exportObjectsToParent(ctx)
+		}
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}
+
+func CallFunctionByParams(parentCtx ExprContext, name string, actualParams map[string]any) (result any, err error) {
+	//var actualParams map[string]any
+	if info, exists := GetFuncInfo(parentCtx, name); exists {
+		functor := info.Functor()
+		ctx := info.AllocContext(parentCtx)
+		if err = info.PrepareCall(name, actualParams); err == nil {
+			result, err = functor.InvokeNamed(ctx, name, actualParams)
+			exportObjectsToParent(ctx)
+		}
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}
+
+func GetParam(args map[string]any, paramName string, paramNum int) (value any, exists bool) {
+	if value, exists = args[paramName]; !exists {
+		if paramNum > 0 && paramNum <= len(args) {
+			value, exists = args["arg"+strconv.Itoa(paramNum)]
+		}
+	}
+	return
+}
+
+func bindActualParams(functor Functor, args []any) (actualParams map[string]any) {
+	formalParams := functor.GetParams()
+	actualParams = make(map[string]any, len(args))
+	for i, arg := range args {
+		if i < len(formalParams) {
+			actualParams[formalParams[i].Name()] = arg
+		} else {
+			actualParams["arg"+strconv.Itoa(i+1)] = arg
+		}
+	}
+	return
+}

global-context.go

@@ -0,0 +1,156 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// global-context.go
+package expr
+
+import (
+	"path/filepath"
+	"strings"
+)
+
+var globalCtx *SimpleStore
+
+func ImportInContext(name string) (exists bool) {
+	var mod *builtinModule
+	if mod, exists = builtinModuleRegister[name]; exists {
+		mod.importFunc(globalCtx)
+		mod.imported = true
+	}
+	return
+}
+
+func ImportInContextByGlobPattern(pattern string) (count int, err error) {
+	var matched bool
+	for name, mod := range builtinModuleRegister {
+		if matched, err = filepath.Match(pattern, name); err == nil {
+			if matched {
+				count++
+				mod.importFunc(globalCtx)
+				mod.imported = true
+			}
+		} else {
+			break
+		}
+	}
+	return
+}
+
+func GetVar(ctx ExprContext, name string) (value any, exists bool) {
+	if value, exists = ctx.GetVar(name); !exists {
+		value, exists = globalCtx.GetVar(name)
+	}
+	return
+}
+
+func GetLocalFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool) {
+	var v any
+	if len(name) > 0 {
+		if v, exists = ctx.GetVar(name); exists && isFunctor(v) {
+			f, _ := v.(Functor)
+			item = f.GetFunc()
+		} else {
+			item, exists = ctx.GetFuncInfo(name)
+		}
+	}
+	return
+}
+
+func GetFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool) {
+	// if len(name) > 0 {
+	// 	if item, exists = GetLocalFuncInfo(ctx, name); exists {
+	// 		ownerCtx = ctx
+	// 	} else if item, exists = globalCtx.GetFuncInfo(name); exists {
+	// 		ownerCtx = globalCtx
+	// 	}
+	// }
+	item, exists, _ = GetFuncInfoAndOwner(ctx, name)
+	return
+}
+
+func GetFuncInfoAndOwner(ctx ExprContext, name string) (item ExprFunc, exists bool, ownerCtx ExprContext) {
+	if len(name) > 0 {
+		if item, exists = GetLocalFuncInfo(ctx, name); exists {
+			ownerCtx = ctx
+		} else if item, exists = globalCtx.GetFuncInfo(name); exists {
+			ownerCtx = globalCtx
+		}
+	}
+	return
+}
+
+func GlobalCtrlSet(name string, newValue any) (currentValue any) {
+	if !strings.HasPrefix(name, "_") {
+		name = "_" + name
+	}
+	currentValue, _ = globalCtx.GetVar(name)
+
+	globalCtx.SetVar(name, newValue)
+	return currentValue
+}
+
+func GlobalCtrlGet(name string) (currentValue any) {
+	if !strings.HasPrefix(name, "_") {
+		name = "_" + name
+	}
+	currentValue, _ = globalCtx.GetVar(name)
+	return currentValue
+}
+
+func CtrlEnable(ctx ExprContext, name string) (currentStatus bool) {
+	if !strings.HasPrefix(name, "_") {
+		name = "_" + name
+	}
+	if v, exists := ctx.GetVar(name); exists && IsBool(v) {
+		currentStatus, _ = v.(bool)
+	}
+
+	ctx.SetVar(name, true)
+	return currentStatus
+}
+
+func CtrlDisable(ctx ExprContext, name string) (currentStatus bool) {
+	if !strings.HasPrefix(name, "_") {
+		name = "_" + name
+	}
+	if v, exists := ctx.GetVar(name); exists && IsBool(v) {
+		currentStatus, _ = v.(bool)
+	}
+
+	ctx.SetVar(name, false)
+	return currentStatus
+}
+
+func CtrlIsEnabled(ctx ExprContext, name string) (status bool) {
+	var v any
+	var exists bool
+
+	if !strings.HasPrefix(name, "_") {
+		name = "_" + name
+	}
+
+	if v, exists = ctx.GetVar(name); !exists {
+		v, exists = globalCtx.GetVar(name)
+	}
+
+	if exists {
+		if b, ok := v.(bool); ok {
+			status = b
+		}
+	}
+	return
+}
+
+func getControlString(name string) (s string, exists bool) {
+	var v any
+	if v, exists = globalCtx.GetVar(name); exists {
+		s, exists = v.(string)
+	}
+	return
+}
+
+func init() {
+	globalCtx = NewSimpleStore()
+	initDefaultVars(globalCtx)
+	ImportBuiltinsFuncs(globalCtx)
+}

go.mod

@@ -0,0 +1,7 @@
+module git.portale-stac.it/go-pkg/expr
+
+go 1.22.0
+
+toolchain go1.23.3
+
+require golang.org/x/exp v0.0.0-20241204233417-43b7b7cde48d

go.sum

@@ -0,0 +1,4 @@
+github.com/yqylovy/goimportdot v0.0.0-20170519021755-eb181a7eeabe h1:bWYrKmmfv37uNgXTdwkLSKYiYPJ1yfWmjBnvtMyAYzk=
+github.com/yqylovy/goimportdot v0.0.0-20170519021755-eb181a7eeabe/go.mod h1:alTKUpAJ/zbp17qvZwcFNwzufrb5DljMDY4mgJlIHao=
+golang.org/x/exp v0.0.0-20241204233417-43b7b7cde48d h1:0olWaB5pg3+oychR51GUVCEsGkeCU/2JxjBgIo4f3M0=
+golang.org/x/exp v0.0.0-20241204233417-43b7b7cde48d/go.mod h1:qj5a5QZpwLU2NLQudwIN5koi3beDhSAlJwa67PuM98c=

graph.go

@@ -0,0 +1,122 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// graph.go
+package expr
+
+import (
+	"fmt"
+	"strings"
+)
+
+func BuildGraph(root *term) (g string) {
+	//var sb strings.Builder
+	g = fmt.Sprintf("tree: %v", root)
+
+	r := NewReticle(root)
+	fmt.Println(r)
+	return
+}
+
+type NodeRef struct {
+	node  *term
+	pos   int
+	label string
+}
+
+type Level []*NodeRef
+
+type Reticle struct {
+	levels      []Level
+	left, right int
+	colsWidth   []int
+}
+
+func NewExprReticle(e Expr) *Reticle {
+	tree, _ := e.(*ast)
+	return NewReticle(tree.root)
+}
+
+func NewReticle(tree *term) *Reticle {
+	r := &Reticle{levels: make([]Level, 0)}
+	r.build(tree, 0, 0)
+	r.computeCharWidth()
+	return r
+}
+
+func (r *Reticle) computeCharWidth() {
+	numCol := r.right - r.left + 1
+	r.colsWidth = make([]int, numCol)
+	for _, level := range r.levels {
+		for _, ref := range level {
+			c := ref.pos - r.left
+			if v := ref.node.value(); v != nil {
+				ref.label = fmt.Sprintf("%v", v)
+			} else {
+				ref.label = ref.node.source()
+			}
+			r.colsWidth[c] = max(r.colsWidth[c], len(ref.label)+2) // +2 to make room for brakets
+		}
+	}
+}
+
+func (r *Reticle) build(node *term, depth, pos int) {
+	var level Level
+	if node == nil {
+		return
+	}
+	if len(r.levels) == depth {
+		level = make(Level, 0)
+		r.levels = append(r.levels, level)
+	} else {
+		level = r.levels[depth]
+	}
+	ref := &NodeRef{node: node, pos: pos}
+	level = append(level, ref)
+	if r.left > pos {
+		r.left = pos
+	}
+	if r.right < pos {
+		r.right = pos
+	}
+	if node.children != nil {
+		halfPos := len(node.children) / 2
+		childPos := pos - halfPos - 1
+		for _, child := range node.children {
+			childPos++
+			if childPos == pos && (len(node.children)&1) == 0 {
+				childPos++
+			}
+			r.build(child, depth+1, childPos)
+		}
+	}
+	r.levels[depth] = level
+}
+
+func (r *Reticle) nodeInLevel(level []*NodeRef, index int) (node *NodeRef) {
+	for _, ref := range level {
+		if ref.pos-r.left == index {
+			node = ref
+			break
+		}
+	}
+	return
+}
+
+func (r *Reticle) String() string {
+	var sb strings.Builder
+	for _, level := range r.levels {
+		for j, w := range r.colsWidth {
+			var label string
+			if ref := r.nodeInLevel(level, j); ref != nil {
+				s := "(" + ref.label + ")"
+				label = fmt.Sprintf("%[1]*s", -w, fmt.Sprintf("%[1]*s", (w+len(s))/2, s))
+			} else {
+				label = strings.Repeat(" ", w)
+			}
+			sb.WriteString(label)
+		}
+		sb.WriteByte('\n')
+	}
+	return sb.String()
+}

helpers.go

@@ -0,0 +1,87 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// helpers.go
+package expr
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+)
+
+func EvalString(ctx ExprContext, source string) (result any, err error) {
+	var tree *ast
+
+	r := strings.NewReader(source)
+	scanner := NewScanner(r, DefaultTranslations())
+	parser := NewParser()
+
+	if tree, err = parser.Parse(scanner); err == nil {
+		result, err = tree.Eval(ctx)
+	}
+	return
+}
+
+type Arg struct {
+	Name  string
+	Value any
+}
+
+func EvalStringA(source string, args ...Arg) (result any, err error) {
+	return EvalStringV(source, args)
+}
+
+func EvalStringV(source string, args []Arg) (result any, err error) {
+	ctx := NewSimpleStore()
+	for _, arg := range args {
+		if isFunc(arg.Value) {
+			if f, ok := arg.Value.(FuncTemplate); ok {
+				functor := NewGolangFunctor(f)
+				// ctx.RegisterFunc(arg.Name, functor, 0, -1)
+				ctx.RegisterFunc(arg.Name, functor, TypeAny, []ExprFuncParam{
+					NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, 0),
+				})
+			} else {
+				err = fmt.Errorf("invalid function specification: %q", arg.Name)
+			}
+		} else if integer, ok := anyInteger(arg.Value); ok {
+			ctx.SetVar(arg.Name, integer)
+		} else if float, ok := anyFloat(arg.Value); ok {
+			ctx.SetVar(arg.Name, float)
+		} else if _, ok := arg.Value.(string); ok {
+			ctx.SetVar(arg.Name, arg.Value)
+		} else if _, ok := arg.Value.(bool); ok {
+			ctx.SetVar(arg.Name, arg.Value)
+		} else {
+			err = fmt.Errorf("unsupported type %T specified for item %q", arg.Value, arg.Name)
+		}
+	}
+
+	if err == nil {
+		result, err = EvalString(ctx, source)
+	}
+	return
+}
+
+func EvalStream(ctx ExprContext, r io.Reader) (result any, err error) {
+	var tree *ast
+	scanner := NewScanner(r, DefaultTranslations())
+	parser := NewParser()
+
+	if tree, err = parser.Parse(scanner); err == nil {
+		result, err = tree.Eval(ctx)
+	}
+	return
+}
+
+func EvalFile(ctx ExprContext, filePath string) (result any, err error) {
+	var fh *os.File
+	if fh, err = os.Open(filePath); err != nil {
+		return nil, err
+	}
+	defer fh.Close()
+	result, err = EvalStream(ctx, fh)
+	return
+}

import-utils.go

@@ -0,0 +1,124 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// import-utils.go
+package expr
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+)
+
+const (
+	ENV_EXPR_SOURCE_PATH = "EXPR_PATH"
+	ENV_EXPR_PLUGIN_PATH = "EXPR_PLUGIN_PATH"
+)
+
+func checkStringParamExpected(funcName string, paramValue any, paramPos int) (err error) {
+	if !(IsString(paramValue) /*|| isList(paramValue)*/) {
+		err = fmt.Errorf("%s(): param nr %d has wrong type %s, string expected", funcName, paramPos+1, TypeName(paramValue))
+	}
+	return
+}
+
+// func addSourceEnvImportDirs(varName string, dirList []string) []string {
+// 	return addEnvImportDirs(ENV_EXPR_SOURCE_PATH, dirList)
+// }
+
+// func addPluginEnvImportDirs(varName string, dirList []string) []string {
+// 	return addEnvImportDirs(ENV_EXPR_PLUGIN_PATH, dirList)
+// }
+
+func addEnvImportDirs(envVarName string, dirList []string) []string {
+	if dirSpec, exists := os.LookupEnv(envVarName); exists {
+		dirs := strings.Split(dirSpec, ":")
+		if dirList == nil {
+			dirList = dirs
+		} else {
+			dirList = append(dirList, dirs...)
+		}
+	}
+	return dirList
+}
+
+func addSearchDirs(endingPath string, dirList []string) []string {
+	if dirSpec, exists := getControlString(ControlSearchPath); exists {
+		dirs := strings.Split(dirSpec, ":")
+		if dirList == nil {
+			dirList = dirs
+		} else {
+			if len(endingPath) > 0 {
+				for _, d := range dirs {
+					dirList = append(dirList, path.Join(d, endingPath))
+				}
+			} else {
+				dirList = append(dirList, dirs...)
+			}
+		}
+	}
+	return dirList
+}
+
+func buildSearchDirList(endingPath, envVarName string) (dirList []string) {
+	dirList = addEnvImportDirs(envVarName, dirList)
+	dirList = addSearchDirs(endingPath, dirList)
+	return
+}
+
+func isFile(filePath string) bool {
+	info, err := os.Stat(filePath)
+	return (err == nil || errors.Is(err, os.ErrExist)) && info.Mode().IsRegular()
+}
+
+func searchAmongPath(filename string, dirList []string) (filePath string) {
+	var err error
+
+	suffix := SHAREDLIBRARY_EXTENSION
+	if strings.HasSuffix(filename, ".debug") {
+		suffix += ".debug"
+	}
+
+	for _, dir := range dirList {
+		if dir, err = ExpandPath(dir); err != nil {
+			continue
+		}
+		if fullPath := path.Join(dir, filename); isFile(fullPath) {
+			filePath = fullPath
+			break
+		}
+
+		subdir := strings.TrimSuffix(filename, suffix)
+		if fullPath := path.Join(dir, subdir, filename); isFile(fullPath) {
+			filePath = fullPath
+			break
+		}
+	}
+	return
+}
+
+func isPathRelative(filePath string) bool {
+	unixPath := filepath.ToSlash(filePath)
+	return strings.HasPrefix(unixPath, "./") || strings.HasPrefix(unixPath, "../")
+}
+
+func makeFilepath(filename string, dirList []string) (filePath string, err error) {
+	if filename, err = ExpandPath(filename); err != nil {
+		return
+	}
+
+	if path.IsAbs(filename) || isPathRelative(filename) {
+		if isFile(filename) {
+			filePath = filename
+		}
+	} else {
+		filePath = searchAmongPath(filename, dirList)
+	}
+	if len(filePath) == 0 {
+		err = fmt.Errorf("file %q not found", filename)
+	}
+	return
+}

it-range.go.unused

@@ -0,0 +1,58 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// it-range.go
+package expr
+
+import "io"
+
+type RangeIterator struct {
+	start   int64
+	end     int64
+	step    int64
+	current int64
+	index   int
+}
+
+func NewRangeIterator(start, end, step int64) *RangeIterator {
+	if step == 0 {
+		panic("Range step must be not zero")
+	}
+	if step < 0 && start < end {
+		panic("When the range's step is less than zero, start must be greater than end")
+	}
+	if step > 0 && start > end {
+		panic("When the range's step is greater than zero, start must be less than end")
+	}
+	return &RangeIterator{start: start, end: end, step: step, current: start, index: 0}
+}
+
+func (it *RangeIterator) Reset() {
+	it.index = 0
+	it.current = it.start
+}
+
+func (it *RangeIterator) Next() (item any, err error) {
+	if it.step > 0 {
+		if it.current < it.end {
+			item = it.current
+			it.current += it.step
+			it.index++
+		} else {
+			err = io.EOF
+		}
+	} else {
+		if it.current > it.end {
+			item = it.current
+			it.current += it.step
+			it.index++
+		} else {
+			err = io.EOF
+		}
+	}
+	return
+}
+
+func (it *RangeIterator) Index() int {
+	return it.index - 1
+}

iter-factory.go

@@ -0,0 +1,25 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// iter-factory.go
+package expr
+
+func NewIterator(value any) (it Iterator, err error) {
+	if value == nil {
+		return NewArrayIterator([]any{}), nil
+	}
+
+	switch v := value.(type) {
+	case *ListType:
+		it = NewListIterator(v, nil)
+	case *DictType:
+		it, err = NewDictIterator(v, nil)
+	case []any:
+		it = NewArrayIterator(v)
+	case Iterator:
+		it = v
+	default:
+		it = NewArrayIterator([]any{value})
+	}
+	return
+}

iterator.go

@@ -0,0 +1,51 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// iterator.go
+package expr
+
+import (
+	// "errors"
+	"fmt"
+)
+
+// Operator names
+
+const (
+	InitName    = "init"
+	CleanName   = "clean"
+	ResetName   = "reset"
+	NextName    = "next"
+	CurrentName = "current"
+	IndexName   = "index"
+	CountName   = "count"
+	FilterName  = "filter"
+	MapName     = "map"
+	KeyName     = "key"
+	ValueName   = "value"
+)
+
+type Iterator interface {
+	Typer
+	fmt.Stringer
+	Next() (item any, err error) // must return io.EOF after the last item
+	Current() (item any, err error)
+	Index() int
+	Count() int
+	HasOperation(name string) bool
+	CallOperation(name string, args map[string]any) (value any, err error)
+}
+
+type ExtIterator interface {
+	Iterator
+	Reset() error
+	Clean() error
+}
+
+func errNoOperation(name string) error {
+	return fmt.Errorf("no %s() function defined in the data-source", name)
+}
+
+// func errInvalidDataSource() error {
+// 	return errors.New("invalid data-source")
+// }

lib-ext-darwin.go

@@ -0,0 +1,9 @@
+//go:build darwin
+
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// lib-ext-darwin.go
+package expr
+
+const SHAREDLIBRARY_EXTENSION = ".dylib"

lib-ext-linux.go

@@ -0,0 +1,9 @@
+//go:build linux
+
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// lib-ext-linux.go
+package expr
+
+const SHAREDLIBRARY_EXTENSION = ".so"

lib-ext-windows.go

@@ -0,0 +1,9 @@
+//go:build windows
+
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// lib-ext-windows.go
+package expr
+
+const SHAREDLIBRARY_EXTENSION = ".dll"

list-iterator.go

@@ -0,0 +1,145 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// list-iterator.go
+package expr
+
+import (
+	"fmt"
+	"io"
+)
+
+type ListIterator struct {
+	a     *ListType
+	count int
+	index int
+	start int
+	stop  int
+	step  int
+}
+
+func NewListIterator(list *ListType, args []any) (it *ListIterator) {
+	var argc int = 0
+	listLen := len(([]any)(*list))
+	if args != nil {
+		argc = len(args)
+	}
+	it = &ListIterator{a: list, count: 0, index: -1, start: 0, stop: listLen - 1, step: 1}
+	if argc >= 1 {
+		if i, err := ToGoInt(args[0], "start index"); err == nil {
+			if i < 0 {
+				i = listLen + i
+			}
+			it.start = i
+		}
+		if argc >= 2 {
+			if i, err := ToGoInt(args[1], "stop index"); err == nil {
+				if i < 0 {
+					i = listLen + i
+				}
+				it.stop = i
+			}
+			if argc >= 3 {
+				if i, err := ToGoInt(args[2], "step"); err == nil {
+					if i < 0 {
+						i = -i
+					}
+					if it.start > it.stop {
+						it.step = -i
+					} else {
+						it.step = i
+					}
+				}
+			}
+		}
+	}
+	it.index = it.start - it.step
+	return
+}
+
+func NewArrayIterator(array []any) (it *ListIterator) {
+	it = &ListIterator{a: (*ListType)(&array), count: 0, index: -1, start: 0, stop: len(array) - 1, step: 1}
+	return
+}
+
+func (it *ListIterator) String() string {
+	var l = 0
+	if it.a != nil {
+		l = len(*it.a)
+	}
+	return fmt.Sprintf("$([#%d])", l)
+}
+
+func (it *ListIterator) TypeName() string {
+	return "ListIterator"
+}
+
+func (it *ListIterator) HasOperation(name string) bool {
+	yes := name == NextName || name == ResetName || name == IndexName || name == CountName || name == CurrentName
+	return yes
+}
+
+func (it *ListIterator) CallOperation(name string, args map[string]any) (v any, err error) {
+	switch name {
+	case NextName:
+		v, err = it.Next()
+	case ResetName:
+		err = it.Reset()
+	case CleanName:
+		err = it.Clean()
+	case IndexName:
+		v = int64(it.Index())
+	case CurrentName:
+		v, err = it.Current()
+	case CountName:
+		v = it.count
+	default:
+		err = errNoOperation(name)
+	}
+	return
+}
+
+func (it *ListIterator) Current() (item any, err error) {
+	a := *(it.a)
+	if it.start <= it.stop {
+		if it.stop < len(a) && it.index >= it.start && it.index <= it.stop {
+			item = a[it.index]
+		} else {
+			err = io.EOF
+		}
+	} else {
+		if it.start < len(a) && it.index >= it.stop && it.index <= it.start {
+			item = a[it.index]
+		} else {
+			err = io.EOF
+		}
+
+	}
+	return
+}
+
+func (it *ListIterator) Next() (item any, err error) {
+	it.index += it.step
+	if item, err = it.Current(); err != io.EOF {
+		it.count++
+	}
+	return
+}
+
+func (it *ListIterator) Index() int {
+	return it.index
+}
+
+func (it *ListIterator) Count() int {
+	return it.count
+}
+
+func (it *ListIterator) Reset() error {
+	it.index = it.start - it.step
+	it.count = 0
+	return nil
+}
+
+func (it *ListIterator) Clean() error {
+	return nil
+}

list-type.go

@@ -0,0 +1,212 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// list-type.go
+package expr
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type ListType []any
+
+func newListA(listAny ...any) (list *ListType) {
+	if listAny == nil {
+		listAny = []any{}
+	}
+	return newList(listAny)
+}
+
+func newList(listAny []any) (list *ListType) {
+	return NewList(listAny)
+}
+
+func NewList(listAny []any) (list *ListType) {
+	if listAny != nil {
+		ls := make(ListType, len(listAny))
+		//		for i, item := range listAny {
+		//			ls[i] = item
+		//		}
+		copy(ls, listAny)
+		list = &ls
+	}
+	return
+}
+
+func MakeList(length, capacity int) (list *ListType) {
+	if capacity < length {
+		capacity = length
+	}
+	ls := make(ListType, length, capacity)
+	list = &ls
+	return
+}
+
+func ListFromStrings(stringList []string) (list *ListType) {
+	list = MakeList(len(stringList), 0)
+	for i, s := range stringList {
+		(*list)[i] = s
+	}
+	return
+}
+
+func (ls *ListType) ToString(opt FmtOpt) (s string) {
+	indent := GetFormatIndent(opt)
+	flags := GetFormatFlags(opt)
+
+	var sb strings.Builder
+	sb.WriteByte('[')
+	if len(*ls) > 0 {
+		innerOpt := MakeFormatOptions(flags, indent+1)
+		nest := strings.Repeat("  ", indent+1)
+
+		if flags&MultiLine != 0 {
+			sb.WriteByte('\n')
+			sb.WriteString(nest)
+		}
+		for i, item := range []any(*ls) {
+			if i > 0 {
+				if flags&MultiLine != 0 {
+					sb.WriteString(",\n")
+					sb.WriteString(nest)
+				} else {
+					sb.WriteString(", ")
+				}
+			}
+			if s, ok := item.(string); ok {
+				sb.WriteByte('"')
+				sb.WriteString(s)
+				sb.WriteByte('"')
+			} else if formatter, ok := item.(Formatter); ok {
+				sb.WriteString(formatter.ToString(innerOpt))
+			} else {
+				sb.WriteString(fmt.Sprintf("%v", item))
+			}
+		}
+		if flags&MultiLine != 0 {
+			sb.WriteByte('\n')
+			sb.WriteString(strings.Repeat("  ", indent))
+		}
+	}
+	sb.WriteByte(']')
+	s = sb.String()
+	if flags&Truncate != 0 && len(s) > TruncateSize {
+		s = TruncateString(s)
+	}
+	return
+}
+
+func (ls *ListType) String() string {
+	return ls.ToString(0)
+}
+
+func (ls *ListType) TypeName() string {
+	return "list"
+}
+
+// func (list *ListType) indexDeepCmp(target any) (index int) {
+// 	index = -1
+// 	for i, item := range *list {
+// 		if reflect.DeepEqual(item, target) {
+// 			index = i
+// 			break
+// 		}
+// 	}
+// 	return
+// }
+
+func (ls *ListType) contains(t *ListType) (answer bool) {
+	if len(*ls) >= len(*t) {
+		answer = true
+		for _, item := range *t {
+			if answer = ls.indexDeepSameCmp(item) >= 0; !answer {
+				break
+			}
+		}
+	}
+	return
+}
+
+func (ls1 *ListType) Equals(ls2 ListType) (answer bool) {
+	if ls2 != nil && len(*ls1) == len(ls2) {
+		answer = true
+		for index, i1 := range *ls1 {
+			// if i1 != (ls2)[index] {
+			if reflect.DeepEqual(i1, ls2[index]) {
+				answer = false
+				break
+			}
+		}
+	}
+	return
+}
+
+func (list *ListType) indexDeepSameCmp(target any) (index int) {
+	var eq bool
+	var err error
+	index = -1
+	for i, item := range *list {
+		if eq, err = deepSame(item, target, sameContent); err != nil {
+			break
+		} else if eq {
+			index = i
+			break
+		}
+	}
+	return
+}
+
+func sameContent(a, b any) (same bool, err error) {
+	la, _ := a.(*ListType)
+	lb, _ := b.(*ListType)
+	if len(*la) == len(*lb) {
+		same = true
+		for _, item := range *la {
+			if pos := lb.indexDeepSameCmp(item); pos < 0 {
+				same = false
+				break
+			}
+		}
+	}
+	return
+}
+
+func deepSame(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
+	if isNumOrFract(a) && isNumOrFract(b) {
+		if IsNumber(a) && IsNumber(b) {
+			if IsInteger(a) && IsInteger(b) {
+				li, _ := a.(int64)
+				ri, _ := b.(int64)
+				eq = li == ri
+			} else {
+				eq = numAsFloat(a) == numAsFloat(b)
+			}
+		} else {
+			var cmp int
+			if cmp, err = cmpAnyFract(a, b); err == nil {
+				eq = cmp == 0
+			}
+		}
+	} else if deepCmp != nil && IsList(a) && IsList(b) {
+		eq, err = deepCmp(a, b)
+	} else {
+		eq = reflect.DeepEqual(a, b)
+	}
+
+	return
+}
+
+func (list *ListType) setItem(index int64, value any) (err error) {
+	if index >= 0 && index < int64(len(*list)) {
+		(*list)[index] = value
+	} else {
+		err = fmt.Errorf("index %d out of bounds (0, %d)", index, len(*list)-1)
+	}
+	return
+}
+
+func (list *ListType) appendItem(value any) {
+	*list = append(*list, value)
+}

operand-const.go

@@ -1,72 +0,0 @@
-// operand-const.go
-package expr
-
-// -------- bool const term
-func newBoolTerm(tk *Token) *term {
-	return &term{
-		tk:       *tk,
-		class:    classConst,
-		kind:     kindBool,
-		parent:   nil,
-		children: nil,
-		position: posLeaf,
-		priority: priValue,
-		evalFunc: evalConst,
-	}
-}
-
-// -------- integer const term
-func newIntegerTerm(tk *Token) *term {
-	return &term{
-		tk:       *tk,
-		class:    classConst,
-		kind:     kindInteger,
-		parent:   nil,
-		children: nil,
-		position: posLeaf,
-		priority: priValue,
-		evalFunc: evalConst,
-	}
-}
-
-// -------- float const term
-func newFloatTerm(tk *Token) *term {
-	return &term{
-		tk:       *tk,
-		class:    classConst,
-		kind:     kindFloat,
-		parent:   nil,
-		children: nil,
-		position: posLeaf,
-		priority: priValue,
-		evalFunc: evalConst,
-	}
-}
-
-// -------- string const term
-func newStringTerm(tk *Token) *term {
-	return &term{
-		tk:       *tk,
-		class:    classConst,
-		kind:     kindString,
-		parent:   nil,
-		children: nil,
-		position: posLeaf,
-		priority: priValue,
-		evalFunc: evalConst,
-	}
-}
-
-// -------- eval func
-func evalConst(ctx exprContext, self *term) (v any, err error) {
-	v = self.tk.Value
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymString, newStringTerm)
-	registerTermConstructor(SymInteger, newIntegerTerm)
-	registerTermConstructor(SymFloat, newFloatTerm)
-	registerTermConstructor(SymBool, newBoolTerm)
-}

operand-dict.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operand-dict.go
+package expr
+
+
+// -------- dict term
+func newDictTerm(args map[any]*term) *term {
+	return &term{
+		tk:       *NewValueToken(0, 0, SymDict, "{}", args),
+		parent:   nil,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalDict,
+	}
+}
+
+// -------- dict func
+func evalDict(ctx ExprContext, opTerm *term) (v any, err error) {
+	dict, _ := opTerm.value().(map[any]*term)
+	items := make(DictType, len(dict))
+	for key, tree := range dict {
+		var param any
+		if param, err = tree.compute(ctx); err != nil {
+			break
+		}
+		items[key] = param
+	}
+	if err == nil {
+		v = &items
+	}
+	return
+}

operand-expr.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operand-expr.go
+package expr
+
+import "fmt"
+
+// -------- expr term
+func newExprTerm(root *term) *term {
+	tk := NewValueToken(root.tk.row, root.tk.col, SymExpression, root.source(), root)
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalExpr,
+	}
+}
+
+// -------- eval expr
+func evalExpr(ctx ExprContext, opTerm *term) (v any, err error) {
+	if expr, ok := opTerm.value().(*term); ok {
+		v, err = expr.compute(ctx)
+	} else {
+		err = fmt.Errorf("expression expected, got %T", opTerm.value())
+	}
+	return
+}

operand-func.go

@@ -1,33 +1,81 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // operand-func.go
 package expr
 
-// -------- function term
-func newFuncTerm(tk *Token, args []*term) *term {
+import (
+	"errors"
+)
+
+// -------- function call term
+func newFuncCallTerm(tk *Token, args []*term) *term {
 	return &term{
 		tk:       *tk,
-		class:    classVar,
-		kind:     kindUnknown,
 		parent:   nil,
 		children: args,
 		position: posLeaf,
 		priority: priValue,
-		evalFunc: evalFunc,
+		evalFunc: evalFuncCall,
 	}
 }
 
-// -------- eval func
-func evalFunc(ctx exprContext, self *term) (v any, err error) {
-	name, _ := self.tk.Value.(string)
-	params := make([]any, len(self.children))
-	for i, tree := range self.children {
-		var param any
-		if param, err = tree.compute(ctx); err != nil {
-			break
-		}
-		params[i] = param
+// -------- eval func call
+// func _evalFuncCall(ctx ExprContext, opTerm *term) (v any, err error) {
+// 	name, _ := opTerm.tk.Value.(string)
+// 	params := make([]any, len(opTerm.children), len(opTerm.children)+5)
+// 	for i, tree := range opTerm.children {
+// 		var param any
+// 		if param, err = tree.compute(ctx); err != nil {
+// 			break
+// 		}
+// 		params[i] = param
+// 	}
+
+// 	if err == nil {
+// 		v, err = CallFunction(ctx, name, params)
+// 	}
+// 	return
+// }
+
+func evalFuncCall(ctx ExprContext, opTerm *term) (v any, err error) {
+	name, _ := opTerm.tk.Value.(string)
+	v, err = CallFunctionByTerm(ctx, name, opTerm)
+	return
+}
+
+// -------- function definition term
+func newFuncDefTerm(tk *Token, args []*term) *term {
+	return &term{
+		tk:       *tk, // value is the expression body
+		parent:   nil,
+		children: args, // function params
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalFuncDef,
 	}
-	if err == nil {
-		v, err = ctx.Call(name, params)
+}
+
+// -------- eval func def
+func evalFuncDef(ctx ExprContext, opTerm *term) (v any, err error) {
+	bodySpec := opTerm.value()
+	if expr, ok := bodySpec.(*ast); ok {
+		paramList := make([]ExprFuncParam, 0, len(opTerm.children))
+		for _, param := range opTerm.children {
+			var defValue any
+			flags := paramFlags(0)
+			if len(param.children) > 0 {
+				flags |= PfDefault
+				if defValue, err = param.children[0].compute(ctx); err != nil {
+					return
+				}
+			}
+			info := NewFuncParamFlagDef(param.source(), flags, defValue)
+			paramList = append(paramList, info)
+		}
+		v = newExprFunctor(expr, paramList, ctx)
+	} else {
+		err = errors.New("invalid function definition: the body specification must be an expression")
 	}
 	return
 }

operand-iterator.go

@@ -0,0 +1,164 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operand-iterator.go
+package expr
+
+import (
+	"slices"
+	"strings"
+)
+
+// -------- iterator term
+
+func newIteratorTerm(tk *Token, args []*term) *term {
+	tk.Sym = SymIterator
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: args,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalIterator,
+	}
+}
+
+// -------- eval iterator
+
+func evalTermArray(ctx ExprContext, terms []*term) (values []any, err error) {
+	values = make([]any, len(terms))
+	for i, t := range terms {
+		var value any
+		if value, err = t.compute(ctx); err == nil {
+			values[i] = value
+		} else {
+			break
+		}
+	}
+	return
+}
+
+func evalFirstChild(ctx ExprContext, iteratorTerm *term) (value any, err error) {
+	if len(iteratorTerm.children) < 1 || iteratorTerm.children[0] == nil {
+		err = iteratorTerm.Errorf("missing the data-source parameter")
+		return
+	}
+
+	value, err = iteratorTerm.children[0].compute(ctx)
+	return
+}
+
+func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]Functor, err error) {
+	if dictAny, ok := firstChildValue.(*DictType); ok {
+		requiredFields := []string{NextName}
+		fieldsMask := 0b1
+		foundFields := 0
+		ds = make(map[string]Functor)
+		for keyAny, item := range *dictAny {
+			if key, ok := keyAny.(string); ok {
+				if functor, ok := item.(Functor); ok {
+					ds[key] = functor
+					if index := slices.Index(requiredFields, key); index >= 0 {
+						foundFields |= 1 << index
+					}
+				}
+			}
+		}
+		// check required functions
+		if foundFields != fieldsMask {
+			missingFields := make([]string, 0, len(requiredFields))
+			for index, field := range requiredFields {
+				if (foundFields & (1 << index)) == 0 {
+					missingFields = append(missingFields, field)
+				}
+			}
+			err = iteratorTerm.children[0].Errorf("the data-source must provide a non-nil %q operator(s)", strings.Join(missingFields, ", "))
+		}
+	}
+	return
+}
+
+func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
+	var firstChildValue any
+	var ds map[string]Functor
+
+	if firstChildValue, err = evalFirstChild(ctx, opTerm); err != nil {
+		return
+	}
+
+	if ds, err = getDataSourceDict(opTerm, firstChildValue); err != nil && ds == nil {
+		return
+	}
+	err = nil
+
+	if ds != nil {
+		if len(ds) > 0 {
+			var dc *dataCursor
+			dcCtx := ctx.Clone()
+			if initFunc, exists := ds[InitName]; exists && initFunc != nil {
+				var args []any
+				var resource any
+				if len(opTerm.children) > 1 {
+					if args, err = evalTermArray(ctx, opTerm.children[1:]); err != nil {
+						return
+					}
+				} else {
+					args = []any{}
+				}
+
+				actualParams := bindActualParams(initFunc, args)
+
+				initCtx := ctx.Clone()
+				if resource, err = initFunc.InvokeNamed(initCtx, InitName, actualParams); err != nil {
+					return
+				}
+				exportObjects(dcCtx, initCtx)
+				dc = NewDataCursor(dcCtx, ds, resource)
+			} else {
+				dc = NewDataCursor(dcCtx, ds, nil)
+			}
+
+			v = dc
+		} else {
+			if dictIt, ok := firstChildValue.(*DictType); ok {
+				var args []any
+				if args, err = evalSibling(ctx, opTerm.children, nil); err == nil {
+					v, err = NewDictIterator(dictIt, args)
+				}
+			} else {
+				err = opTerm.children[0].Errorf("the data-source must be a dictionary")
+			}
+		}
+	} else if list, ok := firstChildValue.(*ListType); ok {
+		var args []any
+		if args, err = evalSibling(ctx, opTerm.children, nil); err == nil {
+			v = NewListIterator(list, args)
+		}
+	} else {
+		var list []any
+		if list, err = evalSibling(ctx, opTerm.children, firstChildValue); err == nil {
+			v = NewArrayIterator(list)
+		}
+	}
+	return
+}
+
+func evalSibling(ctx ExprContext, terms []*term, firstChildValue any) (list []any, err error) {
+	items := make([]any, 0, len(terms))
+	for i, tree := range terms {
+		var param any
+		if i == 0 {
+			if firstChildValue == nil {
+				continue
+			}
+			param = firstChildValue
+		} else if param, err = tree.compute(ctx); err != nil {
+			break
+		}
+		items = append(items, param)
+	}
+	if err == nil {
+		list = items
+	}
+	return
+}

operand-list.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operand-list.go
+package expr
+
+// -------- list term
+func newListTermA(args ...*term) *term {
+	return newListTerm(0, 0, args)
+}
+
+func newListTerm(row, col int, args []*term) *term {
+	return &term{
+		tk:       *NewValueToken(row, col, SymList, "[]", args),
+		parent:   nil,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalList,
+	}
+}
+
+// -------- list func
+func evalList(ctx ExprContext, opTerm *term) (v any, err error) {
+	list, _ := opTerm.value().([]*term)
+	items := make(ListType, len(list))
+	for i, tree := range list {
+		var param any
+		if param, err = tree.compute(ctx); err != nil {
+			break
+		}
+		items[i] = param
+	}
+	if err == nil {
+		v = &items
+	}
+	return
+}

operand-literal.go

@@ -0,0 +1,33 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operand-literal.go
+package expr
+
+// -------- literal term
+func newLiteralTerm(tk *Token) *term {
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalLiteral,
+	}
+}
+
+// -------- eval func
+func evalLiteral(ctx ExprContext, opTerm *term) (v any, err error) {
+	v = opTerm.tk.Value
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymString, newLiteralTerm)
+	registerTermConstructor(SymInteger, newLiteralTerm)
+	registerTermConstructor(SymFloat, newLiteralTerm)
+	registerTermConstructor(SymFraction, newLiteralTerm)
+	registerTermConstructor(SymBool, newLiteralTerm)
+	registerTermConstructor(SymKwNil, newLiteralTerm)
+}

operand-selector-case.go

@@ -0,0 +1,50 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operand-selector-case.go
+package expr
+
+import (
+	"fmt"
+	"strings"
+)
+
+// -------- selector case term
+
+type selectorCase struct {
+	filterList *term
+	caseExpr   Expr
+}
+
+func (sc *selectorCase) String() string {
+	var sb strings.Builder
+	if sc.filterList != nil {
+		sc.filterList.toString(&sb)
+		sb.WriteByte(' ')
+	}
+	sb.WriteByte('{')
+	sb.WriteString(sc.caseExpr.String())
+	sb.WriteByte('}')
+	return sb.String()
+}
+
+func newSelectorCaseTerm(row, col int, filterList *term, caseExpr Expr) *term {
+	tk := NewValueToken(row, col, SymSelectorCase, "", &selectorCase{filterList: filterList, caseExpr: caseExpr})
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalSelectorCase,
+	}
+}
+
+// -------- eval selector case
+func evalSelectorCase(ctx ExprContext, opTerm *term) (v any, err error) {
+	var ok bool
+	if v, ok = opTerm.value().(*selectorCase); !ok {
+		err = fmt.Errorf("selector-case expected, got %T", opTerm.value())
+	}
+	return
+}

operand-var.go

@@ -1,3 +1,6 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // operand-var.go
 package expr
 
@@ -5,23 +8,28 @@ import "fmt"
 
 // -------- variable term
 func newVarTerm(tk *Token) *term {
-	return &term{
+	t := &term{
 		tk:       *tk,
-		class:    classVar,
-		kind:     kindUnknown,
 		parent:   nil,
 		children: nil,
 		position: posLeaf,
 		priority: priValue,
 		evalFunc: evalVar,
 	}
+	t.tk.Sym = SymVariable
+	return t
 }
 
 // -------- eval func
-func evalVar(ctx exprContext, self *term) (v any, err error) {
+func evalVar(ctx ExprContext, opTerm *term) (v any, err error) {
 	var exists bool
-	if v, exists = ctx.GetValue(self.tk.source); !exists {
-		err = fmt.Errorf("undefined variable %q", self.tk.source)
+	name := opTerm.source()
+	if v, exists = GetVar(ctx, name); !exists {
+		if info, exists := GetFuncInfo(ctx, name); exists {
+			v = info.Functor()
+		} else {
+			err = fmt.Errorf("undefined variable or function %q", name)
+		}
 	}
 	return
 }

operator-assign.go

@@ -0,0 +1,220 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserightChilded.
+
+// operator-assign.go
+package expr
+
+//-------- assign term
+
+func newAssignTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priAssign,
+		evalFunc: evalAssign,
+	}
+}
+
+func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, value any) (err error) {
+	var collectionValue, keyListValue, keyValue any
+	var keyList *ListType
+	var ok bool
+
+	if collectionValue, err = collectionTerm.compute(ctx); err != nil {
+		return
+	}
+
+	if keyListValue, err = keyListTerm.compute(ctx); err != nil {
+		return
+	} else if keyList, ok = keyListValue.(*ListType); !ok || len(*keyList) != 1 {
+		err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, TypeName(keyListValue))
+		return
+	}
+	if keyValue = (*keyList)[0]; keyValue == nil {
+		err = keyListTerm.Errorf("index/key is nil")
+		return
+	}
+
+	switch collection := collectionValue.(type) {
+	case *ListType:
+		if index, ok := keyValue.(int64); ok {
+			err = collection.setItem(index, value)
+		} else {
+			err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, TypeName(keyValue))
+		}
+	case *DictType:
+		err = collection.setItem(keyValue, value)
+	default:
+		err = collectionTerm.Errorf("collection expected")
+	}
+	return
+}
+
+func assignValue(ctx ExprContext, leftTerm *term, v any) (err error) {
+	if leftTerm.symbol() == SymIndex {
+		err = assignCollectionItem(ctx, leftTerm.children[0], leftTerm.children[1], v)
+	} else {
+		ctx.UnsafeSetVar(leftTerm.source(), v)
+	}
+	return
+}
+
+func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) {
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	leftTerm := opTerm.children[0]
+	leftSym := leftTerm.symbol()
+	if leftSym != SymVariable && leftSym != SymIndex {
+		err = leftTerm.tk.Errorf("left operand of %q must be a variable or a collection's item", opTerm.tk.source)
+		return
+	}
+
+	rightChild := opTerm.children[1]
+
+	if v, err = rightChild.compute(ctx); err == nil {
+		if functor, ok := v.(Functor); ok {
+			if leftSym == SymVariable {
+				if info := functor.GetFunc(); info != nil {
+					ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
+				} else if funcDef, ok := functor.(*exprFunctor); ok {
+					paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })
+
+					ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, paramSpecs)
+				} else {
+					err = opTerm.Errorf("unknown function %s()", rightChild.source())
+				}
+			} else {
+				err = assignValue(ctx, leftTerm, v)
+			}
+		} else {
+			err = assignValue(ctx, leftTerm, v)
+		}
+	}
+	if err != nil {
+		v = nil
+	}
+	return
+}
+
+//-------- assign term
+
+func newOpAssignTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priAssign,
+		evalFunc: evalOpAssign,
+	}
+}
+
+func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term) (value any, err error) {
+	var collectionValue, keyListValue, keyValue any
+	var keyList *ListType
+	var ok bool
+
+	if collectionValue, err = collectionTerm.compute(ctx); err != nil {
+		return
+	}
+
+	if keyListValue, err = keyListTerm.compute(ctx); err != nil {
+		return
+	} else if keyList, ok = keyListValue.(*ListType); !ok || len(*keyList) != 1 {
+		err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, TypeName(keyListValue))
+		return
+	}
+	if keyValue = (*keyList)[0]; keyValue == nil {
+		err = keyListTerm.Errorf("index/key is nil")
+		return
+	}
+
+	switch collection := collectionValue.(type) {
+	case *ListType:
+		if index, ok := keyValue.(int64); ok {
+			value = (*collection)[index]
+		} else {
+			err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, TypeName(keyValue))
+		}
+	case *DictType:
+		value = (*collection)[keyValue]
+	default:
+		err = collectionTerm.Errorf("collection expected")
+	}
+	return
+}
+
+func getAssignValue(ctx ExprContext, leftTerm *term) (value any, err error) {
+	if leftTerm.symbol() == SymIndex {
+		value, err = getCollectionItemValue(ctx, leftTerm.children[0], leftTerm.children[1])
+	} else {
+		value, _ = ctx.GetVar(leftTerm.source())
+	}
+	return
+}
+
+func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
+	var rightValue, leftValue any
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	leftTerm := opTerm.children[0]
+	leftSym := leftTerm.symbol()
+	if leftSym != SymVariable && leftSym != SymIndex {
+		err = leftTerm.tk.Errorf("left operand of %q must be a variable or a collection's item", opTerm.tk.source)
+		return
+	}
+
+	rightChild := opTerm.children[1]
+
+	if rightValue, err = rightChild.compute(ctx); err == nil {
+		if leftValue, err = getAssignValue(ctx, leftTerm); err == nil {
+			switch opTerm.symbol() {
+			case SymPlusEqual:
+				v, err = sumValues(opTerm, leftValue, rightValue)
+			case SymMinusEqual:
+				v, err = diffValues(opTerm, leftValue, rightValue)
+			case SymStarEqual:
+				v, err = mulValues(opTerm, leftValue, rightValue)
+			case SymSlashEqual:
+				v, err = divValues(opTerm, leftValue, rightValue)
+			case SymPercEqual:
+				v, err = remainderValues(opTerm, leftValue, rightValue)
+			case SymAmpersandEqual:
+				v, err = bitwiseAnd(opTerm, leftValue, rightValue)
+			case SymVertBarEqual:
+				v, err = bitwiseOr(opTerm, leftValue, rightValue)
+			case SymCaretEqual:
+				v, err = bitwiseXor(opTerm, leftValue, rightValue)
+			case SymDoubleLessEqual:
+				v, err = bitLeftShift(opTerm, leftValue, rightValue)
+			case SymDoubleGreaterEqual:
+				v, err = bitRightShift(opTerm, leftValue, rightValue)
+			default:
+				err = opTerm.Errorf("unsupported assign operator %q", opTerm.source())
+			}
+			if err == nil {
+				err = assignValue(ctx, leftTerm, v)
+			}
+		}
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymEqual, newAssignTerm)
+	registerTermConstructor(SymPlusEqual, newOpAssignTerm)
+	registerTermConstructor(SymMinusEqual, newOpAssignTerm)
+	registerTermConstructor(SymStarEqual, newOpAssignTerm)
+	registerTermConstructor(SymSlashEqual, newOpAssignTerm)
+	registerTermConstructor(SymPercEqual, newOpAssignTerm)
+	registerTermConstructor(SymDoubleLessEqual, newOpAssignTerm)
+	registerTermConstructor(SymDoubleGreaterEqual, newOpAssignTerm)
+	registerTermConstructor(SymAmpersandEqual, newOpAssignTerm)
+	registerTermConstructor(SymVertBarEqual, newOpAssignTerm)
+	registerTermConstructor(SymCaretEqual, newOpAssignTerm)
+}

operator-bitwise.go

@@ -0,0 +1,154 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-bitwise.go
+package expr
+
+//-------- Bitwise NOT term
+
+func newBitwiseNotTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priBitwiseNot,
+		evalFunc: evalBitwiseNot,
+	}
+}
+
+func evalBitwiseNot(ctx ExprContext, opTerm *term) (v any, err error) {
+	var value any
+
+	if value, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	if IsInteger(value) {
+		i, _ := value.(int64)
+		v = ^i
+	} else {
+		err = opTerm.errIncompatibleType(value)
+	}
+	return
+}
+
+//-------- Bitwise AND term
+
+func newBitwiseAndTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBitwiseAnd,
+		evalFunc: evalBitwiseAnd,
+	}
+}
+
+func bitwiseAnd(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	var leftInt, rightInt int64
+	var lok, rok bool
+
+	leftInt, lok = leftValue.(int64)
+	rightInt, rok = rightValue.(int64)
+
+	if lok && rok {
+		v = leftInt & rightInt
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+func evalBitwiseAnd(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+	v, err = bitwiseAnd(opTerm, leftValue, rightValue)
+	return
+}
+
+//-------- Bitwise OR term
+
+func newBitwiseOrTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBitwiseOr,
+		evalFunc: evalBitwiseOr,
+	}
+}
+
+func bitwiseOr(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	var leftInt, rightInt int64
+	var lok, rok bool
+
+	leftInt, lok = leftValue.(int64)
+	rightInt, rok = rightValue.(int64)
+
+	if lok && rok {
+		v = leftInt | rightInt
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+func evalBitwiseOr(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	v, err = bitwiseOr(opTerm, leftValue, rightValue)
+	return
+}
+
+//-------- Bitwise XOR term
+
+func newBitwiseXorTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBitwiseOr,
+		evalFunc: evalBitwiseXor,
+	}
+}
+
+func bitwiseXor(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	var leftInt, rightInt int64
+	var lok, rok bool
+
+	leftInt, lok = leftValue.(int64)
+	rightInt, rok = rightValue.(int64)
+
+	if lok && rok {
+		v = leftInt ^ rightInt
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+func evalBitwiseXor(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	v, err = bitwiseXor(opTerm, leftValue, rightValue)
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymTilde, newBitwiseNotTerm)
+	registerTermConstructor(SymAmpersand, newBitwiseAndTerm)
+	registerTermConstructor(SymVertBar, newBitwiseOrTerm)
+	registerTermConstructor(SymCaret, newBitwiseXorTerm)
+}

operator-bool.go

@@ -1,13 +1,16 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // operator-bool.go
 package expr
 
+import "fmt"
+
 //-------- NOT term
 
 func newNotTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindBool,
 		children: make([]*term, 0, 1),
 		position: posPrefix,
 		priority: priNot,
@@ -15,17 +18,17 @@ func newNotTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalNot(ctx exprContext, self *term) (v any, err error) {
+func evalNot(ctx ExprContext, opTerm *term) (v any, err error) {
 	var rightValue any
 
-	if rightValue, err = self.evalPrefix(ctx); err != nil {
+	if rightValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
-	if b, ok := toBool(rightValue); ok {
+	if b, ok := ToBool(rightValue); ok {
 		v = !b
 	} else {
-		err = self.errIncompatibleType(rightValue)
+		err = opTerm.errIncompatibleType(rightValue)
 	}
 	return
 }
@@ -35,8 +38,6 @@ func evalNot(ctx exprContext, self *term) (v any, err error) {
 func newAndTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priAnd,
@@ -44,7 +45,16 @@ func newAndTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalAnd(ctx exprContext, self *term) (v any, err error) {
+func evalAnd(ctx ExprContext, self *term) (v any, err error) {
+	if CtrlIsEnabled(ctx, ControlBoolShortcut) {
+		v, err = evalAndWithShortcut(ctx, self)
+	} else {
+		v, err = evalAndWithoutShortcut(ctx, self)
+	}
+	return
+}
+
+func evalAndWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
 	var leftValue, rightValue any
 	var leftBool, rightBool bool
 	var lok, rok bool
@@ -53,8 +63,8 @@ func evalAnd(ctx exprContext, self *term) (v any, err error) {
 		return
 	}
 
-	leftBool, lok = toBool(leftValue)
-	rightBool, rok = toBool(rightValue)
+	leftBool, lok = ToBool(leftValue)
+	rightBool, rok = ToBool(rightValue)
 
 	if lok && rok {
 		v = leftBool && rightBool
@@ -64,13 +74,37 @@ func evalAnd(ctx exprContext, self *term) (v any, err error) {
 	return
 }
 
+func evalAndWithShortcut(ctx ExprContext, self *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if err = self.checkOperands(); err != nil {
+		return
+	}
+
+	if leftValue, err = self.children[0].compute(ctx); err != nil {
+		return
+	}
+
+	if leftBool, lok := ToBool(leftValue); !lok {
+		err = fmt.Errorf("got %s as left operand type of 'AND' operator, it must be bool", TypeName(leftValue))
+		return
+	} else if !leftBool {
+		v = false
+	} else if rightValue, err = self.children[1].compute(ctx); err == nil {
+		if rightBool, rok := ToBool(rightValue); rok {
+			v = rightBool
+		} else {
+			err = self.errIncompatibleTypes(leftValue, rightValue)
+		}
+	}
+	return
+}
+
 //-------- OR term
 
 func newOrTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priOr,
@@ -78,7 +112,16 @@ func newOrTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalOr(ctx exprContext, self *term) (v any, err error) {
+func evalOr(ctx ExprContext, self *term) (v any, err error) {
+	if CtrlIsEnabled(ctx, ControlBoolShortcut) {
+		v, err = evalOrWithShortcut(ctx, self)
+	} else {
+		v, err = evalOrWithoutShortcut(ctx, self)
+	}
+	return
+}
+
+func evalOrWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
 	var leftValue, rightValue any
 	var leftBool, rightBool bool
 	var lok, rok bool
@@ -87,8 +130,8 @@ func evalOr(ctx exprContext, self *term) (v any, err error) {
 		return
 	}
 
-	leftBool, lok = toBool(leftValue)
-	rightBool, rok = toBool(rightValue)
+	leftBool, lok = ToBool(leftValue)
+	rightBool, rok = ToBool(rightValue)
 
 	if lok && rok {
 		v = leftBool || rightBool
@@ -98,6 +141,32 @@ func evalOr(ctx exprContext, self *term) (v any, err error) {
 	return
 }
 
+func evalOrWithShortcut(ctx ExprContext, self *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if err = self.checkOperands(); err != nil {
+		return
+	}
+
+	if leftValue, err = self.children[0].compute(ctx); err != nil {
+		return
+	}
+
+	if leftBool, lok := ToBool(leftValue); !lok {
+		err = fmt.Errorf("got %s as left operand type of 'OR' operator, it must be bool", TypeName(leftValue))
+		return
+	} else if leftBool {
+		v = true
+	} else if rightValue, err = self.children[1].compute(ctx); err == nil {
+		if rightBool, rok := ToBool(rightValue); rok {
+			v = rightBool
+		} else {
+			err = self.errIncompatibleTypes(leftValue, rightValue)
+		}
+	}
+	return
+}
+
 // init
 func init() {
 	registerTermConstructor(SymNot, newNotTerm)

operator-builtin.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-builtin.go
+package expr
+
+import "io"
+
+//-------- builtin term
+
+func newBuiltinTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priSign,
+		evalFunc: evalBuiltin,
+	}
+}
+
+func evalBuiltin(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	count := 0
+	if IsString(childValue) {
+		module, _ := childValue.(string)
+		count, err = ImportInContextByGlobPattern(module)
+	} else {
+		var moduleSpec any
+		var it Iterator
+		if it, err = NewIterator(childValue); err != nil {
+			return
+		}
+		for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() {
+			if module, ok := moduleSpec.(string); ok {
+				if ImportInContext(module) {
+					count++
+				} else {
+					err = opTerm.Errorf("unknown builtin module %q", module)
+					break
+				}
+			} else {
+				err = opTerm.Errorf("expected string at item nr %d, got %s", it.Index()+1, TypeName(moduleSpec))
+				break
+			}
+		}
+		if err == io.EOF {
+			err = nil
+		}
+	}
+	if err == nil {
+		v = int64(count)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwBuiltin, newBuiltinTerm)
+}

operator-but.go

@@ -0,0 +1,27 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-but.go
+package expr
+
+//-------- but term
+
+func newButTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBut,
+		evalFunc: evalBut,
+	}
+}
+
+func evalBut(ctx ExprContext, opTerm *term) (v any, err error) {
+	_, v, err = opTerm.evalInfix(ctx)
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwBut, newButTerm)
+}

operator-context.go

@@ -0,0 +1,60 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-context-value.go
+package expr
+
+//-------- context term
+
+func newContextTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priIncDec,
+		evalFunc: evalContextValue,
+	}
+}
+
+func evalContextValue(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+
+	var sourceCtx ExprContext
+	if len(opTerm.children) == 0 {
+		sourceCtx = ctx
+	} else if opTerm.children[0].symbol() == SymVariable && opTerm.children[0].source() == "global" {
+		sourceCtx = globalCtx
+	} else if childValue, err = opTerm.evalPrefix(ctx); err == nil {
+		if dc, ok := childValue.(*dataCursor); ok {
+			sourceCtx = dc.ctx
+		}
+	}
+
+	if sourceCtx != nil {
+		if formatter, ok := sourceCtx.(DictFormat); ok {
+			v = formatter.ToDict()
+		} else if formatter, ok := sourceCtx.(Formatter); ok {
+			v = formatter.ToString(0)
+		} else {
+			// keys := sourceCtx.EnumVars(func(name string) bool { return name[0] != '_' })
+			keys := sourceCtx.EnumVars(nil)
+			d := make(map[string]any)
+			for _, key := range keys {
+				d[key], _ = sourceCtx.GetVar(key)
+			}
+			keys = sourceCtx.EnumFuncs(func(name string) bool { return true })
+			for _, key := range keys {
+				d[key], _ = sourceCtx.GetFuncInfo(key)
+			}
+			v = d
+		}
+	} else {
+		err = opTerm.errIncompatibleType(childValue)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymDoubleDollar, newContextTerm)
+}

operator-ctrl.go

@@ -0,0 +1,27 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-ctrl.go
+package expr
+
+//-------- export all term
+
+func newExportAllTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalExportAll,
+	}
+}
+
+func evalExportAll(ctx ExprContext, opTerm *term) (v any, err error) {
+	CtrlEnable(ctx, control_export_all)
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymDoubleAt, newExportAllTerm)
+}

operator-default.go

@@ -0,0 +1,124 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-default.go
+package expr
+
+//-------- default term
+
+func newDefaultTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priDefault,
+		evalFunc: evalDefault,
+	}
+}
+
+func evalDefault(ctx ExprContext, opTerm *term) (v any, err error) {
+	var rightValue any
+
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	leftTerm := opTerm.children[0]
+	if leftTerm.tk.Sym != SymVariable {
+		// err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
+		err = ErrLeftOperandMustBeVariable(leftTerm, opTerm)
+		return
+	}
+
+	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
+		v = leftValue
+	} else if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
+		v = rightValue
+	}
+	return
+}
+
+//-------- alternate term
+
+func newAlternateTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priDefault,
+		evalFunc: evalAlternate,
+	}
+}
+
+func evalAlternate(ctx ExprContext, opTerm *term) (v any, err error) {
+	var rightValue any
+
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	leftTerm := opTerm.children[0]
+	if leftTerm.tk.Sym != SymVariable {
+		// err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
+		err = ErrLeftOperandMustBeVariable(leftTerm, opTerm)
+		return
+	}
+
+	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists && leftValue != nil {
+		if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
+			v = rightValue
+		}
+	} else {
+		v = leftValue
+	}
+	return
+}
+
+//-------- default assign term
+
+func newDefaultAssignTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priDefault,
+		evalFunc: evalAssignDefault,
+	}
+}
+
+func evalAssignDefault(ctx ExprContext, opTerm *term) (v any, err error) {
+	var rightValue any
+
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	leftTerm := opTerm.children[0]
+	if leftTerm.tk.Sym != SymVariable {
+		// err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
+		err = ErrLeftOperandMustBeVariable(leftTerm, opTerm)
+		return
+	}
+
+	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
+		v = leftValue
+	} else if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
+		if functor, ok := rightValue.(Functor); ok {
+			//ctx.RegisterFunc(leftTerm.source(), functor, 0, -1)
+			ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, []ExprFuncParam{
+				NewFuncParamFlag(ParamValue, PfDefault|PfRepeat),
+			})
+		} else {
+			v = rightValue
+			ctx.UnsafeSetVar(leftTerm.source(), rightValue)
+		}
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymDoubleQuestion, newDefaultTerm)
+	registerTermConstructor(SymQuestionEqual, newDefaultAssignTerm)
+	registerTermConstructor(SymQuestionExclam, newAlternateTerm)
+}

operator-dot.go

@@ -0,0 +1,54 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-dot.go
+package expr
+
+// -------- dot term
+func newDotTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priDot,
+		evalFunc: evalDot,
+	}
+}
+
+func evalDot(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+	if leftValue, err = opTerm.children[0].compute(ctx); err != nil {
+		return
+	}
+
+	indexTerm := opTerm.children[1]
+
+	switch unboxedValue := leftValue.(type) {
+	case ExtIterator:
+		if indexTerm.symbol() == SymVariable /*|| indexTerm.symbol() == SymString */ {
+			opName := indexTerm.source()
+			if unboxedValue.HasOperation(opName) {
+				v, err = unboxedValue.CallOperation(opName, map[string]any{})
+			} else {
+				err = indexTerm.Errorf("this iterator do not support the %q command", opName)
+				v = false
+			}
+		} else {
+			err = indexTerm.tk.ErrorExpectedGot("identifier")
+		}
+	default:
+		if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
+			err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+		}
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymDot, newDotTerm)
+}

operator-fact.go

@@ -1,3 +1,6 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // operator-fact.go
 package expr
 
@@ -8,8 +11,6 @@ import "fmt"
 func newFactTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindInteger,
 		children: make([]*term, 0, 1),
 		position: posPostfix,
 		priority: priFact,
@@ -17,14 +18,14 @@ func newFactTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalFact(ctx exprContext, self *term) (v any, err error) {
+func evalFact(ctx ExprContext, opTerm *term) (v any, err error) {
 	var leftValue any
 
-	if leftValue, err = self.evalPrefix(ctx); err != nil {
+	if leftValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
-	if isInteger(leftValue) {
+	if IsInteger(leftValue) {
 		if i, _ := leftValue.(int64); i >= 0 {
 			f := int64(1)
 			for k := int64(1); k <= i; k++ {
@@ -35,7 +36,7 @@ func evalFact(ctx exprContext, self *term) (v any, err error) {
 			err = fmt.Errorf("factorial of a negative integer (%d) is not allowed", i)
 		}
 	} else {
-		err = self.errIncompatibleType(leftValue)
+		err = opTerm.errIncompatibleType(leftValue)
 	}
 	return
 }

operator-fraction.go

@@ -0,0 +1,70 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operand-fraction.go
+package expr
+
+//https://www.youmath.it/lezioni/algebra-elementare/lezioni-di-algebra-e-aritmetica-per-scuole-medie/553-dalle-frazioni-a-numeri-decimali.html
+
+import (
+	"fmt"
+)
+
+// -------- fraction term
+func newFractionTerm(tk *Token) *term {
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priFraction,
+		evalFunc: evalFraction,
+	}
+}
+
+// -------- eval func
+func evalFraction(ctx ExprContext, opTerm *term) (v any, err error) {
+	var numValue, denValue any
+	var num, den int64
+	var ok bool
+
+	if numValue, denValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+	if num, ok = numValue.(int64); !ok {
+		err = fmt.Errorf("numerator must be integer, got %T (%v)", numValue, numValue)
+		return
+	}
+	if den, ok = denValue.(int64); !ok {
+		err = fmt.Errorf("denominator must be integer, got %T (%v)", denValue, denValue)
+		return
+	}
+	if den == 0 {
+		err = opTerm.errDivisionByZero()
+		return
+	}
+
+	if den < 0 {
+		den = -den
+		num = -num
+	}
+	if num != 0 {
+		g := gcd(num, den)
+		num = num / g
+		den = den / g
+		if den == 1 {
+			v = num
+		} else {
+			v = &FractionType{num, den}
+		}
+	} else {
+		v = &FractionType{0, den}
+	}
+	return
+}
+
+// init
+func init() {
+	// registerTermConstructor(SymVertBar, newFractionTerm)
+	registerTermConstructor(SymColon, newFractionTerm)
+}

operator-in.go

@@ -0,0 +1,46 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-in.go
+package expr
+
+//-------- in term
+
+func newInTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priRelational,
+		evalFunc: evalIn,
+	}
+}
+
+// func hasKey(d map[any]any, target any) (ok bool) {
+// 	_, ok = d[target]
+// 	return
+// }
+
+func evalIn(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	if IsList(rightValue) {
+		list, _ := rightValue.(*ListType)
+		v = list.indexDeepSameCmp(leftValue) >= 0
+	} else if IsDict(rightValue) {
+		dict, _ := rightValue.(*DictType)
+		v = dict.hasKey(leftValue)
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwIn, newInTerm)
+}

operator-include.go

@@ -0,0 +1,60 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-include.go
+package expr
+
+//-------- include term
+
+func newIncludeTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priSign,
+		evalFunc: evalInclude,
+	}
+}
+
+func evalInclude(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	count := 0
+	if IsList(childValue) {
+		list, _ := childValue.(*ListType)
+		for i, filePathSpec := range *list {
+			if filePath, ok := filePathSpec.(string); ok {
+				if v, err = EvalFile(ctx, filePath); err == nil {
+					count++
+				} else {
+					err = opTerm.Errorf("can't load file %q", filePath)
+					break
+				}
+			} else {
+				err = opTerm.Errorf("expected string at item nr %d, got %T", i+1, filePathSpec)
+				break
+			}
+		}
+	} else if IsString(childValue) {
+		filePath, _ := childValue.(string)
+		if v, err = EvalFile(ctx, filePath); err == nil {
+			count++
+		}
+	} else {
+		err = opTerm.errIncompatibleType(childValue)
+	}
+	if err != nil {
+		//v = count
+		v = nil
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwInclude, newIncludeTerm)
+}

operator-index.go

@@ -0,0 +1,138 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-index.go
+package expr
+
+// -------- index term
+func newIndexTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priDot,
+		evalFunc: evalIndex,
+	}
+}
+
+func verifyKey(indexList *ListType) (index any, err error) {
+	index = (*indexList)[0]
+	return
+}
+
+func verifyIndex(indexTerm *term, indexList *ListType, maxValue int) (index int, err error) {
+	var v int
+
+	if v, err = ToGoInt((*indexList)[0], "index expression"); err == nil {
+		if v < 0 && v >= -maxValue {
+			v = maxValue + v
+		}
+		if v >= 0 && v < maxValue {
+			index = v
+		} else {
+			err = indexTerm.Errorf("index %d out of bounds", v)
+		}
+	}
+	return
+}
+
+func verifyRange(indexTerm *term, indexList *ListType, maxValue int) (startIndex, endIndex int, err error) {
+	v, _ := ((*indexList)[0]).(*intPair)
+	startIndex = v.a
+	endIndex = v.b
+	if endIndex == ConstLastIndex {
+		endIndex = maxValue
+	}
+	if startIndex < 0 && startIndex >= -maxValue {
+		startIndex = maxValue + startIndex
+	}
+	if endIndex < 0 && endIndex >= -maxValue {
+		endIndex = maxValue + endIndex
+	}
+	if startIndex < 0 || startIndex > maxValue {
+		err = indexTerm.Errorf("range start-index %d is out of bounds", startIndex)
+	} else if endIndex < 0 || endIndex > maxValue {
+		err = indexTerm.Errorf("range end-index %d is out of bounds", endIndex)
+	} else if startIndex > endIndex {
+		err = indexTerm.Errorf("range start-index %d must not be greater than end-index %d", startIndex, endIndex)
+	}
+	return
+}
+
+func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+	var indexList *ListType
+	var ok bool
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	indexTerm := opTerm.children[1]
+	if indexList, ok = rightValue.(*ListType); !ok {
+		err = opTerm.Errorf("invalid index expression")
+		return
+	} else if len(*indexList) != 1 {
+		err = indexTerm.Errorf("one index only is allowed")
+		return
+	}
+
+	if IsInteger((*indexList)[0]) {
+		switch unboxedValue := leftValue.(type) {
+		case *ListType:
+			var index int
+			if index, err = verifyIndex(indexTerm, indexList, len(*unboxedValue)); err == nil {
+				v = (*unboxedValue)[index]
+			}
+		case string:
+			var index int
+			if index, err = verifyIndex(indexTerm, indexList, len(unboxedValue)); err == nil {
+				v = string(unboxedValue[index])
+			}
+		case *DictType:
+			v, err = getDictItem(unboxedValue, indexTerm, indexList, rightValue)
+		default:
+			err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+		}
+	} else if isIntPair((*indexList)[0]) {
+		switch unboxedValue := leftValue.(type) {
+		case *ListType:
+			var start, end int
+			if start, end, err = verifyRange(indexTerm, indexList, len(*unboxedValue)); err == nil {
+				sublist := ListType((*unboxedValue)[start:end])
+				v = &sublist
+			}
+		case string:
+			var start, end int
+			if start, end, err = verifyRange(indexTerm, indexList, len(unboxedValue)); err == nil {
+				v = unboxedValue[start:end]
+			}
+		default:
+			err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+		}
+	} else if IsDict(leftValue) {
+		d := leftValue.(*DictType)
+		v, err = getDictItem(d, indexTerm, indexList, rightValue)
+	} else {
+		rightChild := opTerm.children[1]
+		err = rightChild.Errorf("invalid index type: %v", (*indexList)[0])
+	}
+	return
+}
+
+func getDictItem(d *DictType, indexTerm *term, indexList *ListType, rightValue any) (v any, err error) {
+	var ok bool
+	var indexValue any
+
+	if indexValue, err = verifyKey(indexList); err == nil {
+		if v, ok = (*d)[indexValue]; !ok {
+			err = indexTerm.Errorf("key %v does not belong to the dictionary", rightValue)
+		}
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymIndex, newIndexTerm)
+}

operator-insert.go

@@ -0,0 +1,91 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-insert.go
+package expr
+
+//-------- prepend term
+
+func newPrependTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priInsert,
+		evalFunc: evalPrepend,
+	}
+}
+
+func newAppendTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priInsert,
+		evalFunc: evalAppend,
+	}
+}
+
+func evalPrepend(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	if IsList(rightValue) {
+		list, _ := rightValue.(*ListType)
+		newList := append(ListType{leftValue}, *list...)
+		v = &newList
+		if opTerm.children[1].symbol() == SymVariable {
+			ctx.UnsafeSetVar(opTerm.children[1].source(), v)
+		}
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+func evalAppend(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	if IsList(leftValue) {
+		list, _ := leftValue.(*ListType)
+		newList := append(*list, rightValue)
+		v = &newList
+		if opTerm.children[0].symbol() == SymVariable {
+			ctx.UnsafeSetVar(opTerm.children[0].source(), v)
+		}
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+// func evalAssignAppend(ctx ExprContext, self *term) (v any, err error) {
+// 	var leftValue, rightValue any
+
+// 	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+// 		return
+// 	}
+
+// 	if IsList(leftValue) {
+// 		list, _ := leftValue.(*ListType)
+// 		newList := append(*list, rightValue)
+// 		v = &newList
+// 		if
+// 	} else {
+// 		err = self.errIncompatibleTypes(leftValue, rightValue)
+// 	}
+// 	return
+// }
+
+// init
+func init() {
+	registerTermConstructor(SymPlusGreater, newPrependTerm)
+	registerTermConstructor(SymLessPlus, newAppendTerm)
+}

operator-iter-value.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-iter-value.go
+package expr
+
+//-------- iter value term
+
+func newIterValueTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priDereference,
+		evalFunc: evalIterValue,
+	}
+}
+
+func evalIterValue(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	if it, ok := childValue.(Iterator); ok {
+		v, err = it.Current()
+	} else {
+		err = opTerm.errIncompatibleType(childValue)
+	}
+	return
+}
+
+// init
+func init() {
+	//	registerTermConstructor(SymOpenClosedRound, newIterValueTerm)
+	registerTermConstructor(SymDereference, newIterValueTerm)
+}

operator-length.go

@@ -0,0 +1,52 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-length.go
+package expr
+
+//-------- length term
+
+func newLengthTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priSign,
+		evalFunc: evalLength,
+	}
+}
+
+func evalLength(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	if IsList(childValue) {
+		ls, _ := childValue.(*ListType)
+		v = int64(len(*ls))
+	} else if IsString(childValue) {
+		s, _ := childValue.(string)
+		v = int64(len(s))
+	} else if IsDict(childValue) {
+		m, _ := childValue.(*DictType)
+		v = int64(len(*m))
+	} else if it, ok := childValue.(Iterator); ok {
+		v = int64(it.Count())
+		// if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(CountName) {
+		// 	count, _ := extIt.CallOperation(CountName, nil)
+		// 	v, _ = ToGoInt(count, "")
+		// } else {
+		// 	v = int64(it.Index() + 1)
+		// }
+	} else {
+		err = opTerm.errIncompatibleType(childValue)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymHash, newLengthTerm)
+}

operator-map.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-map.go
+package expr
+
+import (
+	"fmt"
+	"io"
+)
+
+//-------- map term
+
+func newMapTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priIterOp,
+		evalFunc: evalMap,
+	}
+}
+
+func evalMap(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+	var it Iterator
+	var item any
+
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	if leftValue, err = opTerm.children[0].compute(ctx); err != nil {
+		return
+	}
+
+	if it, err = NewIterator(leftValue); err != nil {
+		return nil, fmt.Errorf("left operand of MAP must be an iterable data-source; got %s", TypeName(leftValue))
+	}
+
+	values := newListA()
+	for item, err = it.Next(); err == nil; item, err = it.Next() {
+		ctx.SetVar("_", item)
+		ctx.SetVar("_index", it.Index())
+		ctx.SetVar("_count", it.Count())
+		if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
+			values.appendItem(rightValue)
+		}
+		ctx.DeleteVar("_")
+		if err != nil {
+			break
+		}
+	}
+	if err == io.EOF {
+		err = nil
+	}
+	v = values
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwMap, newMapTerm)
+}

operator-plugin.go

@@ -0,0 +1,36 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-plugin.go
+package expr
+
+//-------- plugin term
+
+func newPluginTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priSign,
+		evalFunc: evalPlugin,
+	}
+}
+
+func evalPlugin(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+	var count int
+
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	if count, err = importPluginFromSearchPath(childValue); err == nil {
+		v = int64(count)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwPlugin, newPluginTerm)
+}

operator-post-inc-dec.go

@@ -0,0 +1,93 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-post-inc-dec.go
+package expr
+
+// -------- post increment term
+
+func newPostIncTerm(tk *Token) *term {
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: make([]*term, 0, 1),
+		position: posPostfix,
+		priority: priIncDec,
+		evalFunc: evalPostInc,
+	}
+}
+
+func evalPostInc(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	if it, ok := childValue.(Iterator); ok {
+		var namePrefix string
+		v, err = it.Next()
+
+		if opTerm.children[0].symbol() == SymVariable {
+			namePrefix = opTerm.children[0].source()
+		}
+		ctx.UnsafeSetVar(namePrefix+"_index", it.Index())
+		if c, err1 := it.Current(); err1 == nil {
+			ctx.UnsafeSetVar(namePrefix+"_current", c)
+		}
+
+		if it.HasOperation(KeyName) {
+			if k, err1 := it.CallOperation(KeyName, nil); err1 == nil {
+				ctx.UnsafeSetVar(namePrefix+"_key", k)
+			}
+		}
+		if it.HasOperation(ValueName) {
+			if v1, err1 := it.CallOperation(ValueName, nil); err1 == nil {
+				ctx.UnsafeSetVar(namePrefix+"_value", v1)
+			}
+		}
+	} else if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
+		v = childValue
+		i, _ := childValue.(int64)
+		ctx.SetVar(opTerm.children[0].source(), i+1)
+	} else {
+		err = opTerm.errIncompatibleType(childValue)
+	}
+	return
+}
+
+// -------- post decrement term
+
+func newPostDecTerm(tk *Token) *term {
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: make([]*term, 0, 1),
+		position: posPostfix,
+		priority: priIncDec,
+		evalFunc: evalPostDec,
+	}
+}
+
+func evalPostDec(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	/* if it, ok := childValue.(Iterator); ok {
+		v, err = it.Next()
+	} else  */if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
+		v = childValue
+		i, _ := childValue.(int64)
+		ctx.SetVar(opTerm.children[0].source(), i-1)
+	} else {
+		err = opTerm.errIncompatibleType(childValue)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymDoublePlus, newPostIncTerm)
+	registerTermConstructor(SymDoubleMinus, newPostDecTerm)
+}

operator-pre-inc-dec.go

@@ -0,0 +1,69 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-pre-inc-dec.go
+package expr
+
+// -------- pre increment term
+
+func newPreIncTerm(tk *Token) *term {
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priIncDec,
+		evalFunc: evalPreInc,
+	}
+}
+
+func evalPreInc(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
+		i := childValue.(int64) + 1
+		ctx.SetVar(opTerm.children[0].source(), i)
+		v = i
+	} else {
+		err = opTerm.errIncompatibleType(childValue)
+	}
+	return
+}
+
+// -------- pre decrement term
+
+func newPreDecTerm(tk *Token) *term {
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priIncDec,
+		evalFunc: evalPreDec,
+	}
+}
+
+func evalPreDec(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
+		i := childValue.(int64) - 1
+		ctx.SetVar(opTerm.children[0].source(), i)
+		v = i
+	} else {
+		err = opTerm.errIncompatibleType(childValue)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymPreInc, newPreIncTerm)
+	registerTermConstructor(SymPreDec, newPreDecTerm)
+}

operator-prod.go

@@ -1,8 +1,10 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // operator-prod.go
 package expr
 
 import (
-	"errors"
 	"strings"
 )
 
@@ -11,8 +13,6 @@ import (
 func newMultiplyTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindUnknown,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priProduct,
@@ -20,38 +20,42 @@ func newMultiplyTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalMultiply(ctx exprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-
-	if isString(leftValue) && isInteger(rightValue) {
+func mulValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	if IsString(leftValue) && IsInteger(rightValue) {
 		s, _ := leftValue.(string)
 		n, _ := rightValue.(int64)
 		v = strings.Repeat(s, int(n))
-	} else if isNumber(leftValue) && isNumber(rightValue) {
-		if isFloat(leftValue) || isFloat(rightValue) {
+	} else if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+		if IsFloat(leftValue) || IsFloat(rightValue) {
 			v = numAsFloat(leftValue) * numAsFloat(rightValue)
+		} else if isFraction(leftValue) || isFraction(rightValue) {
+			v, err = mulAnyFract(leftValue, rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			rightInt, _ := rightValue.(int64)
 			v = leftInt * rightInt
 		}
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
 
+func evalMultiply(ctx ExprContext, prodTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = prodTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return mulValues(prodTerm, leftValue, rightValue)
+}
+
 //-------- divide term
 
 func newDivideTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindUnknown,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priProduct,
@@ -59,37 +63,138 @@ func newDivideTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalDivide(ctx exprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-
-	if isNumber(leftValue) && isNumber(rightValue) {
-		if isFloat(leftValue) || isFloat(rightValue) {
+func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+		if IsFloat(leftValue) || IsFloat(rightValue) {
 			d := numAsFloat(rightValue)
 			if d == 0.0 {
-				err = errors.New("division by zero")
+				err = opTerm.errDivisionByZero()
 			} else {
 				v = numAsFloat(leftValue) / d
 			}
+		} else if isFraction(leftValue) || isFraction(rightValue) {
+			v, err = divAnyFract(leftValue, rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			if rightInt, _ := rightValue.(int64); rightInt == 0 {
-				err = errors.New("division by zero")
+				err = opTerm.errDivisionByZero()
 			} else {
 				v = leftInt / rightInt
 			}
 		}
+	} else if IsString(leftValue) && IsString(rightValue) {
+		source := leftValue.(string)
+		sep := rightValue.(string)
+		v = ListFromStrings(strings.Split(source, sep))
+	} else if IsString(leftValue) && IsInteger(rightValue) {
+		source := leftValue.(string)
+		partSize := int(rightValue.(int64))
+		if partSize == 0 {
+			err = opTerm.errDivisionByZero()
+		} else {
+			partCount := len(source) / partSize
+			remainder := len(source) % partSize
+			listSize := partCount
+			if remainder > 0 {
+				listSize++
+			}
+			parts := make([]any, 0, listSize)
+			for i := 0; i < partCount; i++ {
+				parts = append(parts, source[i*partSize:(i+1)*partSize])
+			}
+			if remainder > 0 {
+				parts = append(parts, source[len(source)-remainder:])
+			}
+			v = newList(parts)
+		}
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
 
+func evalDivide(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return divValues(opTerm, leftValue, rightValue)
+}
+
+//-------- divide as float term
+
+func newDivideAsFloatTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priProduct,
+		evalFunc: evalDivideAsFloat,
+	}
+}
+
+func evalDivideAsFloat(ctx ExprContext, floatDivTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = floatDivTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+		d := numAsFloat(rightValue)
+		if d == 0.0 {
+			err = floatDivTerm.errDivisionByZero()
+		} else {
+			v = numAsFloat(leftValue) / d
+		}
+	} else {
+		err = floatDivTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+//-------- reminder term
+
+func newRemainderTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priProduct,
+		evalFunc: evalRemainder,
+	}
+}
+func remainderValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	if IsInteger(leftValue) && IsInteger(rightValue) {
+		rightInt, _ := rightValue.(int64)
+		if rightInt == 0 {
+			err = opTerm.errDivisionByZero()
+		} else {
+			leftInt, _ := leftValue.(int64)
+			v = leftInt % rightInt
+		}
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+func evalRemainder(ctx ExprContext, remainderTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = remainderTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return remainderValues(remainderTerm, leftValue, rightValue)
+}
+
 // init
 func init() {
 	registerTermConstructor(SymStar, newMultiplyTerm)
 	registerTermConstructor(SymSlash, newDivideTerm)
+	registerTermConstructor(SymDotSlash, newDivideAsFloatTerm)
+	registerTermConstructor(SymPercent, newRemainderTerm)
 }

operator-range.go

@@ -0,0 +1,82 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-range.go
+package expr
+
+import "fmt"
+
+// -------- range term
+type intPair struct {
+	a, b int
+}
+
+func (p *intPair) TypeName() string {
+	return TypePair
+}
+
+func (p *intPair) ToString(opt FmtOpt) string {
+	return fmt.Sprintf("(%d, %d)", p.a, p.b)
+}
+
+func isIntPair(v any) bool {
+	_, ok := v.(*intPair)
+	return ok
+}
+
+func newRangeTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priRange,
+		evalFunc: evalRange,
+	}
+}
+
+func changeColonToRange(t *term) {
+	if t.tk.IsSymbol(SymColon) {
+		t.tk.Sym = SymRange
+		t.evalFunc = evalRange
+	}
+}
+
+func evalRange(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if len(opTerm.children) == 0 {
+		leftValue = int64(0)
+		rightValue = int64(-1)
+	} else if len(opTerm.children) == 1 {
+		if leftValue, err = opTerm.children[0].compute(ctx); err != nil {
+			return
+		}
+		rightValue = int64(ConstLastIndex)
+	} else if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+	if !(IsInteger(leftValue) && IsInteger(rightValue)) {
+		// err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+		err = errRangeInvalidSpecification(opTerm)
+		return
+	}
+
+	startIndex, _ := leftValue.(int64)
+	endIndex, _ := rightValue.(int64)
+
+	v = &intPair{int(startIndex), int(endIndex)}
+	return
+}
+
+func errRangeInvalidSpecification(t *term) error {
+	return t.Errorf("invalid range specification")
+}
+
+func errRangeUnexpectedExpression(t *term) error {
+	return t.Errorf("unexpected range expression")
+}
+
+// init
+func init() {
+	registerTermConstructor(SymRange, newRangeTerm)
+}

operator-rel.go

@@ -1,13 +1,16 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // operator-rel.go
 package expr
 
+import "reflect"
+
 //-------- equal term
 
 func newEqualTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -15,28 +18,41 @@ func newEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalEqual(ctx exprContext, self *term) (v any, err error) {
+type deepFuncTemplate func(a, b any) (eq bool, err error)
+
+func equals(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
+	if isNumOrFract(a) && isNumOrFract(b) {
+		if IsNumber(a) && IsNumber(b) {
+			if IsInteger(a) && IsInteger(b) {
+				li, _ := a.(int64)
+				ri, _ := b.(int64)
+				eq = li == ri
+			} else {
+				eq = numAsFloat(a) == numAsFloat(b)
+			}
+		} else {
+			var cmp int
+			if cmp, err = cmpAnyFract(a, b); err == nil {
+				eq = cmp == 0
+			}
+		}
+	} else if deepCmp != nil && IsList(a) && IsList(b) {
+		eq, err = deepCmp(a, b)
+	} else {
+		eq = reflect.DeepEqual(a, b)
+	}
+
+	return
+}
+
+func evalEqual(ctx ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
-	if isNumber(leftValue) && isNumber(rightValue) {
-		if isInteger(leftValue) && isInteger(rightValue) {
-			li, _ := leftValue.(int64)
-			ri, _ := rightValue.(int64)
-			v = li == ri
-		} else {
-			v = numAsFloat(leftValue) == numAsFloat(rightValue)
-		}
-	} else if isString(leftValue) && isString(rightValue) {
-		ls, _ := leftValue.(string)
-		rs, _ := rightValue.(string)
-		v = ls == rs
-	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
-	}
+	v, err = equals(leftValue, rightValue, nil)
 	return
 }
 
@@ -45,8 +61,6 @@ func evalEqual(ctx exprContext, self *term) (v any, err error) {
 func newNotEqualTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -54,46 +68,19 @@ func newNotEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalNotEqual(ctx exprContext, self *term) (v any, err error) {
-	if v, err = evalEqual(ctx, self); err == nil {
-		b, _ := toBool(v)
+func evalNotEqual(ctx ExprContext, opTerm *term) (v any, err error) {
+	if v, err = evalEqual(ctx, opTerm); err == nil {
+		b, _ := ToBool(v)
 		v = !b
 	}
 	return
 }
 
-// func evalNotEqual(ctx exprContext, self *term) (v any, err error) {
-// 	var leftValue, rightValue any
-
-// 	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-// 		return
-// 	}
-
-// 	if isNumber(leftValue) && isNumber(rightValue) {
-// 		if isInteger(leftValue) && isInteger(rightValue) {
-// 			li, _ := leftValue.(int64)
-// 			ri, _ := rightValue.(int64)
-// 			v = li != ri
-// 		} else {
-// 			v = numAsFloat(leftValue) != numAsFloat(rightValue)
-// 		}
-// 	} else if isString(leftValue) && isString(rightValue) {
-// 		ls, _ := leftValue.(string)
-// 		rs, _ := rightValue.(string)
-// 		v = ls != rs
-// 	} else {
-// 		err = self.errIncompatibleTypes(leftValue, rightValue)
-// 	}
-// 	return
-// }
-
 //-------- less term
 
 func newLessTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -101,28 +88,44 @@ func newLessTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalLess(ctx exprContext, self *term) (v any, err error) {
+func lessThan(self *term, a, b any) (isLess bool, err error) {
+	if isNumOrFract(a) && isNumOrFract(b) {
+		if IsNumber(a) && IsNumber(b) {
+			if IsInteger(a) && IsInteger(b) {
+				li, _ := a.(int64)
+				ri, _ := b.(int64)
+				isLess = li < ri
+			} else {
+				isLess = numAsFloat(a) < numAsFloat(b)
+			}
+		} else {
+			var cmp int
+			if cmp, err = cmpAnyFract(a, b); err == nil {
+				isLess = cmp < 0
+			}
+		}
+	} else if IsString(a) && IsString(b) {
+		ls, _ := a.(string)
+		rs, _ := b.(string)
+		isLess = ls < rs
+		// Inclusion test
+	} else if IsList(a) && IsList(b) {
+		aList, _ := a.(*ListType)
+		bList, _ := b.(*ListType)
+		isLess = len(*aList) < len(*bList) && bList.contains(aList)
+	} else {
+		err = self.errIncompatibleTypes(a, b)
+	}
+	return
+}
+
+func evalLess(ctx ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
 		return
 	}
-
-	if isNumber(leftValue) && isNumber(rightValue) {
-		if isInteger(leftValue) && isInteger(rightValue) {
-			li, _ := leftValue.(int64)
-			ri, _ := rightValue.(int64)
-			v = li < ri
-		} else {
-			v = numAsFloat(leftValue) < numAsFloat(rightValue)
-		}
-	} else if isString(leftValue) && isString(rightValue) {
-		ls, _ := leftValue.(string)
-		rs, _ := rightValue.(string)
-		v = ls < rs
-	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
-	}
+	v, err = lessThan(opTerm, leftValue, rightValue)
 	return
 }
 
@@ -131,8 +134,6 @@ func evalLess(ctx exprContext, self *term) (v any, err error) {
 func newLessEqualTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindUnknown,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -140,28 +141,28 @@ func newLessEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalLessEqual(ctx exprContext, self *term) (v any, err error) {
+func lessThanOrEqual(self *term, a, b any) (isLessEq bool, err error) {
+	if isLessEq, err = lessThan(self, a, b); err == nil {
+		if !isLessEq {
+			if IsList(a) && IsList(b) {
+				isLessEq, err = sameContent(a, b)
+			} else {
+				isLessEq, err = equals(a, b, nil)
+			}
+		}
+	}
+	return
+}
+
+func evalLessEqual(ctx ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
-	if isNumber(leftValue) && isNumber(rightValue) {
-		if isInteger(leftValue) && isInteger(rightValue) {
-			li, _ := leftValue.(int64)
-			ri, _ := rightValue.(int64)
-			v = li <= ri
-		} else {
-			v = numAsFloat(leftValue) <= numAsFloat(rightValue)
-		}
-	} else if isString(leftValue) && isString(rightValue) {
-		ls, _ := leftValue.(string)
-		rs, _ := rightValue.(string)
-		v = ls <= rs
-	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
-	}
+	v, err = lessThanOrEqual(opTerm, leftValue, rightValue)
+
 	return
 }
 
@@ -170,8 +171,6 @@ func evalLessEqual(ctx exprContext, self *term) (v any, err error) {
 func newGreaterTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -179,11 +178,14 @@ func newGreaterTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalGreater(ctx exprContext, self *term) (v any, err error) {
-	if v, err = evalLessEqual(ctx, self); err == nil {
-		b, _ := toBool(v)
-		v = !b
+func evalGreater(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
 	}
+
+	v, err = lessThan(opTerm, rightValue, leftValue)
 	return
 }
 
@@ -192,8 +194,6 @@ func evalGreater(ctx exprContext, self *term) (v any, err error) {
 func newGreaterEqualTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priRelational,
@@ -201,11 +201,14 @@ func newGreaterEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalGreaterEqual(ctx exprContext, self *term) (v any, err error) {
-	if v, err = evalLess(ctx, self); err == nil {
-		b, _ := toBool(v)
-		v = !b
+func evalGreaterEqual(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
 	}
+
+	v, err = lessThanOrEqual(opTerm, rightValue, leftValue)
 	return
 }
 

operator-selector.go

@@ -0,0 +1,81 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-selector.go
+package expr
+
+//-------- selector term
+
+func newSelectorTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 3),
+		position: posInfix,
+		priority: priSelector,
+		evalFunc: evalSelector,
+	}
+}
+
+func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (match bool, selectedValue any, err error) {
+	caseData, _ := caseSel.(*selectorCase)
+	if caseData.filterList == nil {
+		selectedValue, err = caseData.caseExpr.Eval(ctx)
+		match = true
+	} else if filterList, ok := caseData.filterList.value().([]*term); ok {
+		if len(filterList) == 0 {
+			var valueAsInt = int64(0)
+			if b, ok := exprValue.(bool); ok {
+				if !b {
+					valueAsInt = 1
+				}
+			} else if valueAsInt, ok = exprValue.(int64); !ok {
+				return
+			}
+			if valueAsInt == int64(caseIndex) {
+				selectedValue, err = caseData.caseExpr.Eval(ctx)
+				match = true
+			}
+		} else {
+			var caseValue any
+			for _, caseTerm := range filterList {
+				if caseValue, err = caseTerm.compute(ctx); err != nil || caseValue == exprValue {
+					selectedValue, err = caseData.caseExpr.Eval(ctx)
+					match = true
+					break
+				}
+			}
+		}
+	}
+	return
+}
+
+func evalSelector(ctx ExprContext, opTerm *term) (v any, err error) {
+	var exprValue any
+	var match bool
+
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+	exprTerm := opTerm.children[0]
+	if exprValue, err = exprTerm.compute(ctx); err != nil {
+		return
+	}
+
+	caseListTerm := opTerm.children[1]
+	caseList, _ := caseListTerm.value().([]*term)
+	for i, caseTerm := range caseList {
+		caseSel := caseTerm.value()
+		if match, v, err = trySelectorCase(ctx, exprValue, caseSel, i); err != nil || match {
+			break
+		}
+	}
+	if err == nil && !match {
+		err = exprTerm.tk.Errorf("no case catches the value (%v) of the selection expression", exprValue)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymSelector, newSelectorTerm)
+}

operator-shift.go

@@ -0,0 +1,77 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-shift.go
+package expr
+
+//-------- bit right shift term
+
+func newRightShiftTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBinShift,
+		evalFunc: evalRightShift,
+	}
+}
+
+func bitRightShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	if IsInteger(leftValue) && IsInteger(rightValue) {
+		leftInt := leftValue.(int64)
+		rightInt := rightValue.(int64)
+		v = leftInt >> rightInt
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+func evalRightShift(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	v, err = bitRightShift(opTerm, leftValue, rightValue)
+	return
+}
+
+func newLeftShiftTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBinShift,
+		evalFunc: evalLeftShift,
+	}
+}
+
+func bitLeftShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	if IsInteger(leftValue) && IsInteger(rightValue) {
+		leftInt := leftValue.(int64)
+		rightInt := rightValue.(int64)
+		v = leftInt << rightInt
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+func evalLeftShift(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	v, err = bitLeftShift(opTerm, leftValue, rightValue)
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymDoubleGreater, newRightShiftTerm)
+	registerTermConstructor(SymDoubleLess, newLeftShiftTerm)
+}

operator-sign.go

@@ -1,3 +1,6 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // operator-sign.go
 package expr
 
@@ -5,9 +8,9 @@ package expr
 
 func newPlusSignTerm(tk *Token) (inst *term) {
 	return &term{
-		tk:       *tk,
-		class:    classOperator,
-		kind:     kindUnknown,
+		tk: *tk,
+		// class:    classOperator,
+		// kind:     kindUnknown,
 		children: make([]*term, 0, 1),
 		position: posPrefix,
 		priority: priSign,
@@ -18,8 +21,6 @@ func newPlusSignTerm(tk *Token) (inst *term) {
 func newMinusSignTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindUnknown,
 		children: make([]*term, 0, 1),
 		position: posPrefix,
 		priority: priSign,
@@ -27,29 +28,29 @@ func newMinusSignTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalSign(ctx exprContext, self *term) (v any, err error) {
+func evalSign(ctx ExprContext, opTerm *term) (v any, err error) {
 	var rightValue any
 
-	if rightValue, err = self.evalPrefix(ctx); err != nil {
+	if rightValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
-	if isFloat(rightValue) {
-		if self.tk.Sym == SymChangeSign {
+	if IsFloat(rightValue) {
+		if opTerm.tk.Sym == SymChangeSign {
 			f, _ := rightValue.(float64)
 			v = -f
 		} else {
 			v = rightValue
 		}
-	} else if isInteger(rightValue) {
-		if self.tk.Sym == SymChangeSign {
+	} else if IsInteger(rightValue) {
+		if opTerm.tk.Sym == SymChangeSign {
 			i, _ := rightValue.(int64)
 			v = -i
 		} else {
 			v = rightValue
 		}
 	} else {
-		err = self.errIncompatibleType(rightValue)
+		err = opTerm.errIncompatibleType(rightValue)
 	}
 	return
 }

operator-sum.go

@@ -1,8 +1,12 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // operator-sum.go
 package expr
 
 import (
 	"fmt"
+	"slices"
 )
 
 //-------- plus term
@@ -10,8 +14,6 @@ import (
 func newPlusTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindUnknown,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priSum,
@@ -19,27 +21,54 @@ func newPlusTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalPlus(ctx exprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-
-	if (isString(leftValue) && isNumberString(rightValue)) || (isString(rightValue) && isNumberString(leftValue)) {
+func sumValues(plusTerm *term, leftValue, rightValue any) (v any, err error) {
+	if (IsString(leftValue) && isNumberString(rightValue)) || (IsString(rightValue) && isNumberString(leftValue)) {
 		v = fmt.Sprintf("%v%v", leftValue, rightValue)
-	} else if isNumber(leftValue) && isNumber(rightValue) {
-		if isFloat(leftValue) || isFloat(rightValue) {
+	} else if IsNumber(leftValue) && IsNumber(rightValue) {
+		if IsFloat(leftValue) || IsFloat(rightValue) {
 			v = numAsFloat(leftValue) + numAsFloat(rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			rightInt, _ := rightValue.(int64)
 			v = leftInt + rightInt
 		}
+	} else if IsList(leftValue) && IsList(rightValue) {
+		var leftList, rightList *ListType
+		leftList, _ = leftValue.(*ListType)
+		rightList, _ = rightValue.(*ListType)
+
+		sumList := make(ListType, 0, len(*leftList)+len(*rightList))
+		sumList = append(sumList, *leftList...)
+		sumList = append(sumList, *rightList...)
+		v = &sumList
+	} else if (isFraction(leftValue) && IsNumber(rightValue)) || (isFraction(rightValue) && IsNumber(leftValue)) {
+		if IsFloat(leftValue) || IsFloat(rightValue) {
+			v = numAsFloat(leftValue) + numAsFloat(rightValue)
+		} else {
+			v, err = sumAnyFract(leftValue, rightValue)
+		}
+	} else if IsDict(leftValue) && IsDict(rightValue) {
+		leftDict, _ := leftValue.(*DictType)
+		rightDict, _ := rightValue.(*DictType)
+		c := leftDict.clone()
+		c.merge(rightDict)
+		v = c
+	} else if isFraction(leftValue) && isFraction(rightValue) {
+		v, err = sumAnyFract(leftValue, rightValue)
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = plusTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
-	return
+	return v, err
+}
+
+func evalPlus(ctx ExprContext, plusTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = plusTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return sumValues(plusTerm, leftValue, rightValue)
 }
 
 //-------- minus term
@@ -47,8 +76,6 @@ func evalPlus(ctx exprContext, self *term) (v any, err error) {
 func newMinusTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
-		class:    classOperator,
-		kind:     kindUnknown,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priSum,
@@ -56,27 +83,43 @@ func newMinusTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalMinus(ctx exprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-
-	if isNumber(leftValue) && isNumber(rightValue) {
-		if isFloat(leftValue) || isFloat(rightValue) {
+func diffValues(minusTerm *term, leftValue, rightValue any) (v any, err error) {
+	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+		if IsFloat(leftValue) || IsFloat(rightValue) {
 			v = numAsFloat(leftValue) - numAsFloat(rightValue)
+		} else if isFraction(leftValue) || isFraction(rightValue) {
+			v, err = subAnyFract(leftValue, rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			rightInt, _ := rightValue.(int64)
 			v = leftInt - rightInt
 		}
+	} else if IsList(leftValue) && IsList(rightValue) {
+		leftList, _ := leftValue.(*ListType)
+		rightList, _ := rightValue.(*ListType)
+		diffList := make(ListType, 0, len(*leftList)-len(*rightList))
+		for _, item := range *leftList {
+			if slices.Index(*rightList, item) < 0 {
+				diffList = append(diffList, item)
+			}
+		}
+		v = &diffList
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = minusTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
 
+func evalMinus(ctx ExprContext, minusTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = minusTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return diffValues(minusTerm, leftValue, rightValue)
+}
+
 // init
 func init() {
 	registerTermConstructor(SymPlus, newPlusTerm)

operator-unset.go

@@ -0,0 +1,69 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-unset.go
+package expr
+
+import "strings"
+
+//-------- unset term
+
+func newUnsetTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priSign,
+		evalFunc: evalUnset,
+	}
+}
+
+func deleteContextItem(ctx ExprContext, opTerm *term, item any) (deleted bool, err error) {
+	if name, ok := item.(string); ok {
+		var size int
+		if strings.HasSuffix(name, "()") {
+			size = ctx.FuncCount()
+			ctx.DeleteFunc(strings.TrimRight(name, "()"))
+			deleted = ctx.FuncCount() < size
+		} else {
+			size = ctx.VarCount()
+			ctx.DeleteVar(name)
+			deleted = ctx.VarCount() < size
+		}
+	} else {
+		err = opTerm.errIncompatibleType(item)
+	}
+	return
+}
+
+func evalUnset(ctx ExprContext, opTerm *term) (v any, err error) {
+	var childValue any
+	var deleted bool
+
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	count := 0
+	if IsList(childValue) {
+		list, _ := childValue.(*ListType)
+		for _, item := range *list {
+			if deleted, err = deleteContextItem(ctx, opTerm, item); err != nil {
+				break
+			} else if deleted {
+				count++
+			}
+		}
+	} else if deleted, err = deleteContextItem(ctx, opTerm, childValue); err == nil && deleted {
+		count++
+	}
+	if err == nil {
+		v = int64(count)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwUnset, newUnsetTerm)
+}

parser.go

@@ -1,75 +1,570 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // parser.go
 package expr
 
 import (
-	"fmt"
+	"errors"
+
+	"golang.org/x/exp/constraints"
 )
 
 //-------- parser
 
-type parser struct {
-	ctx exprContext
+type parserContext uint16
+
+const (
+	parserNoFlags                = 0
+	allowMultiExpr parserContext = 1 << iota
+	allowVarRef
+	selectorContext
+	listContext                                // squareContext for list
+	indexContext                               // squareContext for index
+	allowIndex                                 // allow index in squareContext
+	squareContext = listContext | indexContext // Square parenthesis for list or index
+)
+
+func hasFlag[T constraints.Unsigned](set T, singleFlag T) bool {
+	return (set & singleFlag) != 0
 }
 
-func NewParser(ctx exprContext) (p *parser) {
-	p = &parser{
-		ctx: ctx,
+func addFlags[T constraints.Unsigned](set T, flags T) T {
+	return set | flags
+}
+
+func addFlagsCond[T constraints.Unsigned](set T, flags T, cond bool) (newSet T) {
+	if cond {
+		newSet = set | flags
+	} else {
+		newSet = set
 	}
+	return
+}
+
+func remFlags[T constraints.Unsigned](set T, flags T) T {
+	return set & (^flags)
+}
+
+type parser struct {
+}
+
+func NewParser() (p *parser) {
+	p = &parser{}
 	return p
 }
 
-func (self *parser) parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, err error) {
-	tree = NewAst()
-	firstToken := true
-	for tk := scanner.Next(); err == nil && tk != nil && !tk.IsTerm(termSymbols); tk = scanner.Next() {
-		if tk.Sym == SymComment {
-			continue
+func (parser *parser) Next(scanner *scanner) (tk *Token) {
+	for tk = scanner.Next(); tk.IsSymbol(SymComment); tk = scanner.Next() {
+	}
+	return
+}
+
+func (parser *parser) parseFuncCall(scanner *scanner, ctx parserContext, tk *Token) (tree *term, err error) {
+	args := make([]*term, 0, 10)
+	itemExpected := false
+	lastSym := SymUnknown
+	for lastSym != SymClosedRound && lastSym != SymEos {
+		var subTree *ast
+		if subTree, err = parser.parseItem(scanner, ctx, SymComma, SymClosedRound); err != nil {
+			break
+		}
+		prev := scanner.Previous()
+		if subTree.root != nil {
+			args = append(args, subTree.root)
+		} else if itemExpected {
+			err = prev.ErrorExpectedGot("function-param-value")
+			break
 		}
 
-		//fmt.Println("Token:", tk)
-		if firstToken && (tk.Sym == SymMinus || tk.Sym == SymPlus) {
-			if tk.Sym == SymMinus {
-				tk.Sym = SymChangeSign
-			} else {
-				tk.Sym = SymUnchangeSign
-			}
-		}
-		firstToken = false
-		if tk.Sym == SymOpenRound {
-			var subTree *ast
-			if subTree, err = self.parse(scanner, SymClosedRound); err == nil {
-				subTree.root.priority = priValue
-				tree.addTerm(subTree.root)
-			}
-		} else if tk.Sym == SymFunction {
-			name, _ := tk.Value.(string)
-			funcObj := self.ctx.GetFuncInfo(name)
-			if funcObj == nil {
-				err = fmt.Errorf("unknown function %q", name)
-				break
-			}
-			maxArgs := funcObj.MaxArgs()
-			if maxArgs < 0 {
-				maxArgs = funcObj.MinArgs() + 10
-			}
-			args := make([]*term, 0, maxArgs)
-			lastSym := SymUnknown
-			for lastSym != SymClosedRound && lastSym != SymEos {
-				var subTree *ast
-				if subTree, err = self.parse(scanner, SymComma, SymClosedRound); err == nil {
-					args = append(args, subTree.root)
-				} else {
-					break
-				}
-				lastSym = scanner.Previous().Sym
-			}
-			if err == nil {
-				// TODO Check arguments
-				t := newFuncTerm(tk, args)
-				tree.addTerm(t)
-			}
+		itemExpected = prev.Sym == SymComma
+		lastSym = scanner.Previous().Sym
+	}
+	if err == nil {
+		if lastSym != SymClosedRound {
+			err = errors.New("unterminated arguments list")
 		} else {
-			err = tree.addToken(tk)
+			tree = newFuncCallTerm(tk, args)
+		}
+	}
+	return
+}
+
+func (parser *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
+	// Example: "add = func(x,y) {x+y}
+	var body *ast
+	args := make([]*term, 0)
+	lastSym := SymUnknown
+	defaultParamsStarted := false
+	itemExpected := false
+	tk := scanner.Previous()
+	for lastSym != SymClosedRound && lastSym != SymEos {
+		tk = parser.Next(scanner)
+		if tk.IsSymbol(SymIdentifier) {
+			param := newTerm(tk)
+			if len(args) > 0 {
+				if pos := paramAlreadyDefined(args, param); pos > 0 {
+					err = tk.Errorf("parameter %q at position %d already defined at position %d", param.source(), len(args)+1, pos)
+					break
+				}
+			}
+			args = append(args, param)
+			tk = parser.Next(scanner)
+			if tk.Sym == SymEqual {
+				var paramExpr *ast
+				defaultParamsStarted = true
+				if paramExpr, err = parser.parseItem(scanner, parserNoFlags, SymComma, SymClosedRound); err != nil {
+					break
+				}
+				param.forceChild(paramExpr.root)
+			} else if defaultParamsStarted {
+				err = tk.Errorf("can't mix default and non-default parameters")
+				break
+			}
+		} else if itemExpected {
+			prev := scanner.Previous()
+			err = prev.ErrorExpectedGot("function-param-spec")
+			break
+		}
+		lastSym = scanner.Previous().Sym
+		itemExpected = lastSym == SymComma
+	}
+
+	if err == nil && lastSym != SymClosedRound {
+		err = tk.ErrorExpectedGot(")")
+	}
+	if err == nil {
+		tk = parser.Next(scanner)
+		if tk.IsSymbol(SymOpenBrace) {
+			body, err = parser.parseGeneral(scanner, allowMultiExpr|allowVarRef, SymClosedBrace)
+		} else {
+			err = tk.ErrorExpectedGot("{")
+		}
+	}
+	if err == nil {
+		if scanner.Previous().Sym != SymClosedBrace {
+			err = scanner.Previous().ErrorExpectedGot("}")
+		} else {
+			tk = scanner.makeValueToken(SymExpression, "", body)
+			tree = newFuncDefTerm(tk, args)
+		}
+	}
+	return
+}
+
+func paramAlreadyDefined(args []*term, param *term) (position int) {
+	position = 0
+	for i, arg := range args {
+		if arg.source() == param.source() {
+			position = i + 1
+		}
+	}
+	return
+}
+
+func (parser *parser) parseList(scanner *scanner, ctx parserContext) (listTerm *term, err error) {
+	r, c := scanner.lastPos()
+	args := make([]*term, 0)
+	lastSym := SymUnknown
+	itemExpected := false
+	itemCtx := remFlags(ctx, allowIndex)
+	for lastSym != SymClosedSquare && lastSym != SymEos {
+		zeroRequired := scanner.current.Sym == SymColon
+		var itemTree *ast
+		if itemTree, err = parser.parseItem(scanner, itemCtx, SymComma, SymClosedSquare); err == nil {
+			root := itemTree.root
+			if root != nil {
+				if hasFlag(ctx, allowIndex) && root.symbol() == SymColon {
+					changeColonToRange(root)
+				}
+				if !hasFlag(ctx, allowIndex) && root.symbol() == SymRange {
+					// err = root.Errorf("unexpected range expression")
+					err = errRangeUnexpectedExpression(root)
+					break
+				}
+				args = append(args, root)
+				if hasFlag(ctx, allowIndex) && root.symbol() == SymRange && zeroRequired { //len(root.children) == 0 {
+					if len(root.children) == 1 {
+						root.children = append(root.children, root.children[0])
+					} else if len(root.children) > 1 {
+						// err = root.Errorf("invalid range specification")
+						err = errRangeInvalidSpecification(root)
+						break
+					}
+					zeroTk := NewValueToken(root.tk.row, root.tk.col, SymInteger, "0", int64(0))
+					zeroTerm := newTerm(zeroTk)
+					zeroTerm.setParent(root)
+					root.children[0] = zeroTerm
+				}
+			} else if itemExpected {
+				prev := scanner.Previous()
+				err = prev.ErrorExpectedGot("list-item")
+				break
+			}
+		} else {
+			break
+		}
+		lastSym = scanner.Previous().Sym
+		if itemExpected = lastSym == SymComma; itemExpected {
+			remFlags(ctx, allowIndex)
+		}
+	}
+	if err == nil {
+		if lastSym != SymClosedSquare {
+			err = scanner.Previous().ErrorExpectedGot("]")
+		} else {
+			listTerm = newListTerm(r, c, args)
+		}
+	}
+	return
+}
+
+func (parser *parser) parseIterDef(scanner *scanner, ctx parserContext) (subtree *term, err error) {
+	tk := scanner.Previous()
+	args := make([]*term, 0)
+	lastSym := SymUnknown
+	itemExpected := false
+	for lastSym != SymClosedRound && lastSym != SymEos {
+		var subTree *ast
+		if subTree, err = parser.parseItem(scanner, ctx, SymComma, SymClosedRound); err == nil {
+			if subTree.root != nil {
+				args = append(args, subTree.root)
+			} else if itemExpected {
+				prev := scanner.Previous()
+				err = prev.ErrorExpectedGot("iterator-param")
+				break
+			}
+		} else {
+			break
+		}
+		lastSym = scanner.Previous().Sym
+		itemExpected = lastSym == SymComma
+	}
+	if err == nil {
+		if lastSym != SymClosedRound {
+			err = scanner.Previous().ErrorExpectedGot(")")
+		} else {
+			subtree = newIteratorTerm(tk, args)
+		}
+	}
+	return
+}
+
+func (parser *parser) parseDictKey(scanner *scanner) (key any, err error) {
+	tk := parser.Next(scanner)
+	if tk.Sym == SymError {
+		err = tk.Error()
+		return
+	}
+	if tk.Sym == SymClosedBrace || tk.Sym == SymEos {
+		return
+	}
+	if tk.Sym == SymInteger || tk.Sym == SymString {
+		tkSep := parser.Next(scanner)
+		if tkSep.Sym != SymColon {
+			err = tkSep.ErrorExpectedGot(":")
+		} else {
+			key = tk.Value
+		}
+	} else {
+		err = tk.ErrorExpectedGot("dictionary-key or }")
+	}
+	return
+}
+
+func (parser *parser) parseDictionary(scanner *scanner, ctx parserContext) (subtree *term, err error) {
+	args := make(map[any]*term, 0)
+	lastSym := SymUnknown
+	itemExpected := false
+	for lastSym != SymClosedBrace && lastSym != SymEos {
+		var subTree *ast
+		var key any
+		if key, err = parser.parseDictKey(scanner); err != nil {
+			break
+		} else if key == nil {
+			tk := scanner.Previous()
+			lastSym = tk.Sym
+			if itemExpected {
+				err = tk.ErrorExpectedGot("dictionary-key")
+			}
+			break
+		}
+		if subTree, err = parser.parseItem(scanner, ctx, SymComma, SymClosedBrace); err == nil {
+			if subTree.root != nil {
+				args[key] = subTree.root
+			} else /*if key != nil*/ {
+				prev := scanner.Previous()
+				err = prev.ErrorExpectedGot("dictionary-value")
+				break
+			}
+		} else {
+			break
+		}
+		lastSym = scanner.Previous().Sym
+		itemExpected = lastSym == SymComma
+	}
+	if err == nil {
+		if lastSym != SymClosedBrace {
+			err = scanner.Previous().ErrorExpectedGot("}")
+		} else {
+			subtree = newDictTerm(args)
+		}
+	}
+	return
+}
+
+func (parser *parser) parseSelectorCase(scanner *scanner, ctx parserContext, defaultCase bool) (caseTerm *term, err error) {
+	var filterList *term
+	var caseExpr *ast
+	ctx = remFlags(ctx, allowIndex)
+	tk := parser.Next(scanner)
+	startRow := tk.row
+	startCol := tk.col
+	if tk.Sym == SymOpenSquare {
+		if defaultCase {
+			err = tk.Errorf("case list in default clause")
+			return
+		}
+		if filterList, err = parser.parseList(scanner, remFlags(ctx, allowIndex)); err != nil {
+			return
+		}
+		tk = parser.Next(scanner)
+		startRow = tk.row
+		startCol = tk.col
+	} else if !defaultCase {
+		filterList = newListTerm(startRow, startCol, make([]*term, 0))
+	}
+
+	if tk.Sym == SymOpenBrace {
+		if caseExpr, err = parser.parseGeneral(scanner, ctx|allowMultiExpr, SymClosedBrace); err != nil {
+			return
+		}
+	} else {
+		err = tk.ErrorExpectedGot("{")
+	}
+
+	if err == nil {
+		caseTerm = newSelectorCaseTerm(startRow, startCol, filterList, caseExpr)
+	}
+	return
+}
+
+func addSelectorCase(selectorTerm, caseTerm *term) {
+	if len(selectorTerm.children) < 2 {
+		caseListTerm := newListTermA(caseTerm)
+		selectorTerm.children = append(selectorTerm.children, caseListTerm)
+	} else {
+		caseListTerm := selectorTerm.children[1]
+		caseList, _ := caseListTerm.value().([]*term)
+		caseList = append(caseList, caseTerm)
+		caseListTerm.tk.Value = caseList
+	}
+	caseTerm.parent = selectorTerm
+}
+
+func (parser *parser) parseSelector(scanner *scanner, tree *ast, ctx parserContext) (selectorTerm *term, err error) {
+	var caseTerm *term
+
+	ctx = remFlags(ctx, allowIndex)
+	tk := scanner.makeToken(SymSelector, '?')
+	if selectorTerm, err = tree.addToken(tk); err != nil {
+		return
+	}
+
+	if caseTerm, err = parser.parseSelectorCase(scanner, ctx|allowVarRef, false); err == nil {
+		addSelectorCase(selectorTerm, caseTerm)
+	}
+	return
+}
+
+func (parser *parser) parseItem(scanner *scanner, ctx parserContext, termSymbols ...Symbol) (tree *ast, err error) {
+	return parser.parseGeneral(scanner, ctx|allowVarRef, termSymbols...)
+}
+
+func (parser *parser) Parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, err error) {
+	termSymbols = append(termSymbols, SymEos)
+	return parser.parseGeneral(scanner, allowMultiExpr, termSymbols...)
+}
+
+func couldBeACollection(t *term) bool {
+	var sym = SymUnknown
+	if t != nil {
+		sym = t.symbol()
+	}
+	return sym == SymList || sym == SymString || sym == SymDict || sym == SymExpression || sym == SymVariable
+}
+
+func listSubTree(tree *ast, listTerm *term, allowIndeces bool) (root *term, err error) {
+	var tk *Token
+	if allowIndeces {
+		tk = NewToken(listTerm.tk.row, listTerm.tk.col, SymIndex, listTerm.source())
+		root = newTerm(tk)
+		if err = tree.addTerm(root); err == nil {
+			err = tree.addTerm(listTerm)
+		}
+	} else {
+		root = listTerm
+		err = tree.addTerm(listTerm)
+	}
+	return
+}
+
+func changePrefix(tk *Token) {
+	switch tk.Sym {
+	case SymMinus:
+		tk.SetSymbol(SymChangeSign)
+	case SymPlus:
+		tk.SetSymbol(SymUnchangeSign)
+	case SymStar:
+		tk.SetSymbol(SymDereference)
+	case SymExclamation:
+		tk.SetSymbol(SymNot)
+	case SymDoublePlus:
+		tk.SetSymbol(SymPreInc)
+	case SymDoubleMinus:
+		tk.SetSymbol(SymPreDec)
+	}
+}
+
+func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymbols ...Symbol) (tree *ast, err error) {
+	var selectorTerm *term = nil
+	var currentTerm *term = nil
+	var tk *Token
+
+	tree = NewAst()
+	firstToken := true
+	// lastSym := SymUnknown
+	for tk = parser.Next(scanner); err == nil && tk != nil && !tk.IsTerm(termSymbols); /*&& !areSymbolsOutOfCtx(tk, selectorTerm, SymColon, SymDoubleColon)*/ tk = parser.Next(scanner) {
+		// if tk.Sym == SymComment {
+		// 	continue
+		// }
+
+		if tk.Sym == SymSemiColon {
+			if hasFlag(ctx, allowMultiExpr) {
+				tree.ToForest()
+				firstToken = true
+				currentTerm = nil
+				selectorTerm = nil
+				continue
+			} else {
+				err = tk.Errorf(`unexpected token %q, expected ",", "]", or ")"`, tk.source)
+				break
+			}
+		}
+
+		//fmt.Println("Token:", tk)
+		if firstToken {
+			changePrefix(tk)
+			// if tk.Sym == SymMinus {
+			// 	tk.Sym = SymChangeSign
+			// } else if tk.Sym == SymPlus {
+			// 	tk.Sym = SymUnchangeSign
+			// } else if tk.IsSymbol(SymStar) {
+			// 	tk.SetSymbol(SymDereference)
+			// } else if tk.IsSymbol(SymExclamation) {
+			// 	tk.SetSymbol(SymNot)
+			// }
+			firstToken = false
+		}
+
+		switch tk.Sym {
+		case SymOpenRound:
+			var subTree *ast
+			if subTree, err = parser.parseGeneral(scanner, ctx, SymClosedRound); err == nil {
+				exprTerm := newExprTerm(subTree.root)
+				err = tree.addTerm(exprTerm)
+				currentTerm = exprTerm
+				// subTree.root.priority = priValue
+				// err = tree.addTerm(newExprTerm(subTree.root))
+				// currentTerm = subTree.root
+			}
+		case SymFuncCall:
+			var funcCallTerm *term
+			if funcCallTerm, err = parser.parseFuncCall(scanner, ctx, tk); err == nil {
+				err = tree.addTerm(funcCallTerm)
+				currentTerm = funcCallTerm
+			}
+		case SymOpenSquare:
+			var listTerm *term
+			newCtx := addFlagsCond(addFlags(ctx, squareContext), allowIndex, couldBeACollection(currentTerm))
+			if listTerm, err = parser.parseList(scanner, newCtx); err == nil {
+				currentTerm, err = listSubTree(tree, listTerm, hasFlag(newCtx, allowIndex))
+			}
+		case SymOpenBrace:
+			if currentTerm != nil && currentTerm.symbol() == SymColon {
+				err = currentTerm.Errorf(`selector-case outside of a selector context`)
+			} else {
+				var mapTerm *term
+				if mapTerm, err = parser.parseDictionary(scanner, ctx); err == nil {
+					err = tree.addTerm(mapTerm)
+					currentTerm = mapTerm
+				}
+			}
+		case SymEqual, SymPlusEqual, SymMinusEqual, SymStarEqual, SymSlashEqual, SymPercEqual, SymAmpersandEqual, SymVertBarEqual, SymDoubleLessEqual, SymDoubleGreaterEqual, SymCaretEqual:
+			currentTerm, err = tree.addToken(tk)
+			firstToken = true
+		case SymFuncDef:
+			var funcDefTerm *term
+			if funcDefTerm, err = parser.parseFuncDef(scanner); err == nil {
+				err = tree.addTerm(funcDefTerm)
+				currentTerm = funcDefTerm
+			}
+		case SymDollarRound:
+			var iterDefTerm *term
+			if iterDefTerm, err = parser.parseIterDef(scanner, ctx); err == nil {
+				err = tree.addTerm(iterDefTerm)
+				currentTerm = iterDefTerm
+			}
+		case SymIdentifier:
+			if tk.source[0] == '@' && !hasFlag(ctx, allowVarRef) {
+				err = tk.Errorf("variable references are not allowed in top level expressions: %q", tk.source)
+			} else {
+				currentTerm, err = tree.addToken(tk)
+			}
+		case SymQuestion:
+			if selectorTerm, err = parser.parseSelector(scanner, tree, ctx); err == nil {
+				currentTerm = selectorTerm
+				addFlags(ctx, selectorContext)
+			}
+		case SymColon, SymDoubleColon:
+			var caseTerm *term
+			if selectorTerm != nil {
+				if caseTerm, err = parser.parseSelectorCase(scanner, ctx, tk.Sym == SymDoubleColon); err == nil {
+					addSelectorCase(selectorTerm, caseTerm)
+					currentTerm = caseTerm
+					if tk.Sym == SymDoubleColon {
+						selectorTerm = nil
+					}
+				}
+			} else {
+				currentTerm, err = tree.addToken(tk)
+				if tk.IsOneOfA(SymColon, SymRange) {
+					// Colon outside a selector term acts like a separator
+					firstToken = true
+				}
+			}
+		default:
+			currentTerm, err = tree.addToken(tk)
+		}
+
+		if currentTerm != nil && currentTerm.tk.Sym != SymSelector && currentTerm.parent != nil && currentTerm.parent.tk.Sym != SymSelector {
+			selectorTerm = nil
+			remFlags(ctx, selectorContext)
+		}
+		// lastSym = tk.Sym
+	}
+
+	if err == nil {
+		if !tk.IsOneOf(termSymbols) {
+			var symDesc string
+			if tk.IsSymbol(SymError) {
+				symDesc = tk.ErrorText()
+			} else {
+				symDesc = SymToString(tk.Sym)
+			}
+			err = tk.ErrorExpectedGotStringWithPrefix("expected one of", SymListToString(termSymbols, true), symDesc)
+		} else {
+			err = tk.Error()
 		}
 	}
 	return

parser_test.go

@@ -1,215 +0,0 @@
-// parser_test.go
-package expr
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-	"testing"
-)
-
-type testContext struct {
-	store map[string]any
-}
-
-func newTestContext() *testContext {
-	return &testContext{
-		store: make(map[string]any),
-	}
-}
-
-func (ctx *testContext) GetValue(varName string) (v any, exists bool) {
-	v, exists = ctx.store[varName]
-	return
-}
-
-func (ctx *testContext) SetValue(varName string, value any) {
-	ctx.store[varName] = value
-}
-
-func (ctx *testContext) GetFuncInfo(name string) (f exprFunc) {
-	if name == "ADD" {
-		f = &testAddFunc{}
-	}
-	return
-}
-
-func (ctx *testContext) Call(name string, args []any) (result any, err error) {
-	if name == "ADD" {
-		funcObj := &testAddFunc{}
-		result, err = funcObj.Invoke(ctx, args)
-	} else {
-		err = fmt.Errorf("unknown function %q", name)
-	}
-	return
-}
-
-type testAddFunc struct {
-}
-
-func (self *testAddFunc) Name() string {
-	return "ADD"
-}
-
-func (self *testAddFunc) MinArgs() int {
-	return 1
-}
-
-func (self *testAddFunc) MaxArgs() int {
-	return -1
-}
-
-func (self *testAddFunc) Invoke(ctx exprContext, args []any) (result any, err error) {
-	var sumAsFloat = false
-	var floatSum float64 = 0.0
-	var intSum int64 = 0
-
-	for i, v := range args {
-		if !isNumber(v) {
-			err = fmt.Errorf("add(): param nr %d has wrong type %T, number expected", i+1, v)
-			break
-		}
-
-		if !sumAsFloat && isFloat(v) {
-			sumAsFloat = true
-			floatSum = float64(intSum)
-		}
-		if sumAsFloat {
-			floatSum += numAsFloat(v)
-		} else {
-			iv, _ := v.(int64)
-			intSum += iv
-		}
-	}
-	if err == nil {
-		if sumAsFloat {
-			result = floatSum
-		} else {
-			result = intSum
-		}
-	}
-	return
-}
-
-func TestParser(t *testing.T) {
-	type inputType struct {
-		source     string
-		wantResult any
-		wantErr    error
-	}
-
-	ctx := newTestContext()
-	ctx.SetValue("var1", int64(123))
-	ctx.SetValue("var2", "abc")
-
-	inputs := []inputType{
-		{`123`, int64(123), nil},
-		{`1.`, float64(1.0), nil},
-		{`1.E-2`, float64(0.01), nil},
-		{`1E2`, float64(100), nil},
-		/*  1 */ {`1+/*5*/2`, int64(3), nil},
-		/*  2 */ {`3 == 4`, false, nil},
-		/*  3 */ {`3 != 4`, true, nil},
-		/*  4 */ {`4 == (3-1)*(10/5)`, true, nil},
-		/*  5 */ {`3 <= 4`, true, nil},
-		/*  6 */ {`3 < 4`, true, nil},
-		/*  7 */ {`4 < 3`, false, nil},
-		/*  8 */ {`1+5 < 4`, false, nil},
-		/*  9 */ {`3 > 4`, false, nil},
-		/* 10 */ {`4 >= 4`, true, nil},
-		/* 11 */ {`4 > 3`, true, nil},
-		/* 12 */ {`1+5 > 4`, true, nil},
-		/* 13 */ {`true`, true, nil},
-		/* 14 */ {`not true`, false, nil},
-		/* 15 */ {`true and false`, false, nil},
-		/* 16 */ {`true or false`, true, nil},
-		/* 17 */ {`"uno" + "due"`, `unodue`, nil},
-		/* 18 */ {`"uno" + 2`, `uno2`, nil},
-		/* 19 */ {`"uno" + (2+1)`, `uno3`, nil},
-		/* 20 */ {`"uno" * (2+1)`, `unounouno`, nil},
-		/* 21 */ {"1", int64(1), nil},
-		/* 22 */ {"1.5", float64(1.5), nil},
-		/* 23 */ {"1.5*2", float64(3.0), nil},
-		/* 24 */ {"+1", int64(1), nil},
-		/* 25 */ {"-1", int64(-1), nil},
-		/* 26 */ {"435 + 105 * 2 - 1", int64(644), nil},
-		/* 27 */ {"200 / 2 - 1", int64(99), nil},
-		/* 28 */ {"(1+1)", int64(2), nil},
-		/* 29 */ {"-(1+1)", int64(-2), nil},
-		/* 30 */ {"-(-2+1)", int64(1), nil},
-		/* 31 */ {"(1+1)*5", int64(10), nil},
-		/* 32 */ {"200 / (1+1) - 1", int64(99), nil},
-		/* 33 */ {`add(1,2,3)`, int64(6), nil},
-		/* 34 */ {`mul(1,2,3)`, nil, errors.New(`unknown function "MUL"`)},
-		/* 35 */ {`add(1+4,3+2,5*(3-2))`, int64(15), nil},
-		/* 36 */ {`add(add(1+4),3+2,5*(3-2))`, int64(15), nil},
-		/* 37 */ {`add(add(1+4),/*3+2,*/5*(3-2))`, int64(10), nil},
-		/* 38 */ {`1+(1+(1+(1)+1)+1)+1`, int64(7), nil},
-		/* 39 */ {`(((1)))`, int64(1), nil},
-		/* 40 */ {`"uno_" + var2`, `uno_abc`, nil},
-		/* 41 */ {`0 || 0.0 && "hello"`, false, nil},
-		/* 42 */ {`"s" + true`, nil, errors.New(`left operand 's' [string] is not compatible with right operand 'true' [bool] with respect to operator "+"`)},
-		/* 43 */ {`+false`, nil, errors.New(`prefix/postfix operator "+" do not support operand 'false' [bool]`)},
-		/* 44 */ {`false // very simple expression`, false, nil},
-		/* 45 */ {`1 + // Missing right operator`, nil, errors.New(`infix operator "+" requires two operands, got 1`)},
-		/* 46 */ {"", nil, errors.New(`empty expression`)},
-		/* 47 */ {"4!", int64(24), nil},
-		/* 48 */ {"(-4)!", nil, errors.New(`factorial of a negative integer (-4) is not allowed`)},
-		/* 49 */ {"-4!", int64(-24), nil},
-		/* 50 */ {"1.5 < 7", true, nil},
-		/* 51 */ {"1.5 > 7", false, nil},
-		/* 52 */ {"1.5 <= 7", true, nil},
-		/* 53 */ {"1.5 >= 7", false, nil},
-		/* 54 */ {"1.5 != 7", true, nil},
-		/* 55 */ {"1.5 == 7", false, nil},
-		/* 56 */ {`"1.5" < "7"`, true, nil},
-		/* 57 */ {`"1.5" > "7"`, false, nil},
-		/* 58 */ {`"1.5" == "7"`, false, nil},
-		/* 59 */ {`"1.5" != "7"`, true, nil},
-		/* 60 */ {"1.5 < ", nil, errors.New(`infix operator "<" requires two operands, got 1`)},
-		/* 61 */ {"1.5 > ", nil, errors.New(`infix operator ">" requires two operands, got 1`)},
-		/* 62 */ {"1.5 <= ", nil, errors.New(`infix operator "<=" requires two operands, got 1`)},
-		/* 63 */ {"1.5 >= ", nil, errors.New(`infix operator ">=" requires two operands, got 1`)},
-		/* 64 */ {"1.5 != ", nil, errors.New(`infix operator "!=" requires two operands, got 1`)},
-		/* 65 */ {"1.5 == ", nil, errors.New(`infix operator "==" requires two operands, got 1`)},
-		/* 66 */ {`"1.5" < `, nil, errors.New(`infix operator "<" requires two operands, got 1`)},
-		/* 67 */ {`"1.5" > `, nil, errors.New(`infix operator ">" requires two operands, got 1`)},
-		/* 68 */ {`"1.5" == `, nil, errors.New(`infix operator "==" requires two operands, got 1`)},
-		/* 69 */ {`"1.5" != `, nil, errors.New(`infix operator "!=" requires two operands, got 1`)},
-		/* 70 */ {"+1.5", float64(1.5), nil},
-		/* 71 */ {"+", nil, errors.New(`prefix operator "+" requires one operand`)},
-		/* 72 */ {"4 / 0", nil, errors.New(`division by zero`)},
-		/* 73 */ {"4.0 / 0", nil, errors.New(`division by zero`)},
-		/* 74 */ {"4.0 / \n2", float64(2.0), nil},
-	}
-
-	parser := NewParser(ctx)
-	for i, input := range inputs {
-		var expr *ast
-		var gotResult any
-		var gotErr error
-
-		if input.wantErr == nil {
-			t.Log(fmt.Sprintf("[+]Test nr %2d -- %q", i+1, input.source))
-		} else {
-			t.Log(fmt.Sprintf("[-]Test nr %2d -- %q", i+1, input.source))
-		}
-
-		r := strings.NewReader(input.source)
-		scanner := NewScanner(r, DefaultTranslations())
-
-		if expr, gotErr = parser.parse(scanner); gotErr == nil {
-			gotResult, gotErr = expr.eval(ctx)
-		}
-
-		if gotResult != input.wantResult {
-			t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-		}
-
-		if gotErr != input.wantErr {
-			if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
-				t.Errorf("%d: %q  -> err = <%v>, want <%v>", i+1, input.source, gotErr, input.wantErr)
-			}
-		}
-	}
-}

plugins.go

@@ -0,0 +1,133 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// plugin.go
+package expr
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"plugin"
+	"strings"
+)
+
+var pluginRegister map[string]*plugin.Plugin
+
+func registerPlugin(name string, p *plugin.Plugin) (err error) {
+	if pluginExists(name) {
+		err = fmt.Errorf("plugin %q already loaded", name)
+	} else {
+		pluginRegister[name] = p
+	}
+	return
+}
+
+func pluginExists(name string) (exists bool) {
+	_, exists = pluginRegister[name]
+	return
+}
+
+func makePluginName(name string) (decorated string) {
+	var template string
+	if execName, err := os.Executable(); err != nil || !strings.Contains(execName, "debug") {
+		template = "expr-%s-plugin%s"
+	} else {
+		template = "expr-%s-plugin%s.debug"
+	}
+	decorated = fmt.Sprintf(template, name, SHAREDLIBRARY_EXTENSION)
+	return
+}
+
+func importPlugin( /*ctx ExprContext,*/ dirList []string, name string) (err error) {
+	var filePath string
+	var p *plugin.Plugin
+	var sym plugin.Symbol
+	var moduleName string
+	var importFunc func(ExprContext)
+	var ok bool
+
+	decoratedName := makePluginName(name)
+
+	if filePath, err = makeFilepath(decoratedName, dirList); err != nil {
+		return
+	}
+
+	if p, err = plugin.Open(filePath); err != nil {
+		return
+	}
+
+	if sym, err = p.Lookup("MODULE_NAME"); err != nil {
+		return
+	}
+
+	if moduleName = *sym.(*string); moduleName == "" {
+		err = fmt.Errorf("plugin %q does not provide a valid module name", decoratedName)
+		return
+	}
+
+	if sym, err = p.Lookup("DEPENDENCIES"); err != nil {
+		return
+	}
+	if deps := *sym.(*[]string); len(deps) > 0 {
+		// var count int
+		if err = loadModules(dirList, deps); err != nil {
+			return
+		}
+	}
+
+	if sym, err = p.Lookup("ImportFuncs"); err != nil {
+		return
+	}
+
+	if importFunc, ok = sym.(func(ExprContext)); !ok {
+		err = fmt.Errorf("plugin %q does not provide a valid import function", decoratedName)
+		return
+	}
+
+	registerPlugin(moduleName, p)
+	importFunc(globalCtx)
+
+	return
+}
+
+func importPluginFromSearchPath(name any) (count int, err error) {
+	var moduleSpec any
+	var it Iterator
+	dirList := buildSearchDirList("plugin", ENV_EXPR_PLUGIN_PATH)
+	count = 0
+	if it, err = NewIterator(name); err != nil {
+		return
+	}
+	for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() {
+		if module, ok := moduleSpec.(string); ok {
+			if err = importPlugin(dirList, module); err != nil {
+				break
+			}
+			count++
+		} else {
+			err = fmt.Errorf("expected string as item nr %d, got %s", it.Index()+1, TypeName(moduleSpec))
+			break
+		}
+	}
+	if err == io.EOF {
+		err = nil
+	}
+	return
+}
+
+func loadModules(dirList []string, moduleNames []string) (err error) {
+	for _, name := range moduleNames {
+		if err1 := importPlugin(dirList, name); err1 != nil {
+			if !ImportInContext(name) {
+				err = err1
+				break
+			}
+		}
+	}
+	return
+}
+
+func init() {
+	pluginRegister = make(map[string]*plugin.Plugin)
+}

scanner.go

@@ -1,9 +1,13 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // expr project scanner.go
 package expr
 
 import (
 	"bufio"
 	"errors"
+	"fmt"
 	"io"
 	"strconv"
 	"strings"
@@ -12,6 +16,7 @@ import (
 type scanner struct {
 	current      *Token
 	prev         *Token
+	stage        *Token
 	stream       *bufio.Reader
 	row          int
 	column       int
@@ -35,8 +40,9 @@ func DefaultTranslations() map[Symbol]Symbol {
 		SymKwAnd:           SymAnd,
 		SymDoubleVertBar:   SymOr,
 		SymKwOr:            SymOr,
-		SymKwNot:           SymNot,
-		SymLessGreater:     SymNotEqual,
+		// SymTilde:           SymNot,
+		SymKwNot:       SymNot,
+		SymLessGreater: SymNotEqual,
 	}
 }
 
@@ -44,294 +50,497 @@ func DefaultTranslations() map[Symbol]Symbol {
 // 	return self.current
 // }
 
-func (self *scanner) readChar() (ch byte, err error) {
-	if ch, err = self.stream.ReadByte(); err == nil {
+func (scanner *scanner) readChar() (ch byte, err error) {
+	if ch, err = scanner.stream.ReadByte(); err == nil {
 		if ch == '\n' {
-			self.row++
-			self.column = 0
+			scanner.row++
+			scanner.column = 0
 		} else {
-			self.column++
+			scanner.column++
 		}
 	}
 	return
 }
 
-func (self *scanner) unreadChar() (err error) {
-	if err = self.stream.UnreadByte(); err == nil {
-		if self.column--; self.column == 0 {
-			if self.row--; self.row == 0 {
+func (scanner *scanner) unreadChar() (err error) {
+	if err = scanner.stream.UnreadByte(); err == nil {
+		if scanner.column--; scanner.column == 0 {
+			if scanner.row--; scanner.row == 0 {
 				err = errors.New("unread beyond the stream boundary")
 			} else {
-				self.column = 1
+				scanner.column = 1
 			}
 		}
 	}
 	return
 }
 
-func (self *scanner) Previous() *Token {
-	return self.prev
+func (scanner *scanner) UnreadToken() (err error) {
+	if scanner.stage == nil {
+		scanner.stage = scanner.current
+		scanner.current = scanner.prev
+	} else {
+		err = fmt.Errorf("staging already present, currently one level only of staging is allowed")
+	}
+	return
 }
 
-func (self *scanner) Next() (tk *Token) {
-	self.prev = self.current
-	tk = self.current
-	self.current = self.fetchNextToken()
+func (scanner *scanner) lastPos() (r, c int) {
+	if scanner.prev != nil {
+		r = scanner.prev.row
+		c = scanner.prev.col
+	}
+	return
+}
+
+func (scanner *scanner) Previous() *Token {
+	return scanner.prev
+}
+
+func (scanner *scanner) Next() (tk *Token) {
+	scanner.prev = scanner.current
+	tk = scanner.current
+	if scanner.stage != nil {
+		scanner.current = scanner.stage
+		scanner.stage = nil
+	} else {
+		scanner.current = scanner.fetchNextToken()
+	}
 	return tk
 }
 
-func (self *scanner) fetchNextToken() (tk *Token) {
-	if err := self.skipBlanks(); err != nil {
-		return self.makeErrorToken(err)
+func (scanner *scanner) fetchNextToken() (tk *Token) {
+	var ch byte
+	if err := scanner.skipBlanks(); err != nil {
+		return scanner.makeErrorToken(err)
 	}
 
 	escape := false
 	for {
-		ch, _ := self.readChar()
+		ch, _ = scanner.readChar()
 		switch ch {
 		case '+':
-			if next, _ := self.peek(); next == '+' {
-				tk = self.moveOn(SymDoublePlus, ch, next)
+			if next, _ := scanner.peek(); next == '+' {
+				tk = scanner.moveOn(SymDoublePlus, ch, next)
 			} else if next == '=' {
-				tk = self.moveOn(SymPlusEqual, ch, next)
+				tk = scanner.moveOn(SymPlusEqual, ch, next)
+			} else if next == '>' {
+				tk = scanner.moveOn(SymPlusGreater, ch, next)
 			} else {
-				tk = self.makeToken(SymPlus, ch)
+				tk = scanner.makeToken(SymPlus, ch)
 			}
 		case '-':
-			if next, _ := self.peek(); next == '-' {
-				tk = self.moveOn(SymDoubleMinus, ch, next)
+			if next, _ := scanner.peek(); next == '-' {
+				tk = scanner.moveOn(SymDoubleMinus, ch, next)
 			} else if next == '=' {
-				tk = self.moveOn(SymMinusEqual, ch, next)
+				tk = scanner.moveOn(SymMinusEqual, ch, next)
 			} else {
-				tk = self.makeToken(SymMinus, ch)
+				tk = scanner.makeToken(SymMinus, ch)
 			}
 		case '*':
-			if next, _ := self.peek(); next == '*' {
-				tk = self.moveOn(SymDoubleStar, ch, next)
+			if next, _ := scanner.peek(); next == '*' {
+				tk = scanner.moveOn(SymDoubleStar, ch, next)
 				// } else if next == '/' {
 				// 	tk = self.moveOn(SymClosedComment, ch, next)
+			} else if next, _ = scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymStarEqual, ch, next)
 			} else {
-				tk = self.makeToken(SymStar, ch)
+				tk = scanner.makeToken(SymStar, ch)
 			}
 		case '/':
-			if next, _ := self.peek(); next == '*' {
-				self.readChar()
-				tk = self.fetchBlockComment()
+			if next, _ := scanner.peek(); next == '*' {
+				scanner.readChar()
+				tk = scanner.fetchBlockComment()
+			} else if next, _ = scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymSlashEqual, ch, next)
 			} else if next == '/' {
-				self.readChar()
-				tk = self.fetchOnLineComment()
+				scanner.readChar()
+				tk = scanner.fetchOnLineComment()
 			} else {
-				tk = self.makeToken(SymSlash, ch)
+				tk = scanner.makeToken(SymSlash, ch)
 			}
 		case '\\':
 			if escape {
-				tk = self.makeToken(SymBackSlash, ch)
+				tk = scanner.makeToken(SymBackSlash, ch)
 				escape = false
 			} else {
 				escape = true
 			}
 		case '|':
-			if next, _ := self.peek(); next == '|' {
-				tk = self.moveOn(SymDoubleVertBar, ch, next)
+			if next, _ := scanner.peek(); next == '|' {
+				tk = scanner.moveOn(SymDoubleVertBar, ch, next)
+			} else if next, _ = scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymVertBarEqual, ch, next)
 			} else {
-				tk = self.makeToken(SymVertBar, ch)
+				tk = scanner.makeToken(SymVertBar, ch)
 			}
 		case ',':
-			tk = self.makeToken(SymComma, ch)
-		case ':':
-			tk = self.makeToken(SymColon, ch)
-		case ';':
-			tk = self.makeToken(SymSemiColon, ch)
-		case '.':
-			if next, _ := self.peek(); next >= '0' && next <= '9' {
-				tk = self.parseNumber(ch)
+			tk = scanner.makeToken(SymComma, ch)
+		case '^':
+			if next, _ := scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymCaretEqual, ch, next)
 			} else {
-				tk = self.makeToken(SymDot, ch)
+				tk = scanner.makeToken(SymCaret, ch)
+			}
+		case ':':
+			if next, _ := scanner.peek(); next == ':' {
+				tk = scanner.moveOn(SymDoubleColon, ch, next)
+			} else {
+				tk = scanner.makeToken(SymColon, ch)
+			}
+		case ';':
+			tk = scanner.makeToken(SymSemiColon, ch)
+		case '.':
+			//if next, _ := self.peek(); next >= '0' && next <= '9' {
+			//	tk = self.parseNumber(ch)
+			//} else if next == '/' {
+			if next, _ := scanner.peek(); next == '/' {
+				tk = scanner.moveOn(SymDotSlash, ch, next)
+			} else if next == '.' {
+				if next1, _ := scanner.peek(); next1 == '.' {
+					tk = scanner.moveOn(SymTripleDot, ch, next, next1)
+				} else {
+					tk = scanner.moveOn(SymDoubleDot, ch, next)
+				}
+			} else {
+				tk = scanner.makeToken(SymDot, ch)
 			}
 		case '\'':
-			tk = self.makeToken(SymQuote, ch)
-		case '"':
 			if escape {
-				tk = self.makeToken(SymDoubleQuote, ch)
+				tk = scanner.makeToken(SymQuote, ch)
 				escape = false
 			} else {
-				tk = self.fetchString()
+				tk = scanner.fetchString(ch, true)
+			}
+		case '"':
+			if escape {
+				tk = scanner.makeToken(SymDoubleQuote, ch)
+				escape = false
+			} else {
+				tk = scanner.fetchString(ch, true)
 			}
 		case '`':
-			tk = self.makeToken(SymBackTick, ch)
+			tk = scanner.makeToken(SymBackTick, ch)
 		case '!':
-			if next, _ := self.peek(); next == '=' {
-				tk = self.moveOn(SymNotEqual, ch, next)
+			if next, _ := scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymNotEqual, ch, next)
 			} else {
-				tk = self.makeToken(SymExclamation, ch)
+				tk = scanner.makeToken(SymExclamation, ch)
 			}
 		case '?':
-			tk = self.makeToken(SymQuestion, ch)
-		case '&':
-			if next, _ := self.peek(); next == '&' {
-				tk = self.moveOn(SymDoubleAmpersand, ch, next)
+			if next, _ := scanner.peek(); next == '?' {
+				tk = scanner.moveOn(SymDoubleQuestion, ch, next)
+			} else if next == '=' {
+				tk = scanner.moveOn(SymQuestionEqual, ch, next)
+			} else if next == '!' {
+				tk = scanner.moveOn(SymQuestionExclam, ch, next)
 			} else {
-				tk = self.makeToken(SymAmpersand, ch)
+				tk = scanner.makeToken(SymQuestion, ch)
+			}
+		case '&':
+			if next, _ := scanner.peek(); next == '&' {
+				tk = scanner.moveOn(SymDoubleAmpersand, ch, next)
+			} else if next, _ = scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymAmpersandEqual, ch, next)
+			} else {
+				tk = scanner.makeToken(SymAmpersand, ch)
 			}
 		case '%':
-			tk = self.makeToken(SymPercent, ch)
-		case '#':
-			tk = self.makeToken(SymHash, ch)
-		case '@':
-			tk = self.makeToken(SymAt, ch)
-		case '_':
-			tk = self.makeToken(SymUndescore, ch)
-		case '=':
-			if next, _ := self.peek(); next == '=' {
-				tk = self.moveOn(SymDoubleEqual, ch, next)
+			if next, _ := scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymPercEqual, ch, next)
 			} else {
-				tk = self.makeToken(SymEqual, ch)
+				tk = scanner.makeToken(SymPercent, ch)
+			}
+		case '#':
+			tk = scanner.makeToken(SymHash, ch)
+		case '@':
+			if next, _ := scanner.peek(); (next >= 'a' && next <= 'z') || (next >= 'A' && next <= 'Z') {
+				scanner.readChar()
+				if tk = scanner.fetchIdentifier(next); tk.Sym == SymIdentifier {
+					//tk.Sym = SymIdRef
+					tk.source = "@" + tk.source
+				} else {
+					tk = scanner.makeErrorToken(fmt.Errorf("invalid variable reference %q", tk.source))
+				}
+			} else if next == '@' {
+				tk = scanner.moveOn(SymDoubleAt, ch, next)
+			} else {
+				tk = scanner.makeToken(SymAt, ch)
+			}
+		case '_':
+			tk = scanner.makeToken(SymUndescore, ch)
+		case '=':
+			if next, _ := scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymDoubleEqual, ch, next)
+			} else {
+				tk = scanner.makeToken(SymEqual, ch)
 			}
 		case '<':
-			if next, _ := self.peek(); next == '=' {
-				tk = self.moveOn(SymLessOrEqual, ch, next)
+			if next, _ := scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymLessOrEqual, ch, next)
+			} else if next == '<' {
+				scanner.readChar()
+				next2, _ := scanner.readChar()
+				scanner.unreadChar()
+				if next2 == '=' {
+					tk = scanner.moveOn(SymDoubleLessEqual, ch, next, next2)
+				} else {
+					tk = scanner.accept(SymDoubleLess, ch, next)
+				}
 			} else if next == '>' {
-				tk = self.moveOn(SymLessGreater, ch, next)
+				tk = scanner.moveOn(SymLessGreater, ch, next)
+			} else if next == '+' {
+				tk = scanner.moveOn(SymLessPlus, ch, next)
 			} else {
-				tk = self.makeToken(SymLess, ch)
+				tk = scanner.makeToken(SymLess, ch)
 			}
 		case '>':
-			if next, _ := self.peek(); next == '=' {
-				tk = self.moveOn(SymGreaterOrEqual, ch, next)
+			if next, _ := scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymGreaterOrEqual, ch, next)
+			} else if next == '>' {
+				scanner.readChar()
+				next2, _ := scanner.readChar()
+				scanner.unreadChar()
+				if next2 == '=' {
+					tk = scanner.moveOn(SymDoubleGreaterEqual, ch, next, next2)
+				} else {
+					tk = scanner.accept(SymDoubleGreater, ch, next)
+				}
 			} else {
-				tk = self.makeToken(SymGreater, ch)
+				tk = scanner.makeToken(SymGreater, ch)
 			}
 		case '$':
-			tk = self.makeToken(SymDollar, ch)
+			if next, _ := scanner.peek(); next == '(' {
+				tk = scanner.moveOn(SymDollarRound, ch, next)
+				tk.source += ")"
+			} else if next == '$' {
+				tk = scanner.moveOn(SymDoubleDollar, ch, next)
+			} else if next == '{' {
+				scanner.readChar()
+				if tk = scanner.fetchString('}', false); tk != nil {
+					tk.Sym = SymIdentifier
+				}
+			} else if next == '_' || (next >= 'a' && next <= 'z') || (next >= 'A' && next <= 'Z') {
+				scanner.readChar()
+				tk = scanner.fetchIdentifier(next)
+			} else {
+				tk = scanner.makeToken(SymDollar, ch)
+			}
 		case '(':
-			tk = self.makeToken(SymOpenRound, ch)
+			//			if next, _ := scanner.peek(); next == ')' {
+			//				tk = scanner.moveOn(SymOpenClosedRound, ch, next)
+			//			} else {
+			tk = scanner.makeToken(SymOpenRound, ch)
+			//			}
 		case ')':
-			tk = self.makeToken(SymClosedRound, ch)
+			tk = scanner.makeToken(SymClosedRound, ch)
 		case '[':
-			tk = self.makeToken(SymOpenSquare, ch)
+			tk = scanner.makeToken(SymOpenSquare, ch)
 		case ']':
-			tk = self.makeToken(SymClosedSquare, ch)
+			tk = scanner.makeToken(SymClosedSquare, ch)
 		case '{':
-			tk = self.makeToken(SymOpenBrace, ch)
+			tk = scanner.makeToken(SymOpenBrace, ch)
 		case '}':
-			tk = self.makeToken(SymClosedBrace, ch)
+			tk = scanner.makeToken(SymClosedBrace, ch)
+		case '~':
+			tk = scanner.makeToken(SymTilde, ch)
 		case 0:
 			if escape {
-				tk = self.makeErrorToken(errors.New("incomplete escape sequence"))
+				tk = scanner.makeErrorToken(errors.New("incomplete escape sequence"))
 			}
 			escape = false
 		default:
-			if ch == '_' || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') {
-				tk = self.fetchIdentifier(ch)
+			if /*ch == '_' ||*/ (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') {
+				if tk = scanner.fetchIdentifier(ch); tk.Sym == SymKwFunc {
+					if next, _ := scanner.peek(); next == '(' {
+						tk = scanner.moveOn(SymFuncDef, ch, next)
+					}
+				}
 			} else if ch >= '0' && ch <= '9' {
-				tk = self.parseNumber(ch)
+				tk = scanner.parseNumber(ch)
 			}
 		}
 		if !escape {
 			break
 		}
 	}
+	if tk == nil {
+		tk = NewErrorToken(scanner.row, scanner.column, fmt.Errorf("unknown symbol '%c'", ch))
+	}
 	return
 }
 
-func (self *scanner) sync(err error) error {
+func (scanner *scanner) sync(err error) error {
 	if err == nil {
-		err = self.unreadChar()
+		err = scanner.unreadChar()
 	}
 	return err
 }
 
-func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
+func isBinaryDigit(ch byte) bool {
+	return ch == '0' || ch == '1'
+}
+
+func isOctalDigit(ch byte) bool {
+	return ch >= '0' && ch <= '7'
+}
+
+func isDecimalDigit(ch byte) bool {
+	return ch >= '0' && ch <= '9'
+}
+
+func isHexDigit(ch byte) bool {
+	return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')
+}
+
+func (scanner *scanner) initBase(currentFirstCh byte) (firstCh byte, numBase int, digitFunc func(byte) bool, err error) {
+	var ch byte
+	var digitType string
+	firstCh = currentFirstCh
+	digitFunc = isDecimalDigit
+	numBase = 10
+
+	if ch, err = scanner.peek(); err == nil {
+		if ch == 'b' || ch == 'B' {
+			numBase = 2
+			digitType = "binary"
+			scanner.readChar()
+			digitFunc = isBinaryDigit
+			firstCh, err = scanner.readChar()
+		} else if ch == 'o' || ch == 'O' {
+			numBase = 8
+			digitType = "octal"
+			scanner.readChar()
+			digitFunc = isOctalDigit
+			firstCh, err = scanner.readChar()
+		} else if ch == 'x' || ch == 'X' {
+			numBase = 16
+			digitType = "hex"
+			scanner.readChar()
+			digitFunc = isHexDigit
+			firstCh, err = scanner.readChar()
+		}
+		if err == nil && !digitFunc(firstCh) {
+			if len(digitType) == 0 {
+				digitType = "decimal"
+			}
+			err = fmt.Errorf("expected %s digit, got '%c'", digitType, firstCh)
+		}
+	} else if err == io.EOF {
+		err = nil
+	}
+	return
+}
+
+func (scanner *scanner) parseNumber(firstCh byte) (tk *Token) {
 	var err error
 	var ch byte
 	var sym Symbol = SymInteger
-	var value any
 	var sb strings.Builder
+	var isDigit func(byte) bool = isDecimalDigit
+	var numBase = 10
 
-	for ch = firstCh; err == nil && (ch >= '0' && ch <= '9'); ch, err = self.readChar() {
+	if firstCh == '0' {
+		firstCh, numBase, isDigit, err = scanner.initBase(firstCh)
+	}
+	for ch = firstCh; err == nil && isDigit(ch); ch, err = scanner.readChar() {
 		sb.WriteByte(ch)
 	}
-	if ch == '.' {
-		sym = SymFloat
-		sb.WriteByte(ch)
-		ch, err = self.readChar()
-		if ch >= '0' && ch <= '9' {
-			for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = self.readChar() {
-				sb.WriteByte(ch)
-			}
-		}
-	}
-	if ch == 'e' || ch == 'E' {
-		sym = SymFloat
-		sb.WriteByte(ch)
-		if ch, err = self.readChar(); err == nil {
-			if ch == '+' || ch == '-' {
-				sb.WriteByte(ch)
-				ch, err = self.readChar()
-			}
+
+	if numBase == 10 {
+		if err == nil && ch == '.' {
+			sym = SymFloat
+			sb.WriteByte(ch)
+			ch, err = scanner.readChar()
 			if ch >= '0' && ch <= '9' {
-				for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = self.readChar() {
+				for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = scanner.readChar() {
 					sb.WriteByte(ch)
 				}
-				//err = self.sync(err)
-			} else {
-				err = errors.New("expected integer exponent")
 			}
 		}
-		// } else {
-		// err = self.sync(err)
+		if err == nil {
+			if ch == 'e' || ch == 'E' {
+				sym = SymFloat
+				sb.WriteByte(ch)
+				if ch, err = scanner.readChar(); err == nil {
+					if ch == '+' || ch == '-' {
+						sb.WriteByte(ch)
+						ch, err = scanner.readChar()
+					}
+					if ch >= '0' && ch <= '9' {
+						for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = scanner.readChar() {
+							sb.WriteByte(ch)
+						}
+					} else {
+						err = fmt.Errorf("[%d:%d] expected integer exponent, got %c", scanner.row, scanner.column, ch)
+					}
+				}
+			} else if ch == '(' {
+				sym = SymFraction
+				sb.WriteByte(ch)
+				ch, err = scanner.readChar()
+				for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = scanner.readChar() {
+					sb.WriteByte(ch)
+				}
+				if err == nil {
+					if ch != ')' {
+						err = fmt.Errorf("[%d:%d] expected ')', got '%c'", scanner.row, scanner.column, ch)
+					} else {
+						sb.WriteByte(ch)
+						_, err = scanner.readChar()
+					}
+				}
+			}
+		}
 	}
 
 	if err != nil && err != io.EOF {
-		tk = self.makeErrorToken(err)
+		tk = scanner.makeErrorToken(err)
 	} else {
-		err = self.sync(err)
+		var value any
+		_ = scanner.sync(err) // TODO: Check this function
 		txt := sb.String()
 		if sym == SymFloat {
 			value, err = strconv.ParseFloat(txt, 64)
-		} else if strings.HasPrefix(txt, "0x") {
-			value, err = strconv.ParseInt(txt, 16, 64)
-		} else if strings.HasPrefix(txt, "0o") {
-			value, err = strconv.ParseInt(txt, 8, 64)
-		} else if strings.HasPrefix(txt, "0b") {
-			value, err = strconv.ParseInt(txt, 2, 64)
+		} else if sym == SymFraction {
+			value, err = makeGeneratingFraction(txt)
 		} else {
-			value, err = strconv.ParseInt(txt, 10, 64)
+			value, err = strconv.ParseInt(txt, numBase, 64)
 		}
 		if err == nil {
-			tk = self.makeValueToken(sym, txt, value)
+			tk = scanner.makeValueToken(sym, txt, value)
 		} else {
-			tk = self.makeErrorToken(err)
+			tk = scanner.makeErrorToken(err)
 		}
 	}
 	return
 }
 
-func (self *scanner) fetchIdentifier(firstCh byte) (tk *Token) {
+func (scanner *scanner) fetchIdentifier(firstCh byte) (tk *Token) {
 	var err error
 	var sb strings.Builder
-	for ch := firstCh; err == nil && (ch == '_' || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')); ch, err = self.readChar() {
+	for ch := firstCh; err == nil && (ch == '_' || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')); ch, err = scanner.readChar() {
 		sb.WriteByte(ch)
 	}
 
 	if err != nil && err != io.EOF {
-		tk = self.makeErrorToken(err)
-	} else if err = self.sync(err); err != nil && err != io.EOF {
-		tk = self.makeErrorToken(err)
+		tk = scanner.makeErrorToken(err)
+	} else if err = scanner.sync(err); err != nil && err != io.EOF {
+		tk = scanner.makeErrorToken(err)
 	} else {
 		txt := sb.String()
 		uptxt := strings.ToUpper(txt)
 		if sym, ok := keywords[uptxt]; ok {
-			tk = self.makeKeywordToken(sym, uptxt)
+			tk = scanner.makeKeywordToken(sym, uptxt)
 		} else if uptxt == `TRUE` {
-			tk = self.makeValueToken(SymBool, txt, true)
+			tk = scanner.makeValueToken(SymBool, txt, true)
 		} else if uptxt == `FALSE` {
-			tk = self.makeValueToken(SymBool, txt, false)
-		} else if ch, _ := self.peek(); ch == '(' {
-			self.readChar()
-			tk = self.makeValueToken(SymFunction, txt+"(", uptxt)
+			tk = scanner.makeValueToken(SymBool, txt, false)
+		} else if ch, _ := scanner.peek(); ch == '(' {
+			scanner.readChar()
+			tk = scanner.makeValueToken(SymFuncCall, txt+"(", txt)
 		} else {
-			tk = self.makeValueToken(SymIdentifier, txt, txt)
+			tk = scanner.makeValueToken(SymIdentifier, txt, txt)
 		}
 	}
 
@@ -351,96 +560,29 @@ func (self *scanner) fetchIdentifier(firstCh byte) (tk *Token) {
 	return
 }
 
-func (self *scanner) fetchBlockComment() *Token {
-	return self.fetchUntil(SymComment, false, '*', '/')
+func (scanner *scanner) fetchBlockComment() *Token {
+	return scanner.fetchUntil(SymComment, false, '*', '/')
 }
 
-func (self *scanner) fetchOnLineComment() *Token {
-	return self.fetchUntil(SymComment, true, '\n')
+func (scanner *scanner) fetchOnLineComment() *Token {
+	return scanner.fetchUntil(SymComment, true, '\n')
 }
 
-// func (self *scanner) fetchUntil(sym Symbol, allowEos bool, endings ...byte) (tk *Token) {
-// 	var err error
-// 	var ch byte
-// 	var sb strings.Builder
-// 	var value string
-// 	end := string(endings)
-// 	endReached := false
-// 	for ch, err = self.readChar(); err == nil && !endReached; {
-// 		sb.WriteByte(ch)
-// 		if sb.Len() >= len(end) && strings.HasSuffix(sb.String(), end) {
-// 			value = sb.String()[0 : sb.Len()-len(end)]
-// 			endReached = true
-// 		} else {
-// 			ch, err = self.readChar()
-// 		}
-// 	}
-// 	if !endReached && allowEos {
-// 		value = sb.String()
-// 		endReached = true
-// 	}
-
-//		if endReached {
-//			tk = self.makeValueToken(sym, "", value)
-//		} else {
-//			tk = self.makeErrorToken(err)
-//		}
-//		return
-//	}
-
-// func (self *scanner) fetchUntil(sym Symbol, allowEos bool, endings ...byte) (tk *Token) {
-// 	var err error
-// 	var ch byte
-// 	var sb strings.Builder
-// 	var value string
-// 	end := make([]byte, len(endings))
-// 	length := 0
-// 	endReached := false
-// 	for ch, err = self.readChar(); err == nil && !endReached; {
-// 		sb.WriteByte(ch)
-// 		if length == len(endings) {
-// 			for i := 0; i < length-1; i++ {
-// 				end[i] = end[i+1]
-// 			}
-// 			length--
-// 		}
-// 		end[length] = ch
-// 		length++
-// 		if bytes.Equal(endings, end) {
-// 			value = sb.String()[0 : sb.Len()-len(end)]
-// 			endReached = true
-// 		} else {
-// 			ch, err = self.readChar()
-// 		}
-// 	}
-// 	if !endReached && allowEos {
-// 		value = sb.String()
-// 		endReached = true
-// 	}
-
-// 	if endReached {
-// 		tk = self.makeValueToken(sym, "", value)
-// 	} else {
-// 		tk = self.makeErrorToken(err)
-// 	}
-// 	return
-// }
-
-func (self *scanner) fetchUntil(sym Symbol, allowEos bool, endings ...byte) (tk *Token) {
+func (scanner *scanner) fetchUntil(sym Symbol, allowEos bool, endings ...byte) (tk *Token) {
 	var err error
 	var ch byte
 	var sb strings.Builder
 	var value string
 	ring := NewByteSlider(len(endings))
 	endReached := false
-	for ch, err = self.readChar(); err == nil && !endReached; {
+	for ch, err = scanner.readChar(); err == nil && !endReached; {
 		sb.WriteByte(ch)
 		ring.PushEnd(ch)
 		if ring.Equal(endings) {
 			value = sb.String()[0 : sb.Len()-len(endings)]
 			endReached = true
 		} else {
-			ch, err = self.readChar()
+			ch, err = scanner.readChar()
 		}
 	}
 	if !endReached && allowEos {
@@ -449,18 +591,18 @@ func (self *scanner) fetchUntil(sym Symbol, allowEos bool, endings ...byte) (tk
 	}
 
 	if endReached {
-		tk = self.makeValueToken(sym, "", value)
+		tk = scanner.makeValueToken(sym, "", value)
 	} else {
-		tk = self.makeErrorToken(err)
+		tk = scanner.makeErrorToken(err)
 	}
 	return
 }
 
-func (self *scanner) fetchString() (tk *Token) {
+func (scanner *scanner) fetchString(termCh byte, addQuote bool) (tk *Token) {
 	var err error
 	var ch, prev byte
 	var sb strings.Builder
-	for ch, err = self.readChar(); err == nil; ch, err = self.readChar() {
+	for ch, err = scanner.readChar(); err == nil; ch, err = scanner.readChar() {
 		if prev == '\\' {
 			switch ch {
 			case '"':
@@ -477,7 +619,7 @@ func (self *scanner) fetchString() (tk *Token) {
 				sb.WriteByte(ch)
 			}
 			prev = 0
-		} else if ch == '"' {
+		} else if ch == termCh {
 			break
 		} else {
 			prev = ch
@@ -488,65 +630,76 @@ func (self *scanner) fetchString() (tk *Token) {
 	}
 	if err != nil {
 		if err == io.EOF {
-			tk = self.makeErrorToken(errors.New("missing string termination \""))
+			tk = scanner.makeErrorToken(errors.New(string(termCh)))
 		} else {
-			tk = self.makeErrorToken(err)
+			tk = scanner.makeErrorToken(err)
 		}
 	} else {
 		txt := sb.String()
-		tk = self.makeValueToken(SymString, `"`+txt+`"`, txt)
+		if addQuote {
+			tk = scanner.makeValueToken(SymString, `"`+txt+`"`, txt)
+		} else {
+			tk = scanner.makeValueToken(SymString, txt, txt)
+		}
 	}
 	return
 }
 
-func (self *scanner) peek() (next byte, err error) {
+func (scanner *scanner) peek() (next byte, err error) {
 	var one []byte
-	if one, err = self.stream.Peek(1); err == nil {
+	if one, err = scanner.stream.Peek(1); err == nil {
 		next = one[0]
 	}
 	return
 }
 
-func (self *scanner) skipBlanks() (err error) {
+func (scanner *scanner) skipBlanks() (err error) {
 	var one []byte
-	for one, err = self.stream.Peek(1); err == nil && one[0] <= 32; one, err = self.stream.Peek(1) {
-		self.readChar()
+	for one, err = scanner.stream.Peek(1); err == nil && one[0] <= 32; one, err = scanner.stream.Peek(1) {
+		scanner.readChar()
 	}
 	return
 }
 
-func (self *scanner) translate(sym Symbol) Symbol {
-	if self.translations != nil {
-		if translatedSym, ok := self.translations[sym]; ok {
+func (scanner *scanner) translate(sym Symbol) Symbol {
+	if scanner.translations != nil {
+		if translatedSym, ok := scanner.translations[sym]; ok {
 			return translatedSym
 		}
 	}
 	return sym
 }
 
-func (self *scanner) moveOn(sym Symbol, chars ...byte) (tk *Token) {
-	tk = NewToken(self.translate(sym), string(chars))
-	for i := 1; i < len(chars); i++ {
-		self.readChar()
+func (scanner *scanner) moveOn(sym Symbol, chars ...byte) (tk *Token) {
+	tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), string(chars))
+	// for i := 1; i < len(chars); i++ {
+	if len(chars) > 1 {
+		scanner.readChar()
 	}
+	// }
 	return
 }
 
-func (self *scanner) makeToken(sym Symbol, chars ...byte) (tk *Token) {
-	tk = NewToken(self.translate(sym), string(chars))
+func (scanner *scanner) accept(sym Symbol, chars ...byte) (tk *Token) {
+	tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), string(chars))
 	return
 }
 
-func (self *scanner) makeKeywordToken(sym Symbol, upperCaseKeyword string) (tk *Token) {
-	tk = NewToken(self.translate(sym), upperCaseKeyword)
+func (scanner *scanner) makeToken(sym Symbol, chars ...byte) (tk *Token) {
+	tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), string(chars))
 	return
 }
 
-func (self *scanner) makeValueToken(sym Symbol, source string, value any) (tk *Token) {
-	tk = NewValueToken(self.translate(sym), source, value)
+func (scanner *scanner) makeKeywordToken(sym Symbol, upperCaseKeyword string) (tk *Token) {
+	tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), upperCaseKeyword)
 	return
 }
 
-func (self *scanner) makeErrorToken(err error) *Token {
-	return NewErrorToken(self.row, self.column, err)
+func (scanner *scanner) makeValueToken(sym Symbol, source string, value any) (tk *Token) {
+	tk = NewValueToken(scanner.row, scanner.column, scanner.translate(sym), source, value)
+	return
+}
+
+func (scanner *scanner) makeErrorToken(err error) *Token {
+	return NewErrorToken(scanner.row, scanner.column, err)
 }

simple-store.go

@@ -0,0 +1,196 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// simple-store.go
+package expr
+
+import (
+	"fmt"
+	"slices"
+	// "strings"
+)
+
+type SimpleStore struct {
+	parent    ExprContext
+	varStore  map[string]any
+	funcStore map[string]ExprFunc
+}
+
+func NewSimpleStore() *SimpleStore {
+	ctx := &SimpleStore{
+		varStore:  make(map[string]any),
+		funcStore: make(map[string]ExprFunc),
+	}
+	return ctx
+}
+
+func (ss *SimpleStore) Init() {
+	ss.varStore = make(map[string]any)
+	ss.funcStore = make(map[string]ExprFunc)
+}
+
+func filterRefName(name string) bool  { return name[0] != '@' }
+//func filterPrivName(name string) bool { return name[0] != '_' }
+
+func (ctx *SimpleStore) SetParent(parentCtx ExprContext) {
+	ctx.parent = parentCtx
+}
+
+func (ctx *SimpleStore) GetParent() ExprContext {
+	return ctx.parent
+}
+
+func (ctx *SimpleStore) Clone() ExprContext {
+	clone := &SimpleStore{
+		varStore:  CloneFilteredMap(ctx.varStore, filterRefName),
+		funcStore: CloneFilteredMap(ctx.funcStore, filterRefName),
+	}
+	return clone
+}
+
+// func (ctx *SimpleStore) Merge(src ExprContext) {
+// 	for _, name := range src.EnumVars(filterRefName) {
+// 		ctx.varStore[name], _ = src.GetVar(name)
+// 	}
+// 	for _, name := range src.EnumFuncs(filterRefName) {
+// 		ctx.funcStore[name], _ = src.GetFuncInfo(name)
+// 	}
+// }
+
+func (ctx *SimpleStore) ToString(opt FmtOpt) string {
+	dict := ctx.ToDict()
+	return dict.ToString(opt)
+}
+
+func (ctx *SimpleStore) varsToDict(dict *DictType) *DictType {
+	names := ctx.EnumVars(nil)
+	slices.Sort(names)
+	for _, name := range ctx.EnumVars(nil) {
+		value, _ := ctx.GetVar(name)
+		if f, ok := value.(Formatter); ok {
+			(*dict)[name] = f.ToString(0)
+		} else if _, ok = value.(Functor); ok {
+			(*dict)[name] = "func(){}"
+		} else {
+			(*dict)[name] = fmt.Sprintf("%v", value)
+		}
+	}
+	return dict
+}
+
+func (ctx *SimpleStore) funcsToDict(dict *DictType) *DictType {
+	names := ctx.EnumFuncs(func(name string) bool { return true })
+	slices.Sort(names)
+	for _, name := range names {
+		value, _ := ctx.GetFuncInfo(name)
+		if formatter, ok := value.(Formatter); ok {
+			(*dict)[name] = formatter.ToString(0)
+		} else {
+			(*dict)[name] = fmt.Sprintf("%v", value)
+		}
+	}
+	return dict
+}
+
+func (ctx *SimpleStore) ToDict() (dict *DictType) {
+	dict = MakeDict()
+	(*dict)["variables"] = ctx.varsToDict(MakeDict())
+	(*dict)["functions"] = ctx.funcsToDict(MakeDict())
+	return
+}
+
+func (ctx *SimpleStore) GetVar(varName string) (v any, exists bool) {
+	v, exists = ctx.varStore[varName]
+	return
+}
+
+func (ctx *SimpleStore) GetLast() (v any) {
+	v = ctx.varStore["last"]
+	return
+}
+
+func (ctx *SimpleStore) UnsafeSetVar(varName string, value any) {
+	// fmt.Printf("[%p] setVar(%v, %v)\n", ctx, varName, value)
+	ctx.varStore[varName] = value
+}
+
+func (ctx *SimpleStore) SetVar(varName string, value any) {
+	// fmt.Printf("[%p] SetVar(%v, %v)\n", ctx, varName, value)
+	if allowedValue, ok := fromGenericAny(value); ok {
+		ctx.varStore[varName] = allowedValue
+	} else {
+		panic(fmt.Errorf("unsupported type %T of value %v", value, value))
+	}
+}
+
+func (ctx *SimpleStore) EnumVars(acceptor func(name string) (accept bool)) (varNames []string) {
+	varNames = make([]string, 0)
+	for name := range ctx.varStore {
+		if acceptor != nil {
+			if acceptor(name) {
+				varNames = append(varNames, name)
+			}
+		} else {
+			varNames = append(varNames, name)
+		}
+	}
+	return
+}
+
+func (ctx *SimpleStore) VarCount() int {
+	return len(ctx.varStore)
+}
+
+func (ctx *SimpleStore) DeleteVar(varName string) {
+	delete(ctx.varStore, varName)
+}
+
+func (ctx *SimpleStore) GetFuncInfo(name string) (info ExprFunc, exists bool) {
+	info, exists = ctx.funcStore[name]
+	return
+}
+
+func (ctx *SimpleStore) RegisterFuncInfo(info ExprFunc) {
+	ctx.funcStore[info.Name()], _ = info.(*funcInfo)
+}
+
+func (ctx *SimpleStore) RegisterFunc(name string, functor Functor, returnType string, params []ExprFuncParam)  (exprFunc ExprFunc, err error) {
+	var info *funcInfo
+	if info, err = newFuncInfo(name, functor, returnType, params); err == nil {
+		ctx.funcStore[name] = info
+		exprFunc = info
+	}
+	return
+}
+
+func (ctx *SimpleStore) EnumFuncs(acceptor func(name string) (accept bool)) (funcNames []string) {
+	funcNames = make([]string, 0)
+	for name := range ctx.funcStore {
+		if acceptor != nil {
+			if acceptor(name) {
+				funcNames = append(funcNames, name)
+			}
+		} else {
+			funcNames = append(funcNames, name)
+		}
+	}
+	return
+}
+
+func (ctx *SimpleStore) FuncCount() int {
+	return len(ctx.funcStore)
+}
+
+func (ctx *SimpleStore) DeleteFunc(funcName string) {
+	delete(ctx.funcStore, funcName)
+}
+
+func (ctx *SimpleStore) Call(name string, args map[string]any) (result any, err error) {
+	if info, exists := GetLocalFuncInfo(ctx, name); exists {
+		functor := info.Functor()
+		result, err = functor.InvokeNamed(ctx, name, args)
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}

symbol-map.go

@@ -0,0 +1,198 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// Symbol.go
+package expr
+
+import (
+	"strings"
+)
+
+var symbolMap map[Symbol]symbolSpec
+
+type symbolClass int16
+
+const (
+	symClassOperator symbolClass = iota
+	symClassCommand
+	symClassIdentifier
+	symClassDelimiter
+	symClassParenthesis
+	symClassDeclaration
+	symClassValue
+	symClassOther
+)
+
+type symbolSpec struct {
+	repr   string
+	kind   symbolClass
+	opType termPosition
+}
+
+func init() {
+
+	symbolMap = map[Symbol]symbolSpec{
+		SymUnknown:            {"<unknown>", symClassOther, posLeaf},  //  -1: Unknown symbol
+		SymNone:               {"<null>", symClassOther, posLeaf},     //   0: Null value for variable of type symbol
+		SymError:              {"<error>", symClassOther, posLeaf},    //   1: Error reading from stream
+		SymEos:                {"<eos>", symClassOther, posLeaf},      //   2: End of stream
+		SymMinus:              {"-", symClassOperator, posInfix},      //   3: '-'
+		SymMinusEqual:         {"-=", symClassOperator, posInfix},     //   4: '-='
+		SymDoubleMinus:        {"--", symClassOperator, posPostfix},   //   5: '--'
+		SymPlus:               {"+", symClassOperator, posInfix},      //   6: '+'
+		SymPlusEqual:          {"+=", symClassOperator, posInfix},     //   7: '+='
+		SymDoublePlus:         {"++", symClassOperator, posPostfix},   //   8: '++'
+		SymStar:               {"*", symClassOperator, posInfix},      //   9: '*'
+		SymDoubleStar:         {"**", symClassOperator, posInfix},     //  10: '**'
+		SymSlash:              {"/", symClassOperator, posInfix},      //  11: '/'
+		SymBackSlash:          {"\\", symClassOperator, posLeaf},      //  12: '\'
+		SymVertBar:            {"|", symClassOperator, posInfix},      //  13: '|'
+		SymDoubleVertBar:      {"||", symClassOperator, posInfix},     //  14: '||'
+		SymComma:              {",", symClassOperator, posInfix},      //  15: ','
+		SymColon:              {":", symClassOperator, posInfix},      //  16: ':'
+		SymSemiColon:          {";", symClassOperator, posInfix},      //  17: ';'
+		SymDot:                {".", symClassOperator, posInfix},      //  18: '.'
+		SymDotSlash:           {"./", symClassOperator, posInfix},     //  19: './'
+		SymQuote:              {"'", symClassDelimiter, posLeaf},      //  20: '\''
+		SymDoubleQuote:        {"\"", symClassDelimiter, posLeaf},     //  21: '"'
+		SymBackTick:           {"`", symClassDelimiter, posLeaf},      //  22: '`'
+		SymExclamation:        {"!", symClassOperator, posPostfix},    //  23: '!'
+		SymQuestion:           {"?", symClassOperator, posInfix},      //  24: '?'
+		SymAmpersand:          {"&", symClassOperator, posInfix},      //  25: '&'
+		SymDoubleAmpersand:    {"&&", symClassOperator, posInfix},     //  26: '&&'
+		SymPercent:            {"%", symClassOperator, posInfix},      //  27: '%'
+		SymAt:                 {"@", symClassOperator, posPrefix},     //  28: '@'
+		SymUndescore:          {"_", symClassIdentifier, posLeaf},     //  29: '_'
+		SymEqual:              {"=", symClassOperator, posInfix},      //  30: '='
+		SymDoubleEqual:        {"==", symClassOperator, posInfix},     //  31: '=='
+		SymLess:               {"<", symClassOperator, posInfix},      //  32: '<'
+		SymLessOrEqual:        {"<=", symClassOperator, posInfix},     //  33: '<='
+		SymGreater:            {">", symClassOperator, posInfix},      //  34: '>'
+		SymGreaterOrEqual:     {">=", symClassOperator, posInfix},     //  35: '>='
+		SymLessGreater:        {"<>", symClassOperator, posInfix},     //  36: '<>'
+		SymNotEqual:           {"!=", symClassOperator, posInfix},     //  37: '!='
+		SymDollar:             {"$", symClassOperator, posPrefix},     //  38: '$'
+		SymHash:               {"#", symClassOperator, posPrefix},     //  39: '#'
+		SymOpenRound:          {"(", symClassParenthesis, posPrefix},  //  40: '('
+		SymClosedRound:        {")", symClassParenthesis, posPostfix}, //  41: ')'
+		SymOpenSquare:         {"[", symClassParenthesis, posPrefix},  //  42: '['
+		SymClosedSquare:       {"]", symClassParenthesis, posPostfix}, //  43: ']'
+		SymOpenBrace:          {"{", symClassParenthesis, posPrefix},  //  44: '{'
+		SymClosedBrace:        {"}", symClassParenthesis, posPostfix}, //  45: '}'
+		SymTilde:              {"~", symClassOperator, posPrefix},     //  46: '~'
+		SymDoubleQuestion:     {"??", symClassOperator, posInfix},     //  47: '??'
+		SymQuestionEqual:      {"?=", symClassOperator, posInfix},     //  48: '?='
+		SymQuestionExclam:     {"?!", symClassOperator, posInfix},     //  49: '?!'
+		SymDoubleAt:           {"@@", symClassCommand, posLeaf},       //  50: '@@'
+		SymDoubleColon:        {"::", symClassOperator, posInfix},     //  51: '::'
+		SymDoubleGreater:      {">>", symClassOperator, posInfix},     //  52: '>>'
+		SymDoubleLess:         {"<<", symClassOperator, posInfix},     //  53: '<<'
+		SymCaret:              {"^", symClassOperator, posInfix},      //  54: '^'
+		SymDollarRound:        {"$(", symClassOperator, posPrefix},    //  55: '$('
+		SymOpenClosedRound:    {"()", symClassOperator, posPostfix},   //  56: '()'
+		SymDoubleDollar:       {"$$", symClassCommand, posLeaf},       //  57: '$$'
+		SymDoubleDot:          {"..", symClassOperator, posInfix},     //  58: '..'
+		SymTripleDot:          {"...", symClassOperator, posPostfix},  //  59: '...'
+		SymStarEqual:          {"*=", symClassOperator, posInfix},     //  60: '*='
+		SymSlashEqual:         {"/=", symClassOperator, posInfix},     //  61: '/='
+		SymPercEqual:          {"%=", symClassOperator, posInfix},     //  62: '%='
+		SymDoubleLessEqual:    {"<<=", symClassOperator, posInfix},    //  63: '<<='
+		SymDoubleGreaterEqual: {">>=", symClassOperator, posInfix},    //  64: '>>='
+		SymAmpersandEqual:     {"&=", symClassOperator, posInfix},     //  65: '&='
+		SymVertBarEqual:       {"|=", symClassOperator, posInfix},     //  65: '|='
+		SymCaretEqual:         {"^=", symClassOperator, posInfix},     //  66: '^='
+		SymPlusGreater:        {"+>", symClassOperator, posInfix},     //  67: '+>'
+		SymLessPlus:           {"<+", symClassOperator, posInfix},     //  68: '<+'
+		SymPreInc:             {"++", symClassOperator, posPrefix},    //    : '++'
+		SymPreDec:             {"--", symClassOperator, posPrefix},    //    : '--'
+		// SymChangeSign
+		// SymUnchangeSign
+		// SymIdentifier
+		// SymBool
+		// SymInteger
+		// SymVariable
+		// SymFloat
+		// SymFraction
+		// SymString
+		// SymIterator
+		// SymOr:  "or",
+		// SymAnd: "and",
+		// SymNot: "not",
+		// SymComment
+		// SymFuncCall
+		// SymFuncDef
+		// SymList
+		// SymDict
+		// SymIndex
+		// SymExpression
+		// SymSelector     // <selector> ::= <expr> "?" <selector-case> {":" <selector-case>} ["::" <default-selector-case>]
+		// SymSelectorCase // <selector-case> ::= [<list>] "{" <multi-expr> "}"
+		// // SymOpenComment                       //   0: '/*'
+		// // SymClosedComment                     //   0: '*/'
+		// // SymOneLineComment                    //   0: '//'
+		// keywordBase
+		SymKwAnd:     {"and", symClassOperator, posInfix},
+		SymKwNot:     {"not", symClassOperator, posInfix},
+		SymKwOr:      {"or", symClassOperator, posInfix},
+		SymKwBut:     {"but", symClassOperator, posInfix},
+		SymKwFunc:    {"func(", symClassDeclaration, posPrefix},
+		SymKwBuiltin: {"builtin", symClassOperator, posPrefix},
+		SymKwPlugin:  {"plugin", symClassOperator, posPrefix},
+		SymKwIn:      {"in", symClassOperator, posInfix},
+		SymKwInclude: {"include", symClassOperator, posPrefix},
+		SymKwNil:     {"nil", symClassValue, posLeaf},
+		SymKwUnset:   {"unset", symClassOperator, posPrefix},
+	}
+}
+
+func SymToString(sym Symbol) string {
+	if s, ok := symbolMap[sym]; ok {
+		return s.repr
+	}
+	return ""
+}
+
+func SymListToString(symList []Symbol, quote bool) string {
+	var sb strings.Builder
+	if len(symList) == 0 {
+		sb.WriteString("<nothing>")
+	} else {
+		for _, sym := range symList {
+			if sb.Len() > 0 {
+				sb.WriteByte(',')
+				sb.WriteByte(' ')
+			}
+			if quote {
+				sb.WriteByte('`')
+			}
+			sb.WriteString(SymToString(sym))
+			if quote {
+				sb.WriteByte('`')
+			}
+		}
+	}
+	return sb.String()
+}
+
+func StringEndsWithOperator(s string) bool {
+	return endingOperator(s) != SymNone
+}
+
+func endingOperator(s string) (sym Symbol) {
+	var matchLength = 0
+	sym = SymNone
+	lower := strings.TrimRight(strings.ToLower(s), " \t")
+	for symbol, spec := range symbolMap {
+		if strings.HasSuffix(lower, spec.repr) {
+			if len(spec.repr) > matchLength {
+				matchLength = len(spec.repr)
+				if spec.kind == symClassOperator && (spec.opType == posInfix || spec.opType == posPrefix) {
+					sym = symbol
+				} else {
+					sym = SymNone
+				}
+			}
+		}
+	}
+	return
+}

symbol.go

@@ -1,73 +1,127 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
 // Symbol.go
 package expr
 
 type Symbol int16
 
 const (
-	SymUnknown         Symbol = iota - 1 //  -1: Unknown symbol
-	SymNone                              //   0: Null value for variable of type symbol
-	SymError                             //   1: Error reading from stream
-	SymEos                               //   2: End of stream
-	SymMinus                             //   3: '-'
-	SymMinusEqual                        //   4: '-='
-	SymDoubleMinus                       //   5: '--'
-	SymPlus                              //   6: '+'
-	SymPlusEqual                         //   7: '+='
-	SymDoublePlus                        //   8: '++'
-	SymStar                              //   9: '*'
-	SymDoubleStar                        //  10: '**'
-	SymSlash                             //  11: '/'
-	SymBackSlash                         //  12: '\'
-	SymVertBar                           //  13: '|'
-	SymDoubleVertBar                     //  14: '||'
-	SymComma                             //  15: ','
-	SymColon                             //  16: ':'
-	SymSemiColon                         //  17: ';'
-	SymDot                               //  18: '.'
-	SymQuote                             //  19: '\''
-	SymDoubleQuote                       //  20: '"'
-	SymBackTick                          //   0: '`'
-	SymExclamation                       //   0: '!'
-	SymQuestion                          //   0: '?'
-	SymAmpersand                         //   0: '&&'
-	SymDoubleAmpersand                   //   0: '&&'
-	SymPercent                           //   0: '%'
-	SymAt                                //   0: '@'
-	SymUndescore                         //   0: '_'
-	SymEqual                             //   0: '='
-	SymDoubleEqual                       //   0: '=='
-	SymLess                              //   0: '<'
-	SymLessOrEqual                       //   0: '<='
-	SymGreater                           //   0: '>'
-	SymGreaterOrEqual                    //   0: '>='
-	SymLessGreater                       //   0: '<>'
-	SymNotEqual                          //   0: '!='
-	SymDollar                            //   0: '$'
-	SymHash                              //   0: '#'
-	SymOpenRound                         //   0: '('
-	SymClosedRound                       //   0: ')'
-	SymOpenSquare                        //   0: '['
-	SymClosedSquare                      //   0: ']'
-	SymOpenBrace                         //   0: '{'
-	SymClosedBrace                       //   0: '}'
+	SymUnknown            Symbol = iota - 1 //  -1: Unknown symbol
+	SymNone                                 //   0: Null value for variable of type symbol
+	SymError                                //   1: Error reading from stream
+	SymEos                                  //   2: End of stream
+	SymMinus                                //   3: '-'
+	SymMinusEqual                           //   4: '-='
+	SymDoubleMinus                          //   5: '--'
+	SymPlus                                 //   6: '+'
+	SymPlusEqual                            //   7: '+='
+	SymDoublePlus                           //   8: '++'
+	SymStar                                 //   9: '*'
+	SymDoubleStar                           //  10: '**'
+	SymSlash                                //  11: '/'
+	SymBackSlash                            //  12: '\'
+	SymVertBar                              //  13: '|'
+	SymDoubleVertBar                        //  14: '||'
+	SymComma                                //  15: ','
+	SymColon                                //  16: ':'
+	SymSemiColon                            //  17: ';'
+	SymDot                                  //  18: '.'
+	SymDotSlash                             //  19: './'
+	SymQuote                                //  20: '\''
+	SymDoubleQuote                          //  21: '"'
+	SymBackTick                             //  22: '`'
+	SymExclamation                          //  23: '!'
+	SymQuestion                             //  24: '?'
+	SymAmpersand                            //  25: '&'
+	SymDoubleAmpersand                      //  26: '&&'
+	SymPercent                              //  27: '%'
+	SymAt                                   //  28: '@'
+	SymUndescore                            //  29: '_'
+	SymEqual                                //  30: '='
+	SymDoubleEqual                          //  31: '=='
+	SymLess                                 //  32: '<'
+	SymLessOrEqual                          //  33: '<='
+	SymGreater                              //  34: '>'
+	SymGreaterOrEqual                       //  35: '>='
+	SymLessGreater                          //  36: '<>'
+	SymNotEqual                             //  37: '!='
+	SymDollar                               //  38: '$'
+	SymHash                                 //  39: '#'
+	SymOpenRound                            //  40: '('
+	SymClosedRound                          //  41: ')'
+	SymOpenSquare                           //  42: '['
+	SymClosedSquare                         //  43: ']'
+	SymOpenBrace                            //  44: '{'
+	SymClosedBrace                          //  45: '}'
+	SymTilde                                //  46: '~'
+	SymDoubleQuestion                       //  47: '??'
+	SymQuestionEqual                        //  48: '?='
+	SymQuestionExclam                       //  49: '?!'
+	SymDoubleAt                             //  50: '@@'
+	SymDoubleColon                          //  51: '::'
+	SymDoubleGreater                        //  52: '>>'
+	SymDoubleLess                           //  53: '<<'
+	SymCaret                                //  54: '^'
+	SymDollarRound                          //  55: '$('
+	SymOpenClosedRound                      //  56: '()'
+	SymDoubleDollar                         //  57: '$$'
+	SymDoubleDot                            //  58: '..'
+	SymTripleDot                            //  59: '...'
+	SymStarEqual                            //  60: '*='
+	SymSlashEqual                           //  61: '/='
+	SymPercEqual                            //  62: '%='
+	SymDoubleLessEqual                      //  63: '<<='
+	SymDoubleGreaterEqual                   //  64: '>>='
+	SymAmpersandEqual                       //  65: '&='
+	SymVertBarEqual                         //  65: '|='
+	SymCaretEqual                           //  66: '^='
+	SymPlusGreater                          //  67: '+>'
+	SymLessPlus                             //  68: '<+'
 	SymChangeSign
 	SymUnchangeSign
+	SymDereference
+	SymPreInc
+	SymPreDec
 	SymIdentifier
 	SymBool
 	SymInteger
+	SymVariable
 	SymFloat
+	SymFraction
 	SymString
-	SymKwAnd
-	SymKwNot
-	SymKwOr
+	SymIterator
 	SymOr
 	SymAnd
 	SymNot
 	SymComment
-	SymFunction
+	SymFuncCall
+	SymFuncDef
+	SymList
+	SymDict
+	SymIndex
+	SymRange // [index : index]
+	SymExpression
+	SymSelector     // <selector> ::= <expr> "?" <selector-case> {":" <selector-case>} ["::" <default-selector-case>]
+	SymSelectorCase // <selector-case> ::= [<list>] "{" <multi-expr> "}"
 	// SymOpenComment                       //   0: '/*'
 	// SymClosedComment                     //   0: '*/'
 	// SymOneLineComment                    //   0: '//'
+	keywordBase
+)
+const (
+	SymKwAnd = keywordBase + iota
+	SymKwNot
+	SymKwOr
+	SymKwBut
+	SymKwFunc
+	SymKwBuiltin
+	SymKwPlugin
+	SymKwIn
+	SymKwInclude
+	SymKwMap
+	SymKwNil
+	SymKwUnset
 )
 
 var keywords map[string]Symbol
@@ -75,8 +129,17 @@ var keywords map[string]Symbol
 func init() {
 	//keywords = make(map[string]Symbol)
 	keywords = map[string]Symbol{
-		"AND": SymKwAnd,
-		"OR":  SymKwOr,
-		"NOT": SymKwNot,
+		"AND":     SymKwAnd,
+		"BUILTIN": SymKwBuiltin,
+		"PLUGIN":  SymKwPlugin,
+		"BUT":     SymKwBut,
+		"FUNC":    SymKwFunc,
+		"IN":      SymKwIn,
+		"INCLUDE": SymKwInclude,
+		"MAP":     SymKwMap,
+		"NOT":     SymKwNot,
+		"OR":      SymKwOr,
+		"NIL":     SymKwNil,
+		"UNSET":   SymKwUnset,
 	}
 }

t_ast_test.go

@@ -1,4 +1,7 @@
-// ast_test.go
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_ast_test.go
 package expr
 
 import (
@@ -14,9 +17,9 @@ func TestAstString(t *testing.T) {
 }
 
 func TestAddTokensGood(t *testing.T) {
-	tk1 := NewValueToken(SymInteger, "100", 100)
-	tk2 := NewToken(SymPlus, "+")
-	tk3 := NewValueToken(SymInteger, "50", 500)
+	tk1 := NewValueToken(0, 0, SymInteger, "100", 100)
+	tk2 := NewToken(0, 0, SymPlus, "+")
+	tk3 := NewValueToken(0, 0, SymInteger, "50", 500)
 
 	tree := NewAst()
 	if gotErr := tree.addTokens(tk1, tk2, tk3); gotErr != nil {
@@ -25,12 +28,12 @@ func TestAddTokensGood(t *testing.T) {
 }
 
 func TestAddTokensBad(t *testing.T) {
-	tk0 := NewValueToken(SymInteger, "200", 200)
-	tk1 := NewValueToken(SymInteger, "100", 100)
-	tk2 := NewToken(SymPlus, "+")
-	tk3 := NewValueToken(SymInteger, "50", 500)
+	tk0 := NewValueToken(0, 0, SymInteger, "200", 200)
+	tk1 := NewValueToken(0, 0, SymInteger, "100", 100)
+	tk2 := NewToken(0, 0, SymPlus, "+")
+	tk3 := NewValueToken(0, 0, SymInteger, "50", 500)
 
-	wantErr := errors.New(`two adjacent operators: "200" and "100"`)
+	wantErr := errors.New(`[0:0] two adjacent operators: "200" and "100"`)
 
 	tree := NewAst()
 	if gotErr := tree.addTokens(tk0, tk1, tk2, tk3); gotErr != nil && gotErr.Error() != wantErr.Error() {
@@ -39,12 +42,12 @@ func TestAddTokensBad(t *testing.T) {
 }
 
 func TestAddUnknownTokens(t *testing.T) {
-	tk0 := NewToken(SymPercent, "%")
+	tk0 := NewToken(0, 0, SymPercent, "%")
 
-	wantErr := errors.New(`No term constructor for token "%"`)
+	wantErr := errors.New(`unexpected token "%"`)
 
 	tree := NewAst()
-	if gotErr := tree.addToken(tk0); gotErr != nil && gotErr.Error() != wantErr.Error() {
+	if _, gotErr := tree.addToken(tk0); gotErr != nil && gotErr.Error() != wantErr.Error() {
 		t.Errorf("err: got <%v>, want <%v>", gotErr, wantErr)
 	}
 }

t_bool_test.go

@@ -0,0 +1,67 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_bool_test.go
+package expr
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestBool(t *testing.T) {
+	section := "Bool"
+	inputs := []inputType{
+		/*   1 */ {`true`, true, nil},
+		/*   2 */ {`false`, false, nil},
+		/*   3 */ {`not false`, true, nil},
+		/*   4 */ {`not 1`, false, nil},
+		/*   5 */ {`not "true"`, false, nil},
+		/*   6 */ {`not "false"`, false, nil},
+		/*   7 */ {`not ""`, true, nil},
+		/*   8 */ {`not []`, nil, errors.New(`[1:4] prefix/postfix operator "NOT" do not support operand '[]' [list]`)},
+		/*   9 */ {`true and false`, false, nil},
+		/*  10 */ {`true and []`, nil, errors.New(`[1:9] left operand 'true' [bool] and right operand '[]' [list] are not compatible with operator "AND"`)},
+		/*  11 */ {`[] and false`, nil, errors.New(`got list as left operand type of 'AND' operator, it must be bool`)},
+		/*  12 */ {`true or false`, true, nil},
+		/*  13 */ {`true or []`, true, nil},
+		/*  14 */ {`[] or false`, nil, errors.New(`got list as left operand type of 'OR' operator, it must be bool`)},
+		/*  15 */ {`!true`, false, nil},
+		/*  13 */ //{`true or []`, nil, errors.New(`[1:8] left operand 'true' [bool] and right operand '[]' [list] are not compatible with operator "OR"`)},
+	}
+
+	// t.Setenv("EXPR_PATH", ".")
+
+	// runTestSuiteSpec(t, section, inputs, 15)
+	runTestSuite(t, section, inputs)
+}
+
+func TestBoolNoShortcut(t *testing.T) {
+	section := "Bool-NoShortcut"
+	inputs := []inputType{
+		/*   1 */ {`true`, true, nil},
+		/*   2 */ {`false`, false, nil},
+		/*   3 */ {`not false`, true, nil},
+		/*   4 */ {`not 1`, false, nil},
+		/*   5 */ {`not "true"`, false, nil},
+		/*   6 */ {`not "false"`, false, nil},
+		/*   7 */ {`not ""`, true, nil},
+		/*   8 */ {`not []`, nil, `[1:4] prefix/postfix operator "NOT" do not support operand '[]' [list]`},
+		/*   9 */ {`true and false`, false, nil},
+		/*  10 */ {`true and []`, nil, `[1:9] left operand 'true' [bool] and right operand '[]' [list] are not compatible with operator "AND"`},
+		/*  11 */ {`[] and false`, nil, `[1:7] left operand '[]' [list] and right operand 'false' [bool] are not compatible with operator "AND"`},
+		/*  12 */ {`true or false`, true, nil},
+		/*  13 */ {`true or []`, nil, `[1:8] left operand 'true' [bool] and right operand '[]' [list] are not compatible with operator "OR"`},
+		/*  14 */ {`[] or false`, nil, `[1:6] left operand '[]' [list] and right operand 'false' [bool] are not compatible with operator "OR"`},
+	}
+
+	// t.Setenv("EXPR_PATH", ".")
+
+	ctx := NewSimpleStore()
+	current := SetCtrl(ctx, ControlBoolShortcut, false)
+
+	// runCtxTestSuiteSpec(t, ctx, section, inputs, 1)
+	runCtxTestSuite(t, ctx, section, inputs)
+
+	SetCtrl(ctx, ControlBoolShortcut, current)
+}

t_builtin-base_test.go

@@ -0,0 +1,72 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_builtin-base_test.go
+package expr
+
+import (
+	"testing"
+)
+
+func TestFuncBase(t *testing.T) {
+	section := "Builtin-Base"
+
+	inputs := []inputType{
+		/*   1 */ {`isNil(nil)`, true, nil},
+		/*   2 */ {`v=nil; isNil(v)`, true, nil},
+		/*   3 */ {`v=5; isNil(v)`, false, nil},
+		/*   4 */ {`int(true)`, int64(1), nil},
+		/*   5 */ {`int(false)`, int64(0), nil},
+		/*   6 */ {`int(3.1)`, int64(3), nil},
+		/*   7 */ {`int(3.9)`, int64(3), nil},
+		/*   8 */ {`int("432")`, int64(432), nil},
+		/*   9 */ {`int("1.5")`, nil, `strconv.Atoi: parsing "1.5": invalid syntax`},
+		/*  10 */ {`int("432", 4)`, nil, `int(): too many params -- expected 1, got 2`},
+		/*  11 */ {`int(nil)`, nil, `int(): can't convert nil to int`},
+		/*  12 */ {`isInt(2+1)`, true, nil},
+		/*  13 */ {`isInt(3.1)`, false, nil},
+		/*  14 */ {`isFloat(3.1)`, true, nil},
+		/*  15 */ {`isString("3.1")`, true, nil},
+		/*  16 */ {`isString("3" + 1)`, true, nil},
+		/*  17 */ {`isList(["3",  1])`, true, nil},
+		/*  18 */ {`isDict({"a":"3",  "b":1})`, true, nil},
+		/*  19 */ {`isFract(1:3)`, true, nil},
+		/*  20 */ {`isFract(3:1)`, false, nil},
+		/*  21 */ {`isRational(3:1)`, true, nil},
+		/*  22 */ {`fract("2.2(3)")`, newFraction(67, 30), nil},
+		/*  23 */ {`fract("1.21(3)")`, newFraction(91, 75), nil},
+		/*  24 */ {`fract(1.21(3))`, newFraction(91, 75), nil},
+		/*  25 */ {`fract(1.21)`, newFraction(121, 100), nil},
+		/*  26 */ {`dec(2)`, float64(2), nil},
+		/*  27 */ {`dec(2.0)`, float64(2), nil},
+		/*  28 */ {`dec("2.0")`, float64(2), nil},
+		/*  29 */ {`dec(true)`, float64(1), nil},
+		/*  30 */ {`dec(true")`, nil, "[1:11] expected one of `,`, `)`, got `\"`"},
+		/*  31 */ {`dec()`, nil, `dec(): too few params -- expected 1, got 0`},
+		/*  32 */ {`dec(1,2,3)`, nil, `dec(): too many params -- expected 1, got 3`},
+		/*  33 */ {`isBool(false)`, true, nil},
+		/*  34 */ {`fract(1:2)`, newFraction(1, 2), nil},
+		/*  35 */ {`fract(12,2)`, newFraction(6, 1), nil},
+		/*  36 */ {`bool(2)`, true, nil},
+		/*  37 */ {`bool(1:2)`, true, nil},
+		/*  38 */ {`bool(1.0)`, true, nil},
+		/*  39 */ {`bool("1")`, true, nil},
+		/*  40 */ {`bool(false)`, false, nil},
+		/*  41 */ {`bool([1])`, true, nil},
+		/*  42 */ {`bool([])`, false, nil},
+		/*  43 */ {`bool({})`, false, nil},
+		/*  44 */ {`bool({1:"one"})`, true, nil},
+		/*  45 */ {`dec(false)`, float64(0), nil},
+		/*  46 */ {`dec(1:2)`, float64(0.5), nil},
+		/*  47 */ {`dec([1])`, nil, `dec(): can't convert list to float`},
+		/*  48 */ {`eval("a=3"); a`, int64(3), nil},
+		/*  49 */ {`int(5:2)`, int64(2), nil},
+
+		// /*  45 */ {`string([1])`, nil, `string(): can't convert list to string`},
+	}
+
+	t.Setenv("EXPR_PATH", ".")
+
+	// runTestSuiteSpec(t, section, inputs, 49)
+	runTestSuite(t, section, inputs)
+}

t_builtin-fmt_test.go

@@ -0,0 +1,48 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_builtin-fmt.go
+package expr
+
+import (
+	// "errors"
+	"bytes"
+	"fmt"
+	"testing"
+)
+
+func TestFuncFmt(t *testing.T) {
+	section := "Builtin-Fmt"
+
+	inputs := []inputType{
+		/*   1 */ {`builtin "fmt"; print("ciao")`, int64(4), nil},
+		/*   2 */ {`builtin "fmt"; println(" ciao")`, int64(6), nil},
+	}
+
+	//t.Setenv("EXPR_PATH", ".")
+
+	// runTestSuiteSpec(t, section, inputs, 1)
+	runTestSuite(t, section, inputs)
+}
+
+func TestFmt(t *testing.T) {
+	section := "Builtin-Fmt"
+
+	text := "ciao mondo"
+	inputs := []inputType{
+		/*   1 */ {fmt.Sprintf(`builtin "fmt"; println("%s")`, text), int64(11), nil},
+	}
+
+	// t.Setenv("EXPR_PATH", ".")
+
+	var b bytes.Buffer
+	ctx := NewSimpleStore()
+	currentStdout := SetCtrl(ctx, ControlStdout, &b)
+
+	runCtxTestSuite(t, ctx, section, inputs)
+
+	SetCtrl(ctx, ControlStdout, currentStdout)
+	if b.String() != text+"\n" {
+		t.Errorf("println(): Got: %q, Want: %q", b.String(), text+"\n")
+	}
+}

t_builtin-import_test.go

@@ -0,0 +1,24 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_builtin-import_test.go
+package expr
+
+import (
+	"testing"
+)
+
+func TestFuncImport(t *testing.T) {
+	section := "Builtin-Import"
+	inputs := []inputType{
+		/*   1 */ {`builtin "import"; import("./test-resources/test-funcs.expr"); (double(3+a) + 1) * two()`, int64(34), nil},
+		/*   2 */ {`builtin "import"; import("test-funcs.expr"); (double(3+a) + 1) * two()`, int64(34), nil},
+		/*   3 */ {`builtin "import"; importAll("./test-resources/test-funcs.expr"); six()`, int64(6), nil},
+		/*   4 */ {`builtin "import"; import("./test-resources/sample-export-all.expr"); six()`, int64(6), nil},
+	}
+
+	t.Setenv("EXPR_PATH", "test-resources")
+
+	//runTestSuiteSpec(t, section, inputs, 1)
+	runTestSuite(t, section, inputs)
+}

t_builtin-iterator_test.go

@@ -0,0 +1,31 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_builtin-iterator.go
+package expr
+
+import (
+	"testing"
+)
+
+func TestFuncRun(t *testing.T) {
+	section := "Builtin-Iterator"
+
+	inputs := []inputType{
+		/*   1 */ {`builtin "iterator"; it=$(1,2,3); run(it)`, nil, nil},
+		/*   2 */ {`builtin "iterator"; run($(1,2,3), func(index,item){item+10})`, nil, nil},
+		/*   3 */ {`builtin "iterator"; run($(1,2,3), func(index,item){status=status+item; true}, {"status":0})`, int64(6), nil},
+		/*   4 */ {`builtin ["iterator", "fmt"]; run($(1,2,3), func(index,item){println(item+10)})`, nil, nil},
+		/*   5 */ {`builtin "iterator"; run(nil)`, nil, `paramter "iterator" must be an iterator, passed <nil> [nil]`},
+		/*   6 */ {`builtin "iterator"; run($(1,2,3), nil)`, nil, nil},
+		/*   7 */ {`builtin "iterator"; run($(1,2,3), func(){1}, "prrr")`, nil, `paramter "vars" must be a dictionary, passed prrr [string]`},
+		/*   8 */ {`builtin "iterator"; run($(1,2,3), operator=nil)`, nil, nil},
+		/*   9 */ {`builtin "iterator"; run($(1,2,3), operatorx=nil)`, nil, `run(): unknown param "operatorx"`},
+		/*   10 */ {`builtin ["os.file", "iterator"]; it = fileReadIterator("test-file.txt"); run(it)`, nil, nil},
+	}
+
+	//t.Setenv("EXPR_PATH", ".")
+
+	runTestSuiteSpec(t, section, inputs, 10)
+	// runTestSuite(t, section, inputs)
+}