operator-post-inc.go: new post int decrement operator '--'

This feature is implemented by expansion, not by dedicated operators, e.g. a*=2+x is exapanded as a=a*(2+x)

ast.go

@@ -8,12 +8,6 @@ import (
 	"strings"
 )
 
-type Expr interface {
-	Eval(ctx ExprContext) (result any, err error)
-	eval(ctx ExprContext, preset bool) (result any, err error)
-	String() string
-}
-
 //-------- ast
 
 type ast struct {
@@ -25,65 +19,69 @@ func NewAst() *ast {
 	return &ast{}
 }
 
-func (self *ast) ToForest() {
+func (expr *ast) TypeName() string {
-	if self.root != nil {
+	return "Expression"
-		if self.forest == nil {
+}
-			self.forest = make([]*term, 0)
+
+func (expr *ast) ToForest() {
+	if expr.root != nil {
+		if expr.forest == nil {
+			expr.forest = make([]*term, 0)
 		}
-		self.forest = append(self.forest, self.root)
+		expr.forest = append(expr.forest, expr.root)
-		self.root = nil
+		expr.root = nil
 	}
 }
 
-func (self *ast) String() string {
+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) {
+// func (expr *ast) addToken(tk *Token) (err error) {
-	_, err = self.addToken2(tk)
+// 	_, err = expr.addToken2(tk)
-	return
+// 	return
-}
+// }
 
-func (self *ast) addToken2(tk *Token) (t *term, err error) {
+func (expr *ast) addToken(tk *Token) (t *term, err error) {
 	if t = newTerm(tk); t != nil {
-		err = self.addTerm(t)
+		err = expr.addTerm(t)
 	} else {
 		err = tk.Errorf("unexpected token %q", tk.String())
 	}
 	return
 }
 
-func (self *ast) addTerm(node *term) (err error) {
+func (expr *ast) addTerm(node *term) (err error) {
-	if self.root == nil {
+	if expr.root == nil {
-		self.root = node
+		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()
-			if subRoot, err = self.insert(last, node); err == nil {
+			if subRoot, err = expr.insert(last, node); err == nil {
 				subRoot.setParent(tree)
 			}
 		} else {
@@ -98,26 +96,20 @@ func (self *ast) insert(tree, node *term) (root *term, err error) {
 	return
 }
 
-func (self *ast) Finish() {
+func (expr *ast) Finish() {
-	if self.root == nil && self.forest != nil && len(self.forest) >= 1 {
+	if expr.root == nil && expr.forest != nil && len(expr.forest) >= 1 {
-		self.root = self.forest[len(self.forest)-1]
+		expr.root = expr.forest[len(expr.forest)-1]
-		self.forest = self.forest[0 : len(self.forest)-1]
+		expr.forest = expr.forest[0 : len(expr.forest)-1]
 	}
 }
 
-func (self *ast) Eval(ctx ExprContext) (result any, err error) {
+func (expr *ast) Eval(ctx ExprContext) (result any, err error) {
-	return self.eval(ctx, true)
+	expr.Finish()
-}
 
-func (self *ast) eval(ctx ExprContext, preset bool) (result any, err error) {
+	if expr.root != nil {
-	self.Finish()
+		// initDefaultVars(ctx)
-
+		if expr.forest != nil {
-	if self.root != nil {
+			for _, root := range expr.forest {
-		if preset {
-			initDefaultVars(ctx)
-		}
-		if self.forest != nil {
-			for _, root := range self.forest {
 				if result, err = root.compute(ctx); err == nil {
 					ctx.UnsafeSetVar(ControlLastResult, result)
 				} else {
@@ -127,7 +119,7 @@ func (self *ast) eval(ctx ExprContext, preset bool) (result any, err error) {
 			}
 		}
 		if err == nil {
-			if result, err = self.root.compute(ctx); err == nil {
+			if result, err = expr.root.compute(ctx); err == nil {
 				ctx.UnsafeSetVar(ControlLastResult, result)
 			}
 		}

bind-expr-functions.go

@@ -0,0 +1,60 @@
+// 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 newExprFunctor(e Expr, params []string, ctx ExprContext) *exprFunctor {
+// 	return &exprFunctor{expr: e, params: params, defCtx: ctx}
+// }
+
+func newExprFunctor(e Expr, params []ExprFuncParam, ctx ExprContext) *exprFunctor {
+	var defCtx ExprContext
+	if ctx != nil {
+//		if ctx.GetParent() != nil {
+//			defCtx = ctx.Clone()
+//			defCtx.SetParent(ctx)
+//		} else {
+			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) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
+	// if functor.defCtx != nil {
+	// 	ctx.Merge(functor.defCtx)
+	// }
+
+	for i, p := range functor.params {
+		if i < len(args) {
+			arg := args[i]
+			if funcArg, ok := arg.(Functor); ok {
+				paramSpecs := funcArg.GetParams()
+				ctx.RegisterFunc(p.Name(), funcArg, TypeAny, paramSpecs)
+			} else {
+				ctx.UnsafeSetVar(p.Name(), arg)
+			}
+		} else {
+			ctx.UnsafeSetVar(p.Name(), nil)
+		}
+	}
+	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) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
+	return functor.f(ctx, name, args)
+}

builtin-base.go

@@ -1,10 +1,11 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// func-builtins.go
+// builtin-base.go
 package expr
 
 import (
+	"fmt"
 	"math"
 	"strconv"
 )
@@ -67,7 +68,7 @@ func boolFunc(ctx ExprContext, name string, args []any) (result any, err error)
 	case string:
 		result = len(v) > 0
 	default:
-		err = errCantConvert(name, v, "bool")
+		err = ErrCantConvert(name, v, "bool")
 	}
 	return
 }
@@ -90,7 +91,7 @@ func intFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 			result = int64(i)
 		}
 	default:
-		err = errCantConvert(name, v, "int")
+		err = ErrCantConvert(name, v, "int")
 	}
 	return
 }
@@ -115,7 +116,33 @@ func decFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	case *FractionType:
 		result = v.toFloat()
 	default:
-		err = errCantConvert(name, v, "float")
+		err = ErrCantConvert(name, v, "float")
+	}
+	return
+}
+
+func stringFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+	switch v := args[0].(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
 }
@@ -127,9 +154,9 @@ func fractFunc(ctx ExprContext, name string, args []any) (result any, err error)
 		if len(args) > 1 {
 			var ok bool
 			if den, ok = args[1].(int64); !ok {
-				err = errExpectedGot(name, "integer", args[1])
+				err = ErrExpectedGot(name, "integer", args[1])
 			} else if den == 0 {
-				err = errFuncDivisionByZero(name)
+				err = ErrFuncDivisionByZero(name)
 			}
 		}
 		if err == nil {
@@ -148,39 +175,40 @@ func fractFunc(ctx ExprContext, name string, args []any) (result any, err error)
 	case *FractionType:
 		result = v
 	default:
-		err = errCantConvert(name, v, "float")
+		err = ErrCantConvert(name, v, "float")
 	}
 	return
 }
 
-func iteratorFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+// func iteratorFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	return
+// 	return
-}
+// }
 
 func ImportBuiltinsFuncs(ctx ExprContext) {
 	anyParams := []ExprFuncParam{
-		newFuncParam(paramValue),
+		NewFuncParam(ParamValue),
 	}
 
-	ctx.RegisterFunc("isNil", newGolangFunctor(isNilFunc), typeBoolean, anyParams)
+	ctx.RegisterFunc("isNil", NewGolangFunctor(isNilFunc), TypeBoolean, anyParams)
-	ctx.RegisterFunc("isInt", newGolangFunctor(isIntFunc), typeBoolean, anyParams)
+	ctx.RegisterFunc("isInt", NewGolangFunctor(isIntFunc), TypeBoolean, anyParams)
-	ctx.RegisterFunc("isFloat", newGolangFunctor(isFloatFunc), typeBoolean, anyParams)
+	ctx.RegisterFunc("isFloat", NewGolangFunctor(isFloatFunc), TypeBoolean, anyParams)
-	ctx.RegisterFunc("isBool", newGolangFunctor(isBoolFunc), typeBoolean, anyParams)
+	ctx.RegisterFunc("isBool", NewGolangFunctor(isBoolFunc), TypeBoolean, anyParams)
-	ctx.RegisterFunc("isString", newGolangFunctor(isStringFunc), typeBoolean, anyParams)
+	ctx.RegisterFunc("isString", NewGolangFunctor(isStringFunc), TypeBoolean, anyParams)
-	ctx.RegisterFunc("isFract", newGolangFunctor(isFractionFunc), typeBoolean, anyParams)
+	ctx.RegisterFunc("isFract", NewGolangFunctor(isFractionFunc), TypeBoolean, anyParams)
-	ctx.RegisterFunc("isRational", newGolangFunctor(isRationalFunc), typeBoolean, anyParams)
+	ctx.RegisterFunc("isRational", NewGolangFunctor(isRationalFunc), TypeBoolean, anyParams)
-	ctx.RegisterFunc("isList", newGolangFunctor(isListFunc), typeBoolean, anyParams)
+	ctx.RegisterFunc("isList", NewGolangFunctor(isListFunc), TypeBoolean, anyParams)
-	ctx.RegisterFunc("isDict", newGolangFunctor(isDictionaryFunc), typeBoolean, anyParams)
+	ctx.RegisterFunc("isDict", NewGolangFunctor(isDictionaryFunc), TypeBoolean, anyParams)
 
-	ctx.RegisterFunc("bool", newGolangFunctor(boolFunc), typeBoolean, anyParams)
+	ctx.RegisterFunc("bool", NewGolangFunctor(boolFunc), TypeBoolean, anyParams)
-	ctx.RegisterFunc("int", newGolangFunctor(intFunc), typeInt, anyParams)
+	ctx.RegisterFunc("int", NewGolangFunctor(intFunc), TypeInt, anyParams)
-	ctx.RegisterFunc("dec", newGolangFunctor(decFunc), typeFloat, anyParams)
+	ctx.RegisterFunc("dec", NewGolangFunctor(decFunc), TypeFloat, anyParams)
-	ctx.RegisterFunc("fract", newGolangFunctor(fractFunc), typeFraction, []ExprFuncParam{
+	ctx.RegisterFunc("string", NewGolangFunctor(stringFunc), TypeString, anyParams)
-		newFuncParam(paramValue),
+	ctx.RegisterFunc("fract", NewGolangFunctor(fractFunc), TypeFraction, []ExprFuncParam{
-		newFuncParamFlagDef("denominator", pfOptional, 1),
+		NewFuncParam(ParamValue),
+		NewFuncParamFlagDef("denominator", PfDefault, 1),
 	})
 }
 
 func init() {
-	registerImport("base", ImportBuiltinsFuncs, "Base expression tools like isNil(), int(), etc.")
+	RegisterBuiltinModule("base", ImportBuiltinsFuncs, "Base expression tools like isNil(), int(), etc.")
 }

builtin-fmt.go

@@ -0,0 +1,51 @@
+// 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 []any) (result any, err error) {
+	var n int
+	if n, err = fmt.Fprint(getStdout(ctx), args...); err == nil {
+		result = int64(n)
+	}
+	return
+}
+
+func printLnFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+	var n int
+	if n, err = fmt.Fprintln(getStdout(ctx), args...); err == nil {
+		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,75 @@
+// 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 []any) (result any, err error) {
+	return importGeneral(ctx, name, args)
+}
+
+func importAllFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+	CtrlEnable(ctx, control_export_all)
+	return importGeneral(ctx, name, args)
+}
+
+func importGeneral(ctx ExprContext, name string, args []any) (result any, err error) {
+	dirList := buildSearchDirList("sources", ENV_EXPR_SOURCE_PATH)
+	result, err = doImport(ctx, name, dirList, NewArrayIterator(args))
+	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, true, true); 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,103 @@
+// 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 []any) (it Iterator, op Functor, err error) {
+	var ok bool
+
+	if it, ok = args[0].(Iterator); !ok {
+		err = fmt.Errorf("paramter %q must be an iterator, passed %v [%s]", ParamIterator, args[0], TypeName(args[0]))
+		return
+	}
+
+	if len(args) > 1 {
+		if op, ok = args[1].(Functor); !ok || op == nil {
+			err = fmt.Errorf("paramter %q must be a function, passed %v [%s]", iterParamOperator, args[1], TypeName(args[1]))
+			return
+		}
+		if len(args) > 2 {
+			var vars *DictType
+			if vars, ok = args[2].(*DictType); !ok || vars == nil {
+				err = fmt.Errorf("paramter %q must be a dictionary, passed %v [%s]", iterParamVars, args[2], TypeName(args[2]))
+				return
+			}
+			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 []any) (result any, err error) {
+	var it Iterator
+	var ok bool
+	var op Functor
+	var v any
+	var usingDefaultOp = false
+	var params []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 = []any{item}
+		} else {
+			params = []any{it.Index(), item}
+		}
+
+		if v, err = op.Invoke(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 {
+		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

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// funcs-math.go
+// builtin-math-arith.go
 package expr
 
 import (
@@ -34,8 +34,8 @@ func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result
 			if v, err = doAdd(ctx, name, subIter, count, level); err != nil {
 				break
 			}
-			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(cleanName) {
+			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(CleanName) {
-				if _, err = extIter.CallOperation(cleanName, nil); err != nil {
+				if _, err = extIter.CallOperation(CleanName, nil); err != nil {
 					return
 				}
 			}
@@ -107,8 +107,8 @@ func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result
 			if v, err = doMul(ctx, name, subIter, count, level); err != nil {
 				break
 			}
-			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(cleanName) {
+			if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(CleanName) {
-				if _, err = extIter.CallOperation(cleanName, nil); err != nil {
+				if _, err = extIter.CallOperation(CleanName, nil); err != nil {
 					return
 				}
 			}
@@ -167,15 +167,15 @@ func mulFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 }
 
 func ImportMathFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("add", &golangFunctor{f: addFunc}, typeNumber, []ExprFuncParam{
+	ctx.RegisterFunc("add", &golangFunctor{f: addFunc}, TypeNumber, []ExprFuncParam{
-		newFuncParamFlagDef(paramValue, pfOptional|pfRepeat, int64(0)),
+		NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(0)),
 	})
 
-	ctx.RegisterFunc("mul", &golangFunctor{f: mulFunc}, typeNumber, []ExprFuncParam{
+	ctx.RegisterFunc("mul", &golangFunctor{f: mulFunc}, TypeNumber, []ExprFuncParam{
-		newFuncParamFlagDef(paramValue, pfOptional|pfRepeat, int64(1)),
+		NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(1)),
 	})
 }
 
 func init() {
-	registerImport("math.arith", ImportMathFuncs, "Functions add() and mul()")
+	RegisterBuiltinModule("math.arith", ImportMathFuncs, "Functions add() and mul()")
 }

builtin-os-file.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// func-os.go
+// builtin-os-file.go
 package expr
 
 import (
@@ -68,7 +68,7 @@ func createFileFunc(ctx ExprContext, name string, args []any) (result any, err e
 			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
 		}
 	} else {
-		err = errMissingFilePath("createFile")
+		err = errMissingFilePath(name)
 	}
 	return
 }
@@ -80,7 +80,7 @@ func openFileFunc(ctx ExprContext, name string, args []any) (result any, err err
 			result = &osReader{fh: fh, reader: bufio.NewReader(fh)}
 		}
 	} else {
-		err = errMissingFilePath("openFile")
+		err = errMissingFilePath(name)
 	}
 	return
 }
@@ -92,7 +92,7 @@ func appendFileFunc(ctx ExprContext, name string, args []any) (result any, err e
 			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
 		}
 	} else {
-		err = errMissingFilePath("openFile")
+		err = errMissingFilePath(name)
 	}
 	return
 }
@@ -118,13 +118,13 @@ func closeFileFunc(ctx ExprContext, name string, args []any) (result any, err er
 		}
 	}
 	if err == nil && (handle == nil || invalidFileHandle != nil) {
-		err = errInvalidFileHandle("closeFileFunc", handle)
+		err = errInvalidFileHandle(name, handle)
 	}
 	result = err == nil
 	return
 }
 
-func writeFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func fileWriteTextFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	var handle osHandle
 	var invalidFileHandle any
 	var ok bool
@@ -142,12 +142,12 @@ func writeFileFunc(ctx ExprContext, name string, args []any) (result any, err er
 	}
 
 	if err == nil && (handle == nil || invalidFileHandle != nil) {
-		err = errInvalidFileHandle("writeFileFunc", invalidFileHandle)
+		err = errInvalidFileHandle(name, invalidFileHandle)
 	}
 	return
 }
 
-func readFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func fileReadTextFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	var handle osHandle
 	var invalidFileHandle any
 	var ok bool
@@ -165,50 +165,86 @@ func readFileFunc(ctx ExprContext, name string, args []any) (result any, err err
 				limit = s[0]
 			}
 
-			if v, err = r.reader.ReadString(limit); err == nil {
+			v, err = r.reader.ReadString(limit)
-				if len(v) > 0 && v[len(v)-1] == 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
 				}
 			}
-			if err == io.EOF {
-				err = nil
-			}
 		} else {
 			invalidFileHandle = handle
 		}
 	}
 
 	if err == nil && (handle == nil || invalidFileHandle != nil) {
-		err = errInvalidFileHandle("readFileFunc", invalidFileHandle)
+		err = errInvalidFileHandle(name, invalidFileHandle)
+	}
+	return
+}
+
+func fileReadTextAllFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+	var handle osHandle
+	var invalidFileHandle any
+	var ok bool
+
+	result = nil
+	if handle, ok = args[0].(osHandle); !ok || args[0] == nil {
+		invalidFileHandle = args[0]
+	}
+
+	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("openFile", newGolangFunctor(openFileFunc), typeHandle, []ExprFuncParam{
+	ctx.RegisterFunc("fileOpen", NewGolangFunctor(openFileFunc), TypeHandle, []ExprFuncParam{
-		newFuncParam(paramFilepath),
+		NewFuncParam(ParamFilepath),
 	})
-	ctx.RegisterFunc("appendFile", newGolangFunctor(appendFileFunc), typeHandle, []ExprFuncParam{
+
-		newFuncParam(paramFilepath),
+	ctx.RegisterFunc("fileAppend", NewGolangFunctor(appendFileFunc), TypeHandle, []ExprFuncParam{
+		NewFuncParam(ParamFilepath),
 	})
-	ctx.RegisterFunc("createFile", newGolangFunctor(createFileFunc), typeHandle, []ExprFuncParam{
+
-		newFuncParam(paramFilepath),
+	ctx.RegisterFunc("fileCreate", NewGolangFunctor(createFileFunc), TypeHandle, []ExprFuncParam{
+		NewFuncParam(ParamFilepath),
 	})
-	ctx.RegisterFunc("writeFile", newGolangFunctor(writeFileFunc), typeInt, []ExprFuncParam{
+
-		newFuncParam(typeHandle),
+	ctx.RegisterFunc("fileClose", NewGolangFunctor(closeFileFunc), TypeBoolean, []ExprFuncParam{
-		newFuncParamFlagDef(typeItem, pfOptional|pfRepeat, ""),
+		NewFuncParam(TypeHandle),
 	})
-	ctx.RegisterFunc("readFile", newGolangFunctor(readFileFunc), typeString, []ExprFuncParam{
+
-		newFuncParam(typeHandle),
+	ctx.RegisterFunc("fileWriteText", NewGolangFunctor(fileWriteTextFunc), TypeInt, []ExprFuncParam{
-		newFuncParamFlagDef("limitCh", pfOptional, "\n"),
+		NewFuncParam(TypeHandle),
+		NewFuncParamFlagDef(TypeItem, PfDefault|PfRepeat, ""),
 	})
-	ctx.RegisterFunc("closeFile", newGolangFunctor(closeFileFunc), typeBoolean, []ExprFuncParam{
+
-		newFuncParam(typeHandle),
+	ctx.RegisterFunc("fileReadText", NewGolangFunctor(fileReadTextFunc), TypeString, []ExprFuncParam{
+		NewFuncParam(TypeHandle),
+		NewFuncParamFlagDef("limitCh", PfDefault, "\n"),
+	})
+
+	ctx.RegisterFunc("fileReadTextAll", NewGolangFunctor(fileReadTextAllFunc), TypeString, []ExprFuncParam{
+		NewFuncParam(TypeHandle),
 	})
 }
 
 func init() {
-	registerImport("os.file", ImportOsFuncs, "Operating system file functions")
+	RegisterBuiltinModule("os.file", ImportOsFuncs, "Operating system file functions")
 }

builtin-string.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// func-string.go
+// builtin-string.go
 package expr
 
 import (
@@ -21,11 +21,11 @@ func doJoinStr(funcName string, sep string, it Iterator) (result any, err error)
 		if s, ok := v.(string); ok {
 			sb.WriteString(s)
 		} else {
-			err = errExpectedGot(funcName, typeString, v)
+			err = ErrExpectedGot(funcName, TypeString, v)
 			return
 		}
 	}
-	if err == nil || err == io.EOF {
+	if err == io.EOF {
 		err = nil
 		result = sb.String()
 	}
@@ -45,13 +45,13 @@ func joinStrFunc(ctx ExprContext, name string, args []any) (result any, err erro
 			} else if it, ok := args[1].(Iterator); ok {
 				result, err = doJoinStr(name, sep, it)
 			} else {
-				err = errInvalidParameterValue(name, paramParts, args[1])
+				err = ErrInvalidParameterValue(name, ParamParts, args[1])
 			}
 		} else {
 			result, err = doJoinStr(name, sep, NewArrayIterator(args[1:]))
 		}
 	} else {
-		err = errWrongParamType(name, paramSeparator, typeString, args[0])
+		err = ErrWrongParamType(name, ParamSeparator, TypeString, args[0])
 	}
 	return
 }
@@ -63,14 +63,14 @@ func subStrFunc(ctx ExprContext, name string, args []any) (result any, err error
 	var ok bool
 
 	if source, ok = args[0].(string); !ok {
-		return nil, errWrongParamType(name, paramSource, typeString, args[0])
+		return nil, ErrWrongParamType(name, ParamSource, TypeString, args[0])
 	}
 
-	if start, err = toInt(args[1], name+"()"); err != nil {
+	if start, err = ToGoInt(args[1], name+"()"); err != nil {
 		return
 	}
 
-	if count, err = toInt(args[2], name+"()"); err != nil {
+	if count, err = ToGoInt(args[2], name+"()"); err != nil {
 		return
 	}
 
@@ -91,7 +91,7 @@ func trimStrFunc(ctx ExprContext, name string, args []any) (result any, err erro
 	var ok bool
 
 	if source, ok = args[0].(string); !ok {
-		return nil, errWrongParamType(name, paramSource, typeString, args[0])
+		return nil, ErrWrongParamType(name, ParamSource, TypeString, args[0])
 	}
 	result = strings.TrimSpace(source)
 	return
@@ -104,7 +104,7 @@ func startsWithStrFunc(ctx ExprContext, name string, args []any) (result any, er
 	result = false
 
 	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, typeString, args[0])
+		return result, ErrWrongParamType(name, ParamSource, TypeString, args[0])
 	}
 	for i, targetSpec := range args[1:] {
 		if target, ok := targetSpec.(string); ok {
@@ -127,7 +127,7 @@ func endsWithStrFunc(ctx ExprContext, name string, args []any) (result any, err
 	result = false
 
 	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, typeString, args[0])
+		return result, ErrWrongParamType(name, ParamSource, TypeString, args[0])
 	}
 	for i, targetSpec := range args[1:] {
 		if target, ok := targetSpec.(string); ok {
@@ -150,7 +150,7 @@ func splitStrFunc(ctx ExprContext, name string, args []any) (result any, err err
 	var ok bool
 
 	if source, ok = args[0].(string); !ok {
-		return result, errWrongParamType(name, paramSource, typeString, args[0])
+		return result, ErrWrongParamType(name, ParamSource, TypeString, args[0])
 	}
 
 	if sep, ok = args[1].(string); !ok {
@@ -182,42 +182,42 @@ func splitStrFunc(ctx ExprContext, name string, args []any) (result any, err err
 
 // Import above functions in the context
 func ImportStringFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("joinStr", newGolangFunctor(joinStrFunc), typeString, []ExprFuncParam{
+	ctx.RegisterFunc("strJoin", NewGolangFunctor(joinStrFunc), TypeString, []ExprFuncParam{
-		newFuncParam(paramSeparator),
+		NewFuncParam(ParamSeparator),
-		newFuncParamFlag(paramItem, pfRepeat),
+		NewFuncParamFlag(ParamItem, PfRepeat),
 	})
 
-	ctx.RegisterFunc("subStr", newGolangFunctor(subStrFunc), typeString, []ExprFuncParam{
+	ctx.RegisterFunc("strSub", NewGolangFunctor(subStrFunc), TypeString, []ExprFuncParam{
-		newFuncParam(paramSource),
+		NewFuncParam(ParamSource),
-		newFuncParamFlagDef(paramStart, pfOptional, int64(0)),
+		NewFuncParamFlagDef(ParamStart, PfDefault, int64(0)),
-		newFuncParamFlagDef(paramCount, pfOptional, int64(-1)),
+		NewFuncParamFlagDef(ParamCount, PfDefault, int64(-1)),
 	})
 
-	ctx.RegisterFunc("splitStr", newGolangFunctor(splitStrFunc), "list of "+typeString, []ExprFuncParam{
+	ctx.RegisterFunc("strSplit", NewGolangFunctor(splitStrFunc), "list of "+TypeString, []ExprFuncParam{
-		newFuncParam(paramSource),
+		NewFuncParam(ParamSource),
-		newFuncParamFlagDef(paramSeparator, pfOptional, ""),
+		NewFuncParamFlagDef(ParamSeparator, PfDefault, ""),
-		newFuncParamFlagDef(paramCount, pfOptional, int64(-1)),
+		NewFuncParamFlagDef(ParamCount, PfDefault, int64(-1)),
 	})
 
-	ctx.RegisterFunc("trimStr", newGolangFunctor(trimStrFunc), typeString, []ExprFuncParam{
+	ctx.RegisterFunc("strTrim", NewGolangFunctor(trimStrFunc), TypeString, []ExprFuncParam{
-		newFuncParam(paramSource),
+		NewFuncParam(ParamSource),
 	})
 
-	ctx.RegisterFunc("startsWithStr", newGolangFunctor(startsWithStrFunc), typeBoolean, []ExprFuncParam{
+	ctx.RegisterFunc("strStartsWith", NewGolangFunctor(startsWithStrFunc), TypeBoolean, []ExprFuncParam{
-		newFuncParam(paramSource),
+		NewFuncParam(ParamSource),
-		newFuncParam(paramPrefix),
+		NewFuncParam(ParamPrefix),
-		newFuncParamFlag("other "+paramPrefix, pfRepeat),
+		NewFuncParamFlag("other "+ParamPrefix, PfRepeat),
 	})
 
-	ctx.RegisterFunc("endsWithStr", newGolangFunctor(endsWithStrFunc), typeBoolean, []ExprFuncParam{
+	ctx.RegisterFunc("strEndsWith", NewGolangFunctor(endsWithStrFunc), TypeBoolean, []ExprFuncParam{
-		newFuncParam(paramSource),
+		NewFuncParam(ParamSource),
-		newFuncParam(paramSuffix),
+		NewFuncParam(ParamSuffix),
-		newFuncParamFlag("other "+paramSuffix, pfRepeat),
+		NewFuncParamFlag("other "+ParamSuffix, PfRepeat),
 	})
 }
 
 // Register the import function in the import-register.
 // That will allow to import all function of this module by the "builtin" operator."
 func init() {
-	registerImport("string", ImportStringFuncs, "string utilities")
+	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-slider.go

@@ -18,17 +18,17 @@ func NewByteSlider(size int) *ByteSlider {
 	}
 }
 
-func (self *ByteSlider) PushEnd(b byte) {
+func (slider *ByteSlider) PushEnd(b byte) {
-	if self.length == cap(self.buf) {
+	if slider.length == cap(slider.buf) {
-		self.length--
+		slider.length--
-		for i := 0; i < self.length; i++ {
+		for i := 0; i < slider.length; i++ {
-			self.buf[i] = self.buf[i+1]
+			slider.buf[i] = slider.buf[i+1]
 		}
 	}
-	self.buf[self.length] = b
+	slider.buf[slider.length] = b
-	self.length++
+	slider.length++
 }
 
-func (self *ByteSlider) Equal(target []byte) bool {
+func (slider *ByteSlider) Equal(target []byte) bool {
-	return target != nil && bytes.Equal(self.buf, target)
+	return target != nil && bytes.Equal(slider.buf, target)
 }

common-errors.go

@@ -8,7 +8,7 @@ import (
 	"fmt"
 )
 
-func errTooFewParams(funcName string, minArgs, maxArgs, argCount int) (err error) {
+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 {
@@ -17,39 +17,45 @@ func errTooFewParams(funcName string, minArgs, maxArgs, argCount int) (err error
 	return
 }
 
-func errTooMuchParams(funcName string, maxArgs, argCount int) (err error) {
+func ErrTooMuchParams(funcName string, maxArgs, argCount int) (err error) {
 	err = fmt.Errorf("%s(): too much params -- expected %d, got %d", funcName, maxArgs, argCount)
 	return
 }
 
 // --- General errors
 
-func errCantConvert(funcName string, value any, kind string) error {
+func ErrCantConvert(funcName string, value any, kind string) error {
-	return fmt.Errorf("%s(): can't convert %s to %s", funcName, typeName(value), kind)
+	return fmt.Errorf("%s(): can't convert %s to %s", funcName, TypeName(value), kind)
 }
 
-func errExpectedGot(funcName string, kind string, value any) error {
+func ErrExpectedGot(funcName string, kind string, value any) error {
-	return fmt.Errorf("%s() expected %s, got %s (%v)", funcName, kind, typeName(value), value)
+	return fmt.Errorf("%s(): expected %s, got %s (%v)", funcName, kind, TypeName(value), value)
 }
 
-func errFuncDivisionByZero(funcName string) error {
+func ErrFuncDivisionByZero(funcName string) error {
 	return fmt.Errorf("%s(): division by zero", funcName)
 }
 
-func errDivisionByZero() error {
+// func ErrDivisionByZero() error {
-	return fmt.Errorf("division by zero")
+// 	return fmt.Errorf("division by zero")
-}
+// }
 
 // --- Parameter errors
 
-func errMissingRequiredParameter(funcName, paramName string) error {
+// func ErrMissingRequiredParameter(funcName, paramName string) error {
-	return fmt.Errorf("%s() missing required parameter %q", funcName, paramName)
+// 	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 errInvalidParameterValue(funcName, paramName string, paramValue any) error {
+func ErrWrongParamType(funcName, paramName, paramType string, paramValue any) error {
-	return fmt.Errorf("%s() invalid value %s (%v) for parameter %q", funcName, typeName(paramValue), paramValue, paramName)
+	return fmt.Errorf("%s(): the %q parameter must be a %s, got a %s (%v)", funcName, paramName, paramType, TypeName(paramValue), paramValue)
 }
 
-func errWrongParamType(funcName, paramName, paramType string, paramValue any) error {
+// --- Operator errors
-	return fmt.Errorf("%s() the %q parameter must be a %s, got a %s (%v)", funcName, paramName, paramType, typeName(paramValue), paramValue)
+
+func ErrLeftOperandMustBeVariable(leftTerm, opTerm *term) error {
+	return leftTerm.Errorf("left operand of %q must be a variable", opTerm.source())
 }

common-params.go

@@ -5,17 +5,24 @@
 package expr
 
 const (
-	paramCount     = "count"
+	ParamCount     = "count"
-	paramItem      = "item"
+	ParamItem      = "item"
-	paramParts     = "parts"
+	ParamParts     = "parts"
-	paramSeparator = "separator"
+	ParamSeparator = "separator"
-	paramSource    = "source"
+	ParamSource    = "source"
-	paramSuffix    = "suffix"
+	ParamSuffix    = "suffix"
-	paramPrefix    = "prefix"
+	ParamPrefix    = "prefix"
-	paramStart     = "start"
+	ParamStart     = "start"
-	paramEnd       = "end"
+	ParamEnd       = "end"
-	paramValue     = "value"
+	ParamValue     = "value"
-	paramEllipsis  = "..."
+	ParamName      = "name"
-	paramFilepath  = "filepath"
+	ParamEllipsis  = "..."
-	paramDirpath   = "dirpath"
+	ParamFilepath  = "filepath"
+	ParamDirpath   = "dirpath"
+	ParamIterator  = "iterator"
+)
+
+// to be moved in its own source file
+const (
+	ConstLastIndex = 0xFFFF_FFFF
 )

common-type-names.go

@@ -5,14 +5,16 @@
 package expr
 
 const (
-	typeAny      = "any"
+	TypeAny      = "any"
-	typeBoolean  = "boolean"
+	TypeBoolean  = "boolean"
-	typeFloat    = "float"
+	TypeFloat    = "float"
-	typeFraction = "fraction"
+	TypeFraction = "fraction"
-	typeHandle   = "handle"
+	TypeHandle   = "handle"
-	typeInt      = "integer"
+	TypeInt      = "integer"
-	typeItem     = "item"
+	TypeItem     = "item"
-	typeNumber   = "number"
+	TypeNumber   = "number"
-	typePair     = "pair"
+	TypePair     = "pair"
-	typeString   = "string"
+	TypeString   = "string"
+	TypeListOf = "list-of-"
+	TypeListOfStrings = "list-of-strings"
 )

context-helpers.go

@@ -22,13 +22,11 @@ func exportFunc(ctx ExprContext, name string, info ExprFunc) {
 	if name[0] == '@' {
 		name = name[1:]
 	}
-	// ctx.RegisterFunc(name, info.Functor(), info.MinArgs(), info.MaxArgs())
-	// ctx.RegisterFuncInfo(name, info)
 	ctx.RegisterFunc(name, info.Functor(), info.ReturnType(), info.Params())
 }
 
 func exportObjects(destCtx, sourceCtx ExprContext) {
-	exportAll := isEnabled(sourceCtx, control_export_all)
+	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] == '@' }) {
@@ -43,3 +41,9 @@ func exportObjects(destCtx, sourceCtx ExprContext) {
 		}
 	}
 }
+
+func exportObjectsToParent(sourceCtx ExprContext) {
+	if parentCtx := sourceCtx.GetParent(); parentCtx != nil {
+		exportObjects(parentCtx, sourceCtx)
+	}
+}

control.go

@@ -4,13 +4,14 @@
 // control.go
 package expr
 
-import "strings"
-
 // Preset control variables
 const (
-	ControlLastResult   = "last"
+	ControlPreset        = "_preset"
-	ControlBoolShortcut = "_bool_shortcut"
+	ControlLastResult    = "last"
-	ControlImportPath   = "_import_path"
+	ControlBoolShortcut  = "_bool_shortcut"
+	ControlSearchPath    = "_search_path"
+	ControlParentContext = "_parent_context"
+	ControlStdout        = "_stdout"
 )
 
 // Other control variables
@@ -20,43 +21,20 @@ const (
 
 // Initial values
 const (
-	init_import_path = "~/.local/lib/go-pkg/expr:/usr/local/lib/go-pkg/expr:/usr/lib/go-pkg/expr"
+	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) {
-	ctx.SetVar(ControlBoolShortcut, true)
+	if _, exists := ctx.GetVar(ControlPreset); exists {
-	ctx.SetVar(ControlImportPath, init_import_path)
+		return
-}
-
-func enable(ctx ExprContext, name string) {
-	if strings.HasPrefix(name, "_") {
-		ctx.SetVar(name, true)
-	} else {
-		ctx.SetVar("_"+name, true)
 	}
-}
+	ctx.UnsafeSetVar(ControlPreset, true)
-
+	ctx.UnsafeSetVar(ControlBoolShortcut, true)
-func disable(ctx ExprContext, name string) {
+	ctx.UnsafeSetVar(ControlSearchPath, init_search_path)
-	if strings.HasPrefix(name, "_") {
-		ctx.SetVar(name, false)
-	} else {
-		ctx.SetVar("_"+name, false)
-	}
-}
-
-func isEnabled(ctx ExprContext, name string) (status bool) {
-	if v, exists := ctx.GetVar(name); exists {
-		if b, ok := v.(bool); ok {
-			status = b
-		}
-	}
-	return
-}
-
-func getControlString(ctx ExprContext, name string) (s string, exists bool) {
-	var v any
-	if v, exists = ctx.GetVar(name); exists {
-		s, exists = v.(string)
-	}
-	return
 }

data-cursor.go

@@ -5,30 +5,49 @@
 package expr
 
 import (
-	"errors"
 	"io"
 )
 
 type dataCursor struct {
-	ds          map[string]Functor
+	ds        map[string]Functor
-	ctx         ExprContext
+	ctx       ExprContext
-	index       int
+	initState bool // true if no item has prodiced yet (this replace di initial Next() call in the contructor)
-	resource    any
+	index     int
-	nextFunc    Functor
+	count     int
-	cleanFunc   Functor
+	current   any
-	resetFunc   Functor
+	lastErr   error
-	currentFunc Functor
+	resource  any
+	nextFunc  Functor
+	cleanFunc Functor
+	resetFunc Functor
 }
 
-func newDataCursor(ctx ExprContext, ds map[string]Functor) (dc *dataCursor) {
+func NewDataCursor(ctx ExprContext, ds map[string]Functor, resource any) (dc *dataCursor) {
 	dc = &dataCursor{
-		ds:    ds,
+		ds:        ds,
-		index: -1,
+		initState: true,
-		ctx:   ctx.Clone(),
+		index:     -1,
+		count:     0,
+		current:   nil,
+		lastErr:   nil,
+		resource:  resource,
+		ctx:       ctx.Clone(),
+		nextFunc:  ds[NextName],
+		cleanFunc: ds[CleanName],
+		resetFunc: ds[ResetName],
 	}
+	//dc.Next()
 	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('{')
@@ -58,7 +77,7 @@ func (dc *dataCursor) String() string {
 }
 
 func (dc *dataCursor) HasOperation(name string) (exists bool) {
-	exists = name == indexName
+	exists = name == IndexName
 	if !exists {
 		f, ok := dc.ds[name]
 		exists = ok && isFunctor(f)
@@ -67,7 +86,7 @@ func (dc *dataCursor) HasOperation(name string) (exists bool) {
 }
 
 func (dc *dataCursor) CallOperation(name string, args []any) (value any, err error) {
-	if name == indexName {
+	if name == IndexName {
 		value = int64(dc.Index())
 	} else if functor, ok := dc.ds[name]; ok && isFunctor(functor) {
 		if functor == dc.cleanFunc {
@@ -89,15 +108,19 @@ func (dc *dataCursor) Reset() (success bool, err error) {
 	if dc.resetFunc != nil {
 		if dc.resource != nil {
 			ctx := cloneContext(dc.ctx)
-			if _, err = dc.resetFunc.Invoke(ctx, resetName, []any{dc.resource}); err == nil {
+			_, err = dc.resetFunc.Invoke(ctx, ResetName, []any{dc.resource})
-				dc.index = -1
-			}
 			exportObjects(dc.ctx, ctx)
+			dc.index = -1
+			dc.count = 0
+			dc.initState = true
+			dc.current = nil
+			dc.lastErr = nil
+			//dc.Next()
 		} else {
 			err = errInvalidDataSource()
 		}
 	} else {
-		err = errNoOperation(resetName)
+		err = errNoOperation(ResetName)
 	}
 	success = err == nil
 	return
@@ -107,48 +130,104 @@ func (dc *dataCursor) Clean() (success bool, err error) {
 	if dc.cleanFunc != nil {
 		if dc.resource != nil {
 			ctx := cloneContext(dc.ctx)
-			_, err = dc.cleanFunc.Invoke(ctx, cleanName, []any{dc.resource})
+			_, err = dc.cleanFunc.Invoke(ctx, CleanName, []any{dc.resource})
-			dc.resource = nil
+			//			dc.resource = nil
 			exportObjects(dc.ctx, ctx)
 		} else {
 			err = errInvalidDataSource()
 		}
 	} else {
-		err = errors.New("no 'clean' function defined in the data-source")
+		err = errNoOperation(CleanName)
 	}
 	success = err == nil
 	return
 }
 
 func (dc *dataCursor) Current() (item any, err error) { // must return io.EOF at the last item
-	ctx := cloneContext(dc.ctx)
+	dc.init()
-	if item, err = dc.currentFunc.Invoke(ctx, currentName, []any{}); err == nil && item == nil {
+
+	if dc.current != nil {
+		item = dc.current
+	} else {
 		err = io.EOF
 	}
-	exportObjects(dc.ctx, ctx)
 	return
 }
 
-func (dc *dataCursor) Next() (item any, err error) { // must return io.EOF after the last item
+func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err error) {
+	var v any
+	var ok bool
+	ctx := cloneContext(dc.ctx)
+	if v, err = filter.Invoke(ctx, FilterName, []any{item, dc.index}); 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)
+	mappedItem, err = mapper.Invoke(ctx, MapName, []any{item, dc.index})
+	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
 	if dc.resource != nil {
-		ctx := cloneContext(dc.ctx)
+		filter := dc.ds[FilterName]
-		// fmt.Printf("Entering Inner-Ctx [%p]: %s\n", ctx, CtxToString(ctx, 0))
+		mapper := dc.ds[MapName]
-		if item, err = dc.nextFunc.Invoke(ctx, nextName, []any{dc.resource}); err == nil {
+		var item any
-			if item == nil {
+		for item == nil && dc.lastErr == nil {
-				err = io.EOF
+			ctx := cloneContext(dc.ctx)
-			} else {
+			dc.index++
-				dc.index++
+			if item, dc.lastErr = dc.nextFunc.Invoke(ctx, NextName, []any{dc.resource, dc.index}); 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()
 		}
-		// fmt.Printf("Exiting Inner-Ctx [%p]: %s\n", ctx, CtxToString(ctx, 0))
-		exportObjects(dc.ctx, ctx)
-		// fmt.Printf("Outer-Ctx [%p]: %s\n", dc.ctx, CtxToString(dc.ctx, 0))
 	} else {
-		err = errInvalidDataSource()
+		dc.lastErr = errInvalidDataSource()
 	}
 	return
 }
 
 func (dc *dataCursor) Index() int {
-	return dc.index
+	return dc.index - 1
+}
+
+func (dc *dataCursor) Count() int {
+	return dc.count
 }

dict-type.go

@@ -12,7 +12,13 @@ import (
 
 type DictType map[any]any
 
-func newDict(dictAny map[any]*term) (dict *DictType) {
+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))
@@ -26,42 +32,67 @@ func newDict(dictAny map[any]*term) (dict *DictType) {
 	return
 }
 
-func (dict *DictType) toMultiLine(sb *strings.Builder, indent int) {
+func newDict(dictAny map[any]*term) (dict *DictType) {
-	sb.WriteString(strings.Repeat("\t", indent))
+	// TODO Change wi a call to NewDict()
-	sb.WriteString("{\n")
+	var d DictType
-
+	if dictAny != nil {
-	first := true
+		d = make(DictType, len(dictAny))
-	for name, value := range *dict {
+		for i, item := range dictAny {
-		if first {
+			d[i] = item
-			first = false
-		} else {
-			sb.WriteByte(',')
-			sb.WriteByte('\n')
-		}
-
-		sb.WriteString(strings.Repeat("\t", indent+1))
-		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(MultiLine))
-		} else if _, ok = value.(Functor); ok {
-			sb.WriteString("func(){}")
-		} else {
-			sb.WriteString(fmt.Sprintf("%v", value))
 		}
+	} else {
+		d = make(DictType)
 	}
-	sb.WriteString(strings.Repeat("\t", indent))
+	dict = &d
-	sb.WriteString("\n}")
+	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
-	if opt&MultiLine != 0 {
+	flags := GetFormatFlags(opt)
-		dict.toMultiLine(&sb, 0)
+	if flags&MultiLine != 0 {
+		dict.toMultiLine(&sb, opt)
 	} else {
 		sb.WriteByte('{')
 		first := true
@@ -124,7 +155,12 @@ func (dict *DictType) merge(second *DictType) {
 }
 
 func (dict *DictType) setItem(key any, value any) (err error) {
-	(*dict)[key]=value
+	(*dict)[key] = value
 	return
 }
 
+////////////////
+
+type DictFormat interface {
+	ToDict() *DictType
+}

doc/Expr.adoc

@@ -9,6 +9,7 @@ Expressions calculator
 :icons: font
 :icon-set: fi
 :numbered:
+:data-uri:
 //:table-caption: Tabella
 //:figure-caption: Diagramma
 :docinfo1:
@@ -19,21 +20,52 @@ Expressions calculator
 :rouge-style: gruvbox
 // :rouge-style: colorful
 //:rouge-style: monokay
+// Work around to manage double-column in back-tick quotes
+:2c: ::
 
 toc::[]
 
-#TODO: Work in progress (last update on 2024/06/02, 08:18 a.m.)#
+#TODO: Work in progress (last update on 2024/06/21, 05:40 a.m.)#
 
 == Expr
 _Expr_ is a GO package capable of analysing, interpreting and calculating expressions.
 
+
 === Concepts and terminology
-#TODO#
+
+Expressions are texts containing sequences of operations represented by a syntax very similar to that of most programming languages. _Expr_ package provides these macro functions:
+
+* *_Scanner_* -- Its input is a text. It scans expression text characters to produce a flow of logical symbol and related attributes, aka tokens.
+* *_Parser_* -- Parser input is the token flow coming from the scanner. It analyses the token flow verifyng if it complies with the _Expr_ syntax. If that is the case, the Parser generates the Abstract Syntax Tree (AST). This is tree data structure that represents the components of an expressions and how they are related one each other.
+* *_Calculator_*. Its input is the AST. It computes the parsed expression contained in the AST and returns the result or an error.
 
 image::expression-diagram.png[]
 
+==== Variables
+_Expr_ supports variables. The result of an expression can be stored in a variable and reused in other espressions simply specifying the name of the variable as an operand.
+
+==== Multi-expression
+An input text valid for _Expr_ can contain more than an expression. Expressions are separated by [blue]`;` (semicolon). When an input contains two or more expressions it is called _multi-expression_.
+
+_Expr_ parses and computes each expression of a multi-espression, from the left to the right. If all expressions are computed without errors, it only returns the value of the last, the right most.
+
+The result of each expression of a multi-expression is stored in an automatic variable named _last_. In this way, each expression can refer to the result of the previous one without the need to assign that value to a new dedicated variable.
+
+==== Calculation context
+All objects, such as variables and functions, created during the calculation of an expression are stored in a memory called _context_.
+
+The expression context is analogous to the stack-frame of other programming languages. When a function is called, a new context is allocated to store local definitions.
+
+Function contexts are created by cloning the calling context. More details on this topic are given later in this document.
+
+_Expr_ creates and keeps a inner _global context_ where it stores imported functions, either from builtin or plugin modules. To perform calculations, the calling program must provide its own context; this is the _main context_. All calculations take place in this context. As mentioned eralier, when a function is called, a new context is created by cloning the calling context. The createt context can be called _function context_.
+
+Imported functions are registerd in the _global context_. When an expression first calls an imported function, that function is linked to the current context; this can be the _main context_ or a _function context_.
+
 === `dev-expr` test tool
-`dev-expr` is a simple program that can be used to evaluate expressions interactively. As its name suggests, it was created for testing purpose.  In fact, in additon to the automatic verification test suite based on the Go test framework, `dev-expr` provides an important aid for quickly testing of new features during their development.
+Before we begin to describe the syntax of _Expr_, it is worth introducing _dev-expr_ because it will be used to show many examples of expressions.
+
+`dev-expr` is a simple program that can be used to evaluate expressions interactively. As its name suggests, it was created for testing purpose.  In fact, in additon to the automatic verification test suite based on the Go test framework, `dev-expr` provided an important aid for quickly testing of new features during their development.
 
 `dev-expr` can work as a _REPL_, _**R**ead-**E**xecute-**P**rint-**L**oop_, or it can process expression acquired from files or standard input.
 
@@ -47,11 +79,10 @@ Here are some examples of execution.
 # Type 'exit' or Ctrl+D to quit the program.
 
 [user]$ ./dev-expr
-expr -- Expressions calculator v1.7.1(build 2),2024/05/16 (celestino.amoroso@portale-stac.it)
+dev-expr -- Expressions calculator v1.10.0(build 14),2024/06/17 (celestino.amoroso@portale-stac.it)
-	Based on the Expr package v0.10.0
+	Based on the Expr package v0.19.0
 	Type help to get the list of available commands
 	See also https://git.portale-stac.it/go-pkg/expr/src/branch/main/README.adoc
-
 >>> help
 --- REPL commands:
       source -- Load a file as input
@@ -61,6 +92,7 @@ expr -- Expressions calculator v1.7.1(build 2),2024/05/16 (celestino.amoroso@por
         help -- Show command list
           ml -- Enable/Disable multi-line output
         mods -- List builtin modules
+      output -- Enable/Disable printing expression results. Options 'on', 'off', 'status'
 
 --- Command line options:
     -b <builtin>       Import builtin modules.
@@ -70,10 +102,11 @@ expr -- Expressions calculator v1.7.1(build 2),2024/05/16 (celestino.amoroso@por
     -i                 Force REPL operation when all -e occurences have been processed
     -h, --help, help   Show this help menu
     -m, --modules      List all builtin modules
+    --noout            Disable printing of expression results
     -p                 Print prefix form
     -t                 Print tree form <2>
-
+    -v, --version      Show program version
->>> 
+>>>
 ----
 
 <1> Only available for single fraction values
@@ -83,8 +116,8 @@ expr -- Expressions calculator v1.7.1(build 2),2024/05/16 (celestino.amoroso@por
 [source,shell]
 ----
 [user]$ ./dev-expr
-expr -- Expressions calculator v1.7.1(build 2),2024/05/16 (celestino.amoroso@portale-stac.it)
+dev-expr -- Expressions calculator v1.10.0(build 14),2024/06/17 (celestino.amoroso@portale-stac.it)
-	Based on the Expr package v0.10.0
+	Based on the Expr package v0.19.0
 	Type help to get the list of available commands
 	See also https://git.portale-stac.it/go-pkg/expr/src/branch/main/README.adoc
 
@@ -101,21 +134,21 @@ expr -- Expressions calculator v1.7.1(build 2),2024/05/16 (celestino.amoroso@por
 7
 -
 6
->>> 1+2 but 5|2+0.5 <4>
+>>> 4+2 but 5|2+0.5 <4>
 3
->>> 1+2; 5|2+0.5 <5>
+>>> 4+2; 5|2+0.5 <5>
 3
 >>>
 ----
 
-<1> Number bases: 0x = hexadecimal, 0o = octal, 0b = binary.
+<1> Number bases: 0x = _hexadecimal_, 0o = _octal_, 0b = _binary_.
-<2> Fractions: numerator | denominator.
+<2> Fractions: _numerator_ | _denominator_.
 <3> Activate multi-line output of fractions.
 <4> But operator, see <<_but_operator>>.
 <5> Multi-expression: the same result of the previous single expression but this it is obtained with two separated calculations.
 
 == Data types
-_Expr_ supports numerical, string, relational, boolean expressions, and mixed-type lists.
+_Expr_ has its type system which is a subset of Golang's type system. It supports numerical, string, relational, boolean expressions, and mixed-type lists and maps.
 
 === Numbers
 _Expr_ supports three type of numbers:
@@ -155,7 +188,7 @@ Value range: *-9223372036854775808* to *9223372036854775807*
 | [blue]`*` | _product_     | Multiply two values       | [blue]`-1 * 2` -> -2
 | [blue]`/` | _Division_    | Divide the left value by the right one^(*)^ | [blue]`-10 / 2` -> 5
 | [blue]`%` | _Modulo_      | Remainder of the integer division | [blue]`5 % 2` -> 1
-|=== 
+|===
 
 ^(*)^ See also the _float division_ [blue]`./` below.
 
@@ -173,15 +206,20 @@ _dec-seq_ = _see-integer-literal-syntax_
 
 .Examples
 `>>>` [blue]`1.0` +
-[green]`1` +
+[green]`1`
+
 `>>>` [blue]`0.123` +
-[green]`0.123` +
+[green]`0.123`
+
 `>>>` [blue]`4.5e+3` +
-[green]`4500` +
+[green]`4500`
+
 `>>>` [blue]`4.5E-33` +
-[green]`4.5e-33` +
+[green]`4.5e-33`
+
 `>>>` [blue]`4.5E-3` +
-[green]`0.0045` +
+[green]`0.0045`
+
 `>>>` [blue]`4.5E10` +
 [green]`4.5e+10`
 
@@ -211,35 +249,43 @@ _digit-seq_ = _see-integer-literal-syntax_
 ====
 
 .Examples
-// [source,go]
-// ----
 `>>>` [blue]`1 | 2` +
-[green]`1|2` +
+[green]`1|2`
+
 `>>>` [blue]`4|6`  [gray]_// Fractions are always reduced to their lowest terms_ +
-[green]`2|3` +
+[green]`2|3`
+
 `>>>` [blue]`1|2 + 2|3` +
-[green]`7|6` +
+[green]`7|6`
+
 `>>>` [blue]`1|2 * 2|3` +
-[green]`1|3` +
+[green]`1|3`
+
 `>>>` [blue]`1|2 / 1|3` +
-[green]`3|2` +
+[green]`3|2`
+
 `>>>` [blue]`1|2 ./ 1|3` [gray]_// Force decimal division_ +
-[green]`1.5` +
+[green]`1.5`
+
 `>>>` [blue]`-1|2` +
-[green]`-1|2` +
+[green]`-1|2`
+
 `>>>` [blue]`1|-2` [gray]_// Invalid sign specification_ +
-[red]_Eval Error: [1:3] infix operator "|" requires two non-nil operands, got 1_ +
+[red]_Eval Error: [1:3] infix operator "|" requires two non-nil operands, got 1_
+
 `>>>` [blue]`1|(-2)` +
 [green]`-1|2`
-// ----
+
 
 Fractions can be used together with integers and floats in expressions.
 
 .Examples
 `>>>` [blue]`1|2 + 5` +
-[green]`11|2` +
+[green]`11|2`
+
 `>>>` [blue]`4 - 1|2` +
-[green]`7|2` +
+[green]`7|2`
+
 `>>>` [blue]`1.0 + 1|2` +
 [green]`1.5`
 
@@ -250,12 +296,15 @@ Strings are character sequences enclosed between two double quote [blue]`"`.
 
 .Examples
 `>>>` [blue]`"I'm a string"` +
-[green]`I'm a string` +
+[green]`I'm a string`
+
 `>>>` [blue]`"123abc?!"` +
-[green]`123abc?!` +
+[green]`123abc?!`
+
 `>>>` [blue]`"123\nabc"` +
 [green]`123` +
-[green]`abc` +
+[green]`abc`
+
 `>>>` [blue]`"123\tabc"` +
 [green]`123{nbsp}{nbsp}{nbsp}{nbsp}abc`
 
@@ -272,25 +321,36 @@ Some arithmetic operators can also be used with strings.
 | [blue]`*` | _repeat_ | Make _n_ copy of a string  | [blue]`"one" * 2` -> _"oneone"_
 |===
 
-The items of strings can be accessed using the dot `.` operator.
+The items of strings can be accessed using the square `[]` operator.
 
 .Item access syntax
 ====
-_item_ = _string-expr_ "**.**" _integer-expr_
+*_item_* = _string-expr_ "**[**" _integer-expr_ "**]**"
+====
+
+.Sub-string syntax
+====
+*_sub-string_* = _string-expr_ "**[**" _integer-expr_ "**:**" _integer-expr_ "**]**"
 ====
 
 .String examples
-`>>>` [blue]`s="abc"`  [gray]_// assign the string to variable s_ +
+`>>>` [blue]`s="abcd"`  [gray]_// assign the string to variable s_ +
-[green]`abc` +
+[green]`"abcd"`
-`>>>` [blue]`s.1`      [gray]_// char at position 1 (starting from 0)_ +
+
-[green]`b` +
+`>>>` [blue]`s[1]`      [gray]_// char at position 1 (starting from 0)_ +
-`>>>` [blue]`s.(-1)`   [gray]_// char at position -1, the rightmost one_ +
+[green]`"b"`
-[green]`c` +
+
+`>>>` [blue]`s.[-1]`    [gray]_// char at position -1, the rightmost one_ +
+[green]`"d"`
+
 `>>>` [blue]`\#s`       [gray]_// number of chars_ +
-[gren]`3` +
+[gren]`4`
-`>>>` [blue]`#"abc"`   [gray]_// number of chars_ +
+
+`>>>` [blue]`#"abc"`    [gray]_// number of chars_ +
 [green]`3`
 
+`>>>` [blue]`s[1:3]`    [gray]_// chars from position 1 to position 3 excluded_ +
+[grean]`"bc"`
 
 === Booleans
 Boolean data type has two values only: [blue]_true_ and [blue]_false_. Relational and boolean expressions result in boolean values.
@@ -334,14 +394,16 @@ Boolean data type has two values only: [blue]_true_ and [blue]_false_. Relationa
 
 [CAUTION]
 ====
-Currently, boolean operations are evaluated using _short cut evaluation_. This means that, if the left expression of the [blue]`and` and [blue]`or` operators is sufficient to establish the result of the whole operation, the right expression would not evaluated at all.
+Currently, boolean operations are evaluated using _short cut evaluation_. This means that, if the left expression of the [blue]`and` and [blue]`or` operators is sufficient to establish the result of the whole operation, the right expression would not be evaluated at all.
-
 .Example
 [source,go]
 ----
 2 > (a=1) or (a=8) > 0; a // <1>
 ----
 <1> This multi-expression returns _1_ because in the first expression the left value of [blue]`or` is _true_ and as a conseguence its right value is not computed. Therefore the _a_ variable only receives the integer _1_.
+
+
+TIP: `dev-expr` provides the _ctrl()_ function that allows to change this behaviour.
 ====
 
 === Lists
@@ -356,13 +418,17 @@ _non-empty-list_ = "**[**" _any-value_ {"**,**" _any-value} "**]**" +
 
 .Examples
 `>>>` [blue]`[1,2,3]`                     [gray]_// List of integers_ +
-[green]`[1, 2, 3]` +
+[green]`[1, 2, 3]`
+
 `>>>` [blue]`["one", "two", "three"]`     [gray]_// List of strings_ +
-[green]`["one", "two", "three"]` +
+[green]`["one", "two", "three"]`
+
 `>>>` [blue]`["one", 2, false, 4.1]`      [gray]_// List of mixed-types_ +
-[green]`["one", 2, false, 4.1]` +
+[green]`["one", 2, false, 4.1]`
+
 `>>>` [blue]`["one"+1, 2.0*(9-2)]`        [gray]_// List of expressions_ +
-[green]`["one1", 14]` +
+[green]`["one1", 14]`
+
 `>>>` [blue]`[ [1,"one"], [2,"two"]]`     [gray]_// List of lists_ +
 [green]`[[1, "one"], [2, "two"]]`
 
@@ -375,37 +441,52 @@ _non-empty-list_ = "**[**" _any-value_ {"**,**" _any-value} "**]**" +
 | [blue]`-` | _Difference_ | Left list without elements in the right list  | [blue]`[1,2,3] - [2]` -> _[1,3]_
 | [blue]`>>` | _Front insertion_ | Insert an item in front | [blue]`0 >> [1,2]` -> _[0,1,2]_
 | [blue]`<<` | _Back insertion_ | Insert an item at end | [blue]`[1,2] << 3` -> _[1,2,3]_
-| [blue]`.` | _List item_ | Item at given position | [blue]`[1,2.3].1` -> _2_
+| [blue]`[]` | _Item at index_ | Item at given position | [blue]`[1,2,3][1]` -> _2_
 | [blue]`in` | _Item in list_ | True if item is in list | [blue]`2 in [1,2,3]` -> _true_ +
 [blue]`6 in [1,2,3]` -> _false_
 |===
 
-The items of array can be accessed using the dot `.` operator.
+Array's items can be accessed using the index `[]` operator.
 
 .Item access syntax
 ====
-_item_ = _list-expr_ "**.**" _integer-expr_
+*_item_* = _list-expr_ "**[**" _integer-expr_ "**]**"
+====
+
+.Sub-array (or slice of array) syntax
+====
+*_slice_* = _string-expr_ "**[**" _integer-expr_ "**:**" _integer-expr_ "**]**"
 ====
 
 .Items of list
 `>>>` [blue]`[1,2,3].1` +
-[green]`2` +
+[green]`2`
+
 `>>>` [blue]`list=[1,2,3]; list.1` +
-[green]`2` +
+[green]`2`
+
 `>>>` [blue]`["one","two","three"].1` +
-[green]`two` +
+[green]`two`
+
 `>>>` [blue]`list=["one","two","three"]; list.(2-1)` +
-[green]`two` +
+[green]`two`
+
 `>>>` [blue]`list.(-1)` +
-[green]`three` +
+[green]`three`
+
 `>>>` [blue]`list.(10)` +
-[red]`Eval Error: [1:9] index 10 out of bounds` +
+[red]`Eval Error: [1:9] index 10 out of bounds`
+
 `>>>` [blue]`#list` +
-[green]`3` +
+[green]`3`
-`>>>` [blue]`index=2; ["a", "b", "c", "d"].index` +
+
+`>>>` [blue]`index=2; ["a", "b", "c", "d"][index]` +
 [green]`c`
 
 
+`>>>` [blue]`["a", "b", "c", "d"][2:]` +
+[green]`["c", "d"]`
+
 
 === Dictionaries
 The _dictionary_, or _dict_, data-type is set of pairs _key/value_. It is also known as _map_ or _associative array_.
@@ -419,14 +500,11 @@ _empty-dict_ = "**{}**" +
 _non-empty-dict_ = "**{**" _key-scalar_ "**:**" _any-value_ {"**,**" _key-scalar_ "**:**" _any-value} "**}**" +
 ====
 
-.Examples
-`>>>` [blue]`{1:"one", 2:"two"}` +
-[green]`{1: "one", 2: "two"}` +
-`>>>` [blue]`{"one":1, "two": 2}` +
-[green]`{"one": 1, "two": 2}` +
-`>>>` [blue]`{"sum":1+2+3, "prod":1*2*3}` +
-[green]`{"sum": 6, "prod": 6}`
 
+.Item access syntax
+====
+*_item_* = _dict-expr_ "**[**" _key-expr_ "**]**"
+====
 
 .Dict operators
 [cols="^2,^2,4,5"]
@@ -434,11 +512,27 @@ _non-empty-dict_ = "**{**" _key-scalar_ "**:**" _any-value_ {"**,**" _key-scalar
 | Symbol    | Operation     | Description               | Examples
 
 | [blue]`+` | _Join_ | Joins two dicts | [blue]`{1:"one"}+{6:"six"}` -> _{1: "one", 6: "six"}_
-| [blue]`.` | _Dict item value_ | Item value of given key | [blue]`{"one":1, "two":2}."two"` -> _2_
+| [blue]`[]` | _Dict item value_ | Item value of given key | [blue]`{"one":1, "two":2}["two"]` -> _2_
 | [blue]`in` | _Key in dict_ | True if key is in dict | [blue]`"one" in {"one":1, "two":2}` -> _true_ +
 [blue]`"six" in {"one":1, "two":2}` -> _false_
 |===
 
+.Examples
+`>>>` [blue]`{1:"one", 2:"two"}` +
+[green]`{1: "one", 2: "two"}`
+
+`>>>` [blue]`{"one":1, "two": 2}` +
+[green]`{"one": 1, "two": 2}`
+
+`>>>` [blue]`{"sum":1+2+3, "prod":1*2*3}` +
+[green]`{"sum": 6, "prod": 6}`
+
+`>>>` [blue]`{"one":1, "two":2}["two"]` +
+[green]`2`
+
+`>>>` [blue]`d={"one":1, "two":2}; d["six"]=6; d` +
+[green]`{"two": 2, "one": 1, "six": 6}`
+
 
 == Variables
 _Expr_, like most programming languages, supports variables. A variable is an identifier with an assigned value. Variables are stored in _contexts_.
@@ -454,17 +548,23 @@ NOTE: The assign operator [blue]`=` returns the value assigned to the variable.
 
 .Examples
 `>>>` [blue]`a=1` +
-[green]`1` +
+[green]`1`
+
 `>>>` [blue]`a_b=1+2` +
-[green]`1+2` +
+[green]`1+2`
+
 `>>>` [blue]`a_b` +
-[green]`3` +
+[green]`3`
-`>>>` [blue]`x = 5.2 * (9-3)`  [gray]_// The assigned value has the approximation error typical of the float data-type_ +
+
-[green]`31.200000000000003` +
+`>>>` [blue]`x = 5.2 * (9-3)`  [gray]_// The assigned value has the typical approximation error of the float data-type_ +
+[green]`31.200000000000003`
+
 `>>>` [blue]`x = 1; y = 2*x` +
-[green]`2` +
+[green]`2`
+
 `>>>` [blue]`_a=2` +
-[red]`Parse Error: [1:2] unexpected token "_"` +
+[red]`Parse Error: [1:2] unexpected token "_"`
+
 `>>>` [blue]`1=2` +
 [red]`Parse Error: assign operator ("=") must be preceded by a variable`
 
@@ -474,6 +574,11 @@ NOTE: The assign operator [blue]`=` returns the value assigned to the variable.
 === [blue]`;` operator
 The semicolon operator [blue]`;` is an infixed pseudo-operator. It evaluates the left expression first and then the right expression. The value of the latter is the final result.
 
+.Mult-expression syntax
+====
+*_multi-expression_* = _expression_ {"**;**" _expression_ }
+====
+
 An expression that contains [blue]`;` is called a _multi-expression_ and each component expressione is called a _sub-expression_.
 
 IMPORTANT: Technically [blue]`;` is not treated as a real operator. It acts as a separator in lists of expressions.
@@ -532,38 +637,47 @@ The [blue]`:` symbol (colon) is the separator of the selector-cases. Note that i
 
 .Examples
 `>>>` [blue]`1 ? {"a"} : {"b"}` +
-[green]`b` +
+[green]`b`
-`>>>` [blue]`10 ? {"a"} : {"b"} :: {"c"}` +
+
-[green]`c' +
+`>>>` [blue]`10 ? {"a"} : {"b"} {2c} {"c"}` +
-[green]`>>>` [blue]`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}` +
+[green]`c`
-[green]`b` +
+
-`>>>` [blue]`10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}` +
+`>>>` [blue]`10 ? {"a"} :[true, 2+8] {"b"} {2c} {"c"}` +
-[red]`Parse Error: [1:34] case list in default clause` +
+[green]`b`
-[green]`>>>` [blue]`10 ? {"a"} :[10] {x="b" but x} :: {"c"}` +
+
-[green]`b` +
+`>>>` [blue]`10 ? {"a"} :[true, 2+8] {"b"} {2c} [10] {"c"}` +
-`>>>` [blue]`10 ? {"a"} :[10] {x="b"; x} :: {"c"}` +
+[red]`Parse Error: [1:34] case list in default clause`
-[green]`b` +
+
+`>>>` [blue]`10 ? {"a"} :[10] {x="b" but x} {2c} {"c"}` +
+[green]`b`
+
+`>>>` [blue]`10 ? {"a"} :[10] {x="b"; x} {2c} {"c"}` +
+[green]`b`
+
 `>>>` [blue]`10 ? {"a"} : {"b"}` +
 [red]`Eval Error: [1:3] no case catches the value (10) of the selection expression`
 
 
 === Variable default value [blue]`??` and [blue]`?=`
-The left operand of these two operators must be a variable. The right operator can be any expression. They return the value of the variable if this is define; otherwise they return the value of the right expression.
+The left operand of these two operators must be a variable. The right operator can be any expression. They return the value of the variable if this is defined; otherwise they return the value of the right expression.
 
-IMPORTANT: If the left variable is defined, the right expression is not evuated at all.
+IMPORTANT: If the left variable is defined, the right expression is not evaluated at all.
 
-The [blue]`??` do not change the status of the left variable.
+The [blue]`??` operator do not change the status of the left variable.
 
 The [blue]`?=` assigns the calculated value of the right expression to the left variable.
 
 .Examples
-`>>>` [blue]`var ?? (1+2)`'
+`>>>` [blue]`var ?? (1+2)`' +
-[green]`3` +
+[green]`3`
+
 `>>>` [blue]`var` +
-[red]`Eval Error: undefined variable or function "var"` +
+[red]`Eval Error: undefined variable or function "var"`
+
 `>>>` [blue]`var ?= (1+2)` +
-[green]`3` +
+[green]`3`
-`>>>` [blue]`var` +
+
+`>>>` [blue]`var`
 [green]`3`
 
 NOTE: These operators have a high priority, in particular higher than the operator [blue]`=`.
@@ -576,57 +690,87 @@ The table below shows all supported operators by decreasing priorities.
 |===
 | Priority | Operators     | Position | Operation | Operands and results
 
-.2+|*ITEM*| [blue]`.` | _Infix_ | _List item_| _list_ `"."` _integer_ -> _any_
+.2+|*ITEM*| [blue]`[`...`]` | _Postfix_ | _List item_| _list_ `[`  _integer_ `]` -> _any_
-| [blue]`.` | _Infix_ | _Dict item_ | _dict_ `"."` _any_ -> _any_
+| [blue]`[`...`]` | _Postfix_ | _Dict item_ | _dict_ `[` _any_ `]` -> _any_
-.2+|*INC*| [blue]`++` | _Postfix_ | _Post increment_| _integer-variable_ `"++"` -> _integer_
+.2+|*INC*| [blue]`++` | _Postfix_ | _Post increment_| _integer-variable_ `++` -> _integer_
-| [blue]`++` | _Postfix_ | _Next item_ | _iterator_ `"++"` -> _any_
+| [blue]`++` | _Postfix_ | _Next item_ | _iterator_ `++` -> _any_
-.1+|*FACT*| [blue]`!` | _Postfix_ | _Factorial_| _integer_ `"!"` -> _integer_
+.2+|*DEFAULT*| [blue]`??` | _Infix_ | _Default value_| _variable_ `??` _any-expr_ -> _any_
-.3+|*SIGN*| [blue]`+`, [blue]`-` | _Prefix_ | _Change-sign_| (`"+"`\|`"-"`) _number_ -> _number_
+| [blue]`?=` | _Infix_ | _Default/assign value_| _variable_ `?=` _any-expr_ -> _any_
-| [blue]`#` | _Prefix_ | _Lenght-of_ | `"#"` _collection_ -> _integer_
+.1+| *ITER*^1^| [blue]`()` | _Prefix_ | _Iterator value_ | `()` _iterator_ -> _any_
-| [blue]`#` | _Prefix_ | _Size-of_ | `"#"` _iterator_ -> _integer_
+.1+|*FACT*| [blue]`!` | _Postfix_ | _Factorial_| _integer_ `!` -> _integer_
-.5+|*PROD*| [blue]`*` | _Infix_ | _Product_ | _number_ `"*"` _number_ -> _number_
+.3+|*SIGN*| [blue]`+`, [blue]`-` | _Prefix_ | _Change-sign_| (`+`\|`-`) _number_ -> _number_
-| [blue]`*` | _Infix_ | _String-repeat_ | _string_ `"*"` _integer_ -> _string_
+| [blue]`#` | _Prefix_ | _Lenght-of_ | `#` _collection_ -> _integer_
-| [blue]`/` | _Infix_ | _Division_ | _number_ `"/"` _number_ -> _number_
+| [blue]`#` | _Prefix_ | _Size-of_ | `#` _iterator_ -> _integer_
-| [blue]`./` | _Infix_ | _Float-division_ | __number__ `"./"` _number_ -> _float_
+.2+|*SELECT*| [blue]`? : ::` | _Multi-Infix_ | _Case-Selector_ | _any-expr_ `?` _case-list_ _case-expr_ `:` _case-list_ _case-expr_ ... `::` _default-expr_ -> _any_
-| [blue]`%` | _Infix_ | _Integer-remainder_ | _integer_ `"%"` _integer_ -> _integer_
+| [blue]`? : ::` | _Multi-Infix_ | _Index-Selector_ | _int-expr_ `?` _case-expr_ `:` _case-expr_ ... `::` _default-expr_ -> _any_
-.6+|*SUM*| [blue]`+` | _Infix_ | _Sum_ | _number_ `"+"` _number_ -> _number_
+.1+|*FRACT*| [blue]`\|` | _Infix_ | _Fraction_ | _integer_ `\|` _integer_ -> _fraction_
-| [blue]`+` | _Infix_ |  _String-concat_ | (_string_\|_number_) `"+"` (_string_\|_number_) -> _string_
+.5+|*PROD*| [blue]`*` | _Infix_ | _Product_ | _number_ `*` _number_ -> _number_
-| [blue]`+` | _Infix_ |  _List-join_ | _list_ `"+"` _list_ -> _list_
+| [blue]`*` | _Infix_ | _String-repeat_ | _string_ `*` _integer_ -> _string_
-| [blue]`+` | _Infix_ |  _Dict-join_ | _dict_ `"+"` _dict_ -> _dict_
+| [blue]`/` | _Infix_ | _Division_ | _number_ `/` _number_ -> _number_
-| [blue]`-` | _Infix_ | _Subtraction_ | _number_ `"-"` _number_ -> _number_
+| [blue]`./` | _Infix_ | _Float-division_ | __number__ `./` _number_ -> _float_
-| [blue]`-` | _Infix_ | _List-difference_ | _list_ `"-"` _list_ -> _list_
+| [blue]`%` | _Infix_ | _Integer-remainder_ | _integer_ `%` _integer_ -> _integer_
-.8+|*RELATION*| [blue]`<` | _Infix_ | _less_ | _comparable_ `"<"` _comparable_ -> _boolean_
+.6+|*SUM*| [blue]`+` | _Infix_ | _Sum_ | _number_ `+` _number_ -> _number_
-| [blue]`\<=` | _Infix_ |  _less-equal_ | _comparable_ `"\<="` _comparable_ -> _boolean_
+| [blue]`+` | _Infix_ |  _String-concat_ | (_string_\|_number_) `+` (_string_\|_number_) -> _string_
-| [blue]`>` | _Infix_ |  _greater_ | _comparable_ `">"` _comparable_ -> _boolean_
+| [blue]`+` | _Infix_ |  _List-join_ | _list_ `+` _list_ -> _list_
-| [blue]`>=` | _Infix_ |  _greater-equal_ | _comparable_ `">="` _comparable_ -> _boolean_
+| [blue]`+` | _Infix_ |  _Dict-join_ | _dict_ `+` _dict_ -> _dict_
-| [blue]`==` | _Infix_ |  _equal_ | _comparable_ `"=="` _comparable_ -> _boolean_
+| [blue]`-` | _Infix_ | _Subtraction_ | _number_ `-` _number_ -> _number_
-| [blue]`!=` | _Infix_ |  _not-equal_ | _comparable_ `"!="` _comparable_ -> _boolean_
+| [blue]`-` | _Infix_ | _List-difference_ | _list_ `-` _list_ -> _list_
-| [blue]`in` | _Infix_ |  _member-of-list_ | _any_ `"in"` _list_ -> _boolean_
+.8+|*RELATION*| [blue]`<` | _Infix_ | _Less_ | _comparable_ `<` _comparable_ -> _boolean_
-| [blue]`in` | _Infix_ |  _key-of-dict_ | _any_ `"in"` _dict_ -> _boolean_
+| [blue]`\<=` | _Infix_ |  _less-equal_ | _comparable_ `\<=` _comparable_ -> _boolean_
-.1+|*NOT*| [blue]`not` | _Prefix_ | _not_ | `"not"` _boolean_ -> _boolean_
+| [blue]`>` | _Infix_ |  _Greater_ | _comparable_ `>` _comparable_ -> _boolean_
-.2+|*AND*| [blue]`and` | _Infix_ | _and_ | _boolean_ `"and"` _boolean_ -> _boolean_
+| [blue]`>=` | _Infix_ |  _Greater-equal_ | _comparable_ `>=` _comparable_ -> _boolean_
-| [blue]`&&` | _Infix_ | _and_ | _boolean_ `"&&"` _boolean_ -> _boolean_
+| [blue]`==` | _Infix_ |  _Equal_ | _comparable_ `==` _comparable_ -> _boolean_
-.2+|*OR*| [blue]`or` | _Infix_ | _or_ | _boolean_ `"or"` _boolean_ -> _boolean_
+| [blue]`!=` | _Infix_ |  _Not-equal_ | _comparable_ `!=` _comparable_ -> _boolean_
-| [blue]`\|\|` | _Infix_ | _or_ | _boolean_ `"\|\|"` _boolean_ -> _boolean_
+| [blue]`in` | _Infix_ |  _Member-of-list_ | _any_ `in` _list_ -> _boolean_
-.3+|*ASSIGN*| [blue]`=` | _Infix_ | _assignment_ | _identifier_ "=" _any_ -> _any_
+| [blue]`in` | _Infix_ |  _Key-of-dict_ | _any_ `in` _dict_ -> _boolean_
-| [blue]`>>` | _Infix_ | _front-insert_ | _any_ ">>" _list_ -> _list_
+.1+|*NOT*| [blue]`not` | _Prefix_ | _Not_ | `not` _boolean_ -> _boolean_
-| [blue]`<<` | _Infix_ | _back-insert_ | _list_ "<<" _any_ -> _list_
+.2+|*AND*| [blue]`and` | _Infix_ | _And_ | _boolean_ `and` _boolean_ -> _boolean_
- .1+|*BUT*| [blue]`but` | _Infix_ | _but_ | _any_ "but" _any_ -> _any_
+| [blue]`&&` | _Infix_ | _And_ | _boolean_ `&&` _boolean_ -> _boolean_
+.2+|*OR*| [blue]`or` | _Infix_ | _Or_ | _boolean_ `or` _boolean_ -> _boolean_
+| [blue]`\|\|` | _Infix_ | _Or_ | _boolean_ `\|\|` _boolean_ -> _boolean_
+.3+|*ASSIGN*| [blue]`=` | _Infix_ | _Assignment_ | _identifier_ `=` _any_ -> _any_
+| [blue]`>>` | _Infix_ | _Front-insert_ | _any_ `>>` _list_ -> _list_
+| [blue]`<<` | _Infix_ | _Back-insert_ | _list_ `<<` _any_ -> _list_
+.1+|*BUT*| [blue]`but` | _Infix_ | _But_ | _any_ `but` _any_ -> _any_
+.1+|*RANGE*| [blue]`:` | _Infix_ | _Index-range_ | _integer_ `:` _integer_ -> _integer-pair_
 |===
 
+^1^ Experimental
+
+
 == Functions
 Functions in _Expr_ are very similar to functions available in many programming languages. Actually, _Expr_ supports two types of function, _expr-functions_ and _go-functions_.
 
 * _expr-functions_ are defined using _Expr_'s syntax. They can be passed as arguments to other functions and can be returned from functions. Moreover, they bind themselves to the defining context, thus becoming closures.
 * _go-functions_ are regular Golang functions callable from _Expr_ expressions. They are defined in Golang source files called _modules_ and compiled within the _Expr_ package. To make Golang functions available in _Expr_ contextes, it is required to _import_ the module in which they are defined.
 
-In _Expr_ functions compute values in a local context (scope) that do not make effects on the calling context. This is the normal behavior. Using the reference operator [blue]`@` it is possibile to export local definition to the calling context.
+
+=== _Expr_ function definition
+A function is identified and referenced by its name. It can have zero or more parameter. _Expr_ functions also support optional parameters.
+
+. Expr's function definition syntax
+====
+*_function-definition_* = _identifier_ "**=**"  "**func(**" [_param-list_] "**)**"  "**{**" _multi-expression_ "**}**"
+_param_list_ = _required-param-list_ [ "**,**" _optional-param-list_ ]
+_required-param-list_ = _identifier_ { "**,**" _identifier_ }
+_optional-param-list_ = _optional-parm_ { "**,**" _optional-param_ }
+_optional-param_ = _identifier_ "**=**" _any-expr_
+====
+
+.Examples
+#TODO#
+
+=== _Golang_ function definition
+Description of how to define Golan functions and how to bind them to _Expr_ are topics treated in another document that I'll write, one day, maybe.
 
 === Function calls
 #TODO: function calls operations#
 
-=== Function definitions
+Functions compute values in a local context (scope) that do not make effects on the calling context. This is the normal behavior. Using the reference operator [blue]`@` it is possibile to export local definition to the calling context.
-#TODO: function definitions operations#
+
+
+== Iterators
+#TODO: function calls operations#
 
 == Builtins
 #TODO: builtins#
@@ -637,4 +781,7 @@ In _Expr_ functions compute values in a local context (scope) that do not make e
 [blue]_import([grey]#<source-file>#)_ loads the multi-expression contained in the specified source and returns its value.
 
 
+== Plugins
+#TODO: plugins#
+
 

expr-context.go

@@ -1,49 +1,30 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// context.go
+// expr-context.go
 package expr
 
-// ---- Functor interface
-type Functor interface {
-	Invoke(ctx ExprContext, name string, args []any) (result any, err error)
-	SetFunc(info ExprFunc)
-	GetFunc() ExprFunc
-	GetParams() []ExprFuncParam
-}
-
-// ---- Function Param Info
-type ExprFuncParam interface {
-	Name() string
-	Type() string
-	IsOptional() bool
-	IsRepeat() bool
-	DefaultValue() any
-}
-
-// ---- Function Info
-type ExprFunc interface {
-	Formatter
-	Name() string
-	MinArgs() int
-	MaxArgs() int
-	Functor() Functor
-	Params() []ExprFuncParam
-	ReturnType() string
-}
-
 // ----Expression Context
 type ExprContext interface {
 	Clone() ExprContext
-	Merge(ctx ExprContext)
+	// Merge(ctx 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 []any) (result any, err error)
-	// RegisterFunc(name string, f Functor, minArgs, maxArgs int)
 	RegisterFuncInfo(info ExprFunc)
 	RegisterFunc(name string, f Functor, returnType string, param []ExprFuncParam) error
 }

expr-function.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// expr-function.go
+package expr
+
+// ---- Functor interface
+type Functor interface {
+	Typer
+	Invoke(ctx ExprContext, name string, args []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
+	ReturnType() string
+	PrepareCall(parentCtx ExprContext, name string, varParams *[]any) (ctx ExprContext, 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
+}

file-reader.expr

@@ -1,33 +0,0 @@
-builtin ["os.file", "base"];
-
-readInt=func(fh){
-	line=readFile(fh);
-	line ? [nil] {nil} :: {int(line)}
-};
-
-ds={
-	"init":func(filename){
-		fh=openFile(filename);
-		fh ? [nil] {nil} :: { @current=readInt(fh); @prev=@current };
-		fh
-	},
-	"current":func(){
-		prev
-	},
-	"next":func(fh){
-		current ? 
-			[nil] {current}
-			:: {@prev=current; @current=readInt(fh) but current}
-	},
-	"clean":func(fh){
-		closeFile(fh)
-	}
-}
-
-//;f=$(ds, "int.list")
-/*
-;f++
-;f++
-;f++
-*/
-//;add(f)

formatter.go

@@ -6,7 +6,7 @@ package expr
 
 import "fmt"
 
-type FmtOpt uint16
+type FmtOpt uint32 // lower 16 bits hold a bit-mask, higher 16 bits hold an indentation number
 
 const (
 	TTY FmtOpt = 1 << iota
@@ -30,6 +30,18 @@ func TruncateString(s string) (trunc string) {
 	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
 }
@@ -51,7 +63,7 @@ type Typer interface {
 	TypeName() string
 }
 
-func typeName(v any) (name string) {
+func TypeName(v any) (name string) {
 	if v == nil {
 		name = "nil"
 	} else if typer, ok := v.(Typer); ok {

fraction-type.go

@@ -50,9 +50,10 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
 	} else if s[0] == '+' {
 		s = s[1:]
 	}
-	if strings.HasSuffix(s, "()") {
+//	if strings.HasSuffix(s, "()") {
-		s = s[0 : len(s)-2]
+//		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
@@ -70,7 +71,7 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
 			}
 			for _, c := range dec[0:lsd] {
 				if c < '0' || c > '9' {
-					return nil, errExpectedGot("fract", "digit", c)
+					return nil, ErrExpectedGot("fract", "digit", c)
 				}
 				num = num*10 + int64(c-'0')
 				den = den * 10
@@ -81,7 +82,7 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
 			mul := int64(1)
 			for _, c := range subParts[0] {
 				if c < '0' || c > '9' {
-					return nil, errExpectedGot("fract", "digit", c)
+					return nil, ErrExpectedGot("fract", "digit", c)
 				}
 				num = num*10 + int64(c-'0')
 				sub = sub*10 + int64(c-'0')
@@ -94,7 +95,7 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
 				p := subParts[1][0 : len(subParts[1])-1]
 				for _, c := range p {
 					if c < '0' || c > '9' {
-						return nil, errExpectedGot("fract", "digit", c)
+						return nil, ErrExpectedGot("fract", "digit", c)
 					}
 					num = num*10 + int64(c-'0')
 					den = den*10 + 9
@@ -212,7 +213,7 @@ func anyToFract(v any) (f *FractionType, err error) {
 		}
 	}
 	if f == nil {
-		err = errExpectedGot("fract", typeFraction, v)
+		err = ErrExpectedGot("fract", TypeFraction, v)
 	}
 	return
 }
@@ -311,7 +312,6 @@ func divAnyFract(af1, af2 any) (quot any, err error) {
 	if f2.num == 0 {
 		err = errors.New("division by zero")
 		return
-		return
 	}
 	if f1.num == 0 || f2.den == 0 {
 		quot = 0

func-fmt.go

@@ -1,36 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// func-fmt.go
-package expr
-
-import "fmt"
-
-func printFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	var n int
-	if n, err = fmt.Print(args...); err == nil {
-		result = int64(n)
-	}
-	return
-}
-
-func printLnFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	var n int
-	if n, err = fmt.Println(args...); err == nil {
-		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() {
-	registerImport("fmt", ImportFmtFuncs, "String and console formatting functions")
-}

func-import.go

@@ -1,150 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// func-import.go
-package expr
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-)
-
-const ENV_EXPR_PATH = "EXPR_PATH"
-
-func importFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	return importGeneral(ctx, name, args)
-}
-
-func importAllFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	enable(ctx, control_export_all)
-	return importGeneral(ctx, name, args)
-}
-
-func importGeneral(ctx ExprContext, name string, args []any) (result any, err error) {
-	var dirList []string
-
-	dirList = addEnvImportDirs(dirList)
-	dirList = addPresetImportDirs(ctx, dirList)
-	result, err = doImport(ctx, name, dirList, NewArrayIterator(args))
-	return
-}
-
-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 %T, string expected", funcName, paramPos+1, paramValue)
-	}
-	return
-}
-
-func addEnvImportDirs(dirList []string) []string {
-	if dirSpec, exists := os.LookupEnv(ENV_EXPR_PATH); exists {
-		dirs := strings.Split(dirSpec, ":")
-		if dirList == nil {
-			dirList = dirs
-		} else {
-			dirList = append(dirList, dirs...)
-		}
-	}
-	return dirList
-}
-
-func addPresetImportDirs(ctx ExprContext, dirList []string) []string {
-	if dirSpec, exists := getControlString(ctx, ControlImportPath); exists {
-		dirs := strings.Split(dirSpec, ":")
-		if dirList == nil {
-			dirList = dirs
-		} else {
-			dirList = append(dirList, dirs...)
-		}
-	}
-	return dirList
-}
-
-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) {
-	for _, dir := range dirList {
-		if fullPath := path.Join(dir, 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 path.IsAbs(filename) || isPathRelative(filename) {
-		if isFile(filename) {
-			filePath = filename
-		}
-	} else {
-		filePath = searchAmongPath(filename, dirList)
-	}
-	if len(filePath) == 0 {
-		err = fmt.Errorf("source file %q not found", filename)
-	}
-	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(ctx)
-			if expr, err = parser.parseGeneral(scanner, true, true); err == nil {
-				result, err = expr.eval(ctx, false)
-			}
-			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() {
-	registerImport("import", ImportImportFuncs, "Functions import() and include()")
-}

function.go

@@ -21,7 +21,7 @@ func (functor *baseFunctor) ToString(opt FmtOpt) (s string) {
 	if functor.info != nil {
 		s = functor.info.ToString(opt)
 	} else {
-		s = "func() {<body>}"
+		s = "func(){}"
 	}
 	return s
 }
@@ -42,65 +42,17 @@ func (functor *baseFunctor) GetFunc() ExprFunc {
 	return functor.info
 }
 
-// ---- Linking with Go functions
+func (functor *baseFunctor) GetDefinitionContext() ExprContext {
-type golangFunctor struct {
+	return nil
-	baseFunctor
-	f FuncTemplate
-}
-
-func newGolangFunctor(f FuncTemplate) *golangFunctor {
-	return &golangFunctor{f: f}
-}
-
-func (functor *golangFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
-	return functor.f(ctx, name, args)
-}
-
-// ---- Linking with Expr functions
-type exprFunctor struct {
-	baseFunctor
-	params []ExprFuncParam
-	expr   Expr
-	defCtx ExprContext
-}
-
-// func newExprFunctor(e Expr, params []string, ctx ExprContext) *exprFunctor {
-// 	return &exprFunctor{expr: e, params: params, defCtx: ctx}
-// }
-
-func newExprFunctor(e Expr, params []ExprFuncParam, ctx ExprContext) *exprFunctor {
-	return &exprFunctor{expr: e, params: params, defCtx: ctx}
-}
-
-func (functor *exprFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
-	if functor.defCtx != nil {
-		ctx.Merge(functor.defCtx)
-	}
-
-	for i, p := range functor.params {
-		if i < len(args) {
-			arg := args[i]
-			if funcArg, ok := arg.(Functor); ok {
-				// ctx.RegisterFunc(p, functor, 0, -1)
-				paramSpecs := funcArg.GetParams()
-				ctx.RegisterFunc(p.Name(), funcArg, typeAny, paramSpecs)
-			} else {
-				ctx.UnsafeSetVar(p.Name(), arg)
-			}
-		} else {
-			ctx.UnsafeSetVar(p.Name(), nil)
-		}
-	}
-	result, err = functor.expr.eval(ctx, false)
-	return
 }
 
 // ---- Function Parameters
 type paramFlags uint16
 
 const (
-	pfOptional paramFlags = 1 << iota
+	PfDefault paramFlags = 1 << iota
-	pfRepeat
+	PfOptional
+	PfRepeat
 )
 
 type funcParamInfo struct {
@@ -109,15 +61,15 @@ type funcParamInfo struct {
 	defaultValue any
 }
 
-func newFuncParam(name string) ExprFuncParam {
+func NewFuncParam(name string) ExprFuncParam {
 	return &funcParamInfo{name: name}
 }
 
-func newFuncParamFlag(name string, flags paramFlags) ExprFuncParam {
+func NewFuncParamFlag(name string, flags paramFlags) ExprFuncParam {
 	return &funcParamInfo{name: name, flags: flags}
 }
 
-func newFuncParamFlagDef(name string, flags paramFlags, defValue any) *funcParamInfo {
+func NewFuncParamFlagDef(name string, flags paramFlags, defValue any) *funcParamInfo {
 	return &funcParamInfo{name: name, flags: flags, defaultValue: defValue}
 }
 
@@ -126,15 +78,19 @@ func (param *funcParamInfo) Name() string {
 }
 
 func (param *funcParamInfo) Type() string {
-	return "any"
+	return TypeAny
+}
+
+func (param *funcParamInfo) IsDefault() bool {
+	return (param.flags & PfDefault) != 0
 }
 
 func (param *funcParamInfo) IsOptional() bool {
-	return (param.flags & pfOptional) != 0
+	return (param.flags & PfOptional) != 0
 }
 
 func (param *funcParamInfo) IsRepeat() bool {
-	return (param.flags & pfRepeat) != 0
+	return (param.flags & PfRepeat) != 0
 }
 
 func (param *funcParamInfo) DefaultValue() any {
@@ -142,50 +98,51 @@ func (param *funcParamInfo) DefaultValue() any {
 }
 
 // --- Functions
+
+// funcInfo implements ExprFunc
 type funcInfo struct {
-	name       string
+	name         string
-	minArgs    int
+	minArgs      int
-	maxArgs    int
+	maxArgs      int
-	functor    Functor
+	functor      Functor
-	params     []ExprFuncParam
+	formalParams []ExprFuncParam
-	returnType string
+	returnType   string
 }
 
 func newFuncInfo(name string, functor Functor, returnType string, params []ExprFuncParam) (info *funcInfo, err error) {
 	var minArgs = 0
 	var maxArgs = 0
-	if params != nil {
+	for _, p := range params {
-		for _, p := range params {
+		if maxArgs == -1 {
-			if maxArgs == -1 {
+			return nil, fmt.Errorf("no more params can be specified after the ellipsis symbol: %q", p.Name())
-				return nil, fmt.Errorf("no more params can be specified after the ellipsis symbol: %q", p.Name())
+		}
-			}
+		if p.IsDefault() || p.IsOptional() {
-			if p.IsOptional() {
+			maxArgs++
-				maxArgs++
+		} else if maxArgs == minArgs {
-			} else if maxArgs == minArgs {
+			minArgs++
-				minArgs++
+			maxArgs++
-				maxArgs++
+		} else {
-			} else {
+			return nil, fmt.Errorf("can't specify non-optional param after optional ones: %q", p.Name())
-				return nil, fmt.Errorf("can't specify non-optional param after optional ones: %q", p.Name())
+		}
-			}
+		if p.IsRepeat() {
-			if p.IsRepeat() {
+			minArgs--
-				minArgs--
+			maxArgs = -1
-				maxArgs = -1
-			}
 		}
 	}
+
 	info = &funcInfo{
-		name: name, minArgs: minArgs, maxArgs: maxArgs, functor: functor, returnType: returnType, params: params,
+		name: name, minArgs: minArgs, maxArgs: maxArgs, functor: functor, returnType: returnType, formalParams: params,
 	}
 	functor.SetFunc(info)
 	return info, nil
 }
 
-func newUnnamedFuncInfo(functor Functor, returnType string, params []ExprFuncParam) (info *funcInfo, err error) {
+// func newUnnamedFuncInfo(functor Functor, returnType string, params []ExprFuncParam) (info *funcInfo, err error) {
-	return newFuncInfo("unnamed", functor, returnType, params)
+// 	return newFuncInfo("unnamed", functor, returnType, params)
-}
+// }
 
 func (info *funcInfo) Params() []ExprFuncParam {
-	return info.params
+	return info.formalParams
 }
 
 func (info *funcInfo) ReturnType() string {
@@ -200,14 +157,14 @@ func (info *funcInfo) ToString(opt FmtOpt) string {
 		sb.WriteString(info.Name())
 	}
 	sb.WriteByte('(')
-	if info.params != nil {
+	if info.formalParams != nil {
-		for i, p := range info.params {
+		for i, p := range info.formalParams {
 			if i > 0 {
 				sb.WriteString(", ")
 			}
 			sb.WriteString(p.Name())
 
-			if p.IsOptional() {
+			if p.IsDefault() {
 				sb.WriteByte('=')
 				if s, ok := p.DefaultValue().(string); ok {
 					sb.WriteByte('"')
@@ -226,9 +183,9 @@ func (info *funcInfo) ToString(opt FmtOpt) string {
 	if len(info.returnType) > 0 {
 		sb.WriteString(info.returnType)
 	} else {
-		sb.WriteString(typeAny)
+		sb.WriteString(TypeAny)
 	}
-	sb.WriteString(" {<body>}")
+	sb.WriteString("{}")
 	return sb.String()
 }
 
@@ -247,3 +204,53 @@ func (info *funcInfo) MaxArgs() int {
 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) PrepareCall(parentCtx ExprContext, name string, varActualParams *[]any) (ctx ExprContext, err error) {
+	passedCount := len(*varActualParams)
+	if info.MinArgs() > passedCount {
+		err = ErrTooFewParams(name, info.MinArgs(), info.MaxArgs(), passedCount)
+	}
+
+	for i := passedCount; i < len(info.formalParams); i++ {
+		p := info.formalParams[i]
+		if !p.IsDefault() {
+			break
+		}
+		*varActualParams = append(*varActualParams, p.DefaultValue())
+	}
+	if err == nil && info.MaxArgs() >= 0 && info.MaxArgs() < len(*varActualParams) {
+		err = ErrTooMuchParams(name, info.MaxArgs(), len(*varActualParams))
+	}
+
+	if err == nil {
+		ctx = info.AllocContext(parentCtx)
+	}
+	return
+}
+
+// ----- Call a function ---
+
+func CallFunction(parentCtx ExprContext, name string, actualParams []any) (result any, err error) {
+	if info, exists, _ := GetFuncInfo(parentCtx, name); exists {
+		var ctx ExprContext
+		if ctx, err = info.PrepareCall(parentCtx, name, &actualParams); err == nil {
+			functor := info.Functor()
+			result, err = functor.Invoke(ctx, name, actualParams)
+			exportObjectsToParent(ctx)
+		}
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}

global-context.go

@@ -4,13 +4,16 @@
 // global-context.go
 package expr
 
-import "path/filepath"
+import (
+	"path/filepath"
+	"strings"
+)
 
 var globalCtx *SimpleStore
 
 func ImportInContext(name string) (exists bool) {
-	var mod *module
+	var mod *builtinModule
-	if mod, exists = moduleRegister[name]; exists {
+	if mod, exists = builtinModuleRegister[name]; exists {
 		mod.importFunc(globalCtx)
 		mod.imported = true
 	}
@@ -19,7 +22,7 @@ func ImportInContext(name string) (exists bool) {
 
 func ImportInContextByGlobPattern(pattern string) (count int, err error) {
 	var matched bool
-	for name, mod := range moduleRegister {
+	for name, mod := range builtinModuleRegister {
 		if matched, err = filepath.Match(pattern, name); err == nil {
 			if matched {
 				count++
@@ -63,7 +66,78 @@ func GetFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool, owne
 	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)
 }

helpers.go

@@ -16,10 +16,10 @@ func EvalString(ctx ExprContext, source string) (result any, err error) {
 
 	r := strings.NewReader(source)
 	scanner := NewScanner(r, DefaultTranslations())
-	parser := NewParser(ctx)
+	parser := NewParser()
 
 	if tree, err = parser.Parse(scanner); err == nil {
-		result, err = tree.eval(ctx, true)
+		result, err = tree.Eval(ctx)
 	}
 	return
 }
@@ -38,10 +38,10 @@ func EvalStringV(source string, args []Arg) (result any, err error) {
 	for _, arg := range args {
 		if isFunc(arg.Value) {
 			if f, ok := arg.Value.(FuncTemplate); ok {
-				functor := newGolangFunctor(f)
+				functor := NewGolangFunctor(f)
 				// ctx.RegisterFunc(arg.Name, functor, 0, -1)
-				ctx.RegisterFunc(arg.Name, functor, typeAny, []ExprFuncParam{
+				ctx.RegisterFunc(arg.Name, functor, TypeAny, []ExprFuncParam{
-					newFuncParamFlagDef(paramValue, pfOptional|pfRepeat, 0),
+					NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, 0),
 				})
 			} else {
 				err = fmt.Errorf("invalid function specification: %q", arg.Name)
@@ -68,7 +68,7 @@ func EvalStringV(source string, args []Arg) (result any, err error) {
 func EvalStream(ctx ExprContext, r io.Reader) (result any, err error) {
 	var tree *ast
 	scanner := NewScanner(r, DefaultTranslations())
-	parser := NewParser(ctx)
+	parser := NewParser()
 
 	if tree, err = parser.Parse(scanner); err == nil {
 		result, err = tree.Eval(ctx)

import-utils.go

@@ -0,0 +1,112 @@
+// 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
+	for _, dir := range dirList {
+		if dir, err = ExpandPath(dir); err != nil {
+			continue
+		}
+		if fullPath := path.Join(dir, 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
+}

iterator.go

@@ -12,19 +12,23 @@ import (
 // Operator names
 
 const (
-	initName    = "init"
+	InitName    = "init"
-	cleanName   = "clean"
+	CleanName   = "clean"
-	resetName   = "reset"
+	ResetName   = "reset"
-	nextName    = "next"
+	NextName    = "next"
-	currentName = "current"
+	CurrentName = "current"
-	indexName   = "index"
+	IndexName   = "index"
-	countName   = "count"
+	CountName   = "count"
+	FilterName  = "filter"
+	MapName     = "map"
 )
 
 type Iterator interface {
+	Typer
 	Next() (item any, err error) // must return io.EOF after the last item
 	Current() (item any, err error)
 	Index() int
+	Count() int
 }
 
 type ExtIterator interface {

list-iterator.go

@@ -1,7 +1,7 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// iter-list.go
+// list-iterator.go
 package expr
 
 import (
@@ -26,21 +26,21 @@ func NewListIterator(list *ListType, args []any) (it *ListIterator) {
 	}
 	it = &ListIterator{a: list, count: 0, index: -1, start: 0, stop: listLen - 1, step: 1}
 	if argc >= 1 {
-		if i, err := toInt(args[0], "start index"); err == nil {
+		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 := toInt(args[1], "stop index"); err == nil {
+			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 := toInt(args[2], "step"); err == nil {
+				if i, err := ToGoInt(args[2], "step"); err == nil {
 					if i < 0 {
 						i = -i
 					}
@@ -85,18 +85,26 @@ func (it *ListIterator) String() string {
 	return fmt.Sprintf("$(#%d)", l)
 }
 
+func (it *ListIterator) TypeName() string {
+	return "ListIterator"
+}
+
 func (it *ListIterator) HasOperation(name string) bool {
-	yes := name == resetName || name == indexName || name == countName
+	yes := name == NextName || name == ResetName || name == IndexName || name == CountName || name == CurrentName
 	return yes
 }
 
 func (it *ListIterator) CallOperation(name string, args []any) (v any, err error) {
 	switch name {
-	case resetName:
+	case NextName:
+		v, err = it.Next()
+	case ResetName:
 		v, err = it.Reset()
-	case indexName:
+	case IndexName:
 		v = int64(it.Index())
-	case countName:
+	case CurrentName:
+		v, err = it.Current()
+	case CountName:
 		v = it.count
 	default:
 		err = errNoOperation(name)
@@ -135,7 +143,12 @@ func (it *ListIterator) Index() int {
 	return it.index
 }
 
+func (it *ListIterator) Count() int {
+	return it.count
+}
+
 func (it *ListIterator) Reset() (bool, error) {
-	it.index = it.start
+	it.index = it.start - it.step
+	it.count = 0
 	return true, nil
 }

list-type.go

@@ -20,27 +20,57 @@ func newListA(listAny ...any) (list *ListType) {
 }
 
 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 {
+//		for i, item := range listAny {
-			ls[i] = item
+//			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 {
-		if opt&MultiLine != 0 {
+                innerOpt := MakeFormatOptions(flags, indent+1)
-			sb.WriteString("\n  ")
+                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 opt&MultiLine != 0 {
+				if flags&MultiLine != 0 {
-					sb.WriteString(",\n  ")
+					sb.WriteString(",\n")
+					sb.WriteString(nest)
 				} else {
 					sb.WriteString(", ")
 				}
@@ -49,17 +79,20 @@ func (ls *ListType) ToString(opt FmtOpt) (s string) {
 				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 opt&MultiLine != 0 {
+		if flags&MultiLine != 0 {
 			sb.WriteByte('\n')
+			sb.WriteString(strings.Repeat("  ", indent))
 		}
 	}
 	sb.WriteByte(']')
 	s = sb.String()
-	if opt&Truncate != 0 && len(s) > TruncateSize {
+	if flags&Truncate != 0 && len(s) > TruncateSize {
 		s = TruncateString(s)
 	}
 	return
@@ -73,16 +106,16 @@ func (ls *ListType) TypeName() string {
 	return "list"
 }
 
-func (list *ListType) indexDeepCmp(target any) (index int) {
+// func (list *ListType) indexDeepCmp(target any) (index int) {
-	index = -1
+// 	index = -1
-	for i, item := range *list {
+// 	for i, item := range *list {
-		if reflect.DeepEqual(item, target) {
+// 		if reflect.DeepEqual(item, target) {
-			index = i
+// 			index = i
-			break
+// 			break
-		}
+// 		}
-	}
+// 	}
-	return
+// 	return
-}
+// }
 
 func (ls *ListType) contains(t *ListType) (answer bool) {
 	if len(*ls) >= len(*t) {

module-register.go

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

operand-dict.go

@@ -18,8 +18,8 @@ func newDictTerm(args map[any]*term) *term {
 }
 
 // -------- dict func
-func evalDict(ctx ExprContext, self *term) (v any, err error) {
+func evalDict(ctx ExprContext, opTerm *term) (v any, err error) {
-	dict, _ := self.value().(map[any]*term)
+	dict, _ := opTerm.value().(map[any]*term)
 	items := make(DictType, len(dict))
 	for key, tree := range dict {
 		var param any

operand-expr.go

@@ -20,11 +20,11 @@ func newExprTerm(root *term) *term {
 }
 
 // -------- eval expr
-func evalExpr(ctx ExprContext, self *term) (v any, err error) {
+func evalExpr(ctx ExprContext, opTerm *term) (v any, err error) {
-	if expr, ok := self.value().(*term); ok {
+	if expr, ok := opTerm.value().(*term); ok {
 		v, err = expr.compute(ctx)
 	} else {
-		err = fmt.Errorf("expression expected, got %T", self.value())
+		err = fmt.Errorf("expression expected, got %T", opTerm.value())
 	}
 	return
 }

operand-func.go

@@ -6,7 +6,6 @@ package expr
 
 import (
 	"errors"
-	"fmt"
 )
 
 // -------- function call term
@@ -22,37 +21,10 @@ func newFuncCallTerm(tk *Token, args []*term) *term {
 }
 
 // -------- eval func call
-func checkFunctionCall(ctx ExprContext, name string, varParams *[]any) (err error) {
+func evalFuncCall(ctx ExprContext, opTerm *term) (v any, err error) {
-	if info, exists, owner := GetFuncInfo(ctx, name); exists {
+	name, _ := opTerm.tk.Value.(string)
-		passedCount := len(*varParams)
+	params := make([]any, len(opTerm.children), len(opTerm.children)+5)
-		if info.MinArgs() > passedCount {
+	for i, tree := range opTerm.children {
-			err = errTooFewParams(name, info.MinArgs(), info.MaxArgs(), passedCount)
-		}
-		for i, p := range info.Params() {
-			if i >= passedCount {
-				if !p.IsOptional() {
-					break
-				}
-				*varParams = append(*varParams, p.DefaultValue())
-			}
-		}
-		if err == nil && info.MaxArgs() >= 0 && info.MaxArgs() < len(*varParams) {
-			err = errTooMuchParams(name, info.MaxArgs(), len(*varParams))
-		}
-		if err == nil && owner != ctx {
-			ctx.RegisterFuncInfo(info)
-		}
-	} else {
-		err = fmt.Errorf("unknown function %s()", name)
-	}
-	return
-}
-
-func evalFuncCall(parentCtx ExprContext, self *term) (v any, err error) {
-	ctx := cloneContext(parentCtx)
-	name, _ := self.tk.Value.(string)
-	params := make([]any, len(self.children), len(self.children)+5)
-	for i, tree := range self.children {
 		var param any
 		if param, err = tree.compute(ctx); err != nil {
 			break
@@ -61,11 +33,7 @@ func evalFuncCall(parentCtx ExprContext, self *term) (v any, err error) {
 	}
 
 	if err == nil {
-		if err = checkFunctionCall(ctx, name, &params); err == nil {
+		v, err = CallFunction(ctx, name, params)
-			if v, err = ctx.Call(name, params); err == nil {
-				exportObjects(parentCtx, ctx)
-			}
-		}
 	}
 	return
 }
@@ -83,20 +51,20 @@ func newFuncDefTerm(tk *Token, args []*term) *term {
 }
 
 // -------- eval func def
-func evalFuncDef(ctx ExprContext, self *term) (v any, err error) {
+func evalFuncDef(ctx ExprContext, opTerm *term) (v any, err error) {
-	bodySpec := self.value()
+	bodySpec := opTerm.value()
 	if expr, ok := bodySpec.(*ast); ok {
-		paramList := make([]ExprFuncParam, 0, len(self.children))
+		paramList := make([]ExprFuncParam, 0, len(opTerm.children))
-		for _, param := range self.children {
+		for _, param := range opTerm.children {
 			var defValue any
 			flags := paramFlags(0)
 			if len(param.children) > 0 {
-				flags |= pfOptional
+				flags |= PfDefault
 				if defValue, err = param.children[0].compute(ctx); err != nil {
 					return
 				}
 			}
-			info := newFuncParamFlagDef(param.source(), flags, defValue)
+			info := NewFuncParamFlagDef(param.source(), flags, defValue)
 			paramList = append(paramList, info)
 		}
 		v = newExprFunctor(expr, paramList, ctx)

operand-iterator.go

@@ -5,28 +5,27 @@
 package expr
 
 import (
-	"fmt"
 	"slices"
 	"strings"
 )
 
 // -------- iterator term
 
-func newDsIteratorTerm(tk *Token, dsTerm *term, args []*term) *term {
+// func newDsIteratorTerm(tk *Token, dsTerm *term, args []*term) *term {
-	tk.Sym = SymIterator
+// 	tk.Sym = SymIterator
 
-	children := make([]*term, 0, 1+len(args))
+// 	children := make([]*term, 0, 1+len(args))
-	children = append(children, dsTerm)
+// 	children = append(children, dsTerm)
-	children = append(children, args...)
+// 	children = append(children, args...)
-	return &term{
+// 	return &term{
-		tk:       *tk,
+// 		tk:       *tk,
-		parent:   nil,
+// 		parent:   nil,
-		children: children,
+// 		children: children,
-		position: posLeaf,
+// 		position: posLeaf,
-		priority: priValue,
+// 		priority: priValue,
-		evalFunc: evalIterator,
+// 		evalFunc: evalIterator,
-	}
+// 	}
-}
+// }
 
 func newIteratorTerm(tk *Token, args []*term) *term {
 	tk.Sym = SymIterator
@@ -42,9 +41,9 @@ func newIteratorTerm(tk *Token, args []*term) *term {
 
 // -------- eval iterator
 
-func evalTermArray(ctx ExprContext, a []*term) (values []any, err error) {
+func evalTermArray(ctx ExprContext, terms []*term) (values []any, err error) {
-	values = make([]any, len(a))
+	values = make([]any, len(terms))
-	for i, t := range a {
+	for i, t := range terms {
 		var value any
 		if value, err = t.compute(ctx); err == nil {
 			values[i] = value
@@ -55,26 +54,24 @@ func evalTermArray(ctx ExprContext, a []*term) (values []any, err error) {
 	return
 }
 
-func evalFirstChild(ctx ExprContext, self *term) (value any, err error) {
+func evalFirstChild(ctx ExprContext, iteratorTerm *term) (value any, err error) {
-	if len(self.children) < 1 || self.children[0] == nil {
+	if len(iteratorTerm.children) < 1 || iteratorTerm.children[0] == nil {
-		err = self.Errorf("missing the data-source parameter")
+		err = iteratorTerm.Errorf("missing the data-source parameter")
 		return
 	}
 
-	value, err = self.children[0].compute(ctx)
+	value, err = iteratorTerm.children[0].compute(ctx)
 	return
 }
 
-func getDataSourceDict(ctx ExprContext, self *term, firstChildValue any) (ds map[string]Functor, err error) {
+func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]Functor, err error) {
-	// if dictAny, ok := firstChildValue.(map[any]any); ok {
 	if dictAny, ok := firstChildValue.(*DictType); ok {
-		requiredFields := []string{currentName, nextName}
+		requiredFields := []string{NextName}
-		fieldsMask := 0b11
+		fieldsMask := 0b1
 		foundFields := 0
 		ds = make(map[string]Functor)
 		for keyAny, item := range *dictAny {
 			if key, ok := keyAny.(string); ok {
-				//if functor, ok := item.(*funcDefFunctor); ok {
 				if functor, ok := item.(Functor); ok {
 					ds[key] = functor
 					if index := slices.Index(requiredFields, key); index >= 0 {
@@ -91,57 +88,55 @@ func getDataSourceDict(ctx ExprContext, self *term, firstChildValue any) (ds map
 					missingFields = append(missingFields, field)
 				}
 			}
-			err = fmt.Errorf("the data-source must provide a non-nil %q operator(s)", strings.Join(missingFields, ", "))
+			err = iteratorTerm.children[0].Errorf("the data-source must provide a non-nil %q operator(s)", strings.Join(missingFields, ", "))
 		}
 	}
 	return
 }
 
-func evalIterator(ctx ExprContext, self *term) (v any, err error) {
+func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
 	var firstChildValue any
 	var ds map[string]Functor
 
-	if firstChildValue, err = evalFirstChild(ctx, self); err != nil {
+	if firstChildValue, err = evalFirstChild(ctx, opTerm); err != nil {
 		return
 	}
 
-	if ds, err = getDataSourceDict(ctx, self, firstChildValue); err != nil {
+	if ds, err = getDataSourceDict(opTerm, firstChildValue); err != nil {
 		return
 	}
 
 	if ds != nil {
-		dc := newDataCursor(ctx, ds)
+		var dc *dataCursor
-		if initFunc, exists := ds[initName]; exists && initFunc != nil {
+		if initFunc, exists := ds[InitName]; exists && initFunc != nil {
 			var args []any
-			if len(self.children) > 1 {
+			var resource any
-				if args, err = evalTermArray(ctx, self.children[1:]); err != nil {
+			if len(opTerm.children) > 1 {
+				if args, err = evalTermArray(ctx, opTerm.children[1:]); err != nil {
 					return
 				}
 			} else {
 				args = []any{}
 			}
 
-			initCtx := dc.ctx.Clone()
+			initCtx := ctx.Clone()
-			if dc.resource, err = initFunc.Invoke(initCtx, initName, args); err != nil {
+			if resource, err = initFunc.Invoke(initCtx, InitName, args); err != nil {
 				return
 			}
-			exportObjects(dc.ctx, initCtx)
+			dcCtx := ctx.Clone()
+			exportObjects(dcCtx, initCtx)
+			dc = NewDataCursor(dcCtx, ds, resource)
 		}
 
-		dc.nextFunc, _ = ds[nextName]
-		dc.currentFunc, _ = ds[currentName]
-		dc.cleanFunc, _ = ds[cleanName]
-		dc.resetFunc, _ = ds[resetName]
-
 		v = dc
 	} else if list, ok := firstChildValue.(*ListType); ok {
 		var args []any
-		if args, err = evalSibling(ctx, self.children, nil); err == nil {
+		if args, err = evalSibling(ctx, opTerm.children, nil); err == nil {
 			v = NewListIterator(list, args)
 		}
 	} else {
 		var list []any
-		if list, err = evalSibling(ctx, self.children, firstChildValue); err == nil {
+		if list, err = evalSibling(ctx, opTerm.children, firstChildValue); err == nil {
 			v = NewArrayIterator(list)
 		}
 	}

operand-list.go

@@ -21,8 +21,8 @@ func newListTerm(row, col int, args []*term) *term {
 }
 
 // -------- list func
-func evalList(ctx ExprContext, self *term) (v any, err error) {
+func evalList(ctx ExprContext, opTerm *term) (v any, err error) {
-	list, _ := self.value().([]*term)
+	list, _ := opTerm.value().([]*term)
 	items := make(ListType, len(list))
 	for i, tree := range list {
 		var param any

operand-literal.go

@@ -17,8 +17,8 @@ func newLiteralTerm(tk *Token) *term {
 }
 
 // -------- eval func
-func evalLiteral(ctx ExprContext, self *term) (v any, err error) {
+func evalLiteral(ctx ExprContext, opTerm *term) (v any, err error) {
-	v = self.tk.Value
+	v = opTerm.tk.Value
 	return
 }
 

operand-selector-case.go

@@ -41,10 +41,10 @@ func newSelectorCaseTerm(row, col int, filterList *term, caseExpr Expr) *term {
 }
 
 // -------- eval selector case
-func evalSelectorCase(ctx ExprContext, self *term) (v any, err error) {
+func evalSelectorCase(ctx ExprContext, opTerm *term) (v any, err error) {
 	var ok bool
-	if v, ok = self.value().(*selectorCase); !ok {
+	if v, ok = opTerm.value().(*selectorCase); !ok {
-		err = fmt.Errorf("selector-case expected, got %T", self.value())
+		err = fmt.Errorf("selector-case expected, got %T", opTerm.value())
 	}
 	return
 }

operand-var.go

@@ -21,9 +21,9 @@ func newVarTerm(tk *Token) *term {
 }
 
 // -------- 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
-	name := self.source()
+	name := opTerm.source()
 	if v, exists = GetVar(ctx, name); !exists {
 		if info, exists, _ := GetFuncInfo(ctx, name); exists {
 			v = info.Functor()

operator-assign.go

@@ -28,7 +28,7 @@ func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, va
 	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))
+		err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, TypeName(keyListValue))
 		return
 	}
 	if keyValue = (*keyList)[0]; keyValue == nil {
@@ -41,7 +41,7 @@ func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, va
 		if index, ok := keyValue.(int64); ok {
 			err = collection.setItem(index, value)
 		} else {
-			err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, typeName(keyValue))
+			err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, TypeName(keyValue))
 		}
 	case *DictType:
 		err = collection.setItem(keyValue, value)
@@ -60,30 +60,34 @@ func assignValue(ctx ExprContext, leftTerm *term, v any) (err error) {
 	return
 }
 
-func evalAssign(ctx ExprContext, self *term) (v any, err error) {
+func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) {
-	if err = self.checkOperands(); err != nil {
+	if err = opTerm.checkOperands(); err != nil {
 		return
 	}
 
-	leftTerm := self.children[0]
+	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", self.tk.source)
+		err = leftTerm.tk.Errorf("left operand of %q must be a variable or a collection's item", opTerm.tk.source)
 		return
 	}
 
-	rightChild := self.children[1]
+	rightChild := opTerm.children[1]
 
 	if v, err = rightChild.compute(ctx); err == nil {
 		if functor, ok := v.(Functor); ok {
-			if info := functor.GetFunc(); info != nil {
+			if leftSym == SymVariable {
-				ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
+				if info := functor.GetFunc(); info != nil {
-			} else if funcDef, ok := functor.(*exprFunctor); ok {
+					ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
-				paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })
+				} else if funcDef, ok := functor.(*exprFunctor); ok {
+					paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })
 
-				ctx.RegisterFunc(leftTerm.source(), functor, typeAny, paramSpecs)
+					ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, paramSpecs)
+				} else {
+					err = opTerm.Errorf("unknown function %s()", rightChild.source())
+				}
 			} else {
-				err = self.Errorf("unknown function %s()", rightChild.source())
+				err = assignValue(ctx, leftTerm, v)
 			}
 		} else {
 			err = assignValue(ctx, leftTerm, v)

operator-bool.go

@@ -18,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
 }
@@ -37,9 +37,7 @@ func evalNot(ctx ExprContext, self *term) (v any, err error) {
 
 func newAndTerm(tk *Token) (inst *term) {
 	return &term{
-		tk: *tk,
+		tk:       *tk,
-		// class:    classOperator,
-		// kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priAnd,
@@ -48,7 +46,7 @@ func newAndTerm(tk *Token) (inst *term) {
 }
 
 func evalAnd(ctx ExprContext, self *term) (v any, err error) {
-	if isEnabled(ctx, ControlBoolShortcut) {
+	if CtrlIsEnabled(ctx, ControlBoolShortcut) {
 		v, err = evalAndWithShortcut(ctx, self)
 	} else {
 		v, err = evalAndWithoutShortcut(ctx, self)
@@ -65,8 +63,8 @@ func evalAndWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	leftBool, lok = toBool(leftValue)
+	leftBool, lok = ToBool(leftValue)
-	rightBool, rok = toBool(rightValue)
+	rightBool, rok = ToBool(rightValue)
 
 	if lok && rok {
 		v = leftBool && rightBool
@@ -87,13 +85,13 @@ func evalAndWithShortcut(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if leftBool, lok := toBool(leftValue); !lok {
+	if leftBool, lok := ToBool(leftValue); !lok {
-		err = fmt.Errorf("got %T as left operand type of 'and' operator, it must be bool", leftBool)
+		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 {
+		if rightBool, rok := ToBool(rightValue); rok {
 			v = rightBool
 		} else {
 			err = self.errIncompatibleTypes(leftValue, rightValue)
@@ -106,9 +104,7 @@ func evalAndWithShortcut(ctx ExprContext, self *term) (v any, err error) {
 
 func newOrTerm(tk *Token) (inst *term) {
 	return &term{
-		tk: *tk,
+		tk:       *tk,
-		// class:    classOperator,
-		// kind:     kindBool,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priOr,
@@ -117,7 +113,7 @@ func newOrTerm(tk *Token) (inst *term) {
 }
 
 func evalOr(ctx ExprContext, self *term) (v any, err error) {
-	if isEnabled(ctx, ControlBoolShortcut) {
+	if CtrlIsEnabled(ctx, ControlBoolShortcut) {
 		v, err = evalOrWithShortcut(ctx, self)
 	} else {
 		v, err = evalOrWithoutShortcut(ctx, self)
@@ -134,8 +130,8 @@ func evalOrWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	leftBool, lok = toBool(leftValue)
+	leftBool, lok = ToBool(leftValue)
-	rightBool, rok = toBool(rightValue)
+	rightBool, rok = ToBool(rightValue)
 
 	if lok && rok {
 		v = leftBool || rightBool
@@ -156,13 +152,13 @@ func evalOrWithShortcut(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	if leftBool, lok := toBool(leftValue); !lok {
+	if leftBool, lok := ToBool(leftValue); !lok {
-		err = fmt.Errorf("got %T as left operand type of 'or' operator, it must be bool", leftBool)
+		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 {
+		if rightBool, rok := ToBool(rightValue); rok {
 			v = rightBool
 		} else {
 			err = self.errIncompatibleTypes(leftValue, rightValue)

operator-builtin.go

@@ -18,10 +18,10 @@ func newBuiltinTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalBuiltin(ctx ExprContext, self *term) (v any, err error) {
+func evalBuiltin(ctx ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 
-	if childValue, err = self.evalPrefix(ctx); err != nil {
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
@@ -37,11 +37,11 @@ func evalBuiltin(ctx ExprContext, self *term) (v any, err error) {
 				if ImportInContext(module) {
 					count++
 				} else {
-					err = self.Errorf("unknown module %q", module)
+					err = opTerm.Errorf("unknown builtin module %q", module)
 					break
 				}
 			} else {
-				err = self.Errorf("expected string at item nr %d, got %T", it.Index()+1, moduleSpec)
+				err = opTerm.Errorf("expected string at item nr %d, got %s", it.Index()+1, TypeName(moduleSpec))
 				break
 			}
 		}

operator-but.go

@@ -16,8 +16,8 @@ func newButTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalBut(ctx ExprContext, self *term) (v any, err error) {
+func evalBut(ctx ExprContext, opTerm *term) (v any, err error) {
-	_, v, err = self.evalInfix(ctx)
+	_, v, err = opTerm.evalInfix(ctx)
 	return
 }
 

operator-coalesce.go

@@ -1,85 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-coalesce.go
-package expr
-
-//-------- null coalesce term
-
-func newNullCoalesceTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 2),
-		position: posInfix,
-		priority: priCoalesce,
-		evalFunc: evalNullCoalesce,
-	}
-}
-
-func evalNullCoalesce(ctx ExprContext, self *term) (v any, err error) {
-	var rightValue any
-
-	if err = self.checkOperands(); err != nil {
-		return
-	}
-
-	leftTerm := self.children[0]
-	if leftTerm.tk.Sym != SymVariable {
-		err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
-		return
-	}
-
-	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
-		v = leftValue
-	} else if rightValue, err = self.children[1].compute(ctx); err == nil {
-		v = rightValue
-	}
-	return
-}
-
-//-------- coalesce assign term
-
-func newCoalesceAssignTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 2),
-		position: posInfix,
-		priority: priCoalesce,
-		evalFunc: evalAssignCoalesce,
-	}
-}
-
-func evalAssignCoalesce(ctx ExprContext, self *term) (v any, err error) {
-	var rightValue any
-
-	if err = self.checkOperands(); err != nil {
-		return
-	}
-
-	leftTerm := self.children[0]
-	if leftTerm.tk.Sym != SymVariable {
-		err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
-		return
-	}
-
-	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
-		v = leftValue
-	} else if rightValue, err = self.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, pfOptional|pfRepeat),
-			})
-		} else {
-			v = rightValue
-			ctx.UnsafeSetVar(leftTerm.source(), rightValue)
-		}
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymDoubleQuestion, newNullCoalesceTerm)
-	registerTermConstructor(SymQuestionEqual, newCoalesceAssignTerm)
-}

operator-context.go

@@ -16,25 +16,28 @@ func newContextTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalContextValue(ctx ExprContext, self *term) (v any, err error) {
+func evalContextValue(ctx ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 
 	var sourceCtx ExprContext
-	if self.children == nil || len(self.children) == 0 {
+	if opTerm.children == nil || len(opTerm.children) == 0 {
 		sourceCtx = ctx
-	} else if self.children[0].symbol() == SymVariable && self.children[0].source() == "global" {
+	} else if opTerm.children[0].symbol() == SymVariable && opTerm.children[0].source() == "global" {
 		sourceCtx = globalCtx
-	} else if childValue, err = self.evalPrefix(ctx); err == nil {
+	} 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.(Formatter); ok {
+		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(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)
@@ -46,7 +49,7 @@ func evalContextValue(ctx ExprContext, self *term) (v any, err error) {
 			v = d
 		}
 	} else {
-		err = self.errIncompatibleType(childValue)
+		err = opTerm.errIncompatibleType(childValue)
 	}
 	return
 }

operator-ctrl.go

@@ -16,8 +16,8 @@ func newExportAllTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalExportAll(ctx ExprContext, self *term) (v any, err error) {
+func evalExportAll(ctx ExprContext, opTerm *term) (v any, err error) {
-	enable(ctx, control_export_all)
+	CtrlEnable(ctx, control_export_all)
 	return
 }
 

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

@@ -15,17 +15,17 @@ func newDotTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalDot(ctx ExprContext, self *term) (v any, err error) {
+func evalDot(ctx ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	if err = self.checkOperands(); err != nil {
+	if err = opTerm.checkOperands(); err != nil {
 		return
 	}
-	if leftValue, err = self.children[0].compute(ctx); err != nil {
+	if leftValue, err = opTerm.children[0].compute(ctx); err != nil {
 		return
 	}
 
-	indexTerm := self.children[1]
+	indexTerm := opTerm.children[1]
 
 	switch unboxedValue := leftValue.(type) {
 	case ExtIterator:
@@ -41,8 +41,8 @@ func evalDot(ctx ExprContext, self *term) (v any, err error) {
 			err = indexTerm.tk.ErrorExpectedGot("identifier")
 		}
 	default:
-		if rightValue, err = self.children[1].compute(ctx); err == nil {
+		if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
-			err = self.errIncompatibleTypes(leftValue, rightValue)
+			err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 		}
 	}
 	return

operator-fact.go

@@ -18,10 +18,10 @@ 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
 	}
 
@@ -36,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

@@ -24,12 +24,12 @@ func newFractionTerm(tk *Token) *term {
 }
 
 // -------- eval func
-func evalFraction(ctx ExprContext, self *term) (v any, err error) {
+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 = self.evalInfix(ctx); err != nil {
+	if numValue, denValue, err = opTerm.evalInfix(ctx); err != nil {
 		return
 	}
 	if num, ok = numValue.(int64); !ok {

operator-in.go

@@ -21,10 +21,10 @@ func newInTerm(tk *Token) (inst *term) {
 // 	return
 // }
 
-func evalIn(ctx ExprContext, self *term) (v any, err error) {
+func evalIn(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
 	}
 
@@ -35,7 +35,7 @@ func evalIn(ctx ExprContext, self *term) (v any, err error) {
 		dict, _ := rightValue.(*DictType)
 		v = dict.hasKey(leftValue)
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }

operator-include.go

@@ -16,37 +16,40 @@ func newIncludeTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalInclude(ctx ExprContext, self *term) (v any, err error) {
+func evalInclude(ctx ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 
-	if childValue, err = self.evalPrefix(ctx); err != nil {
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
 	count := 0
 	if IsList(childValue) {
-		list, _ := childValue.([]any)
+		list, _ := childValue.(*ListType)
-		for i, filePathSpec := range list {
+		for i, filePathSpec := range *list {
 			if filePath, ok := filePathSpec.(string); ok {
 				if v, err = EvalFile(ctx, filePath); err == nil {
 					count++
 				} else {
-					err = self.Errorf("can't load file %q", filePath)
+					err = opTerm.Errorf("can't load file %q", filePath)
 					break
 				}
 			} else {
-				err = self.Errorf("expected string at item nr %d, got %T", i+1, filePathSpec)
+				err = opTerm.Errorf("expected string at item nr %d, got %T", i+1, filePathSpec)
 				break
 			}
 		}
 	} else if IsString(childValue) {
 		filePath, _ := childValue.(string)
-		v, err = EvalFile(ctx, filePath)
+		if v, err = EvalFile(ctx, filePath); err == nil {
+			count++
+		}
 	} else {
-		err = self.errIncompatibleType(childValue)
+		err = opTerm.errIncompatibleType(childValue)
 	}
-	if err == nil {
+	if err != nil {
-		v = count
+		//v = count
+		v = nil
 	}
 	return
 }

operator-index.go

@@ -15,7 +15,7 @@ func newIndexTerm(tk *Token) (inst *term) {
 	}
 }
 
-func verifyKey(indexTerm *term, indexList *ListType) (index any, err error) {
+func verifyKey(indexList *ListType) (index any, err error) {
 	index = (*indexList)[0]
 	return
 }
@@ -23,7 +23,7 @@ func verifyKey(indexTerm *term, indexList *ListType) (index any, err error) {
 func verifyIndex(indexTerm *term, indexList *ListType, maxValue int) (index int, err error) {
 	var v int
 
-	if v, err = toInt((*indexList)[0], "index expression"); err == nil {
+	if v, err = ToGoInt((*indexList)[0], "index expression"); err == nil {
 		if v < 0 && v >= -maxValue {
 			v = maxValue + v
 		}
@@ -40,11 +40,14 @@ func verifyRange(indexTerm *term, indexList *ListType, maxValue int) (startIndex
 	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 + 1
+		endIndex = maxValue + endIndex
 	}
 	if startIndex < 0 || startIndex > maxValue {
 		err = indexTerm.Errorf("range start-index %d is out of bounds", startIndex)
@@ -56,18 +59,18 @@ func verifyRange(indexTerm *term, indexList *ListType, maxValue int) (startIndex
 	return
 }
 
-func evalIndex(ctx ExprContext, self *term) (v any, err error) {
+func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 	var indexList *ListType
 	var ok bool
 
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
-	indexTerm := self.children[1]
+	indexTerm := opTerm.children[1]
 	if indexList, ok = rightValue.(*ListType); !ok {
-		err = self.Errorf("invalid index expression")
+		err = opTerm.Errorf("invalid index expression")
 		return
 	} else if len(*indexList) != 1 {
 		err = indexTerm.Errorf("one index only is allowed")
@@ -87,15 +90,9 @@ func evalIndex(ctx ExprContext, self *term) (v any, err error) {
 				v = string(unboxedValue[index])
 			}
 		case *DictType:
-			var ok bool
+			v, err = getDictItem(unboxedValue, indexTerm, indexList, rightValue)
-			var indexValue any
-			if indexValue, err = verifyKey(indexTerm, indexList); err == nil {
-				if v, ok = (*unboxedValue)[indexValue]; !ok {
-					err = indexTerm.Errorf("key %v does not belong to the dictionary", rightValue)
-				}
-			}
 		default:
-			err = self.errIncompatibleTypes(leftValue, rightValue)
+			err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 		}
 	} else if isIntPair((*indexList)[0]) {
 		switch unboxedValue := leftValue.(type) {
@@ -111,7 +108,22 @@ func evalIndex(ctx ExprContext, self *term) (v any, err error) {
 				v = unboxedValue[start:end]
 			}
 		default:
-			err = self.errIncompatibleTypes(leftValue, rightValue)
+			err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+		}
+	} else if IsDict(leftValue) {
+		d := leftValue.(*DictType)
+		v, err = getDictItem(d, indexTerm, indexList, rightValue)
+	}
+	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

operator-insert.go

@@ -26,10 +26,10 @@ func newAppendTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalInsert(ctx ExprContext, self *term) (v any, err error) {
+func evalInsert(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
 	}
 
@@ -37,19 +37,19 @@ func evalInsert(ctx ExprContext, self *term) (v any, err error) {
 		list, _ := rightValue.(*ListType)
 		newList := append(ListType{leftValue}, *list...)
 		v = &newList
-		if self.children[1].symbol() == SymVariable {
+		if opTerm.children[1].symbol() == SymVariable {
-			ctx.UnsafeSetVar(self.children[1].source(), v)
+			ctx.UnsafeSetVar(opTerm.children[1].source(), v)
 		}
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
 
-func evalAppend(ctx ExprContext, self *term) (v any, err error) {
+func evalAppend(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
 	}
 
@@ -57,11 +57,11 @@ func evalAppend(ctx ExprContext, self *term) (v any, err error) {
 		list, _ := leftValue.(*ListType)
 		newList := append(*list, rightValue)
 		v = &newList
-		if self.children[0].symbol() == SymVariable {
+		if opTerm.children[0].symbol() == SymVariable {
-			ctx.UnsafeSetVar(self.children[0].source(), v)
+			ctx.UnsafeSetVar(opTerm.children[0].source(), v)
 		}
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }

operator-iter-value.go

@@ -16,22 +16,23 @@ func newIterValueTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalIterValue(ctx ExprContext, self *term) (v any, err error) {
+func evalIterValue(ctx ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 
-	if childValue, err = self.evalPrefix(ctx); err != nil {
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
 	if it, ok := childValue.(Iterator); ok {
 		v, err = it.Current()
 	} else {
-		err = self.errIncompatibleType(childValue)
+		err = opTerm.errIncompatibleType(childValue)
 	}
 	return
 }
 
 // init
 func init() {
-	registerTermConstructor(SymOpenClosedRound, newIterValueTerm)
+//	registerTermConstructor(SymOpenClosedRound, newIterValueTerm)
+	registerTermConstructor(SymCaret, newIterValueTerm)
 }

operator-length.go

@@ -16,10 +16,10 @@ func newLengthTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalLength(ctx ExprContext, self *term) (v any, err error) {
+func evalLength(ctx ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 
-	if childValue, err = self.evalPrefix(ctx); err != nil {
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
@@ -30,18 +30,18 @@ func evalLength(ctx ExprContext, self *term) (v any, err error) {
 		s, _ := childValue.(string)
 		v = int64(len(s))
 	} else if IsDict(childValue) {
-		// m, _ := childValue.(map[any]any)
 		m, _ := childValue.(*DictType)
 		v = int64(len(*m))
 	} else if it, ok := childValue.(Iterator); ok {
-		if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(countName) {
+		v = int64(it.Count())
-			count, _ := extIt.CallOperation(countName, nil)
+		// if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(CountName) {
-			v, _ = toInt(count, "")
+		// 	count, _ := extIt.CallOperation(CountName, nil)
-		} else {
+		// 	v, _ = ToGoInt(count, "")
-			v = int64(it.Index() + 1)
+		// } else {
-		}
+		// 	v = int64(it.Index() + 1)
+		// }
 	} else {
-		err = self.errIncompatibleType(childValue)
+		err = opTerm.errIncompatibleType(childValue)
 	}
 	return
 }

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.go

@@ -17,20 +17,51 @@ func newPostIncTerm(tk *Token) *term {
 	}
 }
 
-func evalPostInc(ctx ExprContext, self *term) (v any, err error) {
+func evalPostInc(ctx ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
-	if childValue, err = self.evalPrefix(ctx); err != nil {
+	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
 	if it, ok := childValue.(Iterator); ok {
 		v, err = it.Next()
-	} else if IsInteger(childValue) && self.children[0].symbol() == SymVariable {
+	} else if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
 		v = childValue
 		i, _ := childValue.(int64)
-		ctx.SetVar(self.children[0].source(), i+1)
+		ctx.SetVar(opTerm.children[0].source(), i+1)
 	} else {
-		err = self.errIncompatibleType(childValue)
+		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
 }
@@ -38,4 +69,5 @@ func evalPostInc(ctx ExprContext, self *term) (v any, err error) {
 // init
 func init() {
 	registerTermConstructor(SymDoublePlus, newPostIncTerm)
+	registerTermConstructor(SymDoubleMinus, newPostDecTerm)
 }

operator-prod.go

@@ -14,8 +14,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,
@@ -23,10 +21,10 @@ func newMultiplyTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalMultiply(ctx ExprContext, self *term) (v any, err error) {
+func evalMultiply(ctx ExprContext, prodTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+	if leftValue, rightValue, err = prodTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
@@ -45,7 +43,7 @@ func evalMultiply(ctx ExprContext, self *term) (v any, err error) {
 			v = leftInt * rightInt
 		}
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = prodTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
@@ -55,8 +53,6 @@ func evalMultiply(ctx ExprContext, self *term) (v any, err error) {
 func newDivideTerm(tk *Token) (inst *term) {
 	return &term{
 		tk: *tk,
-		// class:    classOperator,
-		// kind:     kindUnknown,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priProduct,
@@ -64,10 +60,10 @@ func newDivideTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalDivide(ctx ExprContext, self *term) (v any, err error) {
+func evalDivide(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
 	}
 
@@ -90,7 +86,7 @@ func evalDivide(ctx ExprContext, self *term) (v any, err error) {
 			}
 		}
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
@@ -107,10 +103,10 @@ func newDivideAsFloatTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalDivideAsFloat(ctx ExprContext, self *term) (v any, err error) {
+func evalDivideAsFloat(ctx ExprContext, floatDivTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+	if leftValue, rightValue, err = floatDivTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
@@ -122,18 +118,16 @@ func evalDivideAsFloat(ctx ExprContext, self *term) (v any, err error) {
 			v = numAsFloat(leftValue) / d
 		}
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = floatDivTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
 
 //-------- reminder term
 
-func newReminderTerm(tk *Token) (inst *term) {
+func newRemainderTerm(tk *Token) (inst *term) {
 	return &term{
 		tk: *tk,
-		// class:    classOperator,
-		// kind:     kindUnknown,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priProduct,
@@ -141,10 +135,10 @@ func newReminderTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalReminder(ctx ExprContext, self *term) (v any, err error) {
+func evalReminder(ctx ExprContext, ramainderTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+	if leftValue, rightValue, err = ramainderTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
@@ -157,7 +151,7 @@ func evalReminder(ctx ExprContext, self *term) (v any, err error) {
 			v = leftInt % rightInt
 		}
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = ramainderTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
@@ -167,5 +161,5 @@ func init() {
 	registerTermConstructor(SymStar, newMultiplyTerm)
 	registerTermConstructor(SymSlash, newDivideTerm)
 	registerTermConstructor(SymDotSlash, newDivideAsFloatTerm)
-	registerTermConstructor(SymPercent, newReminderTerm)
+	registerTermConstructor(SymPercent, newRemainderTerm)
 }

operator-range.go

@@ -12,7 +12,7 @@ type intPair struct {
 }
 
 func (p *intPair) TypeName() string {
-	return typePair
+	return TypePair
 }
 
 func (p *intPair) ToString(opt FmtOpt) string {
@@ -29,30 +29,30 @@ func newRangeTerm(tk *Token) (inst *term) {
 		tk:       *tk,
 		children: make([]*term, 0, 2),
 		position: posInfix,
-		priority: priDot,
+		priority: priRange,
 		evalFunc: evalRange,
 	}
 }
 
-func evalRange(ctx ExprContext, self *term) (v any, err error) {
+func evalRange(ctx ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	// if err = self.checkOperands(); err != nil {
 	// 	return
 	// }
-	if len(self.children) == 0 {
+	if len(opTerm.children) == 0 {
 		leftValue = int64(0)
 		rightValue = int64(-1)
-	} else if len(self.children) == 1 {
+	} else if len(opTerm.children) == 1 {
-		if leftValue, err = self.children[0].compute(ctx); err != nil {
+		if leftValue, err = opTerm.children[0].compute(ctx); err != nil {
 			return
 		}
-		rightValue = int64(-1)
+		rightValue = int64(ConstLastIndex)
-	} else if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+	} else if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
 		return
 	}
 	if !(IsInteger(leftValue) && IsInteger(rightValue)) {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 		return
 	}
 

operator-rel.go

@@ -45,10 +45,10 @@ func equals(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
 	return
 }
 
-func evalEqual(ctx ExprContext, self *term) (v any, err error) {
+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
 	}
 
@@ -68,9 +68,9 @@ func newNotEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalNotEqual(ctx ExprContext, self *term) (v any, err error) {
+func evalNotEqual(ctx ExprContext, opTerm *term) (v any, err error) {
-	if v, err = evalEqual(ctx, self); err == nil {
+	if v, err = evalEqual(ctx, opTerm); err == nil {
-		b, _ := toBool(v)
+		b, _ := ToBool(v)
 		v = !b
 	}
 	return
@@ -119,13 +119,13 @@ func lessThan(self *term, a, b any) (isLess bool, err error) {
 	return
 }
 
-func evalLess(ctx ExprContext, self *term) (v any, err error) {
+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
 	}
-	v, err = lessThan(self, leftValue, rightValue)
+	v, err = lessThan(opTerm, leftValue, rightValue)
 	return
 }
 
@@ -154,14 +154,14 @@ func lessThanOrEqual(self *term, a, b any) (isLessEq bool, err error) {
 	return
 }
 
-func evalLessEqual(ctx ExprContext, self *term) (v any, err error) {
+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
 	}
 
-	v, err = lessThanOrEqual(self, leftValue, rightValue)
+	v, err = lessThanOrEqual(opTerm, leftValue, rightValue)
 
 	return
 }
@@ -178,14 +178,14 @@ func newGreaterTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalGreater(ctx ExprContext, self *term) (v any, err error) {
+func evalGreater(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
 	}
 
-	v, err = lessThan(self, rightValue, leftValue)
+	v, err = lessThan(opTerm, rightValue, leftValue)
 	return
 }
 
@@ -201,14 +201,14 @@ func newGreaterEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalGreaterEqual(ctx ExprContext, self *term) (v any, err error) {
+func evalGreaterEqual(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
 	}
 
-	v, err = lessThanOrEqual(self, rightValue, leftValue)
+	v, err = lessThanOrEqual(opTerm, rightValue, leftValue)
 	return
 }
 

operator-selector.go

@@ -19,17 +19,17 @@ func newSelectorTerm(tk *Token) (inst *term) {
 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, false)
+		selectedValue, err = caseData.caseExpr.Eval(ctx)
 		match = true
 	} else if filterList, ok := caseData.filterList.value().([]*term); ok {
 		if len(filterList) == 0 && exprValue == int64(caseIndex) {
-			selectedValue, err = caseData.caseExpr.eval(ctx, false)
+			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, false)
+					selectedValue, err = caseData.caseExpr.Eval(ctx)
 					match = true
 					break
 				}
@@ -39,19 +39,19 @@ func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (ma
 	return
 }
 
-func evalSelector(ctx ExprContext, self *term) (v any, err error) {
+func evalSelector(ctx ExprContext, opTerm *term) (v any, err error) {
 	var exprValue any
 	var match bool
 
-	if err = self.checkOperands(); err != nil {
+	if err = opTerm.checkOperands(); err != nil {
 		return
 	}
-	exprTerm := self.children[0]
+	exprTerm := opTerm.children[0]
 	if exprValue, err = exprTerm.compute(ctx); err != nil {
 		return
 	}
 
-	caseListTerm := self.children[1]
+	caseListTerm := opTerm.children[1]
 	caseList, _ := caseListTerm.value().([]*term)
 	for i, caseTerm := range caseList {
 		caseSel := caseTerm.value()

operator-sign.go

@@ -28,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 opTerm.tk.Sym == SymChangeSign {
 			f, _ := rightValue.(float64)
 			v = -f
 		} else {
 			v = rightValue
 		}
 	} else if IsInteger(rightValue) {
-		if self.tk.Sym == SymChangeSign {
+		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

@@ -21,10 +21,10 @@ func newPlusTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalPlus(ctx ExprContext, self *term) (v any, err error) {
+func evalPlus(ctx ExprContext, plusTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+	if leftValue, rightValue, err = plusTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
@@ -44,12 +44,8 @@ func evalPlus(ctx ExprContext, self *term) (v any, err error) {
 		rightList, _ = rightValue.(*ListType)
 
 		sumList := make(ListType, 0, len(*leftList)+len(*rightList))
-		for _, item := range *leftList {
+		sumList = append(sumList, *leftList...)
-			sumList = append(sumList, item)
+		sumList = append(sumList, *rightList...)
-		}
-		for _, item := range *rightList {
-			sumList = append(sumList, item)
-		}
 		v = &sumList
 	} else if (isFraction(leftValue) && IsNumber(rightValue)) || (isFraction(rightValue) && IsNumber(leftValue)) {
 		if IsFloat(leftValue) || IsFloat(rightValue) {
@@ -64,7 +60,7 @@ func evalPlus(ctx ExprContext, self *term) (v any, err error) {
 		c.merge(rightDict)
 		v = c
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = plusTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
@@ -81,10 +77,10 @@ func newMinusTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalMinus(ctx ExprContext, self *term) (v any, err error) {
+func evalMinus(ctx ExprContext, minusTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+	if leftValue, rightValue, err = minusTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
@@ -109,7 +105,7 @@ func evalMinus(ctx ExprContext, self *term) (v any, err error) {
 		}
 		v = &diffList
 	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
+		err = minusTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }

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

@@ -11,23 +11,26 @@ import (
 //-------- parser
 
 type parser struct {
-	ctx ExprContext
 }
 
-func NewParser(ctx ExprContext) (p *parser) {
+func NewParser() (p *parser) {
-	p = &parser{
+	p = &parser{}
-		ctx: ctx,
-	}
 	return p
 }
 
-func (self *parser) parseFuncCall(scanner *scanner, allowVarRef bool, tk *Token) (tree *term, err error) {
+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, allowVarRef bool, 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 = self.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err != nil {
+		if subTree, err = parser.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err != nil {
 			break
 		}
 		prev := scanner.Previous()
@@ -51,7 +54,7 @@ func (self *parser) parseFuncCall(scanner *scanner, allowVarRef bool, tk *Token)
 	return
 }
 
-func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
+func (parser *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 	// Example: "add = func(x,y) {x+y}
 	var body *ast
 	args := make([]*term, 0)
@@ -60,15 +63,15 @@ func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 	itemExpected := false
 	tk := scanner.Previous()
 	for lastSym != SymClosedRound && lastSym != SymEos {
-		tk = scanner.Next()
+		tk = parser.Next(scanner)
 		if tk.IsSymbol(SymIdentifier) {
 			param := newTerm(tk)
 			args = append(args, param)
-			tk = scanner.Next()
+			tk = parser.Next(scanner)
 			if tk.Sym == SymEqual {
 				var paramExpr *ast
 				defaultParamsStarted = true
-				if paramExpr, err = self.parseItem(scanner, false, SymComma, SymClosedRound); err != nil {
+				if paramExpr, err = parser.parseItem(scanner, false, SymComma, SymClosedRound); err != nil {
 					break
 				}
 				param.forceChild(paramExpr.root)
@@ -89,9 +92,9 @@ func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 		err = tk.ErrorExpectedGot(")")
 	}
 	if err == nil {
-		tk = scanner.Next()
+		tk = parser.Next(scanner)
 		if tk.IsSymbol(SymOpenBrace) {
-			body, err = self.parseGeneral(scanner, true, true, SymClosedBrace)
+			body, err = parser.parseGeneral(scanner, true, true, SymClosedBrace)
 		} else {
 			err = tk.ErrorExpectedGot("{")
 		}
@@ -107,7 +110,7 @@ func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 	return
 }
 
-func (self *parser) parseList(scanner *scanner, parsingIndeces bool, allowVarRef bool) (subtree *term, err error) {
+func (parser *parser) parseList(scanner *scanner, parsingIndeces bool, allowVarRef bool) (subtree *term, err error) {
 	r, c := scanner.lastPos()
 	args := make([]*term, 0)
 	lastSym := SymUnknown
@@ -115,7 +118,7 @@ func (self *parser) parseList(scanner *scanner, parsingIndeces bool, allowVarRef
 	for lastSym != SymClosedSquare && lastSym != SymEos {
 		var subTree *ast
 		zeroRequired := scanner.current.Sym == SymColon
-		if subTree, err = self.parseItem(scanner, allowVarRef, SymComma, SymClosedSquare); err == nil {
+		if subTree, err = parser.parseItem(scanner, allowVarRef, SymComma, SymClosedSquare); err == nil {
 			root := subTree.root
 			if root != nil {
 				if !parsingIndeces && root.symbol() == SymColon {
@@ -156,14 +159,14 @@ func (self *parser) parseList(scanner *scanner, parsingIndeces bool, allowVarRef
 	return
 }
 
-func (self *parser) parseIterDef(scanner *scanner, allowVarRef bool) (subtree *term, err error) {
+func (parser *parser) parseIterDef(scanner *scanner, allowVarRef bool) (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 = self.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err == nil {
+		if subTree, err = parser.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err == nil {
 			if subTree.root != nil {
 				args = append(args, subTree.root)
 			} else if itemExpected {
@@ -187,8 +190,8 @@ func (self *parser) parseIterDef(scanner *scanner, allowVarRef bool) (subtree *t
 	return
 }
 
-func (self *parser) parseDictKey(scanner *scanner, allowVarRef bool) (key any, err error) {
+func (parser *parser) parseDictKey(scanner *scanner) (key any, err error) {
-	tk := scanner.Next()
+	tk := parser.Next(scanner)
 	if tk.Sym == SymError {
 		err = tk.Error()
 		return
@@ -197,7 +200,7 @@ func (self *parser) parseDictKey(scanner *scanner, allowVarRef bool) (key any, e
 		return
 	}
 	if tk.Sym == SymInteger || tk.Sym == SymString {
-		tkSep := scanner.Next()
+		tkSep := parser.Next(scanner)
 		if tkSep.Sym != SymColon {
 			err = tkSep.ErrorExpectedGot(":")
 		} else {
@@ -209,14 +212,14 @@ func (self *parser) parseDictKey(scanner *scanner, allowVarRef bool) (key any, e
 	return
 }
 
-func (self *parser) parseDictionary(scanner *scanner, allowVarRef bool) (subtree *term, err error) {
+func (parser *parser) parseDictionary(scanner *scanner, allowVarRef bool) (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 = self.parseDictKey(scanner, allowVarRef); err != nil {
+		if key, err = parser.parseDictKey(scanner); err != nil {
 			break
 		} else if key == nil {
 			tk := scanner.Previous()
@@ -226,10 +229,10 @@ func (self *parser) parseDictionary(scanner *scanner, allowVarRef bool) (subtree
 			}
 			break
 		}
-		if subTree, err = self.parseItem(scanner, allowVarRef, SymComma, SymClosedBrace); err == nil {
+		if subTree, err = parser.parseItem(scanner, allowVarRef, SymComma, SymClosedBrace); err == nil {
 			if subTree.root != nil {
 				args[key] = subTree.root
-			} else if key != nil {
+			} else /*if key != nil*/ {
 				prev := scanner.Previous()
 				err = prev.ErrorExpectedGot("dictionary-value")
 				break
@@ -251,10 +254,10 @@ func (self *parser) parseDictionary(scanner *scanner, allowVarRef bool) (subtree
 	return
 }
 
-func (self *parser) parseSelectorCase(scanner *scanner, allowVarRef bool, defaultCase bool) (caseTerm *term, err error) {
+func (parser *parser) parseSelectorCase(scanner *scanner, allowVarRef bool, defaultCase bool) (caseTerm *term, err error) {
 	var filterList *term
 	var caseExpr *ast
-	tk := scanner.Next()
+	tk := parser.Next(scanner)
 	startRow := tk.row
 	startCol := tk.col
 	if tk.Sym == SymOpenSquare {
@@ -262,10 +265,10 @@ func (self *parser) parseSelectorCase(scanner *scanner, allowVarRef bool, defaul
 			err = tk.Errorf("case list in default clause")
 			return
 		}
-		if filterList, err = self.parseList(scanner, false, allowVarRef); err != nil {
+		if filterList, err = parser.parseList(scanner, false, allowVarRef); err != nil {
 			return
 		}
-		tk = scanner.Next()
+		tk = parser.Next(scanner)
 		startRow = tk.row
 		startCol = tk.col
 	} else if !defaultCase {
@@ -273,7 +276,7 @@ func (self *parser) parseSelectorCase(scanner *scanner, allowVarRef bool, defaul
 	}
 
 	if tk.Sym == SymOpenBrace {
-		if caseExpr, err = self.parseGeneral(scanner, true, allowVarRef, SymClosedBrace); err != nil {
+		if caseExpr, err = parser.parseGeneral(scanner, true, allowVarRef, SymClosedBrace); err != nil {
 			return
 		}
 	} else {
@@ -299,25 +302,25 @@ func addSelectorCase(selectorTerm, caseTerm *term) {
 	caseTerm.parent = selectorTerm
 }
 
-func (self *parser) parseSelector(scanner *scanner, tree *ast, allowVarRef bool) (selectorTerm *term, err error) {
+func (parser *parser) parseSelector(scanner *scanner, tree *ast, allowVarRef bool) (selectorTerm *term, err error) {
 	var caseTerm *term
 	tk := scanner.makeToken(SymSelector, '?')
-	if selectorTerm, err = tree.addToken2(tk); err != nil {
+	if selectorTerm, err = tree.addToken(tk); err != nil {
 		return
 	}
 
-	if caseTerm, err = self.parseSelectorCase(scanner, allowVarRef, false); err == nil {
+	if caseTerm, err = parser.parseSelectorCase(scanner, allowVarRef, false); err == nil {
 		addSelectorCase(selectorTerm, caseTerm)
 	}
 	return
 }
 
-func (self *parser) parseItem(scanner *scanner, allowVarRef bool, termSymbols ...Symbol) (tree *ast, err error) {
+func (parser *parser) parseItem(scanner *scanner, allowVarRef bool, termSymbols ...Symbol) (tree *ast, err error) {
-	return self.parseGeneral(scanner, false, allowVarRef, termSymbols...)
+	return parser.parseGeneral(scanner, false, allowVarRef, termSymbols...)
 }
 
-func (self *parser) Parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, err error) {
+func (parser *parser) Parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, err error) {
-	return self.parseGeneral(scanner, true, false, termSymbols...)
+	return parser.parseGeneral(scanner, true, false, termSymbols...)
 }
 
 func couldBeACollection(t *term) bool {
@@ -328,17 +331,26 @@ func couldBeACollection(t *term) bool {
 	return sym == SymList || sym == SymString || sym == SymDict || sym == SymExpression || sym == SymVariable
 }
 
-func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef bool, termSymbols ...Symbol) (tree *ast, err error) {
+// func areSymbolsOutOfCtx(tk *Token, ctxTerm *term, syms ...Symbol) bool {
+// 	var areOut = false
+// 	if ctxTerm != nil {
+// 		areOut = tk.IsOneOf(syms)
+// 	}
+// 	return areOut
+// }
+
+func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef bool, 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 = scanner.Next(); err == nil && tk != nil && !tk.IsTerm(termSymbols); tk = scanner.Next() {
+	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 {
+		// if tk.Sym == SymComment {
-			continue
+		// 	continue
-		}
+		// }
 
 		if tk.Sym == SymSemiColon {
 			if allowForest {
@@ -366,21 +378,21 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 		switch tk.Sym {
 		case SymOpenRound:
 			var subTree *ast
-			if subTree, err = self.parseGeneral(scanner, false, allowVarRef, SymClosedRound); err == nil {
+			if subTree, err = parser.parseGeneral(scanner, false, allowVarRef, SymClosedRound); err == nil {
 				subTree.root.priority = priValue
 				err = tree.addTerm(newExprTerm(subTree.root))
 				currentTerm = subTree.root
 			}
 		case SymFuncCall:
 			var funcCallTerm *term
-			if funcCallTerm, err = self.parseFuncCall(scanner, allowVarRef, tk); err == nil {
+			if funcCallTerm, err = parser.parseFuncCall(scanner, allowVarRef, tk); err == nil {
 				err = tree.addTerm(funcCallTerm)
 				currentTerm = funcCallTerm
 			}
 		case SymOpenSquare:
 			var listTerm *term
 			parsingIndeces := couldBeACollection(currentTerm)
-			if listTerm, err = self.parseList(scanner, parsingIndeces, allowVarRef); err == nil {
+			if listTerm, err = parser.parseList(scanner, parsingIndeces, allowVarRef); err == nil {
 				if parsingIndeces {
 					indexTk := NewToken(listTerm.tk.row, listTerm.tk.col, SymIndex, listTerm.source())
 					indexTerm := newTerm(indexTk)
@@ -397,24 +409,24 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 				err = currentTerm.Errorf(`selector-case outside of a selector context`)
 			} else {
 				var mapTerm *term
-				if mapTerm, err = self.parseDictionary(scanner, allowVarRef); err == nil {
+				if mapTerm, err = parser.parseDictionary(scanner, allowVarRef); err == nil {
 					err = tree.addTerm(mapTerm)
 					currentTerm = mapTerm
 				}
 			}
 		case SymEqual:
 			// if err = checkPrevSymbol(lastSym, SymIdentifier, tk); err == nil {
-			currentTerm, err = tree.addToken2(tk)
+			currentTerm, err = tree.addToken(tk)
 			// }
 		case SymFuncDef:
 			var funcDefTerm *term
-			if funcDefTerm, err = self.parseFuncDef(scanner); err == nil {
+			if funcDefTerm, err = parser.parseFuncDef(scanner); err == nil {
 				err = tree.addTerm(funcDefTerm)
 				currentTerm = funcDefTerm
 			}
 		case SymDollarRound:
 			var iterDefTerm *term
-			if iterDefTerm, err = self.parseIterDef(scanner, allowVarRef); err == nil {
+			if iterDefTerm, err = parser.parseIterDef(scanner, allowVarRef); err == nil {
 				err = tree.addTerm(iterDefTerm)
 				currentTerm = iterDefTerm
 			}
@@ -422,16 +434,16 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 			if tk.source[0] == '@' && !allowVarRef {
 				err = tk.Errorf("variable references are not allowed in top level expressions: %q", tk.source)
 			} else {
-				currentTerm, err = tree.addToken2(tk)
+				currentTerm, err = tree.addToken(tk)
 			}
 		case SymQuestion:
-			if selectorTerm, err = self.parseSelector(scanner, tree, allowVarRef); err == nil {
+			if selectorTerm, err = parser.parseSelector(scanner, tree, allowVarRef); err == nil {
 				currentTerm = selectorTerm
 			}
 		case SymColon, SymDoubleColon:
 			var caseTerm *term
 			if selectorTerm != nil {
-				if caseTerm, err = self.parseSelectorCase(scanner, allowVarRef, tk.Sym == SymDoubleColon); err == nil {
+				if caseTerm, err = parser.parseSelectorCase(scanner, allowVarRef, tk.Sym == SymDoubleColon); err == nil {
 					addSelectorCase(selectorTerm, caseTerm)
 					currentTerm = caseTerm
 					if tk.Sym == SymDoubleColon {
@@ -439,10 +451,16 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 					}
 				}
 			} else {
-				currentTerm, err = tree.addToken2(tk)
+				currentTerm, err = tree.addToken(tk)
 			}
+			if tk.IsSymbol(SymColon) {
+				// Colon outside a selector term acts like a separator
+				firstToken = true
+			}
+		case SymPlusEqual, SymMinusEqual, SymStarEqual:
+			currentTerm, err = parser.expandOpAssign(scanner, tree, tk, allowVarRef)
 		default:
-			currentTerm, err = tree.addToken2(tk)
+			currentTerm, err = tree.addToken(tk)
 		}
 
 		if currentTerm != nil && currentTerm.tk.Sym != SymSelector && currentTerm.parent != nil && currentTerm.parent.tk.Sym != SymSelector {
@@ -451,6 +469,7 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 		}
 		// lastSym = tk.Sym
 	}
+
 	if err == nil {
 		err = tk.Error()
 	}
@@ -463,3 +482,49 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 // 	}
 // 	return
 // }
+
+func (parser *parser) expandOpAssign(scanner * scanner, tree *ast, tk *Token, allowVarRef bool) (t *term, err error) {
+	var opSym Symbol
+	var opString string
+
+	if tree.root != nil {
+		switch tk.Sym {
+		case SymPlusEqual:
+			opString = "+"
+			opSym = SymPlus
+		case SymMinusEqual:
+			opString = "-"
+			opSym = SymMinus
+		case SymStarEqual:
+			opString = "*"
+			opSym = SymStar
+		default:
+			err = tk.Errorf("unsopported operator %q", tk.source)
+			return
+		}
+		leftExpr := tree.root.Clone()
+		leftExpr.setParent(nil)
+		if t, err = tree.addToken(NewToken(tk.row, tk.col, SymEqual, "=")); err == nil {
+			t = leftExpr
+			if err = tree.addTerm(leftExpr); err == nil {
+				if t, err = tree.addToken(NewToken(tk.row, tk.col, opSym, opString)); err == nil {
+
+					var subTree *ast
+					if subTree, err = parser.parseGeneral(scanner, false, allowVarRef, SymSemiColon, SymClosedRound, SymClosedBrace, SymClosedSquare); err == nil {
+						if scanner.Previous().IsOneOfA(SymSemiColon, SymClosedRound, SymClosedBrace, SymClosedSquare) {
+							if err = scanner.UnreadToken(); err != nil {
+								return
+							}
+						}
+						subTree.root.priority = priValue
+						err = tree.addTerm(newExprTerm(subTree.root))
+						t = subTree.root
+					}
+				}
+			}
+		}
+	} else {
+		err = tk.Errorf("left operand of %q must be a variable or a variable expression", tk)
+	}
+	return
+}

plugins.go

@@ -0,0 +1,131 @@
+// 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.so"
+	} else {
+		template = "expr-%s-plugin.so.debug"
+	}
+	decorated = fmt.Sprintf(template, name)
+	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
+
+	dirList := buildSearchDirList("plugin", ENV_EXPR_PLUGIN_PATH)
+	count = 0
+	it := NewAnyIterator(name)
+	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

@@ -16,6 +16,7 @@ import (
 type scanner struct {
 	current      *Token
 	prev         *Token
+	stage        *Token
 	stream       *bufio.Reader
 	row          int
 	column       int
@@ -49,250 +50,274 @@ func DefaultTranslations() map[Symbol]Symbol {
 // 	return self.current
 // }
 
-func (self *scanner) readChar() (ch byte, err error) {
+func (scanner *scanner) readChar() (ch byte, err error) {
-	if ch, err = self.stream.ReadByte(); err == nil {
+	if ch, err = scanner.stream.ReadByte(); err == nil {
 		if ch == '\n' {
-			self.row++
+			scanner.row++
-			self.column = 0
+			scanner.column = 0
 		} else {
-			self.column++
+			scanner.column++
 		}
 	}
 	return
 }
 
-func (self *scanner) unreadChar() (err error) {
+func (scanner *scanner) unreadChar() (err error) {
-	if err = self.stream.UnreadByte(); err == nil {
+	if err = scanner.stream.UnreadByte(); err == nil {
-		if self.column--; self.column == 0 {
+		if scanner.column--; scanner.column == 0 {
-			if self.row--; self.row == 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) lastPos() (r, c int) {
+func (scanner *scanner) UnreadToken() (err error) {
-	if self.prev != nil {
+	if scanner.stage == nil {
-		r = self.prev.row
+		scanner.stage = scanner.current
-		c = self.prev.col
+		scanner.current = scanner.prev
+	} else {
+		err = fmt.Errorf("staging already present, currently one level only of staging is allowed")
 	}
 	return
 }
 
-func (self *scanner) Previous() *Token {
+func (scanner *scanner) lastPos() (r, c int) {
-	return self.prev
+	if scanner.prev != nil {
+		r = scanner.prev.row
+		c = scanner.prev.col
+	}
+	return
 }
 
-func (self *scanner) Next() (tk *Token) {
+func (scanner *scanner) Previous() *Token {
-	self.prev = self.current
+	return scanner.prev
-	tk = self.current
+}
-	self.current = self.fetchNextToken()
+
+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) {
+func (scanner *scanner) fetchNextToken() (tk *Token) {
 	var ch byte
-	if err := self.skipBlanks(); err != nil {
+	if err := scanner.skipBlanks(); err != nil {
-		return self.makeErrorToken(err)
+		return scanner.makeErrorToken(err)
 	}
 
 	escape := false
 	for {
-		ch, _ = self.readChar()
+		ch, _ = scanner.readChar()
 		switch ch {
 		case '+':
-			if next, _ := self.peek(); next == '+' {
+			if next, _ := scanner.peek(); next == '+' {
-				tk = self.moveOn(SymDoublePlus, ch, next)
+				tk = scanner.moveOn(SymDoublePlus, ch, next)
 			} else if next == '=' {
-				tk = self.moveOn(SymPlusEqual, ch, next)
+				tk = scanner.moveOn(SymPlusEqual, ch, next)
 			} else {
-				tk = self.makeToken(SymPlus, ch)
+				tk = scanner.makeToken(SymPlus, ch)
 			}
 		case '-':
-			if next, _ := self.peek(); next == '-' {
+			if next, _ := scanner.peek(); next == '-' {
-				tk = self.moveOn(SymDoubleMinus, ch, 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 == '*' {
+			if next, _ := scanner.peek(); next == '*' {
-				tk = self.moveOn(SymDoubleStar, ch, 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 == '*' {
+			if next, _ := scanner.peek(); next == '*' {
-				self.readChar()
+				scanner.readChar()
-				tk = self.fetchBlockComment()
+				tk = scanner.fetchBlockComment()
 			} else if next == '/' {
-				self.readChar()
+				scanner.readChar()
-				tk = self.fetchOnLineComment()
+				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 == '|' {
+			if next, _ := scanner.peek(); next == '|' {
-				tk = self.moveOn(SymDoubleVertBar, ch, next)
+				tk = scanner.moveOn(SymDoubleVertBar, ch, next)
 			} else {
-				tk = self.makeToken(SymVertBar, ch)
+				tk = scanner.makeToken(SymVertBar, ch)
 			}
 		case ',':
-			tk = self.makeToken(SymComma, ch)
+			tk = scanner.makeToken(SymComma, ch)
 		case '^':
-			tk = self.makeToken(SymCaret, ch)
+			tk = scanner.makeToken(SymCaret, ch)
 		case ':':
-			if next, _ := self.peek(); next == ':' {
+			if next, _ := scanner.peek(); next == ':' {
-				tk = self.moveOn(SymDoubleColon, ch, next)
+				tk = scanner.moveOn(SymDoubleColon, ch, next)
 			} else {
-				tk = self.makeToken(SymColon, ch)
+				tk = scanner.makeToken(SymColon, ch)
 			}
 		case ';':
-			tk = self.makeToken(SymSemiColon, ch)
+			tk = scanner.makeToken(SymSemiColon, ch)
 		case '.':
 			//if next, _ := self.peek(); next >= '0' && next <= '9' {
 			//	tk = self.parseNumber(ch)
 			//} else if next == '/' {
-			if next, _ := self.peek(); next == '/' {
+			if next, _ := scanner.peek(); next == '/' {
-				tk = self.moveOn(SymDotSlash, ch, next)
+				tk = scanner.moveOn(SymDotSlash, ch, next)
 			} else if next == '.' {
-				if next1, _ := self.peek(); next1 == '.' {
+				if next1, _ := scanner.peek(); next1 == '.' {
-					tk = self.moveOn(SymTripleDot, ch, next, next1)
+					tk = scanner.moveOn(SymTripleDot, ch, next, next1)
 				} else {
-					tk = self.moveOn(SymDoubleDot, ch, next)
+					tk = scanner.moveOn(SymDoubleDot, ch, next)
 				}
 			} else {
-				tk = self.makeToken(SymDot, ch)
+				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)
+			}
+		case '"':
+			if escape {
+				tk = scanner.makeToken(SymDoubleQuote, ch)
+				escape = false
+			} else {
+				tk = scanner.fetchString(ch)
 			}
 		case '`':
-			tk = self.makeToken(SymBackTick, ch)
+			tk = scanner.makeToken(SymBackTick, ch)
 		case '!':
-			if next, _ := self.peek(); next == '=' {
+			if next, _ := scanner.peek(); next == '=' {
-				tk = self.moveOn(SymNotEqual, ch, next)
+				tk = scanner.moveOn(SymNotEqual, ch, next)
 			} else {
-				tk = self.makeToken(SymExclamation, ch)
+				tk = scanner.makeToken(SymExclamation, ch)
 			}
 		case '?':
-			if next, _ := self.peek(); next == '?' {
+			if next, _ := scanner.peek(); next == '?' {
-				tk = self.moveOn(SymDoubleQuestion, ch, next)
+				tk = scanner.moveOn(SymDoubleQuestion, ch, next)
-			} else if next, _ := self.peek(); next == '=' {
+			} else if next == '=' {
-				tk = self.moveOn(SymQuestionEqual, ch, next)
+				tk = scanner.moveOn(SymQuestionEqual, ch, next)
+			} else if next == '!' {
+				tk = scanner.moveOn(SymQuestionExclam, ch, next)
 			} else {
-				tk = self.makeToken(SymQuestion, ch)
+				tk = scanner.makeToken(SymQuestion, ch)
 			}
 		case '&':
-			if next, _ := self.peek(); next == '&' {
+			if next, _ := scanner.peek(); next == '&' {
-				tk = self.moveOn(SymDoubleAmpersand, ch, next)
+				tk = scanner.moveOn(SymDoubleAmpersand, ch, next)
 			} else {
-				tk = self.makeToken(SymAmpersand, ch)
+				tk = scanner.makeToken(SymAmpersand, ch)
 			}
 		case '%':
-			tk = self.makeToken(SymPercent, ch)
+			tk = scanner.makeToken(SymPercent, ch)
 		case '#':
-			tk = self.makeToken(SymHash, ch)
+			tk = scanner.makeToken(SymHash, ch)
 		case '@':
-			if next, _ := self.peek(); (next >= 'a' && next <= 'z') || (next >= 'A' && next <= 'Z') {
+			if next, _ := scanner.peek(); (next >= 'a' && next <= 'z') || (next >= 'A' && next <= 'Z') {
-				self.readChar()
+				scanner.readChar()
-				if tk = self.fetchIdentifier(next); tk.Sym == SymIdentifier {
+				if tk = scanner.fetchIdentifier(next); tk.Sym == SymIdentifier {
 					//tk.Sym = SymIdRef
 					tk.source = "@" + tk.source
 				} else {
-					tk = self.makeErrorToken(fmt.Errorf("invalid variable reference %q", tk.source))
+					tk = scanner.makeErrorToken(fmt.Errorf("invalid variable reference %q", tk.source))
 				}
 			} else if next == '@' {
-				tk = self.moveOn(SymDoubleAt, ch, next)
+				tk = scanner.moveOn(SymDoubleAt, ch, next)
 			} else {
-				tk = self.makeToken(SymAt, ch)
+				tk = scanner.makeToken(SymAt, ch)
 			}
 		case '_':
-			tk = self.makeToken(SymUndescore, ch)
+			tk = scanner.makeToken(SymUndescore, ch)
 		case '=':
-			if next, _ := self.peek(); next == '=' {
+			if next, _ := scanner.peek(); next == '=' {
-				tk = self.moveOn(SymDoubleEqual, ch, next)
+				tk = scanner.moveOn(SymDoubleEqual, ch, next)
 			} else {
-				tk = self.makeToken(SymEqual, ch)
+				tk = scanner.makeToken(SymEqual, ch)
 			}
 		case '<':
-			if next, _ := self.peek(); next == '=' {
+			if next, _ := scanner.peek(); next == '=' {
-				tk = self.moveOn(SymLessOrEqual, ch, next)
+				tk = scanner.moveOn(SymLessOrEqual, ch, next)
 			} else if next == '<' {
-				tk = self.moveOn(SymAppend, ch, next)
+				tk = scanner.moveOn(SymAppend, ch, next)
 			} else if next == '>' {
-				tk = self.moveOn(SymLessGreater, ch, next)
+				tk = scanner.moveOn(SymLessGreater, ch, next)
 			} else {
-				tk = self.makeToken(SymLess, ch)
+				tk = scanner.makeToken(SymLess, ch)
 			}
 		case '>':
-			if next, _ := self.peek(); next == '=' {
+			if next, _ := scanner.peek(); next == '=' {
-				tk = self.moveOn(SymGreaterOrEqual, ch, next)
+				tk = scanner.moveOn(SymGreaterOrEqual, ch, next)
 			} else if next == '>' {
-				tk = self.moveOn(SymInsert, ch, next)
+				tk = scanner.moveOn(SymInsert, ch, next)
 			} else {
-				tk = self.makeToken(SymGreater, ch)
+				tk = scanner.makeToken(SymGreater, ch)
 			}
 		case '$':
-			if next, _ := self.peek(); next == '(' {
+			if next, _ := scanner.peek(); next == '(' {
-				tk = self.moveOn(SymDollarRound, ch, next)
+				tk = scanner.moveOn(SymDollarRound, ch, next)
 				tk.source += ")"
 			} else if next == '$' {
-				tk = self.moveOn(SymDoubleDollar, ch, next)
+				tk = scanner.moveOn(SymDoubleDollar, ch, next)
 			} else {
-				tk = self.makeToken(SymDollar, ch)
+				tk = scanner.makeToken(SymDollar, ch)
 			}
 		case '(':
-			if next, _ := self.peek(); next == ')' {
+			//			if next, _ := scanner.peek(); next == ')' {
-				tk = self.moveOn(SymOpenClosedRound, ch, next)
+			//				tk = scanner.moveOn(SymOpenClosedRound, ch, next)
-			} else {
+			//			} else {
-				tk = self.makeToken(SymOpenRound, ch)
+			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 = self.makeToken(SymTilde, ch)
+			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') {
-				if tk = self.fetchIdentifier(ch); tk.Sym == SymKwFunc {
+				if tk = scanner.fetchIdentifier(ch); tk.Sym == SymKwFunc {
-					if next, _ := self.peek(); next == '(' {
+					if next, _ := scanner.peek(); next == '(' {
-						tk = self.moveOn(SymFuncDef, ch, next)
+						tk = scanner.moveOn(SymFuncDef, ch, next)
 					}
 				}
 			} else if ch >= '0' && ch <= '9' {
-				tk = self.parseNumber(ch)
+				tk = scanner.parseNumber(ch)
 			}
 		}
 		if !escape {
@@ -300,14 +325,14 @@ func (self *scanner) fetchNextToken() (tk *Token) {
 		}
 	}
 	if tk == nil {
-		tk = NewErrorToken(self.row, self.column, fmt.Errorf("unknown symbol '%c'", ch))
+		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
 }
@@ -328,32 +353,32 @@ func isHexDigit(ch byte) bool {
 	return (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')
 }
 
-func (self *scanner) initBase(sb *strings.Builder, currentFirstCh byte) (firstCh byte, numBase int, digitFunc func(byte) bool, err error) {
+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 = self.peek(); err == nil {
+	if ch, err = scanner.peek(); err == nil {
 		if ch == 'b' || ch == 'B' {
 			numBase = 2
 			digitType = "binary"
-			self.readChar()
+			scanner.readChar()
 			digitFunc = isBinaryDigit
-			firstCh, err = self.readChar()
+			firstCh, err = scanner.readChar()
 		} else if ch == 'o' || ch == 'O' {
 			numBase = 8
 			digitType = "octal"
-			self.readChar()
+			scanner.readChar()
 			digitFunc = isOctalDigit
-			firstCh, err = self.readChar()
+			firstCh, err = scanner.readChar()
 		} else if ch == 'x' || ch == 'X' {
 			numBase = 16
 			digitType = "hex"
-			self.readChar()
+			scanner.readChar()
 			digitFunc = isHexDigit
-			firstCh, err = self.readChar()
+			firstCh, err = scanner.readChar()
 		}
 		if err == nil && !digitFunc(firstCh) {
 			if len(digitType) == 0 {
@@ -367,7 +392,7 @@ func (self *scanner) initBase(sb *strings.Builder, currentFirstCh byte) (firstCh
 	return
 }
 
-func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
+func (scanner *scanner) parseNumber(firstCh byte) (tk *Token) {
 	var err error
 	var ch byte
 	var sym Symbol = SymInteger
@@ -376,9 +401,9 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
 	var numBase = 10
 
 	if firstCh == '0' {
-		firstCh, numBase, isDigit, err = self.initBase(&sb, firstCh)
+		firstCh, numBase, isDigit, err = scanner.initBase(firstCh)
 	}
-	for ch = firstCh; err == nil && isDigit(ch); ch, err = self.readChar() {
+	for ch = firstCh; err == nil && isDigit(ch); ch, err = scanner.readChar() {
 		sb.WriteByte(ch)
 	}
 
@@ -386,9 +411,9 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
 		if err == nil && ch == '.' {
 			sym = SymFloat
 			sb.WriteByte(ch)
-			ch, err = self.readChar()
+			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)
 				}
 			}
@@ -397,32 +422,32 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
 			if ch == 'e' || ch == 'E' {
 				sym = SymFloat
 				sb.WriteByte(ch)
-				if ch, err = self.readChar(); err == nil {
+				if ch, err = scanner.readChar(); err == nil {
 					if ch == '+' || ch == '-' {
 						sb.WriteByte(ch)
-						ch, err = self.readChar()
+						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)
 						}
 					} else {
-						err = fmt.Errorf("[%d:%d] expected integer exponent, got %c", self.row, self.column, ch)
+						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 = self.readChar()
+				ch, err = scanner.readChar()
-				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)
 				}
 				if err == nil {
 					if ch != ')' {
-						err = fmt.Errorf("[%d:%d] expected ')', got '%c'", self.row, self.column, ch)
+						err = fmt.Errorf("[%d:%d] expected ')', got '%c'", scanner.row, scanner.column, ch)
 					} else {
 						sb.WriteByte(ch)
-						_, err = self.readChar()
+						_, err = scanner.readChar()
 					}
 				}
 			}
@@ -430,10 +455,10 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
 	}
 
 	if err != nil && err != io.EOF {
-		tk = self.makeErrorToken(err)
+		tk = scanner.makeErrorToken(err)
 	} else {
 		var value any
-		err = self.sync(err)
+		err = scanner.sync(err) // TODO: Check this function
 		txt := sb.String()
 		if sym == SymFloat {
 			value, err = strconv.ParseFloat(txt, 64)
@@ -443,39 +468,39 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
 			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)
+		tk = scanner.makeErrorToken(err)
-	} else if err = self.sync(err); err != nil && err != io.EOF {
+	} else if err = scanner.sync(err); err != nil && err != io.EOF {
-		tk = self.makeErrorToken(err)
+		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)
+			tk = scanner.makeValueToken(SymBool, txt, false)
-		} else if ch, _ := self.peek(); ch == '(' {
+		} else if ch, _ := scanner.peek(); ch == '(' {
-			self.readChar()
+			scanner.readChar()
-			tk = self.makeValueToken(SymFuncCall, txt+"(", txt)
+			tk = scanner.makeValueToken(SymFuncCall, txt+"(", txt)
 		} else {
-			tk = self.makeValueToken(SymIdentifier, txt, txt)
+			tk = scanner.makeValueToken(SymIdentifier, txt, txt)
 		}
 	}
 
@@ -495,29 +520,29 @@ func (self *scanner) fetchIdentifier(firstCh byte) (tk *Token) {
 	return
 }
 
-func (self *scanner) fetchBlockComment() *Token {
+func (scanner *scanner) fetchBlockComment() *Token {
-	return self.fetchUntil(SymComment, false, '*', '/')
+	return scanner.fetchUntil(SymComment, false, '*', '/')
 }
 
-func (self *scanner) fetchOnLineComment() *Token {
+func (scanner *scanner) fetchOnLineComment() *Token {
-	return self.fetchUntil(SymComment, true, '\n')
+	return scanner.fetchUntil(SymComment, true, '\n')
 }
 
-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 {
@@ -526,18 +551,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) (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 '"':
@@ -554,7 +579,7 @@ func (self *scanner) fetchString() (tk *Token) {
 				sb.WriteByte(ch)
 			}
 			prev = 0
-		} else if ch == '"' {
+		} else if ch == termCh {
 			break
 		} else {
 			prev = ch
@@ -565,65 +590,65 @@ 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("missing string termination \""))
 		} else {
-			tk = self.makeErrorToken(err)
+			tk = scanner.makeErrorToken(err)
 		}
 	} else {
 		txt := sb.String()
-		tk = self.makeValueToken(SymString, `"`+txt+`"`, txt)
+		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) {
+	for one, err = scanner.stream.Peek(1); err == nil && one[0] <= 32; one, err = scanner.stream.Peek(1) {
-		self.readChar()
+		scanner.readChar()
 	}
 	return
 }
 
-func (self *scanner) translate(sym Symbol) Symbol {
+func (scanner *scanner) translate(sym Symbol) Symbol {
-	if self.translations != nil {
+	if scanner.translations != nil {
-		if translatedSym, ok := self.translations[sym]; ok {
+		if translatedSym, ok := scanner.translations[sym]; ok {
 			return translatedSym
 		}
 	}
 	return sym
 }
 
-func (self *scanner) moveOn(sym Symbol, chars ...byte) (tk *Token) {
+func (scanner *scanner) moveOn(sym Symbol, chars ...byte) (tk *Token) {
-	tk = NewToken(self.row, self.column, self.translate(sym), string(chars))
+	tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), string(chars))
 	for i := 1; i < len(chars); i++ {
-		self.readChar()
+		scanner.readChar()
 	}
 	return
 }
 
-func (self *scanner) makeToken(sym Symbol, chars ...byte) (tk *Token) {
+func (scanner *scanner) makeToken(sym Symbol, chars ...byte) (tk *Token) {
-	tk = NewToken(self.row, self.column, self.translate(sym), string(chars))
+	tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), string(chars))
 	return
 }
 
-func (self *scanner) makeKeywordToken(sym Symbol, upperCaseKeyword string) (tk *Token) {
+func (scanner *scanner) makeKeywordToken(sym Symbol, upperCaseKeyword string) (tk *Token) {
-	tk = NewToken(self.row, self.column, self.translate(sym), upperCaseKeyword)
+	tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), upperCaseKeyword)
 	return
 }
 
-func (self *scanner) makeValueToken(sym Symbol, source string, value any) (tk *Token) {
+func (scanner *scanner) makeValueToken(sym Symbol, source string, value any) (tk *Token) {
-	tk = NewValueToken(self.row, self.column, self.translate(sym), source, value)
+	tk = NewValueToken(scanner.row, scanner.column, scanner.translate(sym), source, value)
 	return
 }
 
-func (self *scanner) makeErrorToken(err error) *Token {
+func (scanner *scanner) makeErrorToken(err error) *Token {
-	return NewErrorToken(self.row, self.column, err)
+	return NewErrorToken(scanner.row, scanner.column, err)
 }

simple-store.go

@@ -7,10 +7,11 @@ package expr
 import (
 	"fmt"
 	"slices"
-	"strings"
+	// "strings"
 )
 
 type SimpleStore struct {
+	parent    ExprContext
 	varStore  map[string]any
 	funcStore map[string]ExprFunc
 }
@@ -24,87 +25,73 @@ func NewSimpleStore() *SimpleStore {
 }
 
 func filterRefName(name string) bool  { return name[0] != '@' }
-func filterPrivName(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 {
-	return &SimpleStore{
+	clone := &SimpleStore{
 		varStore:  CloneFilteredMap(ctx.varStore, filterRefName),
 		funcStore: CloneFilteredMap(ctx.funcStore, filterRefName),
 	}
+	return clone
 }
 
-func (ctx *SimpleStore) Merge(src ExprContext) {
+// func (ctx *SimpleStore) Merge(src ExprContext) {
-	for _, name := range src.EnumVars(filterRefName) {
+// 	for _, name := range src.EnumVars(filterRefName) {
-		ctx.varStore[name], _ = src.GetVar(name)
+// 		ctx.varStore[name], _ = src.GetVar(name)
-	}
+// 	}
-	for _, name := range src.EnumFuncs(filterRefName) {
+// 	for _, name := range src.EnumFuncs(filterRefName) {
-		ctx.funcStore[name], _ = src.GetFuncInfo(name)
+// 		ctx.funcStore[name], _ = src.GetFuncInfo(name)
-	}
+// 	}
+// }
+
+func (ctx *SimpleStore) ToString(opt FmtOpt) string {
+	dict := ctx.ToDict()
+	return dict.ToString(opt)
 }
 
-func varsCtxToBuilder(sb *strings.Builder, ctx ExprContext, indent int) {
+func (ctx *SimpleStore) varsToDict(dict *DictType) *DictType {
-	sb.WriteString("vars: {\n")
+	names := ctx.EnumVars(nil)
-	first := true
+	slices.Sort(names)
-	for _, name := range ctx.EnumVars(filterPrivName) {
+	for _, name := range ctx.EnumVars(nil) {
-		if first {
-			first = false
-		} else {
-			sb.WriteByte(',')
-			sb.WriteByte('\n')
-		}
-
 		value, _ := ctx.GetVar(name)
-		sb.WriteString(strings.Repeat("\t", indent+1))
-		sb.WriteString(name)
-		sb.WriteString(": ")
 		if f, ok := value.(Formatter); ok {
-			sb.WriteString(f.ToString(0))
+			(*dict)[name] = f.ToString(0)
 		} else if _, ok = value.(Functor); ok {
-			sb.WriteString("func(){}")
+			(*dict)[name] = "func(){}"
-			// } else if _, ok = value.(map[any]any); ok {
-			// 	sb.WriteString("dict{}")
 		} else {
-			sb.WriteString(fmt.Sprintf("%v", value))
+			(*dict)[name] = fmt.Sprintf("%v", value)
 		}
 	}
-	sb.WriteString(strings.Repeat("\t", indent))
+	return dict
-	sb.WriteString("\n}\n")
 }
 
-func varsCtxToString(ctx ExprContext, indent int) string {
+func (ctx *SimpleStore) funcsToDict(dict *DictType) *DictType {
-	var sb strings.Builder
-	varsCtxToBuilder(&sb, ctx, indent)
-	return sb.String()
-}
-
-func funcsCtxToBuilder(sb *strings.Builder, ctx ExprContext, indent int) {
-	sb.WriteString("funcs: {\n")
-	first := true
 	names := ctx.EnumFuncs(func(name string) bool { return true })
 	slices.Sort(names)
 	for _, name := range names {
-		if first {
-			first = false
-		} else {
-			sb.WriteByte(',')
-			sb.WriteByte('\n')
-		}
 		value, _ := ctx.GetFuncInfo(name)
-		sb.WriteString(strings.Repeat("\t", indent+1))
 		if formatter, ok := value.(Formatter); ok {
-			sb.WriteString(formatter.ToString(0))
+			(*dict)[name] = formatter.ToString(0)
 		} else {
-			sb.WriteString(fmt.Sprintf("%v", value))
+			(*dict)[name] = fmt.Sprintf("%v", value)
 		}
 	}
-	sb.WriteString("\n}\n")
+	return dict
 }
 
-func (ctx *SimpleStore) ToString(opt FmtOpt) string {
+func (ctx *SimpleStore) ToDict() (dict *DictType) {
-	var sb strings.Builder
+	dict = MakeDict()
-	varsCtxToBuilder(&sb, ctx, 0)
+	(*dict)["variables"] = ctx.varsToDict(MakeDict())
-	funcsCtxToBuilder(&sb, ctx, 0)
+	(*dict)["functions"] = ctx.funcsToDict(MakeDict())
-	return sb.String()
+	return
 }
 
 func (ctx *SimpleStore) GetVar(varName string) (v any, exists bool) {
@@ -112,6 +99,11 @@ func (ctx *SimpleStore) GetVar(varName string) (v any, exists bool) {
 	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
@@ -140,6 +132,14 @@ func (ctx *SimpleStore) EnumVars(acceptor func(name string) (accept bool)) (varN
 	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
@@ -171,6 +171,14 @@ func (ctx *SimpleStore) EnumFuncs(acceptor func(name string) (accept bool)) (fun
 	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 []any) (result any, err error) {
 	if info, exists := GetLocalFuncInfo(ctx, name); exists {
 		functor := info.Functor()

symbol.go

@@ -57,16 +57,18 @@ const (
 	SymTilde                             //  46: '~'
 	SymDoubleQuestion                    //  47: '??'
 	SymQuestionEqual                     //  48: '?='
-	SymDoubleAt                          //  49: '@@'
+	SymQuestionExclam                    //  49: '?!'
-	SymDoubleColon                       //  50: '::'
+	SymDoubleAt                          //  50: '@@'
-	SymInsert                            //  51: '>>'
+	SymDoubleColon                       //  51: '::'
-	SymAppend                            //  52: '<<'
+	SymInsert                            //  52: '>>'
-	SymCaret                             //  53: '^'
+	SymAppend                            //  53: '<<'
-	SymDollarRound                       //  54: '$('
+	SymCaret                             //  54: '^'
-	SymOpenClosedRound                   //  55: '()'
+	SymDollarRound                       //  55: '$('
-	SymDoubleDollar                      //  56: '$$'
+	SymOpenClosedRound                   //  56: '()'
-	SymDoubleDot                         //  57: '..'
+	SymDoubleDollar                      //  57: '$$'
-	SymTripleDot                         //  58: '...'
+	SymDoubleDot                         //  58: '..'
+	SymTripleDot                         //  59: '...'
+	SymStarEqual                         //  60: '*='
 	SymChangeSign
 	SymUnchangeSign
 	SymIdentifier
@@ -101,9 +103,11 @@ const (
 	SymKwBut
 	SymKwFunc
 	SymKwBuiltin
+	SymKwPlugin
 	SymKwIn
 	SymKwInclude
 	SymKwNil
+	SymKwUnset
 )
 
 var keywords map[string]Symbol
@@ -113,6 +117,7 @@ func init() {
 	keywords = map[string]Symbol{
 		"AND":     SymKwAnd,
 		"BUILTIN": SymKwBuiltin,
+		"PLUGIN":  SymKwPlugin,
 		"BUT":     SymKwBut,
 		"FUNC":    SymKwFunc,
 		"IN":      SymKwIn,
@@ -120,5 +125,6 @@ func init() {
 		"NOT":     SymKwNot,
 		"OR":      SymKwOr,
 		"NIL":     SymKwNil,
+		"UNSET":   SymKwUnset,
 	}
 }

t_ast_test.go

@@ -47,7 +47,7 @@ func TestAddUnknownTokens(t *testing.T) {
 	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,66 @@
+// 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`)},
+		/*  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, 1)
+	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

@@ -1,16 +1,15 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// t_func-base_test.go
+// t_builtin-base_test.go
 package expr
 
 import (
-	"errors"
 	"testing"
 )
 
 func TestFuncBase(t *testing.T) {
-	section := "Func-Base"
+	section := "Builtin-Base"
 
 	inputs := []inputType{
 		/*   1 */ {`isNil(nil)`, true, nil},
@@ -21,9 +20,9 @@ func TestFuncBase(t *testing.T) {
 		/*   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, errors.New(`strconv.Atoi: parsing "1.5": invalid syntax`)},
+		/*   9 */ {`int("1.5")`, nil, `strconv.Atoi: parsing "1.5": invalid syntax`},
-		/*  10 */ {`int("432", 4)`, nil, errors.New(`int(): too much params -- expected 1, got 2`)},
+		/*  10 */ {`int("432", 4)`, nil, `int(): too much params -- expected 1, got 2`},
-		/*  11 */ {`int(nil)`, nil, errors.New(`int(): can't convert nil to int`)},
+		/*  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},
@@ -42,9 +41,9 @@ func TestFuncBase(t *testing.T) {
 		/*  27 */ {`dec(2.0)`, float64(2), nil},
 		/*  28 */ {`dec("2.0")`, float64(2), nil},
 		/*  29 */ {`dec(true)`, float64(1), nil},
-		/*  30 */ {`dec(true")`, nil, errors.New("[1:11] missing string termination \"")},
+		/*  30 */ {`dec(true")`, nil, `[1:11] missing string termination "`},
-		/*  31 */ {`dec()`, nil, errors.New(`dec(): too few params -- expected 1, got 0`)},
+		/*  31 */ {`dec()`, nil, `dec(): too few params -- expected 1, got 0`},
-		/*  32 */ {`dec(1,2,3)`, nil, errors.New(`dec(): too much params -- expected 1, got 3`)},
+		/*  32 */ {`dec(1,2,3)`, nil, `dec(): too much 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},
@@ -53,15 +52,14 @@ func TestFuncBase(t *testing.T) {
 		/*  38 */ {`bool(1.0)`, true, nil},
 		/*  39 */ {`bool("1")`, true, nil},
 		/*  40 */ {`bool(false)`, false, nil},
-		/*  41 */ {`bool([1])`, nil, errors.New(`bool(): can't convert list to bool`)},
+		/*  41 */ {`bool([1])`, nil, `bool(): can't convert list to bool`},
 		/*  42 */ {`dec(false)`, float64(0), nil},
 		/*  43 */ {`dec(1|2)`, float64(0.5), nil},
-		/*  44 */ {`dec([1])`, nil, errors.New(`dec(): can't convert list to float`)},
+		/*  44 */ {`dec([1])`, nil, `dec(): can't convert list to float`},
-		// /*  45 */ {`string([1])`, nil, errors.New(`string(): can't convert list to string`)},
+		// /*  45 */ {`string([1])`, nil, `string(): can't convert list to string`},
 	}
 
 	t.Setenv("EXPR_PATH", ".")
 
-	// parserTestSpec(t, section, inputs, 2)
+	runTestSuite(t, section, inputs)
-	parserTest(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(`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,28 @@
+// 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, `paramter "operator" must be a function, passed <nil> [nil]`},
+		/*   7 */ {`builtin "iterator"; run($(1,2,3), func(){1}, "prrr")`, nil, `paramter "vars" must be a dictionary, passed prrr [string]`},
+	}
+
+	//t.Setenv("EXPR_PATH", ".")
+
+	//runTestSuiteSpec(t, section, inputs, 3)
+	runTestSuite(t, section, inputs)
+}

t_builtin-math-arith_test.go

@@ -1,20 +1,19 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
-// t_func-math-arith_test.go
+// t_builtin-math-arith_test.go
 package expr
 
 import (
-	"errors"
 	"testing"
 )
 
 func TestFuncMathArith(t *testing.T) {
-	section := "Func-Math-Arith"
+	section := "Builtin-Math-Arith"
 	inputs := []inputType{
 		/*   1 */ {`builtin "math.arith"; add(1,2)`, int64(3), nil},
 		/*   2 */ {`builtin "math.arith"; add(1,2,3)`, int64(6), nil},
-		/*   3 */ {`builtin "math.arith"; mulX(1,2,3)`, nil, errors.New(`unknown function mulX()`)},
+		/*   3 */ {`builtin "math.arith"; mulX(1,2,3)`, nil, `unknown function mulX()`},
 		/*   4 */ {`builtin "math.arith"; add(1+4,3+2,5*(3-2))`, int64(15), nil},
 		/*   5 */ {`builtin "math.arith"; add(add(1+4),3+2,5*(3-2))`, int64(15), nil},
 		/*   6 */ {`builtin "math.arith"; add(add(1,4),/*3+2,*/5*(3-2))`, int64(10), nil},
@@ -24,6 +23,6 @@ func TestFuncMathArith(t *testing.T) {
 
 	// t.Setenv("EXPR_PATH", ".")
 
-	// parserTestSpec(t, section, inputs, 69)
+	// runTestSuiteSpec(t, section, inputs, 1)
-	parserTest(t, section, inputs)
+	runTestSuite(t, section, inputs)
 }

t_builtin-os-file_test.go

@@ -0,0 +1,35 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_builtin-os-file_test.go
+package expr
+
+import (
+	"testing"
+)
+
+func TestFuncOs(t *testing.T) {
+	section := "Builtin-OS-File"
+	inputs := []inputType{
+		/*   1 */ {`builtin "os.file"`, int64(1), nil},
+		/*   2 */ {`builtin "os.file"; handle=fileOpen("/etc/hosts"); fileClose(handle)`, true, nil},
+		/*   3 */ {`builtin "os.file"; handle=fileOpen("/etc/hostsX")`, nil, `open /etc/hostsX: no such file or directory`},
+		/*   4 */ {`builtin "os.file"; handle=fileCreate("/tmp/dummy"); fileClose(handle)`, true, nil},
+		/*   5 */ {`builtin "os.file"; handle=fileAppend("/tmp/dummy"); fileWriteText(handle, "bye-bye"); fileClose(handle)`, true, nil},
+		/*   6 */ {`builtin "os.file"; handle=fileOpen("/tmp/dummy"); word=fileReadText(handle, "-"); fileClose(handle);word`, "bye", nil},
+		/*   7 */ {`builtin "os.file"; word=fileReadText(nil, "-")`, nil, `fileReadText(): invalid file handle`},
+		/*   8 */ {`builtin "os.file"; fileWriteText(nil, "bye")`, nil, `fileWriteText(): invalid file handle`},
+		/*   9 */ {`builtin "os.file"; handle=fileOpen()`, nil, `fileOpen(): too few params -- expected 1, got 0`},
+		/*  10 */ {`builtin "os.file"; handle=fileOpen(123)`, nil, `fileOpen(): missing or invalid file path`},
+		/*  11 */ {`builtin "os.file"; handle=fileCreate(123)`, nil, `fileCreate(): missing or invalid file path`},
+		/*  12 */ {`builtin "os.file"; handle=fileAppend(123)`, nil, `fileAppend(): missing or invalid file path`},
+		/*  13 */ {`builtin "os.file"; handle=fileClose(123)`, nil, `fileClose(): invalid file handle`},
+		/*  14 */ {`builtin "os.file"; handle=fileOpen("/tmp/dummy"); c=fileReadTextAll(handle); fileClose(handle); c`, "bye-bye", nil},
+		/*  15 */ {`builtin "os.file"; c=fileReadTextAll(123)`, nil, `fileReadTextAll(): invalid file handle 123 [int64]`},
+	}
+
+	// t.Setenv("EXPR_PATH", ".")
+
+	// runTestSuiteSpec(t, section, inputs, 1)
+	runTestSuite(t, section, inputs)
+}

t_builtin-string_test.go

@@ -0,0 +1,68 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_builtin-string_test.go
+package expr
+
+import (
+	"testing"
+)
+
+func TestFuncString(t *testing.T) {
+	section := "Builtin-String"
+
+	inputs := []inputType{
+		/*   1 */ {`builtin "string"; strJoin("-", "one", "two", "three")`, "one-two-three", nil},
+		/*   2 */ {`builtin "string"; strJoin("-", ["one", "two", "three"])`, "one-two-three", nil},
+		/*   3 */ {`builtin "string"; ls= ["one", "two", "three"]; strJoin("-", ls)`, "one-two-three", nil},
+		/*   4 */ {`builtin "string"; ls= ["one", "two", "three"]; strJoin(1, ls)`, nil, `strJoin(): the "separator" parameter must be a string, got a integer (1)`},
+		/*   5 */ {`builtin "string"; ls= ["one", 2, "three"]; strJoin("-", ls)`, nil, `strJoin(): expected string, got integer (2)`},
+		/*   6 */ {`builtin "string"; "<"+strTrim("  bye bye  ")+">"`, "<bye bye>", nil},
+		/*   7 */ {`builtin "string"; strSub("0123456789", 1,2)`, "12", nil},
+		/*   8 */ {`builtin "string"; strSub("0123456789", -3,2)`, "78", nil},
+		/*   9 */ {`builtin "string"; strSub("0123456789", -3)`, "789", nil},
+		/*  10 */ {`builtin "string"; strSub("0123456789")`, "0123456789", nil},
+		/*  11 */ {`builtin "string"; strStartsWith("0123456789", "xyz", "012")`, true, nil},
+		/*  12 */ {`builtin "string"; strStartsWith("0123456789", "xyz", "0125")`, false, nil},
+		/*  13 */ {`builtin "string"; strStartsWith("0123456789")`, nil, `strStartsWith(): too few params -- expected 2 or more, got 1`},
+		/*  14 */ {`builtin "string"; strEndsWith("0123456789", "xyz", "789")`, true, nil},
+		/*  15 */ {`builtin "string"; strEndsWith("0123456789", "xyz", "0125")`, false, nil},
+		/*  16 */ {`builtin "string"; strEndsWith("0123456789")`, nil, `strEndsWith(): too few params -- expected 2 or more, got 1`},
+		/*  17 */ {`builtin "string"; strSplit("one-two-three", "-")`, newListA("one", "two", "three"), nil},
+		/*  18 */ {`builtin "string"; strJoin("-", [1, "two", "three"])`, nil, `strJoin(): expected string, got integer (1)`},
+		/*  19 */ {`builtin "string"; strJoin()`, nil, `strJoin(): too few params -- expected 1 or more, got 0`},
+
+		/*  69 */ /*{`builtin "string"; $$global`, `vars: {
+		}
+		funcs: {
+		    	add(any=0 ...) -> number,
+		    	dec(any) -> decimal,
+		    	endsWithStr(source, suffix) -> boolean,
+		    	fract(any, denominator=1) -> fraction,
+		    	import( ...) -> any,
+		    	importAll( ...) -> any,
+		    	int(any) -> integer,
+		    	isBool(any) -> boolean,
+		    	isDec(any) -> boolean,
+		    	isDict(any) -> boolean,
+		    	isFloat(any) -> boolean,
+		    	isFract(any) -> boolean,
+		    	isInt(any) -> boolean,
+		    	isList(any) -> boolean,
+		    	isNil(any) -> boolean,
+		    	isString(any) -> boolean,
+		    	joinStr(separator, item="" ...) -> string,
+		    	mul(any=1 ...) -> number,
+		    	splitStr(source, separator="", count=-1) -> list of string,
+		    	startsWithStr(source, prefix) -> boolean,
+		    	subStr(source, start=0, count=-1) -> string,
+		    	trimStr(source) -> string
+		}
+		`, nil},*/
+	}
+
+	//t.Setenv("EXPR_PATH", ".")
+
+	// runTestSuiteSpec(t, section, inputs, 19)
+	runTestSuite(t, section, inputs)
+}

t_common_test.go

@@ -0,0 +1,113 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_common_test.go
+package expr
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type inputType struct {
+	source     string
+	wantResult any
+	wantErr    any
+}
+
+func runCtxTestSuiteSpec(t *testing.T, ctx ExprContext, section string, inputs []inputType, spec ...int) {
+	succeeded := 0
+	failed := 0
+	for _, count := range spec {
+		good := doTest(t, ctx, section, &inputs[count-1], count)
+
+		if good {
+			succeeded++
+		} else {
+			failed++
+		}
+	}
+	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(spec), succeeded, failed)
+}
+
+func runTestSuiteSpec(t *testing.T, section string, inputs []inputType, spec ...int) {
+	runCtxTestSuiteSpec(t, nil, section, inputs, spec...)
+}
+
+func runCtxTestSuite(t *testing.T, ctx ExprContext, section string, inputs []inputType) {
+
+	succeeded := 0
+	failed := 0
+
+	for i, input := range inputs {
+		good := doTest(t, ctx, section, &input, i+1)
+		if good {
+			succeeded++
+		} else {
+			failed++
+		}
+	}
+	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
+}
+func runTestSuite(t *testing.T, section string, inputs []inputType) {
+	runCtxTestSuite(t, nil, section, inputs)
+}
+
+func getWantedError(input *inputType) error {
+	var wantErr error
+	var ok bool
+	if wantErr, ok = input.wantErr.(error); !ok {
+		if msg, ok := input.wantErr.(string); ok {
+			wantErr = errors.New(msg)
+		}
+	}
+	return wantErr
+}
+
+func doTest(t *testing.T, ctx ExprContext, section string, input *inputType, count int) (good bool) {
+	var expr Expr
+	var gotResult any
+	var gotErr error
+
+	wantErr := getWantedError(input)
+
+	parser := NewParser()
+	if ctx == nil {
+		ctx = NewSimpleStore()
+	}
+
+	logTest(t, count, section, input.source, input.wantResult, wantErr)
+
+	r := strings.NewReader(input.source)
+	scanner := NewScanner(r, DefaultTranslations())
+
+	good = true
+	if expr, gotErr = parser.Parse(scanner); gotErr == nil {
+		gotResult, gotErr = expr.Eval(ctx)
+	}
+
+	eq := reflect.DeepEqual(gotResult, input.wantResult)
+
+	if !eq /*gotResult != input.wantResult*/ {
+		t.Errorf("%d: %q -> result = %v [%s], want = %v [%s]", count, input.source, gotResult, TypeName(gotResult), input.wantResult, TypeName(input.wantResult))
+		good = false
+	}
+
+	if gotErr != wantErr {
+		if wantErr == nil || gotErr == nil || (gotErr.Error() != wantErr.Error()) {
+			t.Errorf("%d: %s -> got-err = <%v>, expected-err = <%v>", count, input.source, gotErr, wantErr)
+			good = false
+		}
+	}
+	return
+}
+
+func logTest(t *testing.T, n int, section, source string, wantResult any, wantErr error) {
+	if wantErr == nil {
+		t.Logf("[+]%s nr %3d -- %q  --> %v", section, n, source, wantResult)
+	} else {
+		t.Logf("[-]%s nr %3d -- %q  --> %v", section, n, source, wantErr)
+	}
+}

t_dict_test.go

@@ -22,7 +22,7 @@ func TestDictParser(t *testing.T) {
 
 	inputs := []inputType{
 		/*  1 */ {`{}`, map[any]any{}, nil},
-		/*  2 */ {`{123}`, nil, errors.New(`[1:6] expected ":", got "}"`)},
+		/*  2 */ {`{123}`, nil, errors.New("[1:6] expected `:`, got `}`")},
 		/*  3 */ {`{1:"one",2:"two",3:"three"}`, map[int64]any{int64(1): "one", int64(2): "two", int64(3): "three"}, nil},
 		/*  4 */ {`{1:"one",2:"two",3:"three"}[3]`, "three", nil},
 		/*  5 */ {`#{1:"one",2:"two",3:"three"}`, int64(3), nil},
@@ -31,7 +31,13 @@ func TestDictParser(t *testing.T) {
 		/*  8 */ {`D={"a":1, "b":2}; D["a"]=9; D`, map[any]any{"a": 9, "b": 2}, nil},
 		/*  9 */ {`D={"a":1, "b":2}; D["z"]=9; D`, map[any]any{"z": 9, "a": 1, "b": 2}, nil},
 		/* 10 */ {`D={"a":1, "b":2}; D[nil]=9`, nil, errors.New(`[1:21] index/key is nil`)},
-	}
+		/* 11 */ {`D={"a":1, "b":2}; D["a"]`, int64(1), nil},
+		/* 12 */ {`m={
+			"a":1,
+			//"b":2,
+			"c":3
+			}`, map[any]any{"a": 1, "c": 3}, nil},
+		}
 
 	succeeded := 0
 	failed := 0
@@ -49,7 +55,7 @@ func TestDictParser(t *testing.T) {
 		ctx.SetVar("var1", int64(123))
 		ctx.SetVar("var2", "abc")
 		ImportMathFuncs(ctx)
-		parser := NewParser(ctx)
+		parser := NewParser()
 
 		logTest(t, i+1, "Dict", input.source, input.wantResult, input.wantErr)
 
@@ -110,7 +116,7 @@ func TestDictToStringMultiLine(t *testing.T) {
 	var good bool
 	section := "dict-ToString-ML"
 	want := `{
-	"first": 1
+  "first": 1
 }`
 	args := map[any]*term{
 		"first": newLiteralTerm(NewValueToken(0, 0, SymInteger, "1", 1)),

t_expr_test.go

@@ -14,13 +14,24 @@ func TestExpr(t *testing.T) {
 	inputs := []inputType{
 		/*   1 */ {`0?{}`, nil, nil},
 		/*   2 */ {`fact=func(n){(n)?{1}::{n*fact(n-1)}}; fact(5)`, int64(120), nil},
-		/*   3 */ {`builtin "os.file"; f=openFile("test-file.txt"); line=readFile(f); closeFile(f); line`, "uno", nil},
+		/*   3 */ {`builtin "os.file"; f=fileOpen("test-file.txt"); line=fileReadText(f); fileClose(f); line`, "uno", nil},
 		/*   4 */ {`mynot=func(v){int(v)?{true}::{false}}; mynot(0)`, true, nil},
 		/*   5 */ {`1 ? {1} : [1+0] {3*(1+1)}`, int64(6), nil},
-		/*   6 */ {`
+		/*   6 */ {`a=3; a+=1`, int64(4), nil},
+		/*   7 */ {`a=3; a-=1`, int64(2), nil},
+		/*   8 */ {`a=3; a*=2`, int64(6), nil},
+		/*   9 */ {`v=[10,20,30]; v[0]+=1; v[0]`, int64(11), nil},
+		/*  10 */ {`r={"a":10}; r["a"]+=1; r["a"]`, int64(11), nil},
+		/*  11 */ {`a=3; a/=2`, nil, `[1:8] left operand of "=" must be a variable or a collection's item`},
+		/*  12 */ {`*=2`, nil, `[1:2] left operand of "*=" must be a variable or a variable expression`},
+		/*  13 */ {`a=3; a*=2+1; a`, int64(9), nil},
+		/*  14 */ {`a=3; (a*=2)+1; a`, int64(6), nil},
+		/*  15 */ {`a=3; a*=2)+1; a`, nil, `[1:11] unexpected token ")"`},
+		/*  16 */ {`v=[2]; a=1; v[a-=1]=5; v[0]`, int64(5), nil},
+		/*  17 */ {`
 		ds={
-			"init":func(end){@end=end; @current=0 but true},
+			"init":func(@end){@current=0 but true},
-			"current":func(){current},
+			//"current":func(){current},
 			"next":func(){
 				((next=current+1) <= end) ? [true] {@current=next but current} :: {nil}
 			}
@@ -32,6 +43,6 @@ func TestExpr(t *testing.T) {
 	}
 	// t.Setenv("EXPR_PATH", ".")
 
-	// parserTestSpec(t, section, inputs, 3)
+	//runTestSuiteSpec(t, section, inputs, 9)
-	parserTest(t, section, inputs)
+	runTestSuite(t, section, inputs)
 }

t_fractions_test.go

@@ -5,7 +5,6 @@
 package expr
 
 import (
-	"errors"
 	"testing"
 )
 
@@ -18,23 +17,24 @@ func TestFractionsParser(t *testing.T) {
 		/*   4 */ {`1|2 * 1`, newFraction(1, 2), nil},
 		/*   5 */ {`1|2 * 2|3`, newFraction(2, 6), nil},
 		/*   6 */ {`1|2 / 2|3`, newFraction(3, 4), nil},
-		/*   7 */ {`1|"5"`, nil, errors.New(`denominator must be integer, got string (5)`)},
+		/*   7 */ {`1|"5"`, nil, `denominator must be integer, got string (5)`},
-		/*   8 */ {`"1"|5`, nil, errors.New(`numerator must be integer, got string (1)`)},
+		/*   8 */ {`"1"|5`, nil, `numerator must be integer, got string (1)`},
-		/*   9 */ {`1|+5`, nil, errors.New(`[1:3] infix operator "|" requires two non-nil operands, got 1`)},
+		/*   9 */ {`1|+5`, nil, `[1:3] infix operator "|" requires two non-nil operands, got 1`},
 		/*  10 */ {`1|(-2)`, newFraction(-1, 2), nil},
 		/*  11 */ {`builtin "math.arith"; add(1|2, 2|3)`, newFraction(7, 6), nil},
 		/*  12 */ {`builtin "math.arith"; add(1|2, 1.0, 2)`, float64(3.5), nil},
 		/*  13 */ {`builtin "math.arith"; mul(1|2, 2|3)`, newFraction(2, 6), nil},
 		/*  14 */ {`builtin "math.arith"; mul(1|2, 1.0, 2)`, float64(1.0), nil},
-		/*  15 */ {`1|0`, nil, errors.New(`division by zero`)},
+		/*  15 */ {`1|0`, nil, `division by zero`},
 		/*  16 */ {`fract(-0.5)`, newFraction(-1, 2), nil},
-		/*  17 */ {`fract("")`, (*FractionType)(nil), errors.New(`bad syntax`)},
+		/*  17 */ {`fract("")`, (*FractionType)(nil), `bad syntax`},
 		/*  18 */ {`fract("-1")`, newFraction(-1, 1), nil},
 		/*  19 */ {`fract("+1")`, newFraction(1, 1), nil},
-		/*  20 */ {`fract("1a")`, (*FractionType)(nil), errors.New(`strconv.ParseInt: parsing "1a": invalid syntax`)},
+		/*  20 */ {`fract("1a")`, (*FractionType)(nil), `strconv.ParseInt: parsing "1a": invalid syntax`},
-		/*  21 */ {`fract(1,0)`, nil, errors.New(`fract(): division by zero`)},
+		/*  21 */ {`fract(1,0)`, nil, `fract(): division by zero`},
+		/*  22 */ {`string(1|2)`, "1|2", nil},
 	}
-	parserTest(t, section, inputs)
+	runTestSuite(t, section, inputs)
 }
 
 func TestFractionToStringSimple(t *testing.T) {

t_func-import_test.go

@@ -1,24 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_func-import_test.go
-package expr
-
-import (
-	"testing"
-)
-
-func TestFuncImport(t *testing.T) {
-	section := "Func-Import"
-	inputs := []inputType{
-		/*   1 */ {`builtin "import"; import("./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-funcs.expr"); six()`, int64(6), nil},
-		/*   4 */ {`builtin "import"; import("./sample-export-all.expr"); six()`, int64(6), nil},
-	}
-
-	t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 69)
-	parserTest(t, section, inputs)
-}

t_func-os_test.go

@@ -1,29 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_func-os_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestFuncOs(t *testing.T) {
-	section := "Func-OS"
-	inputs := []inputType{
-		/*   1 */ {`builtin "os.file"`, int64(1), nil},
-		/*   2 */ {`builtin "os.file"; handle=openFile("/etc/hosts"); closeFile(handle)`, true, nil},
-		/*   3 */ {`builtin "os.file"; handle=openFile("/etc/hostsX")`, nil, errors.New(`open /etc/hostsX: no such file or directory`)},
-		/*   4 */ {`builtin "os.file"; handle=createFile("/tmp/dummy"); closeFile(handle)`, true, nil},
-		/*   5 */ {`builtin "os.file"; handle=appendFile("/tmp/dummy"); writeFile(handle, "bye-bye"); closeFile(handle)`, true, nil},
-		/*   6 */ {`builtin "os.file"; handle=openFile("/tmp/dummy"); word=readFile(handle, "-"); closeFile(handle);word`, "bye", nil},
-		/*   7 */ {`builtin "os.file"; word=readFile(nil, "-")`, nil, errors.New(`readFileFunc(): invalid file handle`)},
-		/*   7 */ {`builtin "os.file"; writeFile(nil, "bye")`, nil, errors.New(`writeFileFunc(): invalid file handle`)},
-	}
-
-	// t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 69)
-	parserTest(t, section, inputs)
-}

t_func-string_test.go

@@ -1,69 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// t_func-string_test.go
-package expr
-
-import (
-	"errors"
-	"testing"
-)
-
-func TestFuncString(t *testing.T) {
-	section := "Func-String"
-
-	inputs := []inputType{
-		/*   1 */ {`builtin "string"; joinStr("-", "one", "two", "three")`, "one-two-three", nil},
-		/*   2 */ {`builtin "string"; joinStr("-", ["one", "two", "three"])`, "one-two-three", nil},
-		/*   3 */ {`builtin "string"; ls= ["one", "two", "three"]; joinStr("-", ls)`, "one-two-three", nil},
-		/*   4 */ {`builtin "string"; ls= ["one", "two", "three"]; joinStr(1, ls)`, nil, errors.New(`joinStr() the "separator" parameter must be a string, got a integer (1)`)},
-		/*   5 */ {`builtin "string"; ls= ["one", 2, "three"]; joinStr("-", ls)`, nil, errors.New(`joinStr() expected string, got integer (2)`)},
-		/*   6 */ {`builtin "string"; "<"+trimStr("  bye bye  ")+">"`, "<bye bye>", nil},
-		/*   7 */ {`builtin "string"; subStr("0123456789", 1,2)`, "12", nil},
-		/*   8 */ {`builtin "string"; subStr("0123456789", -3,2)`, "78", nil},
-		/*   9 */ {`builtin "string"; subStr("0123456789", -3)`, "789", nil},
-		/*  10 */ {`builtin "string"; subStr("0123456789")`, "0123456789", nil},
-		/*  11 */ {`builtin "string"; startsWithStr("0123456789", "xyz", "012")`, true, nil},
-		/*  12 */ {`builtin "string"; startsWithStr("0123456789", "xyz", "0125")`, false, nil},
-		/*  13 */ {`builtin "string"; startsWithStr("0123456789")`, nil, errors.New(`startsWithStr(): too few params -- expected 2 or more, got 1`)},
-		/*  14 */ {`builtin "string"; endsWithStr("0123456789", "xyz", "789")`, true, nil},
-		/*  15 */ {`builtin "string"; endsWithStr("0123456789", "xyz", "0125")`, false, nil},
-		/*  16 */ {`builtin "string"; endsWithStr("0123456789")`, nil, errors.New(`endsWithStr(): too few params -- expected 2 or more, got 1`)},
-		/*  17 */ {`builtin "string"; splitStr("one-two-three", "-")`, newListA("one", "two", "three"), nil},
-		/*  18 */ {`builtin "string"; joinStr("-", [1, "two", "three"])`, nil, errors.New(`joinStr() expected string, got integer (1)`)},
-		/*  19 */ {`builtin "string"; joinStr()`, nil, errors.New(`joinStr(): too few params -- expected 1 or more, got 0`)},
-
-		/*  69 */ /*{`builtin "string"; $$global`, `vars: {
-		}
-		funcs: {
-		    	add(any=0 ...) -> number,
-		    	dec(any) -> decimal,
-		    	endsWithStr(source, suffix) -> boolean,
-		    	fract(any, denominator=1) -> fraction,
-		    	import( ...) -> any,
-		    	importAll( ...) -> any,
-		    	int(any) -> integer,
-		    	isBool(any) -> boolean,
-		    	isDec(any) -> boolean,
-		    	isDict(any) -> boolean,
-		    	isFloat(any) -> boolean,
-		    	isFract(any) -> boolean,
-		    	isInt(any) -> boolean,
-		    	isList(any) -> boolean,
-		    	isNil(any) -> boolean,
-		    	isString(any) -> boolean,
-		    	joinStr(separator, item="" ...) -> string,
-		    	mul(any=1 ...) -> number,
-		    	splitStr(source, separator="", count=-1) -> list of string,
-		    	startsWithStr(source, prefix) -> boolean,
-		    	subStr(source, start=0, count=-1) -> string,
-		    	trimStr(source) -> string
-		}
-		`, nil},*/
-	}
-
-	//t.Setenv("EXPR_PATH", ".")
-
-	// parserTestSpec(t, section, inputs, 19)
-	parserTest(t, section, inputs)
-}

t_funcs_test.go

@@ -5,7 +5,6 @@
 package expr
 
 import (
-	"errors"
 	"testing"
 )
 
@@ -17,25 +16,29 @@ func TestFuncs(t *testing.T) {
 		/*   3 */ {`double=func(x){2*x}; double(3)`, int64(6), nil},
 		/*   4 */ {`double=func(x){2*x}; a=5; double(3+a) + 1`, int64(17), nil},
 		/*   5 */ {`double=func(x){2*x}; a=5; two=func() {2}; (double(3+a) + 1) * two()`, int64(34), nil},
-		/*   6 */ {`@x="hello"; @x`, nil, errors.New(`[1:3] variable references are not allowed in top level expressions: "@x"`)},
+		/*   6 */ {`@x="hello"; @x`, nil, `[1:3] variable references are not allowed in top level expressions: "@x"`},
 		/*   7 */ {`f=func(){@x="hello"}; f(); x`, "hello", nil},
 		/*   8 */ {`f=func(@y){@y=@y+1}; f(2); y`, int64(3), nil},
-		/*   9 */ {`f=func(@y){g=func(){@x=5}; @y=@y+g()}; f(2); y+x`, nil, errors.New(`undefined variable or function "x"`)},
+		/*   9 */ {`f=func(@y){g=func(){@x=5}; @y=@y+g()}; f(2); y+x`, nil, `undefined variable or function "x"`},
 		/*  10 */ {`f=func(@y){g=func(){@x=5}; @z=g(); @y=@y+@z}; f(2); y+z`, int64(12), nil},
 		/*  11 */ {`f=func(@y){g=func(){@x=5}; g(); @z=x; @y=@y+@z}; f(2); y+z`, int64(12), nil},
 		/*  12 */ {`f=func(@y){g=func(){@x=5}; g(); @z=x; @x=@y+@z}; f(2); y+x`, int64(9), nil},
 		/*  13 */ {`two=func(){2}; four=func(f){f()+f()}; four(two)`, int64(4), nil},
-		/*  14 */ {`two=func(){2}; two(123)`, nil, errors.New(`two(): too much params -- expected 0, got 1`)},
+		/*  14 */ {`two=func(){2}; two(123)`, nil, `two(): too much params -- expected 0, got 1`},
 		/*  15 */ {`f=func(x,n=2){x+n}; f(3)`, int64(5), nil},
-		/*  16 */ {`f=func(x,n=2,y){x+n}`, nil, errors.New(`[1:16] can't mix default and non-default parameters`)},
+		/*  16 */ {`f=func(x,n=2,y){x+n}`, nil, `[1:16] can't mix default and non-default parameters`},
-		/*  17 */ {`f=func(x,n){1}; f(3,4,)`, nil, errors.New(`[1:24] expected "function-param-value", got ")"`)},
+		/*  17 */ {`f=func(x,n){1}; f(3,4,)`, nil, "[1:24] expected `function-param-value`, got `)`"},
+		/*  18 */ {`factory=func(base){func(){@base=base+1}}; inc10=factory(10); inc5=factory(5); inc10(); inc5(); inc10()`, int64(12), nil},
+		/*  19 */ {`f=func(a,y=1,z="sos"){}; string(f)`, `f(a, y=1, z="sos"):any{}`, nil},
+//		/*  20 */ {`a=[func(){3}]; a[0]()`, int64(3), nil},
+//		/*  20 */ {`m={}; m["f"]=func(){3}; m["f"]()`, int64(3), nil},
 		// /*  18 */ {`f=func(a){a*2}`, nil, errors.New(`[1:24] expected "function-param-value", got ")"`)},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")
 
-	// parserTestSpec(t, section, inputs, 17)
+	//runTestSuiteSpec(t, section, inputs, 20)
-	parserTest(t, section, inputs)
+	runTestSuite(t, section, inputs)
 }
 
 func dummy(ctx ExprContext, name string, args []any) (result any, err error) {
@@ -43,16 +46,17 @@ func dummy(ctx ExprContext, name string, args []any) (result any, err error) {
 }
 
 func TestFunctionToStringSimple(t *testing.T) {
-	source := newGolangFunctor(dummy)
+	source := NewGolangFunctor(dummy)
-	want := "func() {<body>}"
+	want := "func(){}"
 	got := source.ToString(0)
 	if got != want {
 		t.Errorf(`(func() -> result = %v [%T], want = %v [%T]`, got, got, want, want)
 	}
 }
 
+
 func TestFunctionGetFunc(t *testing.T) {
-	source := newGolangFunctor(dummy)
+	source := NewGolangFunctor(dummy)
 	want := ExprFunc(nil)
 	got := source.GetFunc()
 	if got != want {

t_index_test.go

@@ -5,7 +5,6 @@
 package expr
 
 import (
-	"errors"
 	"testing"
 )
 
@@ -17,11 +16,11 @@ func TestCollections(t *testing.T) {
 		/*   3 */ {`"abcdef"[1:]`, "bcdef", nil},
 		/*   4 */ {`"abcdef"[:]`, "abcdef", nil},
 		// /*   5 */ {`[0,1,2,3,4][:]`, ListType{int64(0), int64(1), int64(2), int64(3), int64(4)}, nil},
-		/*   5 */ {`"abcdef"[1:2:3]`, nil, errors.New(`[1:14] left operand '(1, 2)' [pair] and right operand '3' [integer] are not compatible with operator ":"`)},
+		/*   5 */ {`"abcdef"[1:2:3]`, nil, `[1:14] left operand '(1, 2)' [pair] and right operand '3' [integer] are not compatible with operator ":"`},
 	}
 
 	t.Setenv("EXPR_PATH", ".")
 
 	// parserTestSpec(t, section, inputs, 5)
-	parserTest(t, section, inputs)
+	runTestSuite(t, section, inputs)
 }

t_iter-list_test.go

@@ -0,0 +1,162 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_iter-list_test.go
+package expr
+
+import (
+	"io"
+	"testing"
+)
+
+func TestNewListIterator(t *testing.T) {
+	list := newListA("a", "b", "c", "d")
+	it := NewListIterator(list, []any{1, 3, 1})
+	if item, err := it.Next(); err != nil {
+		t.Errorf("error: %v", err)
+	} else if item != "b" {
+		t.Errorf("expected %q, got %q", "b", item)
+	} else {
+		t.Logf("Next: %v", item)
+	}
+}
+
+func TestNewListIterator2(t *testing.T) {
+	list := newListA("a", "b", "c", "d")
+	it := NewListIterator(list, []any{3, 1, -1})
+	if item, err := it.Next(); err != nil {
+		t.Errorf("error: %v", err)
+	} else if item != "d" {
+		t.Errorf("expected %q, got %q", "d", item)
+	} else {
+		t.Logf("Next: %v", item)
+	}
+}
+
+func TestNewListIterator3(t *testing.T) {
+	list := newListA("a", "b", "c", "d")
+	it := NewListIterator(list, []any{1, -1, 1})
+	if item, err := it.Next(); err != nil {
+		t.Errorf("error: %v", err)
+	} else if item != "b" {
+		t.Errorf("expected %q, got %q", "b", item)
+	} else {
+		t.Logf("Next: %v", item)
+	}
+}
+
+func TestNewIterList2(t *testing.T) {
+	list := []any{"a", "b", "c", "d"}
+	it := NewArrayIterator(list)
+	if item, err := it.Next(); err != nil {
+		t.Errorf("error: %v", err)
+	} else if item != "a" {
+		t.Errorf("expected %q, got %q", "a", item)
+	} else {
+		t.Logf("Next: %v", item)
+	}
+}
+
+func TestNewIterList3(t *testing.T) {
+	list := []any{"a", "b", "c", "d"}
+	it := NewAnyIterator(list)
+	if item, err := it.Next(); err != nil {
+		t.Errorf("error: %v", err)
+	} else if item != "a" {
+		t.Errorf("expected %q, got %q", "a", item)
+	} else {
+		t.Logf("Next: %v", item)
+	}
+}
+
+func TestNewIterList4(t *testing.T) {
+	list := any(nil)
+	it := NewAnyIterator(list)
+	if _, err := it.Next(); err != io.EOF {
+		t.Errorf("error: %v", err)
+	}
+}
+
+func TestNewIterList5(t *testing.T) {
+	list := "123"
+	it := NewAnyIterator(list)
+	if item, err := it.Next(); err != nil {
+		t.Errorf("error: %v", err)
+	} else if item != "123" {
+		t.Errorf("expected %q, got %q", "123", item)
+	} else {
+		t.Logf("Next: %v", item)
+	}
+}
+
+func TestNewIterList6(t *testing.T) {
+	list := newListA("a", "b", "c", "d")
+	it1 := NewAnyIterator(list)
+	it := NewAnyIterator(it1)
+	if item, err := it.Next(); err != nil {
+		t.Errorf("error: %v", err)
+	} else if item != "a" {
+		t.Errorf("expected %q, got %q", "a", item)
+	} else {
+		t.Logf("Next: %v", item)
+	}
+}
+func TestNewString(t *testing.T) {
+	list := "123"
+	it := NewAnyIterator(list)
+	if s := it.String(); s != "$(#1)" {
+		t.Errorf("expected $(#1), got %s", s)
+	}
+}
+
+func TestHasOperation(t *testing.T) {
+
+	list := newListA("a", "b", "c", "d")
+	it := NewListIterator(list, []any{1, 3, 1})
+	hasOp := it.HasOperation("reset")
+	if !hasOp {
+		t.Errorf("HasOperation(reset) must be true, got false")
+	}
+}
+
+func TestCallOperationReset(t *testing.T) {
+
+	list := newListA("a", "b", "c", "d")
+	it := NewListIterator(list, []any{1, 3, 1})
+	if v, err := it.CallOperation("reset", nil); err != nil {
+		t.Errorf("Error on CallOperation(reset): %v", err)
+	} else {
+		t.Logf("Reset result: %v", v)
+	}
+}
+
+func TestCallOperationIndex(t *testing.T) {
+
+	list := newListA("a", "b", "c", "d")
+	it := NewListIterator(list, []any{1, 3, 1})
+	if v, err := it.CallOperation("index", nil); err != nil {
+		t.Errorf("Error on CallOperation(index): %v", err)
+	} else {
+		t.Logf("Index result: %v", v)
+	}
+}
+
+func TestCallOperationCount(t *testing.T) {
+
+	list := newListA("a", "b", "c", "d")
+	it := NewListIterator(list, []any{1, 3, 1})
+	if v, err := it.CallOperation("count", nil); err != nil {
+		t.Errorf("Error on CallOperation(count): %v", err)
+	} else {
+		t.Logf("Count result: %v", v)
+	}
+}
+
+func TestCallOperationUnknown(t *testing.T) {
+
+	list := newListA("a", "b", "c", "d")
+	it := NewListIterator(list, []any{1, 3, 1})
+	if v, err := it.CallOperation("unknown", nil); err == nil {
+		t.Errorf("Expected error on CallOperation(unknown), got %v", v)
+	}
+}

t_iterator_test.go

@@ -7,20 +7,26 @@ package expr
 import "testing"
 
 func TestIteratorParser(t *testing.T) {
+	section := "Iterator"
 	inputs := []inputType{
-		/*   1 */ {`include "iterator.expr"; it=$(ds,3); ()it`, int64(0), nil},
+		/*   1 */ {`include "test-resources/iterator.expr"; it=$(ds,3); ^it`, int64(0), nil},
-		/*   2 */ {`include "iterator.expr"; it=$(ds,3); it++; it++`, int64(1), nil},
+		/*   2 */ {`include "test-resources/iterator.expr"; it=$(ds,3); it++; it++`, int64(1), nil},
-		/*   3 */ {`include "iterator.expr"; it=$(ds,3); it++; it++; #it`, int64(2), nil},
+		/*   3 */ {`include "test-resources/iterator.expr"; it=$(ds,3); it++; it++; #it`, int64(3), nil},
-		/*   4 */ {`include "iterator.expr"; it=$(ds,3); it++; it++; it.reset; ()it`, int64(0), nil},
+		/*   4 */ {`include "test-resources/iterator.expr"; it=$(ds,3); it++; it++; it.reset; ^it`, int64(0), nil},
-		/*   5 */ {`builtin "math.arith"; include "iterator.expr"; it=$(ds,3); add(it)`, int64(6), nil},
+		/*   5 */ {`builtin "math.arith"; include "test-resources/iterator.expr"; it=$(ds,3); add(it)`, int64(6), nil},
-		/*   6 */ {`builtin "math.arith"; include "iterator.expr"; it=$(ds,3); mul(it)`, int64(0), nil},
+		/*   6 */ {`builtin "math.arith"; include "test-resources/iterator.expr"; it=$(ds,3); mul(it)`, int64(0), nil},
-		/*   7 */ {`builtin "math.arith"; include "file-reader.expr"; it=$(ds,"int.list"); mul(it)`, int64(12000), nil},
+		/*   7 */ {`builtin "math.arith"; include "test-resources/file-reader.expr"; it=$(ds,"test-resources/int.list"); mul(it)`, int64(12000), nil},
-		/*   8 */ {`include "file-reader.expr"; it=$(ds,"int.list"); it++; it.index`, int64(0), nil},
+		/*   8 */ {`include "test-resources/file-reader.expr"; it=$(ds,"test-resources/int.list"); it++; it.index`, int64(0), nil},
-		/*  10 */ {`include "file-reader.expr"; it=$(ds,"int.list"); it.clean`, true, nil},
+		/*   9 */ {`include "test-resources/file-reader.expr"; it=$(ds,"test-resources/int.list"); it.clean`, true, nil},
-		/*  11 */ {`it=$(1,2,3); it++`, int64(1), nil},
+		/*  10 */ {`it=$(1,2,3); it++`, int64(1), nil},
+		/*  11 */ {`it=$(1,2,3); it++; it.reset; it++`, int64(1), nil},
+		/*  12 */ {`it=$([1,2,3,4],1); it++`, int64(2), nil},
+		/*  13 */ {`it=$([1,2,3,4],1,3); it++; it++;`, int64(3), nil},
+		/*  14 */ {`it=$([1,2,3,4],1,3,2); it++; it++;`, int64(4), nil},
+		/*  15 */ {`it=$([1,2,3,4],1,2,2); it++; it++;`, nil, `EOF`},
+		/*  16 */ {`include "test-resources/filter.expr"; it=$(ds,10); it++`, int64(2), nil},
 	}
-	// inputs1 := []inputType{
+
-	// 	/*   1 */ {`0?{}`, nil, nil},
+	//runTestSuiteSpec(t, section, inputs, 3)
-	// }
+	runTestSuite(t, section, inputs)
-	parserTest(t, "Iterator", inputs)
 }

t_list_test.go

@@ -5,20 +5,12 @@
 package expr
 
 import (
-	"errors"
-	"strings"
 	"testing"
 )
 
 func TestListParser(t *testing.T) {
 	section := "List"
 
-	/*	type inputType struct {
-			source     string
-			wantResult any
-			wantErr    error
-		}
-	*/
 	inputs := []inputType{
 		/*   1 */ {`[]`, newListA(), nil},
 		/*   2 */ {`[1,2,3]`, newListA(int64(1), int64(2), int64(3)), nil},
@@ -29,14 +21,14 @@ func TestListParser(t *testing.T) {
 		/*   7 */ {`add([1,4,3,2])`, int64(10), nil},
 		/*   8 */ {`add([1,[2,2],3,2])`, int64(10), nil},
 		/*   9 */ {`mul([1,4,3.0,2])`, float64(24.0), nil},
-		/*  10 */ {`add([1,"hello"])`, nil, errors.New(`add(): param nr 2 (2 in 1) has wrong type string, number expected`)},
+		/*  10 */ {`add([1,"hello"])`, nil, `add(): param nr 2 (2 in 1) has wrong type string, number expected`},
 		/*  11 */ {`[a=1,b=2,c=3] but a+b+c`, int64(6), nil},
 		/*  12 */ {`[1,2,3] << 2+2`, newListA(int64(1), int64(2), int64(3), int64(4)), nil},
 		/*  13 */ {`2-1 >> [2,3]`, newListA(int64(1), int64(2), int64(3)), nil},
 		/*  14 */ {`[1,2,3][1]`, int64(2), nil},
 		/*  15 */ {`ls=[1,2,3] but ls[1]`, int64(2), nil},
 		/*  16 */ {`ls=[1,2,3] but ls[-1]`, int64(3), nil},
-		/*  17 */ {`list=["one","two","three"]; list[10]`, nil, errors.New(`[1:34] index 10 out of bounds`)},
+		/*  17 */ {`list=["one","two","three"]; list[10]`, nil, `[1:34] index 10 out of bounds`},
 		/*  18 */ {`["a", "b", "c"]`, newListA("a", "b", "c"), nil},
 		/*  19 */ {`["a", "b", "c"]`, newList([]any{"a", "b", "c"}), nil},
 		/*  20 */ {`#["a", "b", "c"]`, int64(3), nil},
@@ -44,94 +36,26 @@ func TestListParser(t *testing.T) {
 		/*  22 */ {`a=[1,2]; (a)<<3`, newListA(int64(1), int64(2), int64(3)), nil},
 		/*  23 */ {`a=[1,2]; (a)<<3; a`, newListA(int64(1), int64(2)), nil},
 		/*  24 */ {`["a","b","c","d"][1]`, "b", nil},
-		/*  25 */ {`["a","b","c","d"][1,1]`, nil, errors.New(`[1:19] one index only is allowed`)},
+		/*  25 */ {`["a","b","c","d"][1,1]`, nil, `[1:19] one index only is allowed`},
 		/*  26 */ {`[0,1,2,3,4][:]`, newListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil},
-		/*  27 */ {`["a", "b", "c"] << ;`, nil, errors.New(`[1:18] infix operator "<<" requires two non-nil operands, got 1`)},
+		/*  27 */ {`["a", "b", "c"] << ;`, nil, `[1:18] infix operator "<<" requires two non-nil operands, got 1`},
-		/*  28 */ {`2 << 3;`, nil, errors.New(`[1:4] left operand '2' [integer] and right operand '3' [integer] are not compatible with operator "<<"`)},
+		/*  28 */ {`2 << 3;`, nil, `[1:4] left operand '2' [integer] and right operand '3' [integer] are not compatible with operator "<<"`},
-		/*  29 */ {`but >> ["a", "b", "c"]`, nil, errors.New(`[1:6] infix operator ">>" requires two non-nil operands, got 0`)},
+		/*  29 */ {`but >> ["a", "b", "c"]`, nil, `[1:6] infix operator ">>" requires two non-nil operands, got 0`},
-		/*  30 */ {`2 >> 3;`, nil, errors.New(`[1:4] left operand '2' [integer] and right operand '3' [integer] are not compatible with operator ">>"`)},
+		/*  30 */ {`2 >> 3;`, nil, `[1:4] left operand '2' [integer] and right operand '3' [integer] are not compatible with operator ">>"`},
 		/*  31 */ {`a=[1,2]; a<<3`, newListA(int64(1), int64(2), int64(3)), nil},
 		/*  33 */ {`a=[1,2]; 5>>a`, newListA(int64(5), int64(1), int64(2)), nil},
 		/*  34 */ {`L=[1,2]; L[0]=9; L`, newListA(int64(9), int64(2)), nil},
-		/*  35 */ {`L=[1,2]; L[5]=9; L`, nil, errors.New(`index 5 out of bounds (0, 1)`)},
+		/*  35 */ {`L=[1,2]; L[5]=9; L`, nil, `index 5 out of bounds (0, 1)`},
-		/*  36 */ {`L=[1,2]; L[]=9; L`, nil, errors.New(`[1:12] index/key specification expected, got [] [list]`)},
+		/*  36 */ {`L=[1,2]; L[]=9; L`, nil, `[1:12] index/key specification expected, got [] [list]`},
-		/*  37 */ {`L=[1,2]; L[nil]=9;`, nil, errors.New(`[1:12] index/key is nil`)},
+		/*  37 */ {`L=[1,2]; L[nil]=9;`, nil, `[1:12] index/key is nil`},
-		// /*  8 */ {`[int(x)|x=csv("test.csv",1,all(),1)]`, []any{int64(10), int64(40), int64(20)}, nil},
+		/*  38 */ {`[0,1,2,3,4][2:3]`, newListA(int64(2)), nil},
-		// /*  9 */ {`sum(@[int(x)|x=csv("test.csv",1,all(),1)])`, []any{int64(10), int64(40), int64(20)}, nil},
+		/*  39 */ {`[0,1,2,3,4][3:-1]`, newListA(int64(3)), nil},
+		/*  40 */ {`[0,1,2,3,4][-3:-1]`, newListA(int64(2), int64(3)), nil},
+		/*  41 */ {`[0,1,2,3,4][0:]`, newListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")
 
-	// parserTestSpec(t, section, inputs, 17)
+	// runTestSuiteSpec(t, section, inputs, 1)
-	parserTest(t, section, inputs)
+	runTestSuite(t, section, inputs)
-	return
-	succeeded := 0
-	failed := 0
-
-	// inputs1 := []inputType{
-	// 	/*  7 */ {`add([1,4,3,2])`, int64(10), nil},
-	// }
-
-	for i, input := range inputs {
-		var expr *ast
-		var gotResult any
-		var gotErr error
-
-		ctx := NewSimpleStore()
-		ImportMathFuncs(ctx)
-		parser := NewParser(ctx)
-
-		logTest(t, i+1, "List", input.source, input.wantResult, input.wantErr)
-
-		r := strings.NewReader(input.source)
-		scanner := NewScanner(r, DefaultTranslations())
-
-		good := true
-		if expr, gotErr = parser.Parse(scanner); gotErr == nil {
-			gotResult, gotErr = expr.Eval(ctx)
-		}
-
-		if (gotResult == nil && input.wantResult != nil) || (gotResult != nil && input.wantResult == nil) {
-			t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-			good = false
-		}
-
-		if gotList, okGot := gotResult.([]any); okGot {
-			if wantList, okWant := input.wantResult.([]any); okWant {
-				if (gotList == nil && wantList != nil) || (gotList != nil && wantList == nil) {
-					t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-					good = false
-				} else {
-					equal := len(gotList) == len(wantList)
-					if equal {
-						for i, gotItem := range gotList {
-							wantItem := wantList[i]
-							equal = gotItem == wantItem
-							if !equal {
-								break
-							}
-						}
-					}
-					if !equal {
-						t.Errorf("%d: %q -> result = %v [%T], want %v [%T]", i+1, input.source, gotResult, gotResult, input.wantResult, input.wantResult)
-						good = false
-					}
-				}
-			}
-		}
-
-		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)
-				good = false
-			}
-		}
-
-		if good {
-			succeeded++
-		} else {
-			failed++
-		}
-	}
-	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
 }

t_module-register_test.go

@@ -12,7 +12,7 @@ func TestIterateModules(t *testing.T) {
 	section := "Module-Register"
 
 	mods := make([]string, 0, 100)
-	IterateModules(func(name, description string, imported bool) bool {
+	IterateBuiltinModules(func(name, description string, imported bool) bool {
 		mods = append(mods, name)
 		return true
 	})

t_operator_test.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// t_operator_test.go
+package expr
+
+import (
+	"testing"
+)
+
+func TestOperator(t *testing.T) {
+	section := "Operator"
+	inputs := []inputType{
+		/*   1 */ {`a=1; unset "a"; a`, nil, `undefined variable or function "a"`},
+		/*   2 */ {`a=1; unset ["a", "b"]`, int64(1), nil},
+		/*   3 */ {`f=func(){3}; unset "f()"`, int64(1), nil},
+	}
+
+	// t.Setenv("EXPR_PATH", ".")
+
+	//runTestSuiteSpec(t, section, inputs, 3)
+	runTestSuite(t, section, inputs)
+}

t_parser_test.go

@@ -5,18 +5,9 @@
 package expr
 
 import (
-	"errors"
-	"reflect"
-	"strings"
 	"testing"
 )
 
-type inputType struct {
-	source     string
-	wantResult any
-	wantErr    error
-}
-
 func TestGeneralParser(t *testing.T) {
 	section := "Parser"
 
@@ -57,13 +48,13 @@ func TestGeneralParser(t *testing.T) {
 		/*  34 */ {`(((1)))`, int64(1), nil},
 		/*  35 */ {`var2="abc"; "uno_" + var2`, `uno_abc`, nil},
 		/*  36 */ {`0 || 0.0 && "hello"`, false, nil},
-		/*  37 */ {`"s" + true`, nil, errors.New(`[1:6] left operand 's' [string] and right operand 'true' [bool] are not compatible with operator "+"`)},
+		/*  37 */ {`"s" + true`, nil, `[1:6] left operand 's' [string] and right operand 'true' [bool] are not compatible with operator "+"`},
-		/*  38 */ {`+false`, nil, errors.New(`[1:2] prefix/postfix operator "+" do not support operand 'false' [bool]`)},
+		/*  38 */ {`+false`, nil, `[1:2] prefix/postfix operator "+" do not support operand 'false' [bool]`},
 		/*  39 */ {`false // very simple expression`, false, nil},
-		/*  40 */ {`1 + // Missing right operator`, nil, errors.New(`[1:4] infix operator "+" requires two non-nil operands, got 1`)},
+		/*  40 */ {`1 + // Missing right operator`, nil, `[1:4] infix operator "+" requires two non-nil operands, got 1`},
 		/*  41 */ {"", nil, nil},
 		/*  42 */ {"4!", int64(24), nil},
-		/*  43 */ {"(-4)!", nil, errors.New(`factorial of a negative integer (-4) is not allowed`)},
+		/*  43 */ {"(-4)!", nil, `factorial of a negative integer (-4) is not allowed`},
 		/*  44 */ {"-4!", int64(-24), nil},
 		/*  45 */ {"1.5 < 7", true, nil},
 		/*  46 */ {"1.5 > 7", false, nil},
@@ -75,20 +66,20 @@ func TestGeneralParser(t *testing.T) {
 		/*  52 */ {`"1.5" > "7"`, false, nil},
 		/*  53 */ {`"1.5" == "7"`, false, nil},
 		/*  54 */ {`"1.5" != "7"`, true, nil},
-		/*  55 */ {"1.5 < ", nil, errors.New(`[1:6] infix operator "<" requires two non-nil operands, got 1`)},
+		/*  55 */ {"1.5 < ", nil, `[1:6] infix operator "<" requires two non-nil operands, got 1`},
-		/*  56 */ {"1.5 > ", nil, errors.New(`[1:6] infix operator ">" requires two non-nil operands, got 1`)},
+		/*  56 */ {"1.5 > ", nil, `[1:6] infix operator ">" requires two non-nil operands, got 1`},
-		/*  57 */ {"1.5 <= ", nil, errors.New(`[1:6] infix operator "<=" requires two non-nil operands, got 1`)},
+		/*  57 */ {"1.5 <= ", nil, `[1:6] infix operator "<=" requires two non-nil operands, got 1`},
-		/*  58 */ {"1.5 >= ", nil, errors.New(`[1:6] infix operator ">=" requires two non-nil operands, got 1`)},
+		/*  58 */ {"1.5 >= ", nil, `[1:6] infix operator ">=" requires two non-nil operands, got 1`},
-		/*  59 */ {"1.5 != ", nil, errors.New(`[1:6] infix operator "!=" requires two non-nil operands, got 1`)},
+		/*  59 */ {"1.5 != ", nil, `[1:6] infix operator "!=" requires two non-nil operands, got 1`},
-		/*  60 */ {"1.5 == ", nil, errors.New(`[1:6] infix operator "==" requires two non-nil operands, got 1`)},
+		/*  60 */ {"1.5 == ", nil, `[1:6] infix operator "==" requires two non-nil operands, got 1`},
-		/*  61 */ {`"1.5" < `, nil, errors.New(`[1:8] infix operator "<" requires two non-nil operands, got 1`)},
+		/*  61 */ {`"1.5" < `, nil, `[1:8] infix operator "<" requires two non-nil operands, got 1`},
-		/*  62 */ {`"1.5" > `, nil, errors.New(`[1:8] infix operator ">" requires two non-nil operands, got 1`)},
+		/*  62 */ {`"1.5" > `, nil, `[1:8] infix operator ">" requires two non-nil operands, got 1`},
-		/*  63 */ {`"1.5" == `, nil, errors.New(`[1:8] infix operator "==" requires two non-nil operands, got 1`)},
+		/*  63 */ {`"1.5" == `, nil, `[1:8] infix operator "==" requires two non-nil operands, got 1`},
-		/*  64 */ {`"1.5" != `, nil, errors.New(`[1:8] infix operator "!=" requires two non-nil operands, got 1`)},
+		/*  64 */ {`"1.5" != `, nil, `[1:8] infix operator "!=" requires two non-nil operands, got 1`},
 		/*  65 */ {"+1.5", float64(1.5), nil},
-		/*  66 */ {"+", nil, errors.New(`[1:2] prefix operator "+" requires one not nil operand`)},
+		/*  66 */ {"+", nil, `[1:2] prefix operator "+" requires one not nil operand`},
-		/*  67 */ {"4 / 0", nil, errors.New(`division by zero`)},
+		/*  67 */ {"4 / 0", nil, `division by zero`},
-		/*  68 */ {"4.0 / 0", nil, errors.New(`division by zero`)},
+		/*  68 */ {"4.0 / 0", nil, `division by zero`},
 		/*  69 */ {"4.0 / \n2", float64(2.0), nil},
 		/*  70 */ {`123`, int64(123), nil},
 		/*  71 */ {`1.`, float64(1.0), nil},
@@ -100,7 +91,7 @@ func TestGeneralParser(t *testing.T) {
 		/*  77 */ {`5 % 2`, int64(1), nil},
 		/*  78 */ {`5 % (-2)`, int64(1), nil},
 		/*  79 */ {`-5 % 2`, int64(-1), nil},
-		/*  80 */ {`5 % 2.0`, nil, errors.New(`[1:4] left operand '5' [integer] and right operand '2' [float] are not compatible with operator "%"`)},
+		/*  80 */ {`5 % 2.0`, nil, `[1:4] left operand '5' [integer] and right operand '2' [float] are not compatible with operator "%"`},
 		/*  81 */ {`"a" < "b" AND NOT (2 < 1)`, true, nil},
 		/*  82 */ {`"a" < "b" AND NOT (2 == 1)`, true, nil},
 		/*  83 */ {`"a" < "b" AND ~ 2 == 1`, true, nil},
@@ -113,12 +104,12 @@ func TestGeneralParser(t *testing.T) {
 		/*  90 */ {`x=2 but x*10`, int64(20), nil},
 		/*  91 */ {`false and true`, false, nil},
 		/*  92 */ {`false and (x==2)`, false, nil},
-		/*  93 */ {`false and (x=2 but x==2) or x==2`, nil, errors.New(`undefined variable or function "x"`)},
+		/*  93 */ {`false and (x=2 but x==2) or x==2`, nil, `undefined variable or function "x"`},
 		/*  94 */ {`false or true`, true, nil},
-		/*  95 */ {`false or (x==2)`, nil, errors.New(`undefined variable or function "x"`)},
+		/*  95 */ {`false or (x==2)`, nil, `undefined variable or function "x"`},
 		/*  96 */ {`a=5; a`, int64(5), nil},
-		/*  97 */ {`2=5`, nil, errors.New(`[1:2] left operand of "=" must be a variable or a collection's item`)},
+		/*  97 */ {`2=5`, nil, `[1:2] left operand of "=" must be a variable or a collection's item`},
-		/*  98 */ {`2+a=5`, nil, errors.New(`[1:3] left operand of "=" must be a variable or a collection's item`)},
+		/*  98 */ {`2+a=5`, nil, `[1:3] left operand of "=" must be a variable or a collection's item`},
 		/*  99 */ {`2+(a=5)`, int64(7), nil},
 		/* 100 */ {`x ?? "default"`, "default", nil},
 		/* 101 */ {`x="hello"; x ?? "default"`, "hello", nil},
@@ -128,98 +119,31 @@ func TestGeneralParser(t *testing.T) {
 		/* 105 */ {`1 ? {"a"} : {"b"}`, "b", nil},
 		/* 106 */ {`10 ? {"a"} : {"b"} :: {"c"}`, "c", nil},
 		/* 107 */ {`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}`, "b", nil},
-		/* 108 */ {`10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}`, nil, errors.New(`[1:34] case list in default clause`)},
+		/* 108 */ {`10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}`, nil, `[1:34] case list in default clause`},
 		/* 109 */ {`10 ? {"a"} :[10] {x="b" but x} :: {"c"}`, "b", nil},
 		/* 110 */ {`10 ? {"a"} :[10] {x="b"; x} :: {"c"}`, "b", nil},
-		/* 111 */ {`10 ? {"a"} : {"b"}`, nil, errors.New(`[1:3] no case catches the value (10) of the selection expression`)},
+		/* 111 */ {`10 ? {"a"} : {"b"}`, nil, `[1:3] no case catches the value (10) of the selection expression`},
-		/* 112 */ {`10 ? {"a"} :: {"b"} : {"c"}`, nil, errors.New(`[1:22] selector-case outside of a selector context`)},
+		/* 112 */ {`10 ? {"a"} :: {"b"} : {"c"}`, nil, `[1:22] selector-case outside of a selector context`},
 		/* 113 */ {`1 ? {"a"} : {"b"} ? ["a"] {"A"} :["b"] {"B"}`, "B", nil},
 		/* 114 */ {`2 + 1 ? {"a"} : {"b"} * 3`, "2bbb", nil},
 		/* 115 */ {`nil`, nil, nil},
-		/* 116 */ {`null`, nil, errors.New(`undefined variable or function "null"`)},
+		/* 116 */ {`null`, nil, `undefined variable or function "null"`},
-		/* 117 */ {`{"key"}`, nil, errors.New(`[1:8] expected ":", got "}"`)},
+		/* 117 */ {`{"key"}`, nil, "[1:8] expected `:`, got `}`"},
-		/* 118 */ {`{"key":}`, nil, errors.New(`[1:9] expected "dictionary-value", got "}"`)},
+		/* 118 */ {`{"key":}`, nil, "[1:9] expected `dictionary-value`, got `}`"},
 		/* 119 */ {`{}`, &DictType{}, nil},
 		/* 120 */ {`v=10; v++; v`, int64(11), nil},
 		/* 121 */ {`1+1|2+0.5`, float64(2), nil},
 		/* 122 */ {`1.2()`, newFraction(6, 5), nil},
-		/* 123 */ {`1|(2-2)`, nil, errors.New(`division by zero`)},
+		/* 123 */ {`1|(2-2)`, nil, `division by zero`},
+		/* 124 */ {`x="abc"; x ?! #x`, int64(3), nil},
+		/* 125 */ {`x ?! #x`, nil, `[1:7] prefix/postfix operator "#" do not support operand '<nil>' [nil]`},
+		/* 126 */ {`x ?! (x+1)`, nil, nil},
+		/* 127 */ {`"abx" ?! (x+1)`, nil, `[1:6] left operand of "?!" must be a variable`},
+		/* 128 */ {`"abx" ?? "pqr"`, nil, `[1:6] left operand of "??" must be a variable`},
+		/* 129 */ {`"abx" ?= "pqr"`, nil, `[1:6] left operand of "?=" must be a variable`},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")
-	// parserTestSpec(t, section, inputs, 102)
+	//runTestSuiteSpec(t, section, inputs, 130)
-	parserTest(t, section, inputs)
+	runTestSuite(t, section, inputs)
-}
-
-func parserTestSpec(t *testing.T, section string, inputs []inputType, spec ...int) {
-	succeeded := 0
-	failed := 0
-	for _, count := range spec {
-		good := doTest(t, section, &inputs[count-1], count)
-
-		if good {
-			succeeded++
-		} else {
-			failed++
-		}
-	}
-	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(spec), succeeded, failed)
-}
-
-func parserTest(t *testing.T, section string, inputs []inputType) {
-
-	succeeded := 0
-	failed := 0
-
-	for i, input := range inputs {
-		good := doTest(t, section, &input, i+1)
-		if good {
-			succeeded++
-		} else {
-			failed++
-		}
-	}
-	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
-}
-
-func doTest(t *testing.T, section string, input *inputType, count int) (good bool) {
-	var expr Expr
-	var gotResult any
-	var gotErr error
-
-	ctx := NewSimpleStore()
-	parser := NewParser(ctx)
-
-	logTest(t, count, section, input.source, input.wantResult, input.wantErr)
-
-	r := strings.NewReader(input.source)
-	scanner := NewScanner(r, DefaultTranslations())
-
-	good = true
-	if expr, gotErr = parser.Parse(scanner); gotErr == nil {
-		gotResult, gotErr = expr.Eval(ctx)
-	}
-
-	eq := reflect.DeepEqual(gotResult, input.wantResult)
-
-	if !eq /*gotResult != input.wantResult*/ {
-		t.Errorf("%d: %q -> result = %v [%s], want = %v [%s]", count, input.source, gotResult, typeName(gotResult), input.wantResult, typeName(input.wantResult))
-		good = false
-	}
-
-	if gotErr != input.wantErr {
-		if input.wantErr == nil || gotErr == nil || (gotErr.Error() != input.wantErr.Error()) {
-			t.Errorf("%d: %q -> got-err = <%v>, expected-err = <%v>", count, input.source, gotErr, input.wantErr)
-			good = false
-		}
-	}
-	return
-}
-
-func logTest(t *testing.T, n int, section, source string, wantResult any, wantErr error) {
-	if wantErr == nil {
-		t.Logf("[+]%s nr %3d -- %q  --> %v", section, n, source, wantResult)
-	} else {
-		t.Logf("[-]%s nr %3d -- %q  --> %v", section, n, source, wantErr)
-	}
 }