graph.go: conditioned compilation by 'graph' tag

README.adoc

@@ -144,4 +144,4 @@ Variables and functions can be added to a context both programmatically and ad a
 
 == Expressions syntax
 
-See #TODO link to doc/Expr.html#
+See https://cdn.paas.portale-stac.it/howto/go-pkg/expr/doc/Expr.html[Expr documentation] for a complete reference of the expression syntax and available functions.

ast.go

@@ -5,7 +5,10 @@
 package expr
 
 import (
+	"errors"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 //-------- ast
@@ -19,33 +22,33 @@ func NewAst() *ast {
 	return &ast{}
 }
 
-func (expr *ast) TypeName() string {
+func (ast *ast) TypeName() string {
 	return "Expression"
 }
 
-func (expr *ast) ToForest() {
+func (ast *ast) ToForest() {
-	if expr.root != nil {
+	if ast.root != nil {
-		if expr.forest == nil {
+		if ast.forest == nil {
-			expr.forest = make([]*term, 0)
+			ast.forest = make([]*term, 0)
 		}
-		expr.forest = append(expr.forest, expr.root)
+		ast.forest = append(ast.forest, ast.root)
-		expr.root = nil
+		ast.root = nil
 	}
 }
 
-func (expr *ast) String() string {
+func (ast *ast) String() string {
 	var sb strings.Builder
-	if expr.root == nil {
+	if ast.root == nil {
 		sb.WriteString("(nil)")
 	} else {
-		expr.root.toString(&sb)
+		ast.root.toString(&sb)
 	}
 	return sb.String()
 }
 
-func (expr *ast) addTokens(tokens ...*Token) (err error) {
+func (ast *ast) addTokens(tokens ...*Token) (err error) {
 	for _, tk := range tokens {
-		if _, err = expr.addToken(tk); err != nil {
+		if _, err = ast.addToken(tk); err != nil {
 			break
 		}
 	}
@@ -57,31 +60,31 @@ func (expr *ast) addTokens(tokens ...*Token) (err error) {
 // 	return
 // }
 
-func (expr *ast) addToken(tk *Token) (t *term, err error) {
+func (ast *ast) addToken(tk *Token) (t *term, err error) {
 	if t = newTerm(tk); t != nil {
-		err = expr.addTerm(t)
+		err = ast.addTerm(t)
 	} else {
 		err = tk.Errorf("unexpected token %q", tk.String())
 	}
 	return
 }
 
-func (expr *ast) addTerm(node *term) (err error) {
+func (ast *ast) addTerm(node *term) (err error) {
-	if expr.root == nil {
+	if ast.root == nil {
-		expr.root = node
+		ast.root = node
 	} else {
-		expr.root, err = expr.insert(expr.root, node)
+		ast.root, err = ast.insert(ast.root, node)
 	}
 	return
 }
 
-func (expr *ast) insert(tree, node *term) (root *term, err error) {
+func (ast *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 = expr.insert(last, node); err == nil {
+			if subRoot, err = ast.insert(last, node); err == nil {
 				subRoot.setParent(tree)
 			}
 		} else {
@@ -96,22 +99,32 @@ func (expr *ast) insert(tree, node *term) (root *term, err error) {
 	return
 }
 
-func (expr *ast) Finish() {
+func (ast *ast) Finish() {
-	if expr.root == nil && expr.forest != nil && len(expr.forest) >= 1 {
+	if ast.root == nil && ast.forest != nil && len(ast.forest) >= 1 {
-		expr.root = expr.forest[len(expr.forest)-1]
+		ast.root = ast.forest[len(ast.forest)-1]
-		expr.forest = expr.forest[0 : len(expr.forest)-1]
+		ast.forest = ast.forest[0 : len(ast.forest)-1]
 	}
 }
 
-func (expr *ast) Eval(ctx ExprContext) (result any, err error) {
+func (ast *ast) Eval(ctx kern.ExprContext) (result any, err error) {
-	expr.Finish()
+	defer func() {
+		if r := recover(); r != nil {
+			if errVal, ok := r.(error); ok {
+				err = errVal
+			} else {
+				err = errors.New("unexpected error while evaluating the expression")
+			}
+		}
+	}()
 
-	if expr.root != nil {
+	ast.Finish()
+
+	if ast.root != nil {
 		// initDefaultVars(ctx)
-		if expr.forest != nil {
+		if ast.forest != nil {
-			for _, root := range expr.forest {
+			for _, tree := range ast.forest {
-				if result, err = root.compute(ctx); err == nil {
+				if result, err = tree.Compute(ctx); err == nil {
-					ctx.UnsafeSetVar(ControlLastResult, result)
+					ctx.UnsafeSetVar(kern.ControlLastResult, result)
 				} else {
 					//err = fmt.Errorf("error in expression nr %d: %v", i+1, err)
 					break
@@ -119,8 +132,8 @@ func (expr *ast) Eval(ctx ExprContext) (result any, err error) {
 			}
 		}
 		if err == nil {
-			if result, err = expr.root.compute(ctx); err == nil {
+			if result, err = ast.root.Compute(ctx); err == nil {
-				ctx.UnsafeSetVar(ControlLastResult, result)
+				ctx.UnsafeSetVar(kern.ControlLastResult, result)
 			}
 		}
 		// } else {

bind-expr-functions.go

@@ -4,20 +4,24 @@
 // function.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 // ---- Linking with Expr functions
 type exprFunctor struct {
-	baseFunctor
+	kern.BaseFunctor
-	params []ExprFuncParam
+	params []kern.ExprFuncParam
 	expr   Expr
-	defCtx ExprContext
+	defCtx kern.ExprContext
 }
 
-func (functor *exprFunctor) GetParams() (params []ExprFuncParam) {
+func (functor *exprFunctor) GetParams() (params []kern.ExprFuncParam) {
 	return functor.params
 }
 
-func newExprFunctor(e Expr, params []ExprFuncParam, ctx ExprContext) *exprFunctor {
+func newExprFunctor(e Expr, params []kern.ExprFuncParam, ctx kern.ExprContext) *exprFunctor {
-	var defCtx ExprContext
+	var defCtx kern.ExprContext
 	if ctx != nil {
 		defCtx = ctx
 	}
@@ -28,17 +32,17 @@ func (functor *exprFunctor) TypeName() string {
 	return "ExprFunctor"
 }
 
-func (functor *exprFunctor) GetDefinitionContext() ExprContext {
+func (functor *exprFunctor) GetDefinitionContext() kern.ExprContext {
 	return functor.defCtx
 }
 
-func (functor *exprFunctor) InvokeNamed(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func (functor *exprFunctor) InvokeNamed(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var missing []string
 	for _, p := range functor.params {
 		if arg, exists := args[p.Name()]; exists {
-			if funcArg, ok := arg.(Functor); ok {
+			if funcArg, ok := arg.(kern.Functor); ok {
 				paramSpecs := funcArg.GetParams()
-				ctx.RegisterFunc(p.Name(), funcArg, TypeAny, paramSpecs)
+				ctx.RegisterFunc(p.Name(), funcArg, kern.TypeAny, paramSpecs)
 			} else {
 				ctx.UnsafeSetVar(p.Name(), arg)
 			}
@@ -51,7 +55,7 @@ func (functor *exprFunctor) InvokeNamed(ctx ExprContext, name string, args map[s
 		}
 	}
 	if missing != nil {
-		err = ErrMissingParams(name, missing)
+		err = kern.ErrMissingParams(name, missing)
 	} else {
 		result, err = functor.expr.Eval(ctx)
 	}

builtin-base.go

@@ -9,77 +9,83 @@ import (
 	"math"
 	"strconv"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 const (
 	ParamDenominator = "denominator"
 )
 
-func isNilFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func isNilFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	result = args[ParamValue] == nil
+	result = args[kern.ParamValue] == nil
 	return
 }
 
-func isIntFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func isIntFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsInteger(args[ParamValue])
+	result = kern.IsInteger(args[kern.ParamValue])
 	return
 }
 
-func isFloatFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func isFloatFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsFloat(args[ParamValue])
+	result = kern.IsFloat(args[kern.ParamValue])
 	return
 }
 
-func isBoolFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func isBoolFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsBool(args[ParamValue])
+	result = kern.IsBool(args[kern.ParamValue])
 	return
 }
 
-func isStringFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func isStringFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsString(args[ParamValue])
+	result = kern.IsString(args[kern.ParamValue])
 	return
 }
 
-func isFractionFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func isFractionFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsFract(args[ParamValue])
+	result = kern.IsFraction(args[kern.ParamValue])
 	return
 }
 
-func isRationalFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func isRationalFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsRational(args[ParamValue])
+	result = kern.IsRational(args[kern.ParamValue])
 	return
 }
 
-func isListFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func isListFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsList(args[ParamValue])
+	result = kern.IsList(args[kern.ParamValue])
 	return
 }
 
-func isDictionaryFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func isDictionaryFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsDict(args[ParamValue])
+	result = kern.IsDict(args[kern.ParamValue])
 	return
 }
 
-func boolFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func boolFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	switch v := args[ParamValue].(type) {
+	switch v := args[kern.ParamValue].(type) {
 	case int64:
 		result = (v != 0)
-	case *FractionType:
+	case *kern.FractionType:
-		result = v.num != 0
+		result = v.N() != 0
 	case float64:
 		result = v != 0.0
 	case bool:
 		result = v
 	case string:
 		result = len(v) > 0
+	case *kern.ListType:
+		result = len(*v) > 0
+	case *kern.DictType:
+		result = len(*v) > 0
 	default:
-		err = ErrCantConvert(name, v, "bool")
+		err = kern.ErrCantConvert(name, v, "bool")
 	}
 	return
 }
 
-func intFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func intFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	switch v := args[ParamValue].(type) {
+	switch v := args[kern.ParamValue].(type) {
 	case int64:
 		result = v
 	case float64:
@@ -95,14 +101,16 @@ func intFunc(ctx ExprContext, name string, args map[string]any) (result any, err
 		if i, err = strconv.Atoi(v); err == nil {
 			result = int64(i)
 		}
+	case *kern.FractionType:
+		result = int64(v.N() / v.D())
 	default:
-		err = ErrCantConvert(name, v, "int")
+		err = kern.ErrCantConvert(name, v, "int")
 	}
 	return
 }
 
-func decFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func decFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	switch v := args[ParamValue].(type) {
+	switch v := args[kern.ParamValue].(type) {
 	case int64:
 		result = float64(v)
 	case float64:
@@ -118,16 +126,16 @@ func decFunc(ctx ExprContext, name string, args map[string]any) (result any, err
 		if f, err = strconv.ParseFloat(v, 64); err == nil {
 			result = f
 		}
-	case *FractionType:
+	case *kern.FractionType:
-		result = v.toFloat()
+		result = v.ToFloat()
 	default:
-		err = ErrCantConvert(name, v, "float")
+		err = kern.ErrCantConvert(name, v, "float")
 	}
 	return
 }
 
-func stringFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func stringFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	switch v := args[ParamValue].(type) {
+	switch v := args[kern.ParamValue].(type) {
 	case int64:
 		result = strconv.FormatInt(v, 10)
 	case float64:
@@ -140,106 +148,169 @@ func stringFunc(ctx ExprContext, name string, args map[string]any) (result any,
 		}
 	case string:
 		result = v
-	case *FractionType:
+	case *kern.FractionType:
 		result = v.ToString(0)
-	case Formatter:
+	case kern.Formatter:
 		result = v.ToString(0)
 	case fmt.Stringer:
 		result = v.String()
 	default:
-		err = ErrCantConvert(name, v, "string")
+		err = kern.ErrCantConvert(name, v, "string")
 	}
 	return
 }
 
-func fractFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func fractFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	switch v := args[ParamValue].(type) {
+	switch v := args[kern.ParamValue].(type) {
 	case int64:
 		var den int64 = 1
 
 		var ok bool
 		if den, ok = args[ParamDenominator].(int64); !ok {
-			err = ErrExpectedGot(name, "integer", args[ParamDenominator])
+			err = kern.ErrExpectedGot(name, "integer", args[ParamDenominator])
 		} else if den == 0 {
-			err = ErrFuncDivisionByZero(name)
+			err = kern.ErrFuncDivisionByZero(name)
 		}
 
 		if err == nil {
-			result = newFraction(v, den)
+			result = kern.NewFraction(v, den)
 		}
 	case float64:
-		result, err = float64ToFraction(v)
+		result, err = kern.Float64ToFraction(v)
 	case bool:
 		if v {
-			result = newFraction(1, 1)
+			result = kern.NewFraction(1, 1)
 		} else {
-			result = newFraction(0, 1)
+			result = kern.NewFraction(0, 1)
 		}
 	case string:
-		result, err = makeGeneratingFraction(v)
+		result, err = kern.MakeGeneratingFraction(v)
-	case *FractionType:
+	case *kern.FractionType:
 		result = v
 	default:
-		err = ErrCantConvert(name, v, "float")
+		err = kern.ErrCantConvert(name, v, "float")
 	}
 	return
 }
 
-// func iteratorFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+// func iteratorFunc(ctx expr.ExprContext, name string, args []any) (result any, err error) {
 // 	return
 // }
 
-func evalFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func evalFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	if source, ok := args[ParamSource].(string); ok {
+	if source, ok := args[kern.ParamSource].(string); ok {
-		var expr Expr
+		var ast Expr
 
 		parser := NewParser()
 		if ctx == nil {
-			ctx = NewSimpleStore()
+			ctx = NewSimpleStoreWithoutGlobalContext()
 		}
 
 		r := strings.NewReader(source)
 		scanner := NewScanner(r, DefaultTranslations())
 
-		if expr, err = parser.Parse(scanner); err == nil {
+		if ast, err = parser.Parse(scanner); err == nil {
-			CtrlEnable(ctx, control_export_all)
+			CtrlEnable(ctx, kern.ControlExportAll)
-			result, err = expr.Eval(ctx)
+			result, err = ast.Eval(ctx)
 		}
 	} else {
-		err = ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+		err = kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
 	}
 	return
 }
 
-//// import
+func varFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+	var varName string
+	var ok bool
 
-func ImportBuiltinsFuncs(ctx ExprContext) {
+	if varName, ok = args[kern.ParamName].(string); !ok {
-	anyParams := []ExprFuncParam{
+		return nil, kern.ErrWrongParamType(name, kern.ParamName, kern.TypeString, args[kern.ParamName])
-		NewFuncParam(ParamValue),
 	}
 
-	ctx.RegisterFunc("isNil", NewGolangFunctor(isNilFunc), TypeBoolean, anyParams)
+	if result, ok = args[kern.ParamValue]; ok && result != nil {
-	ctx.RegisterFunc("isInt", NewGolangFunctor(isIntFunc), TypeBoolean, anyParams)
+		ctx.GetParent().UnsafeSetVar(varName, result)
-	ctx.RegisterFunc("isFloat", NewGolangFunctor(isFloatFunc), TypeBoolean, anyParams)
+		// } else {
-	ctx.RegisterFunc("isBool", NewGolangFunctor(isBoolFunc), TypeBoolean, anyParams)
+		// 	err = expr.ErrWrongParamType(name, expr.ParamSource, expr.TypeString, args[expr.ParamSource])
-	ctx.RegisterFunc("isString", NewGolangFunctor(isStringFunc), TypeBoolean, anyParams)
+		// }
-	ctx.RegisterFunc("isFract", NewGolangFunctor(isFractionFunc), TypeBoolean, anyParams)
+	} else if result, ok = ctx.GetVar(varName); !ok {
-	ctx.RegisterFunc("isRational", NewGolangFunctor(isRationalFunc), TypeBoolean, anyParams)
+		err = kern.ErrUnknownVar(name, varName)
-	ctx.RegisterFunc("isList", NewGolangFunctor(isListFunc), TypeBoolean, anyParams)
+	}
-	ctx.RegisterFunc("isDict", NewGolangFunctor(isDictionaryFunc), TypeBoolean, anyParams)
+	return
+}
 
-	ctx.RegisterFunc("bool", NewGolangFunctor(boolFunc), TypeBoolean, anyParams)
+func setFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	ctx.RegisterFunc("int", NewGolangFunctor(intFunc), TypeInt, anyParams)
+	var varName string
-	ctx.RegisterFunc("dec", NewGolangFunctor(decFunc), TypeFloat, anyParams)
+	var ok bool
-	ctx.RegisterFunc("string", NewGolangFunctor(stringFunc), TypeString, anyParams)
+
-	ctx.RegisterFunc("fract", NewGolangFunctor(fractFunc), TypeFraction, []ExprFuncParam{
+	if varName, ok = args[kern.ParamName].(string); !ok {
-		NewFuncParam(ParamValue),
+		return nil, kern.ErrWrongParamType(name, kern.ParamName, kern.TypeString, args[kern.ParamName])
+	}
+
+	if result, ok = args[kern.ParamValue]; ok {
+		ctx.GetParent().UnsafeSetVar(varName, result)
+	} else {
+		err = kern.ErrWrongParamType(name, kern.ParamValue, kern.TypeAny, args[kern.ParamValue])
+	}
+	return
+}
+
+// func unsetFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+// 	var varName string
+// 	var ok bool
+
+// 	if varName, ok = args[kern.ParamName].(string); !ok {
+// 		return nil, kern.ErrWrongParamType(name, kern.ParamName, kern.TypeString, args[kern.ParamName])
+// 	} else {
+// 		ctx.GetParent().DeleteVar(varName)
+// 		result = nil
+// 	}
+// 	return
+// }
+
+//// import
+
+func ImportBuiltinsFuncs(ctx kern.ExprContext) {
+	anyParams := []kern.ExprFuncParam{
+		NewFuncParam(kern.ParamValue),
+	}
+
+	ctx.RegisterFunc("isNil", kern.NewGolangFunctor(isNilFunc), kern.TypeBoolean, anyParams)
+	ctx.RegisterFunc("isInt", kern.NewGolangFunctor(isIntFunc), kern.TypeBoolean, anyParams)
+	ctx.RegisterFunc("isFloat", kern.NewGolangFunctor(isFloatFunc), kern.TypeBoolean, anyParams)
+	ctx.RegisterFunc("isBool", kern.NewGolangFunctor(isBoolFunc), kern.TypeBoolean, anyParams)
+	ctx.RegisterFunc("isString", kern.NewGolangFunctor(isStringFunc), kern.TypeBoolean, anyParams)
+	ctx.RegisterFunc("isFract", kern.NewGolangFunctor(isFractionFunc), kern.TypeBoolean, anyParams)
+	ctx.RegisterFunc("isRational", kern.NewGolangFunctor(isRationalFunc), kern.TypeBoolean, anyParams)
+	ctx.RegisterFunc("isList", kern.NewGolangFunctor(isListFunc), kern.TypeBoolean, anyParams)
+	ctx.RegisterFunc("isDict", kern.NewGolangFunctor(isDictionaryFunc), kern.TypeBoolean, anyParams)
+
+	ctx.RegisterFunc("bool", kern.NewGolangFunctor(boolFunc), kern.TypeBoolean, anyParams)
+	ctx.RegisterFunc("int", kern.NewGolangFunctor(intFunc), kern.TypeInt, anyParams)
+	ctx.RegisterFunc("dec", kern.NewGolangFunctor(decFunc), kern.TypeFloat, anyParams)
+	ctx.RegisterFunc("string", kern.NewGolangFunctor(stringFunc), kern.TypeString, anyParams)
+	ctx.RegisterFunc("fract", kern.NewGolangFunctor(fractFunc), kern.TypeFraction, []kern.ExprFuncParam{
+		NewFuncParam(kern.ParamValue),
 		NewFuncParamFlagDef(ParamDenominator, PfDefault, int64(1)),
 	})
 
-	ctx.RegisterFunc("eval", NewGolangFunctor(evalFunc), TypeAny, []ExprFuncParam{
+	ctx.RegisterFunc("eval", kern.NewGolangFunctor(evalFunc), kern.TypeAny, []kern.ExprFuncParam{
-		NewFuncParam(ParamSource),
+		NewFuncParam(kern.ParamSource),
 	})
+
+	ctx.RegisterFunc("var", kern.NewGolangFunctor(varFunc), kern.TypeAny, []kern.ExprFuncParam{
+		NewFuncParam(kern.ParamName),
+		NewFuncParamFlagDef(kern.ParamValue, PfDefault, nil),
+	})
+
+	ctx.RegisterFunc("set", kern.NewGolangFunctor(setFunc), kern.TypeAny, []kern.ExprFuncParam{
+		NewFuncParam(kern.ParamName),
+		NewFuncParam(kern.ParamValue),
+	})
+
+	// ctx.RegisterFunc("unset", kern.NewGolangFunctor(unsetFunc), kern.TypeAny, []kern.ExprFuncParam{
+	// 	NewFuncParam(kern.ParamName),
+	// 	NewFuncParam(kern.ParamValue),
+	// })
 }
 
 func init() {

builtin-fmt.go

@@ -8,11 +8,13 @@ import (
 	"fmt"
 	"io"
 	"os"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
-func getStdout(ctx ExprContext) io.Writer {
+func getStdout(ctx kern.ExprContext) io.Writer {
 	var w io.Writer
-	if wany, exists := ctx.GetVar(ControlStdout); exists && wany != nil {
+	if wany, exists := ctx.GetVar(kern.ControlStdout); exists && wany != nil {
 		w, _ = wany.(io.Writer)
 	}
 	if w == nil {
@@ -21,9 +23,9 @@ func getStdout(ctx ExprContext) io.Writer {
 	return w
 }
 
-func printFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func printFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var n int = 0
-	if v, exists := args[ParamItem]; exists && v != nil {
+	if v, exists := args[kern.ParamItem]; exists && v != nil {
 		argv := v.([]any)
 		n, err = fmt.Fprint(getStdout(ctx), argv...)
 	}
@@ -31,9 +33,9 @@ func printFunc(ctx ExprContext, name string, args map[string]any) (result any, e
 	return
 }
 
-func printLnFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func printLnFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var n int = 0
-	if v, exists := args[ParamItem]; exists && v != nil {
+	if v, exists := args[kern.ParamItem]; exists && v != nil {
 		argv := v.([]any)
 		n, err = fmt.Fprintln(getStdout(ctx), argv...)
 	} else {
@@ -43,12 +45,12 @@ func printLnFunc(ctx ExprContext, name string, args map[string]any) (result any,
 	return
 }
 
-func ImportFmtFuncs(ctx ExprContext) {
+func ImportFmtFuncs(ctx kern.ExprContext) {
-	ctx.RegisterFunc("print", NewGolangFunctor(printFunc), TypeInt, []ExprFuncParam{
+	ctx.RegisterFunc("print", kern.NewGolangFunctor(printFunc), kern.TypeInt, []kern.ExprFuncParam{
-		NewFuncParamFlag(ParamItem, PfRepeat),
+		NewFuncParamFlag(kern.ParamItem, PfRepeat),
 	})
-	ctx.RegisterFunc("println", NewGolangFunctor(printLnFunc), TypeInt, []ExprFuncParam{
+	ctx.RegisterFunc("println", kern.NewGolangFunctor(printLnFunc), kern.TypeInt, []kern.ExprFuncParam{
-		NewFuncParamFlag(ParamItem, PfRepeat),
+		NewFuncParamFlag(kern.ParamItem, PfRepeat),
 	})
 }
 

builtin-import.go

@@ -7,32 +7,34 @@ package expr
 import (
 	"io"
 	"os"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
-func importFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func importFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	return importGeneral(ctx, name, args)
 }
 
-func importAllFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func importAllFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	CtrlEnable(ctx, control_export_all)
+	CtrlEnable(ctx, kern.ControlExportAll)
 	return importGeneral(ctx, name, args)
 }
 
-func importGeneral(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func importGeneral(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	dirList := buildSearchDirList("sources", ENV_EXPR_SOURCE_PATH)
+	dirList := buildSearchDirList(ctx, "sources", ENV_EXPR_SOURCE_PATH)
-	if v, exists := args[ParamFilepath]; exists && v != nil {
+	if v, exists := args[kern.ParamFilepath]; exists && v != nil {
 		argv := v.([]any)
 		result, err = doImport(ctx, name, dirList, NewArrayIterator(argv))
 	}
 	return
 }
 
-func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (result any, err error) {
+func doImport(ctx kern.ExprContext, name string, dirList []string, it kern.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 {
+		if err = checkStringParamExpected(name, v, int(it.Index())); err != nil {
 			break
 		}
 		if sourceFilepath, err = makeFilepath(v.(string), dirList); err != nil {
@@ -64,12 +66,12 @@ func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (resu
 	return
 }
 
-func ImportImportFuncs(ctx ExprContext) {
+func ImportImportFuncs(ctx kern.ExprContext) {
-	ctx.RegisterFunc("import", NewGolangFunctor(importFunc), TypeAny, []ExprFuncParam{
+	ctx.RegisterFunc("import", kern.NewGolangFunctor(importFunc), kern.TypeAny, []kern.ExprFuncParam{
-		NewFuncParamFlag(ParamFilepath, PfRepeat),
+		NewFuncParamFlag(kern.ParamFilepath, PfRepeat),
 	})
-	ctx.RegisterFunc("importAll", NewGolangFunctor(importAllFunc), TypeAny, []ExprFuncParam{
+	ctx.RegisterFunc("importAll", kern.NewGolangFunctor(importAllFunc), kern.TypeAny, []kern.ExprFuncParam{
-		NewFuncParamFlag(ParamFilepath, PfRepeat),
+		NewFuncParamFlag(kern.ParamFilepath, PfRepeat),
 	})
 }
 

builtin-iterator.go

@@ -7,6 +7,8 @@ package expr
 import (
 	"fmt"
 	"io"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 const (
@@ -15,22 +17,24 @@ const (
 	iterVarStatus     = "status"
 )
 
-func parseRunArgs(localCtx ExprContext, args map[string]any) (it Iterator, op Functor, err error) {
+func parseRunArgs(localCtx kern.ExprContext, args map[string]any) (it kern.Iterator, op kern.Functor, err error) {
 	var ok bool
 
-	if it, ok = args[ParamIterator].(Iterator); !ok {
+	if it, ok = args[kern.ParamIterator].(kern.Iterator); !ok {
-		err = fmt.Errorf("paramter %q must be an iterator, passed %v [%s]", ParamIterator, args[ParamIterator], TypeName(args[ParamIterator]))
+		err = fmt.Errorf("paramter %q must be an iterator, passed %v [%s]", kern.ParamIterator, args[kern.ParamIterator], kern.TypeName(args[kern.ParamIterator]))
 		return
 	}
 
-	if op, ok = args[iterParamOperator].(Functor); !ok && args[iterParamOperator] != nil {
+	if args[iterParamOperator] != nil {
-		err = fmt.Errorf("paramter %q must be a function, passed %v [%s]", iterParamOperator, args[iterParamOperator], TypeName(args[iterParamOperator]))
+		if op, ok = args[iterParamOperator].(kern.Functor); !ok || op == nil {
+			err = fmt.Errorf("paramter %q must be a function, passed %v [%s]", iterParamOperator, args[iterParamOperator], kern.TypeName(args[iterParamOperator]))
 			return
 		}
+	}
 
-	var vars *DictType
+	var vars *kern.DictType
-	if vars, ok = args[iterParamVars].(*DictType); !ok && args[iterParamVars] != nil {
+	if vars, ok = args[iterParamVars].(*kern.DictType); !ok && args[iterParamVars] != nil {
-		err = fmt.Errorf("paramter %q must be a dictionary, passed %v [%s]", iterParamVars, args[iterParamVars], TypeName(args[iterParamVars]))
+		err = fmt.Errorf("paramter %q must be a dictionary, passed %v [%s]", iterParamVars, args[iterParamVars], kern.TypeName(args[iterParamVars]))
 		return
 	}
 
@@ -46,12 +50,12 @@ func parseRunArgs(localCtx ExprContext, args map[string]any) (it Iterator, op Fu
 	return
 }
 
-func runFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func runFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	var it Iterator
+	var it kern.Iterator
 	var ok bool
-	var op Functor
+	var op kern.Functor
 	var v any
-	var usingDefaultOp = false
+	// var usingDefaultOp = false
 	var params map[string]any
 	var item any
 
@@ -60,40 +64,37 @@ func runFunc(ctx ExprContext, name string, args map[string]any) (result any, err
 
 	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 {
+		if op != nil {
-			params = map[string]any{ParamItem: []any{item}}
+			params = map[string]any{kern.ParamIndex: it.Index(), kern.ParamItem: item}
-		} else {
-			params = map[string]any{ParamIndex: it.Index(), ParamItem: item}
-		}
-
 			if v, err = op.InvokeNamed(localCtx, iterParamOperator, params); err != nil {
 				break
 			} else {
 				var success bool
-			if success, ok = ToBool(v); !success || !ok {
+				if success, ok = kern.ToBool(v); !success || !ok {
 					break
 				}
 			}
 		}
+	}
 
 	if err == io.EOF {
 		err = nil
 	}
 	if err == nil {
+		if op == nil {
+			ctx.UnsafeSetVar(iterVarStatus, it.Count())
+		}
 		result, _ = localCtx.GetVar(iterVarStatus)
 	}
 	return
 }
 
-func ImportIterFuncs(ctx ExprContext) {
+func ImportIterFuncs(ctx kern.ExprContext) {
-	ctx.RegisterFunc("run", NewGolangFunctor(runFunc), TypeAny, []ExprFuncParam{
+	ctx.RegisterFunc("run", kern.NewGolangFunctor(runFunc), kern.TypeAny, []kern.ExprFuncParam{
-		NewFuncParam(ParamIterator),
+		NewFuncParam(kern.ParamIterator),
 		NewFuncParamFlag(iterParamOperator, PfOptional),
 		NewFuncParamFlag(iterParamVars, PfOptional),
 	})

builtin-math-arith.go

@@ -7,67 +7,69 @@ package expr
 import (
 	"fmt"
 	"io"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 func checkNumberParamExpected(funcName string, paramValue any, paramPos, level, subPos int) (err error) {
-	if !(IsNumber(paramValue) || isFraction(paramValue)) /*|| isList(paramValue)*/ {
+	if !(kern.IsNumber(paramValue) || kern.IsFraction(paramValue)) /*|| isList(paramValue)*/ {
 		err = fmt.Errorf("%s(): param nr %d (%d in %d) has wrong type %T, number expected",
 			funcName, paramPos+1, subPos+1, level, paramValue)
 	}
 	return
 }
 
-func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result any, err error) {
+func doAdd(ctx kern.ExprContext, name string, it kern.Iterator, count, level int) (result any, err error) {
 	var sumAsFloat, sumAsFract bool
 	var floatSum float64 = 0.0
 	var intSum int64 = 0
-	var fractSum *FractionType
+	var fractSum *kern.FractionType
 	var v any
 
 	level++
 
 	for v, err = it.Next(); err == nil; v, err = it.Next() {
-		if list, ok := v.(*ListType); ok {
+		if list, ok := v.(*kern.ListType); ok {
 			v = NewListIterator(list, nil)
 		}
-		if subIter, ok := v.(Iterator); ok {
+		if subIter, ok := v.(kern.Iterator); ok {
 			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.(kern.ExtIterator); ok && extIter.HasOperation(kern.CleanName) {
-				if _, err = extIter.CallOperation(CleanName, nil); err != nil {
+				if _, err = extIter.CallOperation(kern.CleanName, nil); err != nil {
 					return
 				}
 			}
-		} else if err = checkNumberParamExpected(name, v, count, level, it.Index()); err != nil {
+		} else if err = checkNumberParamExpected(name, v, count, level, int(it.Index())); err != nil {
 			break
 		}
 		count++
 
 		if !sumAsFloat {
-			if IsFloat(v) {
+			if kern.IsFloat(v) {
 				sumAsFloat = true
 				if sumAsFract {
-					floatSum = fractSum.toFloat()
+					floatSum = fractSum.ToFloat()
 				} else {
 					floatSum = float64(intSum)
 				}
-			} else if !sumAsFract && isFraction(v) {
+			} else if !sumAsFract && kern.IsFraction(v) {
-				fractSum = newFraction(intSum, 1)
+				fractSum = kern.NewFraction(intSum, 1)
 				sumAsFract = true
 			}
 		}
 
 		if sumAsFloat {
-			floatSum += numAsFloat(v)
+			floatSum += kern.NumAsFloat(v)
 		} else if sumAsFract {
-			var item *FractionType
+			var item *kern.FractionType
 			var ok bool
-			if item, ok = v.(*FractionType); !ok {
+			if item, ok = v.(*kern.FractionType); !ok {
 				iv, _ := v.(int64)
-				item = newFraction(iv, 1)
+				item = kern.NewFraction(iv, 1)
 			}
-			fractSum = sumFract(fractSum, item)
+			fractSum = kern.SumFract(fractSum, item)
 		} else {
 			iv, _ := v.(int64)
 			intSum += iv
@@ -86,64 +88,64 @@ func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result
 	return
 }
 
-func addFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func addFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	argv := args[ParamValue].([]any)
+	argv := args[kern.ParamValue].([]any)
 	result, err = doAdd(ctx, name, NewArrayIterator(argv), 0, -1)
 	return
 }
 
-func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result any, err error) {
+func doMul(ctx kern.ExprContext, name string, it kern.Iterator, count, level int) (result any, err error) {
 	var mulAsFloat, mulAsFract bool
 	var floatProd float64 = 1.0
 	var intProd int64 = 1
-	var fractProd *FractionType
+	var fractProd *kern.FractionType
 	var v any
 
 	level++
 	for v, err = it.Next(); err == nil; v, err = it.Next() {
-		if list, ok := v.(*ListType); ok {
+		if list, ok := v.(*kern.ListType); ok {
 			v = NewListIterator(list, nil)
 		}
-		if subIter, ok := v.(Iterator); ok {
+		if subIter, ok := v.(kern.Iterator); ok {
 			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.(kern.ExtIterator); ok && extIter.HasOperation(kern.CleanName) {
-				if _, err = extIter.CallOperation(CleanName, nil); err != nil {
+				if _, err = extIter.CallOperation(kern.CleanName, nil); err != nil {
 					return
 				}
 			}
 		} else {
-			if err = checkNumberParamExpected(name, v, count, level, it.Index()); err != nil {
+			if err = checkNumberParamExpected(name, v, count, level, int(it.Index())); err != nil {
 				break
 			}
 		}
 		count++
 
 		if !mulAsFloat {
-			if IsFloat(v) {
+			if kern.IsFloat(v) {
 				mulAsFloat = true
 				if mulAsFract {
-					floatProd = fractProd.toFloat()
+					floatProd = fractProd.ToFloat()
 				} else {
 					floatProd = float64(intProd)
 				}
-			} else if !mulAsFract && isFraction(v) {
+			} else if !mulAsFract && kern.IsFraction(v) {
-				fractProd = newFraction(intProd, 1)
+				fractProd = kern.NewFraction(intProd, 1)
 				mulAsFract = true
 			}
 		}
 
 		if mulAsFloat {
-			floatProd *= numAsFloat(v)
+			floatProd *= kern.NumAsFloat(v)
 		} else if mulAsFract {
-			var item *FractionType
+			var item *kern.FractionType
 			var ok bool
-			if item, ok = v.(*FractionType); !ok {
+			if item, ok = v.(*kern.FractionType); !ok {
 				iv, _ := v.(int64)
-				item = newFraction(iv, 1)
+				item = kern.NewFraction(iv, 1)
 			}
-			fractProd = mulFract(fractProd, item)
+			fractProd = kern.MulFract(fractProd, item)
 		} else {
 			iv, _ := v.(int64)
 			intProd *= iv
@@ -162,19 +164,19 @@ func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result
 	return
 }
 
-func mulFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func mulFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	argv := args[ParamValue].([]any)
+	argv := args[kern.ParamValue].([]any)
 	result, err = doMul(ctx, name, NewArrayIterator(argv), 0, -1)
 	return
 }
 
-func ImportMathFuncs(ctx ExprContext) {
+func ImportMathFuncs(ctx kern.ExprContext) {
-	ctx.RegisterFunc("add", NewGolangFunctor(addFunc), TypeNumber, []ExprFuncParam{
+	ctx.RegisterFunc("add", kern.NewGolangFunctor(addFunc), kern.TypeNumber, []kern.ExprFuncParam{
-		NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(0)),
+		NewFuncParamFlagDef(kern.ParamValue, PfDefault|PfRepeat, int64(0)),
 	})
 
-	ctx.RegisterFunc("mul", NewGolangFunctor(mulFunc), TypeNumber, []ExprFuncParam{
+	ctx.RegisterFunc("mul", kern.NewGolangFunctor(mulFunc), kern.TypeNumber, []kern.ExprFuncParam{
-		NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(1)),
+		NewFuncParamFlagDef(kern.ParamValue, PfDefault|PfRepeat, int64(1)),
 	})
 }
 

builtin-os-file-iter.go

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

builtin-os-file.go

@@ -9,6 +9,8 @@ import (
 	"fmt"
 	"io"
 	"os"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 const (
@@ -65,8 +67,8 @@ func errInvalidFileHandle(funcName string, v any) error {
 	}
 }
 
-func createFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func createFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 {
+	if filePath, ok := args[kern.ParamFilepath].(string); ok && len(filePath) > 0 {
 		var fh *os.File
 		if fh, err = os.Create(filePath); err == nil {
 			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
@@ -77,8 +79,8 @@ func createFileFunc(ctx ExprContext, name string, args map[string]any) (result a
 	return
 }
 
-func openFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func openFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 {
+	if filePath, ok := args[kern.ParamFilepath].(string); ok && len(filePath) > 0 {
 		var fh *os.File
 		if fh, err = os.Open(filePath); err == nil {
 			result = &osReader{fh: fh, reader: bufio.NewReader(fh)}
@@ -89,8 +91,8 @@ func openFileFunc(ctx ExprContext, name string, args map[string]any) (result any
 	return
 }
 
-func appendFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func appendFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 {
+	if filePath, ok := args[kern.ParamFilepath].(string); ok && len(filePath) > 0 {
 		var fh *os.File
 		if fh, err = os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0660); err == nil {
 			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
@@ -101,13 +103,13 @@ func appendFileFunc(ctx ExprContext, name string, args map[string]any) (result a
 	return
 }
 
-func closeFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func closeFileFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var handle osHandle
 	var invalidFileHandle any
 	var ok bool
 
-	if handle, ok = args[ParamHandle].(osHandle); !ok {
+	if handle, ok = args[kern.ParamHandle].(osHandle); !ok {
-		invalidFileHandle = args[ParamHandle]
+		invalidFileHandle = args[kern.ParamHandle]
 	}
 
 	if handle != nil {
@@ -128,18 +130,18 @@ func closeFileFunc(ctx ExprContext, name string, args map[string]any) (result an
 	return
 }
 
-func fileWriteTextFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func fileWriteTextFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var handle osHandle
 	var invalidFileHandle any
 	var ok bool
 
-	if handle, ok = args[ParamHandle].(osHandle); !ok {
+	if handle, ok = args[kern.ParamHandle].(osHandle); !ok {
-		invalidFileHandle = args[ParamHandle]
+		invalidFileHandle = args[kern.ParamHandle]
 	}
 
 	if handle != nil {
 		if w, ok := handle.(*osWriter); ok {
-			if v, exists := args[ParamItem]; exists {
+			if v, exists := args[kern.ParamItem]; exists {
 				argv := v.([]any)
 				result, err = fmt.Fprint(w.writer, argv...)
 			}
@@ -154,14 +156,14 @@ func fileWriteTextFunc(ctx ExprContext, name string, args map[string]any) (resul
 	return
 }
 
-func fileReadTextFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func fileReadTextFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var handle osHandle
 	var invalidFileHandle any
 	var ok bool
 
 	result = nil
-	if handle, ok = args[ParamHandle].(osHandle); !ok || args[ParamHandle] == nil {
+	if handle, ok = args[kern.ParamHandle].(osHandle); !ok || args[kern.ParamHandle] == nil {
-		invalidFileHandle = args[ParamHandle]
+		invalidFileHandle = args[kern.ParamHandle]
 	}
 
 	if handle != nil {
@@ -194,14 +196,14 @@ func fileReadTextFunc(ctx ExprContext, name string, args map[string]any) (result
 	return
 }
 
-func fileReadTextAllFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func fileReadTextAllFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var handle osHandle
 	var invalidFileHandle any
 	var ok bool
 
 	result = nil
-	if handle, ok = args[ParamHandle].(osHandle); !ok || args[ParamHandle] == nil {
+	if handle, ok = args[kern.ParamHandle].(osHandle); !ok || args[kern.ParamHandle] == nil {
-		invalidFileHandle = args[ParamHandle]
+		invalidFileHandle = args[kern.ParamHandle]
 	}
 
 	if handle != nil {
@@ -220,35 +222,39 @@ func fileReadTextAllFunc(ctx ExprContext, name string, args map[string]any) (res
 	return
 }
 
-func ImportOsFuncs(ctx ExprContext) {
+func ImportOsFuncs(ctx kern.ExprContext) {
-	ctx.RegisterFunc("fileOpen", NewGolangFunctor(openFileFunc), TypeFileHandle, []ExprFuncParam{
+	ctx.RegisterFunc("fileOpen", kern.NewGolangFunctor(openFileFunc), kern.TypeFileHandle, []kern.ExprFuncParam{
-		NewFuncParam(ParamFilepath),
+		NewFuncParam(kern.ParamFilepath),
 	})
 
-	ctx.RegisterFunc("fileAppend", NewGolangFunctor(appendFileFunc), TypeFileHandle, []ExprFuncParam{
+	ctx.RegisterFunc("fileAppend", kern.NewGolangFunctor(appendFileFunc), kern.TypeFileHandle, []kern.ExprFuncParam{
-		NewFuncParam(ParamFilepath),
+		NewFuncParam(kern.ParamFilepath),
 	})
 
-	ctx.RegisterFunc("fileCreate", NewGolangFunctor(createFileFunc), TypeFileHandle, []ExprFuncParam{
+	ctx.RegisterFunc("fileCreate", kern.NewGolangFunctor(createFileFunc), kern.TypeFileHandle, []kern.ExprFuncParam{
-		NewFuncParam(ParamFilepath),
+		NewFuncParam(kern.ParamFilepath),
 	})
 
-	ctx.RegisterFunc("fileClose", NewGolangFunctor(closeFileFunc), TypeBoolean, []ExprFuncParam{
+	ctx.RegisterFunc("fileClose", kern.NewGolangFunctor(closeFileFunc), kern.TypeBoolean, []kern.ExprFuncParam{
-		NewFuncParam(ParamHandle),
+		NewFuncParam(kern.ParamHandle),
 	})
 
-	ctx.RegisterFunc("fileWriteText", NewGolangFunctor(fileWriteTextFunc), TypeInt, []ExprFuncParam{
+	ctx.RegisterFunc("fileWriteText", kern.NewGolangFunctor(fileWriteTextFunc), kern.TypeInt, []kern.ExprFuncParam{
-		NewFuncParam(ParamHandle),
+		NewFuncParam(kern.ParamHandle),
-		NewFuncParamFlagDef(ParamItem, PfDefault|PfRepeat, ""),
+		NewFuncParamFlagDef(kern.ParamItem, PfDefault|PfRepeat, ""),
 	})
 
-	ctx.RegisterFunc("fileReadText", NewGolangFunctor(fileReadTextFunc), TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("fileReadText", kern.NewGolangFunctor(fileReadTextFunc), kern.TypeString, []kern.ExprFuncParam{
-		NewFuncParam(ParamHandle),
+		NewFuncParam(kern.ParamHandle),
 		NewFuncParamFlagDef(osLimitCh, PfDefault, "\n"),
 	})
 
-	ctx.RegisterFunc("fileReadTextAll", NewGolangFunctor(fileReadTextAllFunc), TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("fileReadTextAll", kern.NewGolangFunctor(fileReadTextAllFunc), kern.TypeString, []kern.ExprFuncParam{
-		NewFuncParam(ParamHandle),
+		NewFuncParam(kern.ParamHandle),
+	})
+
+	ctx.RegisterFunc("fileReadIterator", kern.NewGolangFunctor(fileReadIteratorFunc), kern.TypeIterator, []kern.ExprFuncParam{
+		NewFuncParam(paramHandleOrPath),
 	})
 }
 

builtin-string.go

@@ -8,6 +8,8 @@ import (
 	"fmt"
 	"io"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 const (
@@ -15,7 +17,7 @@ const (
 )
 
 // --- Start of function definitions
-func doJoinStr(funcName string, sep string, it Iterator) (result any, err error) {
+func doJoinStr(funcName string, sep string, it kern.Iterator) (result any, err error) {
 	var sb strings.Builder
 	var v any
 	for v, err = it.Next(); err == nil; v, err = it.Next() {
@@ -25,7 +27,7 @@ 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 = kern.ErrExpectedGot(funcName, kern.TypeString, v)
 			return
 		}
 	}
@@ -36,45 +38,45 @@ func doJoinStr(funcName string, sep string, it Iterator) (result any, err error)
 	return
 }
 
-func joinStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func joinStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
-	if sep, ok := args[ParamSeparator].(string); ok {
+	if sep, ok := args[kern.ParamSeparator].(string); ok {
-		if v, exists := args[ParamItem]; exists {
+		if v, exists := args[kern.ParamItem]; exists {
 			argv := v.([]any)
 			if len(argv) == 1 {
-				if ls, ok := argv[0].(*ListType); ok {
+				if ls, ok := argv[0].(*kern.ListType); ok {
 					result, err = doJoinStr(name, sep, NewListIterator(ls, nil))
-				} else if it, ok := argv[0].(Iterator); ok {
+				} else if it, ok := argv[0].(kern.Iterator); ok {
 					result, err = doJoinStr(name, sep, it)
 				} else if s, ok := argv[0].(string); ok {
 					result = s
 				} else {
-					err = ErrInvalidParameterValue(name, ParamItem, v)
+					err = kern.ErrInvalidParameterValue(name, kern.ParamItem, v)
 				}
 			} else {
 				result, err = doJoinStr(name, sep, NewArrayIterator(argv))
 			}
 		}
 	} else {
-		err = ErrWrongParamType(name, ParamSeparator, TypeString, args[ParamSeparator])
+		err = kern.ErrWrongParamType(name, kern.ParamSeparator, kern.TypeString, args[kern.ParamSeparator])
 	}
 	return
 }
 
-func subStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func subStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var start = 0
 	var count = -1
 	var source string
 	var ok bool
 
-	if source, ok = args[ParamSource].(string); !ok {
+	if source, ok = args[kern.ParamSource].(string); !ok {
-		return nil, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+		return nil, kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
 	}
 
-	if start, err = ToGoInt(args[ParamStart], name+"()"); err != nil {
+	if start, err = kern.ToGoInt(args[kern.ParamStart], name+"()"); err != nil {
 		return
 	}
 
-	if count, err = ToGoInt(args[ParamCount], name+"()"); err != nil {
+	if count, err = kern.ToGoInt(args[kern.ParamCount], name+"()"); err != nil {
 		return
 	}
 
@@ -90,29 +92,29 @@ func subStrFunc(ctx ExprContext, name string, args map[string]any) (result any,
 	return
 }
 
-func trimStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func trimStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var source string
 	var ok bool
 
-	if source, ok = args[ParamSource].(string); !ok {
+	if source, ok = args[kern.ParamSource].(string); !ok {
-		return nil, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+		return nil, kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
 	}
 	result = strings.TrimSpace(source)
 	return
 }
 
-func startsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func startsWithStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var source, prefix string
 	var ok bool
 
 	result = false
 
-	if source, ok = args[ParamSource].(string); !ok {
+	if source, ok = args[kern.ParamSource].(string); !ok {
-		return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+		return result, kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
 	}
 
-	if prefix, ok = args[ParamPrefix].(string); !ok {
+	if prefix, ok = args[kern.ParamPrefix].(string); !ok {
-		return result, ErrWrongParamType(name, ParamPrefix, TypeString, args[ParamPrefix])
+		return result, kern.ErrWrongParamType(name, kern.ParamPrefix, kern.TypeString, args[kern.ParamPrefix])
 	}
 	if strings.HasPrefix(source, prefix) {
 		result = true
@@ -125,7 +127,7 @@ func startsWithStrFunc(ctx ExprContext, name string, args map[string]any) (resul
 					break
 				}
 			} else {
-				err = fmt.Errorf("target item nr %d is %s, string expected", i+1, TypeName(targetSpec))
+				err = fmt.Errorf("target item nr %d is %s, string expected", i+1, kern.TypeName(targetSpec))
 				break
 			}
 		}
@@ -133,18 +135,18 @@ func startsWithStrFunc(ctx ExprContext, name string, args map[string]any) (resul
 	return
 }
 
-func endsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func endsWithStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var source, suffix string
 	var ok bool
 
 	result = false
 
-	if source, ok = args[ParamSource].(string); !ok {
+	if source, ok = args[kern.ParamSource].(string); !ok {
-		return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+		return result, kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
 	}
 
-	if suffix, ok = args[ParamSuffix].(string); !ok {
+	if suffix, ok = args[kern.ParamSuffix].(string); !ok {
-		return result, ErrWrongParamType(name, ParamSuffix, TypeString, args[ParamSuffix])
+		return result, kern.ErrWrongParamType(name, kern.ParamSuffix, kern.TypeString, args[kern.ParamSuffix])
 	}
 	if strings.HasPrefix(source, suffix) {
 		result = true
@@ -157,7 +159,7 @@ func endsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result
 					break
 				}
 			} else {
-				err = fmt.Errorf("target item nr %d is %s, string expected", i+1, TypeName(targetSpec))
+				err = fmt.Errorf("target item nr %d is %s, string expected", i+1, kern.TypeName(targetSpec))
 				break
 			}
 		}
@@ -165,24 +167,24 @@ func endsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result
 	return
 }
 
-func splitStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+func splitStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
 	var source, sep string
 	var count int = -1
 	var parts []string
 	var ok bool
 
-	if source, ok = args[ParamSource].(string); !ok {
+	if source, ok = args[kern.ParamSource].(string); !ok {
-		return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+		return result, kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
 	}
 
-	if sep, ok = args[ParamSeparator].(string); !ok {
+	if sep, ok = args[kern.ParamSeparator].(string); !ok {
-		return nil, fmt.Errorf("separator param must be string, got %s (%v)", TypeName(args[ParamSeparator]), args[ParamSeparator])
+		return nil, fmt.Errorf("separator param must be string, got %s (%v)", kern.TypeName(args[kern.ParamSeparator]), args[kern.ParamSeparator])
 	}
 
-	if count64, ok := args[ParamCount].(int64); ok { // TODO replace type assertion with toInt()
+	if count64, ok := args[kern.ParamCount].(int64); ok { // TODO replace type assertion with toInt()
 		count = int(count64)
 	} else {
-		return nil, fmt.Errorf("part count must be integer, got %s (%v)", TypeName(args[ParamCount]), args[ParamCount])
+		return nil, fmt.Errorf("part count must be integer, got %s (%v)", kern.TypeName(args[kern.ParamCount]), args[kern.ParamCount])
 	}
 
 	if count > 0 {
@@ -192,7 +194,7 @@ func splitStrFunc(ctx ExprContext, name string, args map[string]any) (result any
 	} else {
 		parts = []string{}
 	}
-	list := make(ListType, len(parts))
+	list := make(kern.ListType, len(parts))
 	for i, part := range parts {
 		list[i] = part
 	}
@@ -200,42 +202,68 @@ func splitStrFunc(ctx ExprContext, name string, args map[string]any) (result any
 	return
 }
 
+func upperStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+	if source, ok := args[kern.ParamSource].(string); ok {
+		result = strings.ToUpper(source)
+	} else {
+		err = kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
+	}
+	return
+}
+
+func lowerStrFunc(ctx kern.ExprContext, name string, args map[string]any) (result any, err error) {
+	if source, ok := args[kern.ParamSource].(string); ok {
+		result = strings.ToLower(source)
+	} else {
+		err = kern.ErrWrongParamType(name, kern.ParamSource, kern.TypeString, args[kern.ParamSource])
+	}
+	return
+}
+
 // --- End of function definitions
 
 // Import above functions in the context
-func ImportStringFuncs(ctx ExprContext) {
+func ImportStringFuncs(ctx kern.ExprContext) {
-	ctx.RegisterFunc("strJoin", NewGolangFunctor(joinStrFunc), TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("strJoin", kern.NewGolangFunctor(joinStrFunc), kern.TypeString, []kern.ExprFuncParam{
-		NewFuncParam(ParamSeparator),
+		NewFuncParam(kern.ParamSeparator),
-		NewFuncParamFlag(ParamItem, PfRepeat),
+		NewFuncParamFlag(kern.ParamItem, PfRepeat),
 	})
 
-	ctx.RegisterFunc("strSub", NewGolangFunctor(subStrFunc), TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("strSub", kern.NewGolangFunctor(subStrFunc), kern.TypeString, []kern.ExprFuncParam{
-		NewFuncParam(ParamSource),
+		NewFuncParam(kern.ParamSource),
-		NewFuncParamFlagDef(ParamStart, PfDefault, int64(0)),
+		NewFuncParamFlagDef(kern.ParamStart, PfDefault, int64(0)),
-		NewFuncParamFlagDef(ParamCount, PfDefault, int64(-1)),
+		NewFuncParamFlagDef(kern.ParamCount, PfDefault, int64(-1)),
 	})
 
-	ctx.RegisterFunc("strSplit", NewGolangFunctor(splitStrFunc), "list of "+TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("strSplit", kern.NewGolangFunctor(splitStrFunc), "list of "+kern.TypeString, []kern.ExprFuncParam{
-		NewFuncParam(ParamSource),
+		NewFuncParam(kern.ParamSource),
-		NewFuncParamFlagDef(ParamSeparator, PfDefault, ""),
+		NewFuncParamFlagDef(kern.ParamSeparator, PfDefault, ""),
-		NewFuncParamFlagDef(ParamCount, PfDefault, int64(-1)),
+		NewFuncParamFlagDef(kern.ParamCount, PfDefault, int64(-1)),
 	})
 
-	ctx.RegisterFunc("strTrim", NewGolangFunctor(trimStrFunc), TypeString, []ExprFuncParam{
+	ctx.RegisterFunc("strTrim", kern.NewGolangFunctor(trimStrFunc), kern.TypeString, []kern.ExprFuncParam{
-		NewFuncParam(ParamSource),
+		NewFuncParam(kern.ParamSource),
 	})
 
-	ctx.RegisterFunc("strStartsWith", NewGolangFunctor(startsWithStrFunc), TypeBoolean, []ExprFuncParam{
+	ctx.RegisterFunc("strStartsWith", kern.NewGolangFunctor(startsWithStrFunc), kern.TypeBoolean, []kern.ExprFuncParam{
-		NewFuncParam(ParamSource),
+		NewFuncParam(kern.ParamSource),
-		NewFuncParam(ParamPrefix),
+		NewFuncParam(kern.ParamPrefix),
 		NewFuncParamFlag(strParamOther, PfRepeat),
 	})
 
-	ctx.RegisterFunc("strEndsWith", NewGolangFunctor(endsWithStrFunc), TypeBoolean, []ExprFuncParam{
+	ctx.RegisterFunc("strEndsWith", kern.NewGolangFunctor(endsWithStrFunc), kern.TypeBoolean, []kern.ExprFuncParam{
-		NewFuncParam(ParamSource),
+		NewFuncParam(kern.ParamSource),
-		NewFuncParam(ParamSuffix),
+		NewFuncParam(kern.ParamSuffix),
 		NewFuncParamFlag(strParamOther, PfRepeat),
 	})
+
+	ctx.RegisterFunc("strUpper", kern.NewGolangFunctor(upperStrFunc), kern.TypeString, []kern.ExprFuncParam{
+		NewFuncParam(kern.ParamSource),
+	})
+
+	ctx.RegisterFunc("strLower", kern.NewGolangFunctor(lowerStrFunc), kern.TypeString, []kern.ExprFuncParam{
+		NewFuncParam(kern.ParamSource),
+	})
 }
 
 // Register the import function in the import-register.

builtins-register.go

@@ -6,21 +6,23 @@ package expr
 
 import (
 	"fmt"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 type builtinModule struct {
-	importFunc  func(ExprContext)
+	importFunc  func(kern.ExprContext)
 	description string
 	imported    bool
 }
 
-func newBuiltinModule(importFunc func(ExprContext), description string) *builtinModule {
+func newBuiltinModule(importFunc func(kern.ExprContext), description string) *builtinModule {
 	return &builtinModule{importFunc, description, false}
 }
 
 var builtinModuleRegister map[string]*builtinModule
 
-func RegisterBuiltinModule(name string, importFunc func(ExprContext), description string) {
+func RegisterBuiltinModule(name string, importFunc func(kern.ExprContext), description string) {
 	if builtinModuleRegister == nil {
 		builtinModuleRegister = make(map[string]*builtinModule)
 	}

data-cursor.go

@@ -7,24 +7,26 @@ package expr
 import (
 	"io"
 	"slices"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 type dataCursor struct {
-	ds        map[string]Functor
+	ds        map[string]kern.Functor
-	ctx       ExprContext
+	ctx       kern.ExprContext
 	initState bool // true if no item has produced yet (this replace di initial Next() call in the contructor)
 	// cursorValid bool // true if resource is nil or if clean has not yet been called
-	index     int
+	index     int64
-	count     int
+	count     int64
 	current   any
 	lastErr   error
 	resource  any
-	nextFunc  Functor
+	nextFunc  kern.Functor
-	cleanFunc Functor
+	cleanFunc kern.Functor
-	resetFunc Functor
+	resetFunc kern.Functor
 }
 
-func NewDataCursor(ctx ExprContext, ds map[string]Functor, resource any) (dc *dataCursor) {
+func NewDataCursor(ctx kern.ExprContext, ds map[string]kern.Functor, resource any) (dc *dataCursor) {
 	dc = &dataCursor{
 		ds:        ds,
 		initState: true,
@@ -35,14 +37,14 @@ func NewDataCursor(ctx ExprContext, ds map[string]Functor, resource any) (dc *da
 		lastErr:   nil,
 		resource:  resource,
 		ctx:       ctx.Clone(),
-		nextFunc:  ds[NextName],
+		nextFunc:  ds[kern.NextName],
-		cleanFunc: ds[CleanName],
+		cleanFunc: ds[kern.CleanName],
-		resetFunc: ds[ResetName],
+		resetFunc: ds[kern.ResetName],
 	}
 	return
 }
 
-func (dc *dataCursor) Context() ExprContext {
+func (dc *dataCursor) Context() kern.ExprContext {
 	return dc.ctx
 }
 
@@ -79,27 +81,27 @@ func (dc *dataCursor) String() string {
 }
 
 func (dc *dataCursor) HasOperation(name string) (exists bool) {
-	exists = slices.Contains([]string{CleanName, ResetName, CurrentName, IndexName}, name)
+	exists = slices.Contains([]string{kern.CleanName, kern.ResetName, kern.CurrentName, kern.IndexName}, name)
 	if !exists {
 		f, ok := dc.ds[name]
-		exists = ok && isFunctor(f)
+		exists = ok && kern.IsFunctor(f)
 	}
 	return
 }
 
 func (dc *dataCursor) CallOperation(name string, args map[string]any) (value any, err error) {
-	if name == IndexName {
+	if name == kern.IndexName {
 		value = int64(dc.Index())
-	} else if name == CleanName {
+	} else if name == kern.CleanName {
 		err = dc.Clean()
-	} else if name == ResetName {
+	} else if name == kern.ResetName {
 		err = dc.Reset()
-	} else if functor, ok := dc.ds[name]; ok && isFunctor(functor) {
+	} else if functor, ok := dc.ds[name]; ok && kern.IsFunctor(functor) {
-		ctx := cloneContext(dc.ctx)
+		ctx := kern.CloneContext(dc.ctx)
 		value, err = functor.InvokeNamed(ctx, name, args)
-		exportObjects(dc.ctx, ctx)
+		kern.ExportObjects(dc.ctx, ctx)
 	} else {
-		err = errNoOperation(name)
+		err = kern.ErrNoOperation(name)
 	}
 	return
 }
@@ -127,10 +129,10 @@ func (dc *dataCursor) CallOperation(name string, args map[string]any) (value any
 
 func (dc *dataCursor) Reset() (err error) {
 	if dc.resetFunc != nil {
-		ctx := cloneContext(dc.ctx)
+		ctx := kern.CloneContext(dc.ctx)
-		actualParams := bindActualParams(dc.resetFunc, []any{dc.resource})
+		actualParams := kern.BindActualParams(dc.resetFunc, []any{dc.resource})
-		_, err = dc.resetFunc.InvokeNamed(ctx, ResetName, actualParams)
+		_, err = dc.resetFunc.InvokeNamed(ctx, kern.ResetName, actualParams)
-		exportObjects(dc.ctx, ctx)
+		kern.ExportObjects(dc.ctx, ctx)
 	}
 	dc.index = -1
 	dc.count = 0
@@ -142,10 +144,10 @@ func (dc *dataCursor) Reset() (err error) {
 
 func (dc *dataCursor) Clean() (err error) {
 	if dc.cleanFunc != nil {
-		ctx := cloneContext(dc.ctx)
+		ctx := kern.CloneContext(dc.ctx)
-		actualParams := bindActualParams(dc.cleanFunc, []any{dc.resource})
+		actualParams := kern.BindActualParams(dc.cleanFunc, []any{dc.resource})
-		_, err = dc.cleanFunc.InvokeNamed(ctx, CleanName, actualParams)
+		_, err = dc.cleanFunc.InvokeNamed(ctx, kern.CleanName, actualParams)
-		exportObjects(dc.ctx, ctx)
+		kern.ExportObjects(dc.ctx, ctx)
 	}
 	dc.lastErr = io.EOF
 	return
@@ -178,13 +180,13 @@ func (dc *dataCursor) Current() (item any, err error) { // must return io.EOF at
 	return
 }
 
-func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err error) {
+func (dc *dataCursor) checkFilter(filter kern.Functor, item any) (accepted bool, err error) {
 	var v any
 	var ok bool
-	ctx := cloneContext(dc.ctx)
+	ctx := kern.CloneContext(dc.ctx)
 
-	actualParams := bindActualParams(filter, []any{item, dc.index})
+	actualParams := kern.BindActualParams(filter, []any{item, dc.index})
-	if v, err = filter.InvokeNamed(ctx, FilterName, actualParams); err == nil && v != nil {
+	if v, err = filter.InvokeNamed(ctx, kern.FilterName, actualParams); err == nil && v != nil {
 		if accepted, ok = v.(bool); !ok {
 			accepted = true // NOTE: A non-boolean value that is not nil means the item has been accepted
 		}
@@ -192,10 +194,10 @@ func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err
 	return
 }
 
-func (dc *dataCursor) mapItem(mapper Functor, item any) (mappedItem any, err error) {
+func (dc *dataCursor) mapItem(mapper kern.Functor, item any) (mappedItem any, err error) {
-	ctx := cloneContext(dc.ctx)
+	ctx := kern.CloneContext(dc.ctx)
-	actualParams := bindActualParams(mapper, []any{item, dc.index})
+	actualParams := kern.BindActualParams(mapper, []any{item, dc.index})
-	mappedItem, err = mapper.InvokeNamed(ctx, MapName, actualParams)
+	mappedItem, err = mapper.InvokeNamed(ctx, kern.MapName, actualParams)
 	return
 }
 
@@ -213,15 +215,15 @@ func (dc *dataCursor) Next() (current any, err error) { // must return io.EOF af
 		return
 	}
 	current = dc.current
-	filter := dc.ds[FilterName]
+	filter := dc.ds[kern.FilterName]
-	mapper := dc.ds[MapName]
+	mapper := dc.ds[kern.MapName]
 	var item any
 	for item == nil && dc.lastErr == nil {
-		ctx := cloneContext(dc.ctx)
+		ctx := kern.CloneContext(dc.ctx)
 		dc.index++
 
-		actualParams := bindActualParams(dc.nextFunc, []any{dc.resource, dc.index})
+		actualParams := kern.BindActualParams(dc.nextFunc, []any{dc.resource, dc.index})
-		if item, dc.lastErr = dc.nextFunc.InvokeNamed(ctx, NextName, actualParams); dc.lastErr == nil {
+		if item, dc.lastErr = dc.nextFunc.InvokeNamed(ctx, kern.NextName, actualParams); dc.lastErr == nil {
 			if item == nil {
 				dc.lastErr = io.EOF
 			} else {
@@ -239,7 +241,7 @@ func (dc *dataCursor) Next() (current any, err error) { // must return io.EOF af
 				}
 			}
 		}
-		exportObjects(dc.ctx, ctx)
+		kern.ExportObjects(dc.ctx, ctx)
 	}
 	dc.current = item
 	if dc.lastErr != nil {
@@ -296,10 +298,10 @@ func (dc *dataCursor) Next() (current any, err error) { // must return io.EOF af
 // 	return
 // }
 
-func (dc *dataCursor) Index() int {
+func (dc *dataCursor) Index() int64 {
 	return dc.index - 1
 }
 
-func (dc *dataCursor) Count() int {
+func (dc *dataCursor) Count() int64 {
 	return dc.count
 }

dict-iterator.go

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

doc/Expr.adoc

@@ -22,13 +22,22 @@ Expressions calculator
 //:rouge-style: monokay
 // Workaround to manage double-column in back-tick quotes
 :2c: ::
+// Workaround to manage double-plus in back-tick quotes
+:plusplus: ++
+// Workaround to manage asterisk in back-tick quotes
+:star: *
+
+:sp:  
+:2sp:   
+:4sp:     
+
 
 toc::[]
 
-#TODO: Work in progress (last update on 2024/06/21, 05:40 a.m.)#
+#TODO: Work in progress (last update on 2026/04/21, 6:49 p.m.)#
 
 == Expr
-_Expr_ is a GO package capable of analysing, interpreting and calculating expressions.
+_Expr_ is a GO package that can analyze, interpret and calculate expressions.
 
 
 === Concepts and terminology
@@ -42,7 +51,7 @@ Expressions are texts containing sequences of operations represented by a syntax
 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.
+_Expr_ supports variables. The result of an expression can be stored in a variable and reused in other espressions by 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_.
@@ -58,9 +67,40 @@ The expression context is analogous to the stack-frame of other programming lang
 
 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 user 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 created context can be called _function context_.
+_Expr_ creates and keeps a inner _global context_ where it stores imported functions, either from builtin or plugin modules. To perform calculations, the user program must provide its own context; this is the _main context_. All calculations take place in this context. As mentioned earlier, when a function is called, a new context is created by cloning the calling context. The created 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_.
+Imported functions are registered 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_.
+
+===== Inspecting contexts
+_Expr_ provides the operator [blue]_$$_ that returns the current context. This can be used to inspect the content of the context, for example to check the value of a variable or to see which functions are currently linked to the context. This operator is primarily intended for debugging purposes.
+
+An interactive tool could like `dev-expr` (see <<_dev-expr_test_tool>>) can be used to inspect contexts interactively.
+
+
+.Example: inspecting contexts
+`>>>` [blue]`$$` +
+[green]`{"variables": {"ls": "[10, 20, 30]", "it": "$(#3)", "last": "-1"}, "functions": {"about": "about():string{}", "bin": "bin(value, digits=8):integer{}", "ctrl": "ctrl(prop, value):any{}", "ctrlList": "ctrlList():list-of-strings{}", "envGet": "envGet(name):string{}", "envSet": "envSet(name, value):string{}"}}` +
+
+`>>>` [gray]_// Let use the *ml* command to activate multi-line output of contexts, which is more readable._ +
+`>>>` [blue]`ml` +
+`>>>` [blue]`$$` +
+[green]`{` +
+  [green]`{2sp}"variables": {` +
+  [green]`{4sp}"last": {"variables": {"last": "-1", "ls": "[10, 20, 30]", "it": "$(#3)"}, "functions": {"ctrlList": "ctrlList():list-of-strings{}", "envGet": "envGet(name):string{}", "envSet": "envSet(name, value):string{}", "about": "about():string{}", "bin": "bin(value, digits=8):integer{}", "ctrl": "ctrl(prop, value):any{}"}},` +
+  [green]`{4sp}"ls": [10, 20, 30],` +
+  [green]`{4sp}"it": $(#3)` +
+  [green]`{2sp}},` +
+  [green]`{2sp}"functions": {` +
+  [green]`{4sp}"ctrlList": ctrlList():list-of-strings{},` +
+  [green]`{4sp}"envGet": envGet(name):string{},` +
+  [green]`{4sp}"envSet": envSet(name, value):string{},` +
+  [green]`{4sp}"about": about():string{},` +
+  [green]`{4sp}"bin": bin(value, digits=8):integer{},` +
+  [green]`{4sp}"ctrl": ctrl(prop, value):any{}` +
+  [green]`{2sp}}` +
+[green]`}`
+
+In order to inspect the global context issue the [blue]`$$global` operator.
 
 === `dev-expr` test tool
 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.
@@ -145,7 +185,7 @@ dev-expr -- Expressions calculator v1.10.0(build 14),2024/06/17 (celestino.amoro
 <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.
+<5> Multi-expression: the same result as the previous single expression, but this time it is obtained with two separate calculations.
 
 == Data types
 _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.
@@ -240,10 +280,11 @@ _Expr_ also supports fractions. Fraction literals are made with two integers sep
 
 .Fraction literal syntax
 ====
-*_fraction_* = [__sign__] (_num-den-spec_ "**:**" _float-spec_) +
+*_fraction_* = [__sign__] (_num-den-spec_ | _float-spec_) +
 _sign_ = "**+**" | "**-**" +
-_num-den-spec_ = _digit-seq_ "**|**" _digit-seq_ +
+_num-den-spec_ = _digit-seq_ "**:**" _digit-seq_ +
-_float-spec_ = _dec-seq_ "**.**" [_dec-seq_] "**(**" _dec-seq_ "**)**" +
+_float-spec_ = _dec-seq_ "**.**" [_dec-seq_] "**(**" _repetend_ "**)**" +
+_repetend_ = _dec-seq_ +
 _dec-seq_ = _see-integer-literal-syntax_ +
 _digit-seq_ = _see-integer-literal-syntax_
 ====
@@ -276,6 +317,8 @@ _digit-seq_ = _see-integer-literal-syntax_
 `>>>` [blue]`1:(-2)` +
 [green]`-1:2`
 
+`>>>` [blue]`1.(3)` // 1.33333... +
+[green]`4:3`
 
 Fractions can be used together with integers and floats in expressions.
 
@@ -395,12 +438,13 @@ 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 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_.
+<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.
@@ -492,10 +536,10 @@ Array's items can be accessed using the index `[]` operator.
 [green]`3`
 
 .Examples: Element insertion
-`>>>` [blue]`"first" >> list` +
+`>>>` [blue]`"first" +> list` +
 [green]`["first", "one", "six", "three"]`
 
-`>>>` [blue]`list << "last"` +
+`>>>` [blue]`list <+ "last"` +
 [green]`["first", "one", "six", "three", "last"]`
 
 .Examples: Element in list
@@ -509,7 +553,7 @@ Array's items can be accessed using the index `[]` operator.
 `>>>` [blue]`[1,2,3] + ["one", "two", "three"]` +
 [green]`[1, 2, 3, "one", "two", "three"]`
 
-`>>>` [blue]`[1,2,3,4] - [2,4]` +
+`>>>` [blue]`[1,2,3,2,4] - [2,4]` +
 [green]`[1, 3]`
 
 
@@ -570,7 +614,7 @@ _Expr_, like most programming languages, supports variables. A variable is an id
 .Variable literal syntax
 ====
 *_variable_* = _identifier_ "*=*" _any-value_ +
-_identifier_ = _alpha_ {(_alpha_)|_dec-digit_|"*_*"} +
+_identifier_ = _alpha_ {_alpha_|_dec-digit_|"*_*"} +
 __alpha__ = "*a*"|"*b*"|..."*z*"|"*A*"|"*B*"|..."*Z*"
 ====
 
@@ -695,7 +739,7 @@ The [blue]`:` symbol (colon) is the separator of the selector-cases. Note that i
 
 
 === Variable default value [blue]`??`, [blue]`?=`, and [blue]`?!`
-The left operand of first two operators, [blue]`??` and [blue]`?=`, 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.
+The left operand of the first two operators, [blue]`??` and [blue]`?=`, 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 evaluated at all.
 
@@ -741,8 +785,11 @@ The table below shows all supported operators by decreasing priorities.
 
 .2+|*ITEM*| [blue]`[`...`]` | _Postfix_ | _List item_| _list_ `[`  _integer_ `]` -> _any_
 | [blue]`[`...`]` | _Postfix_ | _Dict item_ | _dict_ `[` _any_ `]` -> _any_
-.2+|*INC*| [blue]`++` | _Postfix_ | _Post increment_| _integer-variable_ `++` -> _integer_
+.5+|*INC/DEC*| [blue]`++` | _Postfix_ | _Iterator next item_ | _iterator_ `++` -> _any_
-| [blue]`++` | _Postfix_ | _Next item_ | _iterator_ `++` -> _any_
+| [blue]`++` | _Postfix_ | _Post increment_| _integer-variable_ `++` -> _integer_
+| [blue]`++` | _Prefix_ | _Pre increment_ | `++` _integer-variable_ -> _integer_
+| [blue]`--` | _Postfix_ | _Post decrement_ | _integer-variable_ `--` -> _integer_
+| [blue]`--` | _Prefix_ | _Pre decrement_ | `--` _integer-variable_ -> _integer_
 .3+|*DEFAULT*| [blue]`??` | _Infix_ | _Default value_| _variable_ `??` _any-expr_ -> _any_
 | [blue]`?=` | _Infix_ | _Default/assign value_| _variable_ `?=` _any-expr_ -> _any_
 | [blue]`?!` | _Infix_ | _Alternate value_| _variable_ `?!` _any-expr_ -> _any_
@@ -769,9 +816,10 @@ The table below shows all supported operators by decreasing priorities.
 | [blue]`+` | _Infix_ |  _Dict-join_ | _dict_ `+` _dict_ -> _dict_
 | [blue]`-` | _Infix_ | _Subtraction_ | _number_ `-` _number_ -> _number_
 | [blue]`-` | _Infix_ | _List-difference_ | _list_ `-` _list_ -> _list_
-.1+|*BITWISE NOT*| [blue]`~` | _Prefix_ | _Binary Not_ | `~` _number_ -> _number_
+.1+|*BITWISE NOT*| [blue]`~` | _Prefix_ | _Binary Not_ | `~` _integer_ -> _integer_
-.1+|*BITWISE AND*| [blue]`&` | _Infix_ | _Binary And_ | _number_ `&` _number_ -> _number_
+.1+|*BITWISE AND*| [blue]`&` | _Infix_ | _Binary And_ | _integer_ `&` _integer_ -> _integer_
-.1+|*BITWISE OR*| [blue]`\|` | _Infix_ | _Binary Or_ | _number_ `\|` _number_ -> _number_
+.2+|*BITWISE OR*| [blue]`\|` | _Infix_ | _Binary Or_ | _integer_ `\|` _integer_ -> _integer_
+| [blue]`^` | _Infix_ | _Binary Xor_ | _integer_ `^` _integer_ -> _integer_
 .8+|*RELATION*| [blue]`<` | _Infix_ | _Less_ | _comparable_ `<` _comparable_ -> _boolean_
 | [blue]`\<=` | _Infix_ |  _less-equal_ | _comparable_ `\<=` _comparable_ -> _boolean_
 | [blue]`>` | _Infix_ |  _Greater_ | _comparable_ `>` _comparable_ -> _boolean_
@@ -788,7 +836,7 @@ The table below shows all supported operators by decreasing priorities.
 .2+|*INSERT*| [blue]`+>` | _Infix_ | _Prepend_ | _any_ `+>` _list_ -> _list_
 | [blue]`<+` | _Infix_ | _Append_ | _list_ `<+` _any_ -> _list_
 .2+|*ASSIGN*| [blue]`=` | _Infix_ | _Assignment_ | _identifier_ `=` _any_ -> _any_
-4+| _See also the special assignment operators table below_
+4+| _See also the table of special allocation operators below_
 .1+|*BUT*| [blue]`but` | _Infix_ | _But_ | _any_ `but` _any_ -> _any_
 .1+|*RANGE*| [blue]`:` | _Infix_ | _Index-range_ | _integer_ `:` _integer_ -> _integer-pair_
 |===
@@ -837,12 +885,12 @@ Functions in _Expr_ are very similar to functions available in many programming
 
 
 === _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 and passing paramters by name.
+An expr-function is identified and referenced by its name. It can have zero or more parameter. expr-functions also support optional parameters and passing paramters by name.
 
 .Expr's function definition syntax
 ====
 *_function-definition_* = _identifier_ "**=**"  "**func(**" [_formal-param-list_] "**)**"  "**{**" _multi-expression_ "**}**" +
-_formal-param_list_ = _required-param-list_ [ "**,**" _optional-param-list_ ] +
+_formal-param-list_ = _required-param-list_ [ "**,**" _optional-param-list_ ] +
 _required-param-list_ = _identifier_ { "**,**" _identifier_ } +
 _optional-param-list_ = _optional-parm_ { "**,**" _optional-param_ } +
 _optional-param_ = _param-name_ "**=**" _any-expr_ +
@@ -854,7 +902,7 @@ _param-name_ = _identifier_
 `>>>` [blue]`sum = func(a, b){ a + b }` +
 [green]`sum(a, b):any{}`
 
-^(\*)^ Since the plus, *+*, operator is defined for multiple data-types, the _sum()_ function can be used for any pair of that types.
+^(*)^ Since the plus, **+**, operator is defined for multiple data-types, the _sum()_ function can be used for any pair of that types.
 
 `>>>` [gray]_// A more complex example: recursive calculation of the n-th value of Fibonacci's sequence_ +
 `>>>` [blue]`fib = func(n){ n ? [0] {0}: [1] {1} :: {fib(n-1)+fib(n-2)} }` +
@@ -957,7 +1005,7 @@ _param-name_ = _identifier_
 === Function context
 Functions compute values in a local context (scope) that do not make effects on the calling context. This is the normal behavior. Using the _clone_ modifier [blue]`@` it is possibile to export local definition to the calling context. The clone modifier must be used as prefix to variable names and it is part of the name. E.g. [blue]`@x` is not the same as [blue]`x`; they are two different and unrelated variables.
 
-Clone variables are normal local variables. The only diffence will appear when the defining function terminate, just before the destruction of its local context. At that point, all local clone variables are cloned in the calling context with the same names but the [blue]`@` symbol.
+Clone variables are normal local variables. The only diffence will appear when the defining function ends, just before the destruction of its local context. At that point, all local clone variables are cloned in the calling context with the same names but the [blue]`@` symbol.
 
 .Example
 `>>>` [blue]`f = func() { @x = 3; x = 5 }` [gray]_// f() declares two *different* local variables: ``@x`` and ``x``_ +
@@ -974,24 +1022,715 @@ NOTE: The clone modifier [blue]`@` does not make a variable a reference variable
 The clone modifier can also be used to declare the formal parameters of functions, because they are local variables too.
 
 .Example
-`>>>` [blue]`g = func(@p) {2+@p}`
+`>>>` [blue]`g = func(@p) {2+@p}` +
-g(@p):any{}`
+[green]`g(@p):any{}` +
-`>>>` [blue]`g(9)`
+`>>>` [blue]`g(9)` +
-11`
+[green]`11` +
-`>>>` [blue]`p
+`>>>` [blue]`p` +
-9
+[green]`9`
 ====
 
-== Iterators
-#TODO: function calls operations#
-
 == Builtins
-#TODO: builtins#
+Builtins are collection of function dedicated to specific domains of application. They are defined in Golang source files called _modules_ and compiled within the _Expr_ package. To make builtins available in _Expr_ contextes, it is required to activate the builtin module in which they are defined.
 
-=== Builtin functions
+There are currently several builtin modules. More builtin modules will be added in the future.
+
+.Available builtin modules
+* <<_module_base,*base*>>: Base expression tools like isNil(), int(), etc.
+* <<_module_fmt,*fmt*>>: String and console formatting functions
+* <<_module_import,*import*>>: Functions <<_import,import()>> and <<_include,include()>>
+* <<_module_iterator,*iterator*>>: Iterator helper functions
+* <<_module_math_arith,*math.arith*>>: Functions <<_add,add()>> and <<_mul,mul()>>
+* <<_module_os_file,*os.file*>>: Operating system file functions
+* <<_module_string,*string*>>: string utilities
+
+Builtins activation is done by using the [blue]`BUILTIN` operator. All modules except "base" must be explicitly enabled. The syntax is as follows.
+
+.Builtin activation syntax
+====
+*_builtin-activation_* = [blue]`BUILTIN` (_builtin-name_ | _list-of-builtin-names_) +
+_builtin-name_ = _string_ +
+_list-of-builtin-names_ = **[** _string_ { "**,**" _string_ } **]**
+====
+
+The following example shows how to activate the builtin module "math.arith" and then use the function add() defined in that module.
+
+.Example: using built functions
+`>>>` [blue]`BUILTIN "math.arith"` +
+[green]`1` +
+`>>>` [blue]`add(5, 3, -2)` +
+[green]`6`
+
+TIP: To avoid the need to activate builtin modules one by one, it is possible to activate all builtin modules at once by using the [blue]`BUILTIN "*"` syntax.
+
+=== Builtin modules
+
+==== Module "base"
+The "base" builtin module provides functions for type checking and type conversion. These functions are always available in _Expr_ contexts without the need to activate the "base" module.
+
+.Checking functions
+* <<_isbool,isBool()>>
+* <<_isdict,isDict()>>
+* <<_isfloat,isFloat()>>
+* <<_isfract,isFract()>>
+* <<_islist,isList()>>
+* <<_isnil,isNil()>>
+* <<_isrational,isRational()>>
+* <<_isstring,isString()>>
+
+.Conversion functions
+* <<_bool,bool()>>
+* <<_int,int()>>
+* <<_dec,dec()>>
+* <<_string,string()>>
+* <<_fract,fract()>>
+
+.Other functions
+* <<_eval,eval()>>
+* <<_set,set()>>
+* <<_unset,unset()>>
+* <<_var,var()>>
+
+
+===== isBool()
+Syntax: `isBool(<expr>) -> bool` +
+Returns _true_ if the value type of _<expr>_ is boolean, false otherwise.
+
+.Examples
+`>>>` [blue]`isBool(true)` +
+[green]`true` +
+`>>>` [blue]`isBool(3==2)` +
+[green]`true`
+
+===== isDict()
+Syntax: `isDict(<expr>) -> bool` +
+Returns _true_ if the value type of _<expr>_ is dictionary, false otherwise.
+
+.Examples
+`>>>` [blue]`isDict({})` +
+[green]`true` +
+`>>>` [blue]`isDict({1: "one", 2: "two"})` +
+[green]`true` +
+`>>>` [blue]`isDict(1:"one")` +
+[red]`Eval Error: denominator must be integer, got string (one)`
+
+===== isFloat()
+Syntax: `isFloat(<expr>) -> bool` +
+Returns _true_ if the value type of _<expr>_ is float, false otherwise.
+
+.Examples
+`>>>` [blue]`isFloat(4.)` +
+[green]`true` +
+`>>>` [blue]`isFloat(4)` +
+[green]`false` +
+`>>>` [blue]`isFloat("2.1")` +
+[green]`false`
+
+===== isFract()
+Syntax: `isFract(<expr>) -> bool` +
+Returns _true_ if the value type of _<expr>_ is fraction, false otherwise.
+
+.Examples
+`>>>` [blue]`isFract(4.5)` +
+[green]`false` +
+`>>>` [blue]`isFract(4:5)` +
+[green]`true` +
+`>>>` [blue]`isFract(4)` +
+[green]**`false`** +
+`>>>` [blue]`isFract(1.(3))` +
+[green]`true`
+
+===== isList()
+Syntax: `isList(<expr>) -> bool` +
+Returns _true_ if the value type of _<expr>_ is list, false otherwise.
+
+.Examples
+`>>>` [blue]`isList([])` +
+[green]`true` +
+`>>>` [blue]`isList([1, "2"])` +
+[green]`true` +
+`>>>` [blue]`isList(1,2)` +
+[red]`Eval Error: isList(): too many params -- expected 1, got 2`
+
+===== isNil()
+Syntax: `isNil(<expr>) -> bool` +
+Returns _true_ if the value type of _<expr>_ is nil, false otherwise.
+
+.Examples
+`>>>` [blue]`isNil(nil)` +
+[green]`true` +
+`>>>` [blue]`isNil(1)` +
+[green]`false`
+
+===== isRational()
+Syntax: `isRational(<expr>) -> bool` +
+Returns _true_ if the value type of _<expr>_ is fraction or int, false otherwise.
+
+.Examples
+`>>>` [blue]`isRational(4.5)` +
+[green]`false` +
+`>>>` [blue]`isRational(4:5)` +
+[green]`true` +
+`>>>` [blue]`isRational(4)` +
+[green]**`true`** +
+`>>>` [blue]`isRational(1.(3))` +
+[green]`true`
+
+===== isString()
+Syntax: `isString(<expr>) -> bool` +
+Returns a boolean value , false otherwise.
+
+.Examples
+`>>>` [blue]`isString("ciao")` +
+[green]`true` +
+`>>>` [blue]`isString(2)` +
+[green]`false` +
+`>>>` [blue]`isString(2+"2")` +
+[green]`true`
+
+===== bool()
+Syntax: `bool(<expr>) -> bool` +
+Returns a _boolean_ value consisent to the value of the expression.
+
+.Examples
+`>>>` [blue]`bool(1)` +
+[green]`true` +
+`>>>` [blue]`bool(0)` +
+[green]`false` +
+`>>>` [blue]`bool("")` +
+[green]`false` +
+`>>>` [blue]`bool([])` +
+[green]`false` +
+`>>>` [blue]`bool([1])` +
+[green]`true` +
+`>>>` [blue]`bool({})` +
+[green]`false` +
+`>>>` [blue]`bool({1: "one"})` +
+[green]`true`
+
+===== int()
+Syntax: `int(<expr>) -> int` +
+Returns an _integer_ value consistent with the value of the expression.
+
+.Examples
+`>>>` [blue]`int(2)` +
+[green]`2` +
+`>>>` [blue]`int("2")` +
+[green]`2` +
+`>>>` [blue]`int("0x1")` +
+[red]`Eval Error: strconv.Atoi: parsing "0x1": invalid syntax` +
+`>>>` [blue]`int(0b10)` +
+[green]`2` +
+`>>>` [blue]`int(0o2)` +
+[green]`2` +
+`>>>` [blue]`int(0x2)` +
+[green]`2` +
+`>>>` [blue]`int(1.8)` +
+[green]`1` +
+`>>>` [blue]`int(5:2)` +
+[green]`2` +
+`>>>` [blue]`int([])` +
+[red]`Eval Error: int(): can't convert list to int` +
+`>>>` [blue]`int(true)` +
+[green]`1` +
+`>>>` [blue]`int(false)` +
+[green]`0`
+
+
+===== dec()
+Syntax: `dec(<expr>) -> float` +
+Returns a _float_ value consistent with the value of the expression.
+
+.Examples
+`>>>` [blue]`dec(2)` +
+[green]`2` +
+`>>>` [blue]`dec(2.1)` +
+[green]`2.1` +
+`>>>` [blue]`dec(2.3(1))` +
+[green]`2.311111111111111` +
+`>>>` [blue]`dec("3.14")` +
+[green]`3.14` +
+`>>>` [blue]`dec(3:4)` +
+[green]`0.75` +
+`>>>` [blue]`dec(true)` +
+[green]`1` +
+`>>>` [blue]`dec(false)` +
+[green]`0`
+
+===== string()
+Syntax: `string(<expr>) -> string` +
+Returns a _string_ value consistent with the value of the expression.
+
+.Examples
+`>>>` [blue]`string(2)` +
+[green]`"2"` +
+`>>>` [blue]`string(0.8)` +
+[green]`"0.8"` +
+`>>>` [blue]`string([1,2])` +
+[green]`"[1, 2]"` +
+`>>>` [blue]`string({1: "one", 2: "two"})` +
+[green]`"{1: "one", 2: "two"}"` +
+`>>>` [blue]`string(2:5)` +
+[green]`"2:5"` +
+`>>>` [blue]`string(3==2)` +
+[green]`"false"`
+
+===== fract()
+Syntax: `fract(<expr>) -> fraction` +
+Returns a _fraction_ value consistent with the value of the expression.
+
+.Examples
+`>>>` [blue]`fract(2)` +
+[green]`2:1` +
+`>>>` [blue]`fract(2.5)` +
+[green]`5:2` +
+`>>>` [blue]`fract("2.5")` +
+[green]`5:2` +
+`>>>` [blue]`fract(1.(3))` +
+[green]`4:3` +
+`>>>` [blue]`fract([2])` +
+[red]`Eval Error: fract(): can't convert list to float` +
+`>>>` [blue]`fract(false)` +
+[green]`0:1` +
+`>>>` [blue]`fract(true)` +
+[green]`1:1`
+
+===== eval()
+Syntax: `eval(<string-expr>) -> any` +
+Computes and returns the value of the [.underline]#string# expression.
+
+.Examples
+`>>>` [blue]`eval( "2 + fract(1.(3))" )` +
+[green]`10:3`
+
+===== var()
+Syntax: +
+ `{4sp}var(<string-expr>, <expr>) -> any` +
+ `{4sp}var(<string-expr>) -> any`
+
+This function allows you to define variables whose names must include special characters. The first form of the function allows you to define a variable with a name specified by the first parameter and assign it the value of the second parameter. The second form only returns the value of the variable with the specified name.
+
+.Examples
+`>>>` [blue]`var("$x", 3+9)` +
+[green]`12` +
+`>>>` [blue]`var("$x")` +
+[green]`12` +
+`>>>` [blue]`var("gain%", var("$x"))` +
+[green]`12` +
+`>>>` [blue]`var("gain%", var("$x")+1)` +
+[green]`13`
+
+===== set
+Syntax: +
+ `{4sp}set(<string-expr>, <expr>) -> any`
+
+This function allows you to set the value of a variable whose name can include special characters. The first parameter is the name of the variable and the second parameter is the new value to assign to that variable.
+
+It is equivalent to the first form of the var() function, but it is more explicit about the intent of changing the value of an existing variable. 
+
+.Examples
+`>>>` [blue]`set("$x", 100)` +
+[green]`100` +
+`>>>` [blue]`var("$x")` +
+[green]`100` +
+
+===== unset()
+Syntax: +
+ `{4sp}unset(<string-expr>) -> any`
+
+This function allows you to unset a variable whose name can include special characters. The parameter is the name of the variable to unset.
+
+.Examples
+`>>>` [blue]`unset("$x")` +
+[green]`nil` +
+`>>>` [blue]`var("$x")` +
+[red]`Eval Error: var(): unknown variable "$x"`
+
+==== Module "fmt"
+
+===== print()
+
+===== println()
+
+==== Module "import"
+Module actiovation: +
+
+===== _import()_
+Syntax: +
+`{4sp}import(<source-file>)`
+
+Loads the multi-expression contained in the specified source and returns its value.
+
+===== _importAll()_
+
+==== Module "iterator"
+
+===== run()
+Syntax: +
+`{4sp}run(<iterator>, <operator>, <vars>) -> any`
+
+Iterates over the specified iterator and applies the specified operator to the current value of the iterator.
+
+==== Module "math.arith"
+Currently, the "math.arith" module provides two functions, add() and mul(), that perform addition and multiplication of an arbitrary number of parameters. More functions will be added in the future.
+
+* <<_add,add()>>
+* <<_mul,mul()>>
+
+
+===== add()
+Syntax: +
+`{4sp}add(<num-expr1>, <num-expr2>, ...) -> any` +
+`{4sp}add(<list-of-num-expr>]) -> any` +
+`{4sp}add(<iterator-over-num-values>) -> any`
+
+Returns the sum of the values of the parameters. The parameters can be of any numeric type for which the [blue]`+` operator is defined. The result type depends on the types of the parameters. If all parameters are of the same type, the result is of that type. If the parameters are of different types, the result is of the type that can represent all the parameter types without loss of information. For example, if the parameters are a mix of integers and floats, the result is a float. If the parameters are a mix of number types, the result has the type of the most general one.
+
+.Examples
+`>>>` [blue]`builtin "math.arith"` +
+[green]`1` +
+`>>>` [blue]`add(1,2,3)` +
+[green]`6` +
+`>>>` [blue]`add(1.1,2.1,3.1)` +
+[green]`6.300000000000001` +
+`>>>` [blue]`add("1","2","3")` +
+[red]`Eval Error: add(): param nr 1 (1 in 0) has wrong type string, number expected` +
+`>>>` [blue]`add(1:3, 2:3, 3:3)` +
+[green]`2:1` +
+`>>>` [blue]`add(1, "2")` +
+[red]`Eval Error: add(): param nr 2 (2 in 0) has wrong type string, number expected` +
+`>>>` [blue]`add([1,2,3])` +
+[green]`6` +
+`>>>` [blue]`iterator=$([1,2,3]); add(iterator)` +
+[green]`6` +
+`>>>` [blue]`add($([1,2,3]))` +
+[green]`6`
+
+===== mul()
+Syntax: +
+`{4sp}mul(<num-expr1>, <num-expr2>, ...) -> any` +
+`{4sp}mul(<list-of-num-expr>]) -> any` +
+`{4sp}mul(<iterator-over-num-values>) -> any`
+
+Same as <<_add,add()>> but returns the product of the values of the parameters.
+
+.Examples
+`>>>` [blue]`builtin "math.arith"` +
+[green]`1` +
+`>>>` [blue]`mul(2,3,4)` +
+[green]`24`
+
+==== Module "os.file"
+The "os.file" module provides functions for working with files.
+
+Activation: +
+`{4sp}builtin "os.file"`
+
+Currently available functions:
+
+* <<_fileOpen,fileOpen()>>
+* <<_fileAppend,fileAppend()>>
+* <<_fileCreate,fileCreate()>>
+* <<_fileClose,fileClose()>>
+* <<_fileWriteText,fileWriteText()>>
+* <<_fileReadText,fileReadText()>>
+* <<_fileReadTextAll,fileReadTextAll()>>
+
+More functions will be added in the future.
+
+---
+
+===== fileOpen()
+Syntax: +
+`{4sp}fileOpen(<file-path>) -> file-handle`
+
+Returns a file handle for the specified file path. The file is opened in read-write mode. If the file does not exist, it is created.
+
+===== fileAppend()
+
+===== fileCreate()
+Syntax: +
+`{4sp}fileCreate(<file-path>) -> file-handle`
+
+Creates or truncates the named _<file-path>_. If the file already exists, it is truncated. If the file does not exist, it is created with mode 0o666 (before umask). The associated file descriptor has mode [O_RDWR]. The directory containing the file must already exist.
+
+===== fileClose()
+
+===== fileWriteText()
+
+===== fileReadText()
+
+===== fileReadTextAll()
+
+
+==== Module "string"
+This module provides functions for working with strings.
+
+Activation: +
+`{4sp}builtin "string"`
+
+
+Currently available functions:
+
+* <<_strJoin,strJoin()>>
+* <<_strSub,strSub()>>
+* <<_strSplit,strSplit()>>
+* <<_strTrim,strTrim()>>
+* <<_strStartsWith,strStartsWith()>>
+* <<_strEndsWith,strEndsWith()>>
+* <<_strUpper,strUpper()>>
+* <<_strLower,strLower()>>
+
+---
+
+===== strJoin()
+Syntax: +
+`{4sp}strJoin(<separator>, <item> ...) -> string`
+
+Returns a string obtained by concatenating the string items (sarting from the second argument), separated by the string value of the separator.
+
+.Examples
+`>>>` [blue]`strJoin(", ", "one", "two", "three")` +
+[green]`"one, two, three"` +
+`>>>` [blue]`strJoin(", ", ["one", "two", "three"])` +
+[green]`"one, two, three"`
+
+===== strSub()
+Syntax: +
+`{4sp}strSub(<string>, <start-index>=0, <count>=-1) -> string`
+
+Returns a substring of the specified string starting at the specified index and having the specified length. If the start index is negative, it is interpreted as an offset from the end of the string. If the count is negative, it means to take all characters until the end of the string.
+
+.Examples
+`>>>` [blue]`strSub("Hello, world!", 7, 5)` +
+[green]`"world"` +
+`>>>` [blue]`strSub("Hello, world!", -6, 5)` +
+[green]`"world"` +
+`>>>` [blue]`strSub("Hello, world!", 7)` +
+[green]`"world!"` +
+`>>>` [blue]`strSub("Hello, world!", -6)` +
+[green]`"world!"`
+
+===== strSplit()
+Syntax: +
+`{4sp}strSplit(<string>, <separator>="", <count>=-1) -> list`
+
+Returns a list of substrings obtained by splitting the specified string using the specified separator. If the separator is an empty string, the string is split into individual characters. If the count is negative, it means to split all occurrences of the separator.
+
+.Examples
+`>>>` [blue]`strSplit("one, two, three", ", ")` +
+[green]`["one", "two", "three"]` +
+`>>>` [blue]`strSplit("one, two, three", ", ", 2)` +
+[green]`["one", "two, three"]` +
+`>>>` [blue]`strSplit("one, two, three")` +
+[green]`["o", "n", "e", ",", " ", "t", "w", "o", ",", " ", "t", "h", "r", "e", "e"]`
+
+===== strTrim()
+Syntax: +
+`{4sp}strTrim(<string>) -> string`
+
+Returns a string obtained by removing leading and trailing whitespace characters from the specified string.
+
+.Examples
+`>>>` [blue]`strTrim("  Hello, world!  ")` +
+[green]`"Hello, world!"`
+
+===== strStartsWith()
+Syntax: +
+`{4sp}strStartsWith(<string>, <prefix> ...) -> bool`
+
+Returns a boolean indicating whether the specified string starts with any of the given prefixes.
+
+.Examples
+`>>>` [blue]`strStartsWith("Hello, world!", "Hello")` +
+[green]`true` +
+`>>>` [blue]`strStartsWith("Hello, world!", "world")` +
+[green]`false` +
+`>>>` [blue]`strStartsWith("Hello, world!", "Hi", "He")` +
+[green]`true`
+
+
+===== strEndsWith()
+Syntax: +
+`{4sp}strEndsWith(<string>, <suffix> ...) -> bool`
+
+Returns a boolean indicating whether the specified string ends with any of the given suffixes.
+
+.Examples
+`>>>` [blue]`strEndsWith("Hello, world!", "world!")` +
+[green]`true` +
+`>>>` [blue]`strEndsWith("Hello, world!", "Hello")` +
+[green]`false` +
+`>>>` [blue]`strEndsWith("Hello, world!", "Hi", "world!")` +
+[green]`true`
+
+
+===== strUpper()
+Syntax: +
+`{4sp}strUpper(<string>) -> string`
+
+Returns a string obtained by converting all characters of the specified string to uppercase.
+
+.Examples
+`>>>` [blue]`strUpper("Hello, world!")` +
+[green]`"HELLO, WORLD!"`
+
+===== strLower()
+Syntax: +
+`{4sp}strLower(<string>) -> string`
+
+Returns a string obtained by converting all characters of the specified string to lowercase.
+
+.Examples
+`>>>` [blue]`strLower("Hello, world!")` +
+[green]`"hello, world!"`
+
+== Iterators
+Iterators are objects that can be used to traverse collections, such as lists and dictionaries. They are created by providing a _data-source_ object, the collection, in a `$(<data-source>)` expression. Once an iterator is created, it can be used to access the elements of the collection one by one.
+
+In general, data-sources are objects that can be iterated over. They are defined as dictionaries having the key `next` whose value is a function that returns the next element of the collection and updates the state of the iterator. The _next_ function must return a special value, [blue]_nil_, when there are no more elements to iterate over.
+
+Lists and dictionaries are implicit data-sources. The syntax for creating an iterator is as follows.
+
+.Iterator creation syntax
+====
+*_iterator_* = "**$(**" _data-source_ "**)**" +
+_data-source_ = _explicit_ | _list-spec_ | _dict-spec_ | _custom-data-source_
+
+_explicit_ = _any-expr_ { "**,**" _any-expr_ }
+
+_list-spec_ = _list_  _range-options_ +
+_list_ = "**[**" _any-expr_ { "**,**" _any-expr_ } "**]**" +
+_range-options_ = [ "**,**" _start-index_ [ "**,**" _end-index_ [ "**,**" _step_ ]]] +
+_start-index_, _end-index_, _step_ = _integer-expr_
+
+_dict-spec_ = _dict_  _dict-options_ +
+_dict_ = "**{**" _key-value-pair_ { "**,**" _key-value-pair_ } "**}**" +
+_key-value-pair_ = _scalar-value_ "**:**" _any-expr_ +
+_scalar-value_ = _string_ | _number_ | _boolean_ +
+_dict-options_ = [ "**,**" _sort-order_ [ "**,**" _iter-mode_ ] ] +
+_sort-order_ = _asc-order_ | _desc-order_ | _no-sort_ | _default-order_ +
+_asc-order_ = "**asc**" | "**a**" +
+_desc-order_ = "**desc**" | "**d**" +
+_no-sort_ = "**none**" | "**nosort**" | "**no-sort**" | "**n**" +
+_default-order_ = "**default**" | "" +
+_iter-mode_ = _keys-iter_ | _values-iter_ | _items-iter_ | _default-iter_ +
+_keys-iter_ = "**key**" | "**keys**" | "**k**" +
+_values-iter_ = "**value**" | "**values**" | "**v**" +
+_items-iter_ = "**item**" | "**items**" | "**i**" +
+_default-iter_ = "**default**" | ""
+
+_custom-data-source_ = _dict_ having the key `next` whose value is a function that returns the next element of the collection and updates the state of the iterator.
+====
+
+NOTE: Currently, _default-order_ is the same as _asc-order_. In the future, it will be possible to specify a custom sorting function to define the default order.
+
+NOTE: Currently, _default-iter_ is the same as _keys-iter_. In the future, it will be possible to specify a custom iteration function to define the default iteration mode.
+
+.Example: iterator over an explicit list of elements
+`>>>` [blue]`it = $("A", "B", "C")` +
+[green]`$(#3)` +
+`>>>` [blue]`it{plusplus}` +
+[green]`"A"` +
+`>>>` [blue]`it{plusplus}` +
+[green]`"B"` +
+`>>>` [blue]`it{plusplus}` +
+[green]`"C"` +
+`>>>` [blue]`it{plusplus}` +
+[red]`Eval Error: EOF`
+
+.Example: iterator over a list
+`>>>` [blue]`it = $(["one", "two", "three"])` +
+[green]`$(#3)` +
+`>>>` [blue]`it{plusplus}` +
+[green]`"one"` +
+`>>>` [blue]`it{plusplus}` +
+[green]`"two"` +
+`>>>` [blue]`it{plusplus}` +
+[green]`"three"` +
+`>>>` [blue]`it{plusplus}` +
+[red]`Eval Error: EOF`
+
+When creating a list-type iterator expression, you can specify a range of indices and a step to iterate over a subset of the list.
+
+Indexing starts at 0. If the start index is not specified, it defaults to 0. If the end index is not specified, it defaults to the index of the last element of the list. If the step is not specified, it defaults to 1.
+
+Negative indexes are allowed. They are interpreted as offsets from the end of the list. For example, an end index of -1 means the index of the last element of the list, an end index of -2 means the index of the second to last element of the list, and so on.
+
+Negative steps are also allowed. They are interpreted as reverse iteration. For example, a step of -1 means to iterate over the list in reverse order.
+
+.Example: iterator over a list with index range and step 
+`>>>` [blue]`it = $([1, 2, 3, 4, 5], 1, 4, 2)` +
+[green]`$(#5)` +
+`>>>` [blue]`it{plusplus}` +
+[green]`2` +
+`>>>` [blue]`it{plusplus}` +
+[green]`4` +
+`>>>` [blue]`it{plusplus}` +
+[red]`Eval Error: EOF`
+
+.Example: iterator over a list in reverse order
+`>>>` [blue]`it = $([1, 2, 3], -1, 0, -1)` + 
+[green]`$(#3)` +
+`>>>` [blue]`it{plusplus}` +
+[green]`3` +
+`>>>` [blue]`it{plusplus}` +
+[green]`2` +
+`>>>` [blue]`it{plusplus}` +
+[green]`1` +
+`>>>` [blue]`it{plusplus}` +
+[red]`Eval Error: EOF`
+
+
+=== Operators on iterators
+The above example shows the use of the [blue]`{plusplus}` operator to get the next element of an iterator. The [blue]`{plusplus}` operator is a postfix operator that can be used with iterators. It returns the next element of the collection and updates the state of the iterator. When there are no more elements to iterate over, it returns the error [red]_Eval Error: EOF_.
+
+
+After the first use of the [blue]`{plusplus}` operator, the prefixed operato [blue]`{star}` operator can be used to get the current element of the collection without updating the state of the iterator. When there are no more elements to iterate over, it returns the error [red]_Eval Error: EOF_. Same error is returned if the [blue]`{star}` operator is used before the first use of the [blue]`{plusplus}` operator.
+
+.Example: using the [blue]`{star}` operator
+`>>>` [blue]`it = $(["one", "two", "three"])` +
+[green]`$(#3)` +
+`>>>` [blue]`{star}it` +
+[red]`Eval Error: EOF` +
+`>>>` [blue]`it{plusplus}` +
+[green]`"one"` +
+`>>>` [blue]`{star}it` +
+[green]`"one"`
+
+==== Named operators
+Named operators are operators that are identified by a name instead of a symbol. They are implicitly defined and can be called using a special syntax. For example, the [blue]`{plusplus}` has the equivalent named operator [blue]`.next`.
+
+.Available named operators
+* *_.next_*: same as [blue]`{plusplus}`.
+* *_.current_*: same as [blue]`{star}`.
+* *_.reset_*: resets the state of the iterator to the initial state.
+* *_.count_*: returns the number of elements in the iterator already visited.
+* *_.index_*: returns the index of the current element in the iterator. Before the first use of the [blue]`{plusplus}` operator, it returns the error [red]_-1_.
+
+TIP: Iterators built on custom data-sources can provide additional named operators, depending on the functionality they want to expose. For example, an iterator over a list could provide a named operator called [blue]`.reverse` that returns the next element of the collection in reverse order.
+
+.Example: using the named operators
+`>>>` [blue]`it = $(["one", "two", "three"])` +
+[green]`$(#3)` +
+`>>>` [blue]`it.next` +
+[green]`"one"` +
+`>>>` [blue]`it.current` +
+[green]`"one"` +
+`>>>` [blue]`it.next` +
+[green]`"two"` +
+`>>>` [blue]`it.reset` +
+[green]`<nil>` +
+`>>>` [blue]`it.current` +
+[red]`Eval Error: EOF` +
+`>>>` [blue]`it.next` +
+[green]`"one"`
+
+=== Iterator over custom data-sources
+It is possible to create iterators over custom data-sources by defining a dictionary that has the key `next` whose value is a function that returns the next element of the collection and updates the state of the iterator. The syntax for creating an iterator over a custom data-source is as follows.
+
+#TODO: custom data-sources#
 
-=== [blue]_import()_
-[blue]_import([grey]#<source-file>#)_ loads the multi-expression contained in the specified source and returns its value.
 
 
 == Plugins

expr.go

@@ -4,9 +4,13 @@
 // expr.go
 package expr
 
+import (
+	kern "git.portale-stac.it/go-pkg/expr/kern"
+)
+
 // ----Expression interface
 type Expr interface {
-	Typer
+	kern.Typer
-	Eval(ctx ExprContext) (result any, err error)
+	Eval(ctx kern.ExprContext) (result any, err error)
 	String() string
 }

function.go

@@ -6,19 +6,20 @@ package expr
 
 import (
 	"fmt"
-	"strconv"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 // ---- Function template
-type FuncTemplate func(ctx ExprContext, name string, args map[string]any) (result any, err error)
+// type FuncTemplate func(ctx expr.ExprContext, name string, args map[string]any) (result any, err error)
 
 // ---- Common functor definition
-type baseFunctor struct {
+type BaseFunctor struct {
-	info ExprFunc
+	info kern.ExprFunc
 }
 
-func (functor *baseFunctor) ToString(opt FmtOpt) (s string) {
+func (functor *BaseFunctor) ToString(opt kern.FmtOpt) (s string) {
 	if functor.info != nil {
 		s = functor.info.ToString(opt)
 	} else {
@@ -27,23 +28,23 @@ func (functor *baseFunctor) ToString(opt FmtOpt) (s string) {
 	return s
 }
 
-func (functor *baseFunctor) GetParams() (params []ExprFuncParam) {
+func (functor *BaseFunctor) GetParams() (params []kern.ExprFuncParam) {
 	if functor.info != nil {
 		return functor.info.Params()
 	} else {
-		return []ExprFuncParam{}
+		return []kern.ExprFuncParam{}
 	}
 }
 
-func (functor *baseFunctor) SetFunc(info ExprFunc) {
+func (functor *BaseFunctor) SetFunc(info kern.ExprFunc) {
 	functor.info = info
 }
 
-func (functor *baseFunctor) GetFunc() ExprFunc {
+func (functor *BaseFunctor) GetFunc() kern.ExprFunc {
 	return functor.info
 }
 
-func (functor *baseFunctor) GetDefinitionContext() ExprContext {
+func (functor *BaseFunctor) GetDefinitionContext() kern.ExprContext {
 	return nil
 }
 
@@ -62,11 +63,11 @@ type funcParamInfo struct {
 	defaultValue any
 }
 
-func NewFuncParam(name string) ExprFuncParam {
+func NewFuncParam(name string) kern.ExprFuncParam {
 	return &funcParamInfo{name: name}
 }
 
-func NewFuncParamFlag(name string, flags paramFlags) ExprFuncParam {
+func NewFuncParamFlag(name string, flags paramFlags) kern.ExprFuncParam {
 	return &funcParamInfo{name: name, flags: flags}
 }
 
@@ -79,7 +80,7 @@ func (param *funcParamInfo) Name() string {
 }
 
 func (param *funcParamInfo) Type() string {
-	return TypeAny
+	return kern.TypeAny
 }
 
 func (param *funcParamInfo) IsDefault() bool {
@@ -100,17 +101,17 @@ func (param *funcParamInfo) DefaultValue() any {
 
 // --- Functions
 
-// funcInfo implements ExprFunc
+// funcInfo implements expr.ExprFunc
 type funcInfo struct {
 	name         string
 	minArgs      int
 	maxArgs      int
-	functor      Functor
+	functor      kern.Functor
-	formalParams []ExprFuncParam
+	formalParams []kern.ExprFuncParam
 	returnType   string
 }
 
-func newFuncInfo(name string, functor Functor, returnType string, params []ExprFuncParam) (info *funcInfo, err error) {
+func newFuncInfo(name string, functor kern.Functor, returnType string, params []kern.ExprFuncParam) (info *funcInfo, err error) {
 	var minArgs = 0
 	var maxArgs = 0
 	for _, p := range params {
@@ -138,7 +139,7 @@ func newFuncInfo(name string, functor Functor, returnType string, params []ExprF
 	return info, nil
 }
 
-func (info *funcInfo) Params() []ExprFuncParam {
+func (info *funcInfo) Params() []kern.ExprFuncParam {
 	return info.formalParams
 }
 
@@ -146,7 +147,7 @@ func (info *funcInfo) ReturnType() string {
 	return info.returnType
 }
 
-func (info *funcInfo) ToString(opt FmtOpt) string {
+func (info *funcInfo) ToString(opt kern.FmtOpt) string {
 	var sb strings.Builder
 	if len(info.Name()) == 0 {
 		sb.WriteString("func")
@@ -180,7 +181,7 @@ func (info *funcInfo) ToString(opt FmtOpt) string {
 	if len(info.returnType) > 0 {
 		sb.WriteString(info.returnType)
 	} else {
-		sb.WriteString(TypeAny)
+		sb.WriteString(kern.TypeAny)
 	}
 	sb.WriteString("{}")
 	return sb.String()
@@ -198,11 +199,11 @@ func (info *funcInfo) MaxArgs() int {
 	return info.maxArgs
 }
 
-func (info *funcInfo) Functor() Functor {
+func (info *funcInfo) Functor() kern.Functor {
 	return info.functor
 }
 
-func (info *funcInfo) AllocContext(parentCtx ExprContext) (ctx ExprContext) {
+func (info *funcInfo) AllocContext(parentCtx kern.ExprContext) (ctx kern.ExprContext) {
 	if defCtx := info.functor.GetDefinitionContext(); defCtx != nil {
 		ctx = defCtx.Clone()
 		ctx.SetParent(defCtx)
@@ -213,7 +214,7 @@ func (info *funcInfo) AllocContext(parentCtx ExprContext) (ctx ExprContext) {
 	return
 }
 
-func (info *funcInfo) ParamSpec(paramName string) ExprFuncParam {
+func (info *funcInfo) ParamSpec(paramName string) kern.ExprFuncParam {
 	for _, spec := range info.formalParams {
 		if spec.Name() == paramName {
 			return spec
@@ -222,7 +223,7 @@ func (info *funcInfo) ParamSpec(paramName string) ExprFuncParam {
 	return nil
 }
 
-func initActualParams(ctx ExprContext, info ExprFunc, callTerm *term) (actualParams map[string]any, err error) {
+func initActualParams(ctx kern.ExprContext, info kern.ExprFunc, callTerm *term) (actualParams map[string]any, err error) {
 	var varArgs []any
 	var varName string
 
@@ -237,10 +238,10 @@ func initActualParams(ctx ExprContext, info ExprFunc, callTerm *term) (actualPar
 	for i, tree := range callTerm.children {
 		var paramValue any
 		paramCtx := ctx.Clone()
-		if paramValue, err = tree.compute(paramCtx); err != nil {
+		if paramValue, err = tree.Compute(paramCtx); err != nil {
 			break
 		}
-		if paramName, namedParam := getAssignVarName(tree); namedParam {
+		if paramName, namedParam := kern.GetAssignVarName(tree); namedParam {
 			if info.ParamSpec(paramName) == nil {
 				err = fmt.Errorf("%s(): unknown param %q", info.Name(), paramName)
 				break
@@ -260,7 +261,7 @@ func initActualParams(ctx ExprContext, info ExprFunc, callTerm *term) (actualPar
 					actualParams[spec.Name()] = paramValue
 				}
 			} else {
-				err = ErrTooManyParams(info.Name(), len(formalParams), len(callTerm.children))
+				err = kern.ErrTooManyParams(info.Name(), len(formalParams), len(callTerm.children))
 				break
 			}
 		} else {
@@ -279,7 +280,7 @@ func initActualParams(ctx ExprContext, info ExprFunc, callTerm *term) (actualPar
 func (info *funcInfo) PrepareCall(name string, actualParams map[string]any) (err error) {
 	passedCount := len(actualParams)
 	if info.MinArgs() > passedCount {
-		err = ErrTooFewParams(name, info.MinArgs(), info.MaxArgs(), passedCount)
+		err = kern.ErrTooFewParams(name, info.MinArgs(), info.MaxArgs(), passedCount)
 		return
 	}
 
@@ -301,86 +302,86 @@ func (info *funcInfo) PrepareCall(name string, actualParams map[string]any) (err
 	}
 
 	if info.MaxArgs() >= 0 && info.MaxArgs() < len(actualParams) {
-		err = ErrTooManyParams(name, info.MaxArgs(), len(actualParams))
+		err = kern.ErrTooManyParams(name, info.MaxArgs(), len(actualParams))
 	}
 	return
 }
 
 // ----- Call a function ---
 
-func getAssignVarName(t *term) (name string, ok bool) {
+// func getAssignVarName(t *term) (name string, ok bool) {
-	if ok = t.symbol() == SymEqual; ok {
+// 	if ok = t.symbol() == SymEqual; ok {
-		name = t.children[0].source()
+// 		name = t.children[0].source()
-	}
+// 	}
-	return
+// 	return
-}
+// }
 
-func CallFunctionByTerm(parentCtx ExprContext, name string, callTerm *term) (result any, err error) {
+// func CallFunctionByTerm(parentCtx expr.ExprContext, name string, callTerm *term) (result any, err error) {
-	var actualParams map[string]any
-	if info, exists := GetFuncInfo(parentCtx, name); exists {
-		if actualParams, err = initActualParams(parentCtx, info, callTerm); err == nil {
-			ctx := info.AllocContext(parentCtx)
-			if err = info.PrepareCall(name, actualParams); err == nil {
-				functor := info.Functor()
-				result, err = functor.InvokeNamed(ctx, name, actualParams)
-				exportObjectsToParent(ctx)
-			}
-		}
-	} else {
-		err = fmt.Errorf("unknown function %s()", name)
-	}
-	return
-}
-
-func CallFunctionByArgs(parentCtx ExprContext, name string, args []any) (result any, err error) {
-	var actualParams map[string]any
-	if info, exists := GetFuncInfo(parentCtx, name); exists {
-		functor := info.Functor()
-		actualParams = bindActualParams(functor, args)
-		ctx := info.AllocContext(parentCtx)
-		if err = info.PrepareCall(name, actualParams); err == nil {
-			result, err = functor.InvokeNamed(ctx, name, actualParams)
-			exportObjectsToParent(ctx)
-		}
-	} else {
-		err = fmt.Errorf("unknown function %s()", name)
-	}
-	return
-}
-
-func CallFunctionByParams(parentCtx ExprContext, name string, actualParams map[string]any) (result any, err error) {
 // 	var actualParams map[string]any
-	if info, exists := GetFuncInfo(parentCtx, name); exists {
+// 	if info, exists := GetFuncInfo(parentCtx, name); exists {
-		functor := info.Functor()
+// 		if actualParams, err = initActualParams(parentCtx, info, callTerm); err == nil {
-		ctx := info.AllocContext(parentCtx)
+// 			ctx := info.AllocContext(parentCtx)
-		if err = info.PrepareCall(name, actualParams); err == nil {
+// 			if err = info.PrepareCall(name, actualParams); err == nil {
-			result, err = functor.InvokeNamed(ctx, name, actualParams)
+// 				functor := info.Functor()
-			exportObjectsToParent(ctx)
+// 				result, err = functor.InvokeNamed(ctx, name, actualParams)
-		}
+// 				exportObjectsToParent(ctx)
-	} else {
+// 			}
-		err = fmt.Errorf("unknown function %s()", name)
+// 		}
-	}
+// 	} else {
-	return
+// 		err = fmt.Errorf("unknown function %s()", name)
-}
+// 	}
+// 	return
+// }
 
-func GetParam(args map[string]any, paramName string, paramNum int) (value any, exists bool) {
+// func CallFunctionByArgs(parentCtx expr.ExprContext, name string, args []any) (result any, err error) {
-	if value, exists = args[paramName]; !exists {
+// 	var actualParams map[string]any
-		if paramNum > 0 && paramNum <= len(args) {
+// 	if info, exists := GetFuncInfo(parentCtx, name); exists {
-			value, exists = args["arg"+strconv.Itoa(paramNum)]
+// 		functor := info.Functor()
-		}
+// 		actualParams = bindActualParams(functor, args)
-	}
+// 		ctx := info.AllocContext(parentCtx)
-	return
+// 		if err = info.PrepareCall(name, actualParams); err == nil {
-}
+// 			result, err = functor.InvokeNamed(ctx, name, actualParams)
+// 			exportObjectsToParent(ctx)
+// 		}
+// 	} else {
+// 		err = fmt.Errorf("unknown function %s()", name)
+// 	}
+// 	return
+// }
 
-func bindActualParams(functor Functor, args []any) (actualParams map[string]any) {
+// func CallFunctionByParams(parentCtx expr.ExprContext, name string, actualParams map[string]any) (result any, err error) {
-	formalParams := functor.GetParams()
+// 	//var actualParams map[string]any
-	actualParams = make(map[string]any, len(args))
+// 	if info, exists := GetFuncInfo(parentCtx, name); exists {
-	for i, arg := range args {
+// 		functor := info.Functor()
-		if i < len(formalParams) {
+// 		ctx := info.AllocContext(parentCtx)
-			actualParams[formalParams[i].Name()] = arg
+// 		if err = info.PrepareCall(name, actualParams); err == nil {
-		} else {
+// 			result, err = functor.InvokeNamed(ctx, name, actualParams)
-			actualParams["arg"+strconv.Itoa(i+1)] = arg
+// 			exportObjectsToParent(ctx)
-		}
+// 		}
-	}
+// 	} else {
-	return
+// 		err = fmt.Errorf("unknown function %s()", name)
-}
+// 	}
+// 	return
+// }
+
+// func GetParam(args map[string]any, paramName string, paramNum int) (value any, exists bool) {
+// 	if value, exists = args[paramName]; !exists {
+// 		if paramNum > 0 && paramNum <= len(args) {
+// 			value, exists = args["arg"+strconv.Itoa(paramNum)]
+// 		}
+// 	}
+// 	return
+// }
+
+// func bindActualParams(functor Functor, args []any) (actualParams map[string]any) {
+// 	formalParams := functor.GetParams()
+// 	actualParams = make(map[string]any, len(args))
+// 	for i, arg := range args {
+// 		if i < len(formalParams) {
+// 			actualParams[formalParams[i].Name()] = arg
+// 		} else {
+// 			actualParams["arg"+strconv.Itoa(i+1)] = arg
+// 		}
+// 	}
+// 	return
+// }

global-context.go

@@ -7,20 +7,25 @@ package expr
 import (
 	"path/filepath"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
-var globalCtx *SimpleStore
+//var globalCtx *SimpleStore
 
-func ImportInContext(name string) (exists bool) {
+func ImportInContext(ctx kern.ExprContext, name string) (exists bool) {
+	if globalCtx := ctx.GetGlobal(); globalCtx != nil {
 		var mod *builtinModule
 		if mod, exists = builtinModuleRegister[name]; exists {
 			mod.importFunc(globalCtx)
 			mod.imported = true
 		}
+	}
 	return
 }
 
-func ImportInContextByGlobPattern(pattern string) (count int, err error) {
+func ImportInContextByGlobPattern(ctx kern.ExprContext, pattern string) (count int, err error) {
+	if globalCtx := ctx.GetGlobal(); globalCtx != nil {
 		var matched bool
 		for name, mod := range builtinModuleRegister {
 			if matched, err = filepath.Match(pattern, name); err == nil {
@@ -33,75 +38,37 @@ func ImportInContextByGlobPattern(pattern string) (count int, err error) {
 				break
 			}
 		}
-	return
-}
-
-func GetVar(ctx ExprContext, name string) (value any, exists bool) {
-	if value, exists = ctx.GetVar(name); !exists {
-		value, exists = globalCtx.GetVar(name)
 	}
 	return
 }
 
-func GetLocalFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool) {
+func GlobalCtrlSet(ctx kern.ExprContext, name string, newValue any) (currentValue any) {
-	var v any
+	if globalCtx := ctx.GetGlobal(); globalCtx != nil {
-	if len(name) > 0 {
-		if v, exists = ctx.GetVar(name); exists && isFunctor(v) {
-			f, _ := v.(Functor)
-			item = f.GetFunc()
-		} else {
-			item, exists = ctx.GetFuncInfo(name)
-		}
-	}
-	return
-}
-
-func GetFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool) {
-	// if len(name) > 0 {
-	// 	if item, exists = GetLocalFuncInfo(ctx, name); exists {
-	// 		ownerCtx = ctx
-	// 	} else if item, exists = globalCtx.GetFuncInfo(name); exists {
-	// 		ownerCtx = globalCtx
-	// 	}
-	// }
-	item, exists, _ = GetFuncInfoAndOwner(ctx, name)
-	return
-}
-
-func GetFuncInfoAndOwner(ctx ExprContext, name string) (item ExprFunc, exists bool, ownerCtx ExprContext) {
-	if len(name) > 0 {
-		if item, exists = GetLocalFuncInfo(ctx, name); exists {
-			ownerCtx = ctx
-		} else if item, exists = globalCtx.GetFuncInfo(name); exists {
-			ownerCtx = globalCtx
-		}
-	}
-	return
-}
-
-func GlobalCtrlSet(name string, newValue any) (currentValue any) {
 		if !strings.HasPrefix(name, "_") {
 			name = "_" + name
 		}
-	currentValue, _ = globalCtx.GetVar(name)
 
+		currentValue, _ = globalCtx.GetVar(name)
 		globalCtx.SetVar(name, newValue)
+	}
 	return currentValue
 }
 
-func GlobalCtrlGet(name string) (currentValue any) {
+func GlobalCtrlGet(ctx kern.ExprContext, name string) (currentValue any) {
+	if globalCtx := ctx.GetGlobal(); globalCtx != nil {
 		if !strings.HasPrefix(name, "_") {
 			name = "_" + name
 		}
 		currentValue, _ = globalCtx.GetVar(name)
+	}
 	return currentValue
 }
 
-func CtrlEnable(ctx ExprContext, name string) (currentStatus bool) {
+func CtrlEnable(ctx kern.ExprContext, name string) (currentStatus bool) {
 	if !strings.HasPrefix(name, "_") {
 		name = "_" + name
 	}
-	if v, exists := ctx.GetVar(name); exists && IsBool(v) {
+	if v, exists := ctx.GetVar(name); exists && kern.IsBool(v) {
 		currentStatus, _ = v.(bool)
 	}
 
@@ -109,11 +76,11 @@ func CtrlEnable(ctx ExprContext, name string) (currentStatus bool) {
 	return currentStatus
 }
 
-func CtrlDisable(ctx ExprContext, name string) (currentStatus bool) {
+func CtrlDisable(ctx kern.ExprContext, name string) (currentStatus bool) {
 	if !strings.HasPrefix(name, "_") {
 		name = "_" + name
 	}
-	if v, exists := ctx.GetVar(name); exists && IsBool(v) {
+	if v, exists := ctx.GetVar(name); exists && kern.IsBool(v) {
 		currentStatus, _ = v.(bool)
 	}
 
@@ -121,36 +88,39 @@ func CtrlDisable(ctx ExprContext, name string) (currentStatus bool) {
 	return currentStatus
 }
 
-func CtrlIsEnabled(ctx ExprContext, name string) (status bool) {
+// func CtrlIsEnabled(ctx ExprContext, name string) (status bool) {
-	var v any
+// 	var v any
-	var exists bool
+// 	var exists bool
 
-	if !strings.HasPrefix(name, "_") {
+// 	if !strings.HasPrefix(name, "_") {
-		name = "_" + name
+// 		name = "_" + name
-	}
+// 	}
 
-	if v, exists = ctx.GetVar(name); !exists {
+// 	if v, exists = ctx.GetVar(name); !exists {
-		v, exists = globalCtx.GetVar(name)
+// 		v, exists = globalCtx.GetVar(name)
-	}
+// 	}
 
-	if exists {
+// 	if exists {
-		if b, ok := v.(bool); ok {
+// 		if b, ok := v.(bool); ok {
-			status = b
+// 			status = b
-		}
+// 		}
-	}
+// 	}
-	return
+// 	return
-}
+// }
 
-func getControlString(name string) (s string, exists bool) {
+func getControlString(ctx kern.ExprContext, name string) (s string, exists bool) {
+	if globalCtx := ctx.GetGlobal(); globalCtx != nil {
 		var v any
 		if v, exists = globalCtx.GetVar(name); exists {
 			s, exists = v.(string)
 		}
+	}
 	return
 }
 
-func init() {
+func InitGlobal() (ctx kern.ExprContext) {
-	globalCtx = NewSimpleStore()
+	ctx = NewSimpleStoreWithoutGlobalContext()
-	initDefaultVars(globalCtx)
+	kern.InitDefaultVars(ctx)
-	ImportBuiltinsFuncs(globalCtx)
+	ImportBuiltinsFuncs(ctx)
+	return
 }

graph.go

@@ -1,6 +1,8 @@
 // Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
 // All rights reserved.
 
+//go:build graph
+
 // graph.go
 package expr
 
@@ -53,7 +55,7 @@ func (r *Reticle) computeCharWidth() {
 			if v := ref.node.value(); v != nil {
 				ref.label = fmt.Sprintf("%v", v)
 			} else {
-				ref.label = ref.node.source()
+				ref.label = ref.node.Source()
 			}
 			r.colsWidth[c] = max(r.colsWidth[c], len(ref.label)+2) // +2 to make room for brakets
 		}

helpers.go

@@ -9,9 +9,12 @@ import (
 	"io"
 	"os"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+	"git.portale-stac.it/go-pkg/expr/util"
 )
 
-func EvalString(ctx ExprContext, source string) (result any, err error) {
+func EvalString(ctx kern.ExprContext, source string) (result any, err error) {
 	var tree *ast
 
 	r := strings.NewReader(source)
@@ -34,21 +37,21 @@ func EvalStringA(source string, args ...Arg) (result any, err error) {
 }
 
 func EvalStringV(source string, args []Arg) (result any, err error) {
-	ctx := NewSimpleStore()
+	ctx := NewSimpleStoreWithoutGlobalContext()
 	for _, arg := range args {
-		if isFunc(arg.Value) {
+		if util.IsFunc(arg.Value) {
-			if f, ok := arg.Value.(FuncTemplate); ok {
+			if f, ok := arg.Value.(kern.FuncTemplate); ok {
-				functor := NewGolangFunctor(f)
+				functor := kern.NewGolangFunctor(f)
 				// ctx.RegisterFunc(arg.Name, functor, 0, -1)
-				ctx.RegisterFunc(arg.Name, functor, TypeAny, []ExprFuncParam{
+				ctx.RegisterFunc(arg.Name, functor, kern.TypeAny, []kern.ExprFuncParam{
-					NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, 0),
+					NewFuncParamFlagDef(kern.ParamValue, PfDefault|PfRepeat, 0),
 				})
 			} else {
 				err = fmt.Errorf("invalid function specification: %q", arg.Name)
 			}
-		} else if integer, ok := anyInteger(arg.Value); ok {
+		} else if integer, ok := kern.AnyInteger(arg.Value); ok {
 			ctx.SetVar(arg.Name, integer)
-		} else if float, ok := anyFloat(arg.Value); ok {
+		} else if float, ok := kern.AnyFloat(arg.Value); ok {
 			ctx.SetVar(arg.Name, float)
 		} else if _, ok := arg.Value.(string); ok {
 			ctx.SetVar(arg.Name, arg.Value)
@@ -65,7 +68,7 @@ func EvalStringV(source string, args []Arg) (result any, err error) {
 	return
 }
 
-func EvalStream(ctx ExprContext, r io.Reader) (result any, err error) {
+func EvalStream(ctx kern.ExprContext, r io.Reader) (result any, err error) {
 	var tree *ast
 	scanner := NewScanner(r, DefaultTranslations())
 	parser := NewParser()
@@ -76,7 +79,7 @@ func EvalStream(ctx ExprContext, r io.Reader) (result any, err error) {
 	return
 }
 
-func EvalFile(ctx ExprContext, filePath string) (result any, err error) {
+func EvalFile(ctx kern.ExprContext, filePath string) (result any, err error) {
 	var fh *os.File
 	if fh, err = os.Open(filePath); err != nil {
 		return nil, err

import-utils.go

@@ -11,6 +11,9 @@ import (
 	"path"
 	"path/filepath"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+	"git.portale-stac.it/go-pkg/expr/util"
 )
 
 const (
@@ -19,8 +22,8 @@ const (
 )
 
 func checkStringParamExpected(funcName string, paramValue any, paramPos int) (err error) {
-	if !(IsString(paramValue) /*|| isList(paramValue)*/) {
+	if !(kern.IsString(paramValue) /*|| isList(paramValue)*/) {
-		err = fmt.Errorf("%s(): param nr %d has wrong type %s, string expected", funcName, paramPos+1, TypeName(paramValue))
+		err = fmt.Errorf("%s(): param nr %d has wrong type %s, string expected", funcName, paramPos+1, kern.TypeName(paramValue))
 	}
 	return
 }
@@ -45,8 +48,8 @@ func addEnvImportDirs(envVarName string, dirList []string) []string {
 	return dirList
 }
 
-func addSearchDirs(endingPath string, dirList []string) []string {
+func addSearchDirs(ctx kern.ExprContext, endingPath string, dirList []string) []string {
-	if dirSpec, exists := getControlString(ControlSearchPath); exists {
+	if dirSpec, exists := getControlString(ctx, kern.ControlSearchPath); exists {
 		dirs := strings.Split(dirSpec, ":")
 		if dirList == nil {
 			dirList = dirs
@@ -63,9 +66,9 @@ func addSearchDirs(endingPath string, dirList []string) []string {
 	return dirList
 }
 
-func buildSearchDirList(endingPath, envVarName string) (dirList []string) {
+func buildSearchDirList(ctx kern.ExprContext, endingPath, envVarName string) (dirList []string) {
 	dirList = addEnvImportDirs(envVarName, dirList)
-	dirList = addSearchDirs(endingPath, dirList)
+	dirList = addSearchDirs(ctx, endingPath, dirList)
 	return
 }
 
@@ -76,14 +79,26 @@ func isFile(filePath string) bool {
 
 func searchAmongPath(filename string, dirList []string) (filePath string) {
 	var err error
+
+	suffix := SHAREDLIBRARY_EXTENSION
+	if strings.HasSuffix(filename, ".debug") {
+		suffix += ".debug"
+	}
+
 	for _, dir := range dirList {
-		if dir, err = ExpandPath(dir); err != nil {
+		if dir, err = util.ExpandPath(dir); err != nil {
 			continue
 		}
 		if fullPath := path.Join(dir, filename); isFile(fullPath) {
 			filePath = fullPath
 			break
 		}
+
+		subdir := strings.TrimSuffix(filename, suffix)
+		if fullPath := path.Join(dir, subdir, filename); isFile(fullPath) {
+			filePath = fullPath
+			break
+		}
 	}
 	return
 }
@@ -94,7 +109,7 @@ func isPathRelative(filePath string) bool {
 }
 
 func makeFilepath(filename string, dirList []string) (filePath string, err error) {
-	if filename, err = ExpandPath(filename); err != nil {
+	if filename, err = util.ExpandPath(filename); err != nil {
 		return
 	}
 

int-iterator.go

@@ -0,0 +1,137 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// int-iterator.go
+package expr
+
+import (
+	"fmt"
+	"io"
+	"slices"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
+type IntIterator struct {
+	count int64
+	index int64
+	start int64
+	stop  int64
+	step  int64
+}
+
+func NewIntIterator(args []any) (it *IntIterator, err error) {
+	var argc int = 0
+	if args != nil {
+		argc = len(args)
+	}
+	it = &IntIterator{count: 0, index: -1, start: 0, stop: 0, step: 1}
+	if argc >= 1 {
+		if it.stop, err = kern.ToGoInt64(args[0], "start index"); err != nil {
+			return
+		}
+		if argc >= 2 {
+			it.start = it.stop
+			if it.stop, err = kern.ToGoInt64(args[1], "stop index"); err != nil {
+				return
+			}
+			if argc >= 3 {
+				if it.step, err = kern.ToGoInt64(args[2], "step"); err != nil {
+					return
+				}
+			} else if it.start > it.stop {
+				it.step = -1
+			}
+		}
+	}
+	if it.step == 0 {
+		err = fmt.Errorf("step cannot be zero")
+		return
+	}
+	if it.start < it.stop && it.step < 0 {
+		err = fmt.Errorf("step cannot be negative when start < stop")
+		return
+	}
+	if it.start > it.stop && it.step > 0 {
+		err = fmt.Errorf("step cannot be positive when start > stop")
+		return
+	}
+	it.Reset()
+	return
+}
+
+func (it *IntIterator) String() string {
+	return fmt.Sprintf("$(%d..%d..%d)", it.start, it.stop, it.step)
+}
+
+func (it *IntIterator) TypeName() string {
+	return "IntIterator"
+}
+
+func (it *IntIterator) HasOperation(name string) bool {
+	yes := slices.Contains([]string{kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName}, name)
+	return yes
+}
+
+func (it *IntIterator) CallOperation(name string, args map[string]any) (v any, err error) {
+	switch name {
+	case kern.NextName:
+		v, err = it.Next()
+	case kern.ResetName:
+		err = it.Reset()
+	case kern.CleanName:
+		err = it.Clean()
+	case kern.IndexName:
+		v = int64(it.Index())
+	case kern.CurrentName:
+		v, err = it.Current()
+	case kern.CountName:
+		v = it.count
+	default:
+		err = kern.ErrNoOperation(name)
+	}
+	return
+}
+
+func (it *IntIterator) Current() (item any, err error) {
+	if it.start <= it.stop {
+		if it.index >= it.start && it.index < it.stop {
+			item = it.index
+		} else {
+			err = io.EOF
+		}
+	} else {
+		if it.index > it.stop && it.index <= it.start {
+			item = it.index
+		} else {
+			err = io.EOF
+		}
+	}
+	return
+}
+
+func (it *IntIterator) Next() (item any, err error) {
+	it.index += it.step
+	if item, err = it.Current(); err != io.EOF {
+		it.count++
+	}
+	return
+}
+
+func (it *IntIterator) Index() int64 {
+	return it.index
+}
+
+func (it *IntIterator) Count() int64 {
+	return it.count
+}
+
+func (it *IntIterator) Reset() error {
+	it.index = it.start - it.step
+	it.count = 0
+	return nil
+}
+
+func (it *IntIterator) Clean() error {
+	return nil
+}

iter-factory.go

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

kern/bind-go-functions.go

@@ -2,11 +2,11 @@
 // All rights reserved.
 
 // bind-go-function.go
-package expr
+package kern
 
 // ---- Linking with Go functions
 type golangFunctor struct {
-	baseFunctor
+	BaseFunctor
 	f FuncTemplate
 }
 

kern/bool.go

@@ -0,0 +1,27 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// string.go
+package kern
+
+func IsBool(v any) (ok bool) {
+	_, ok = v.(bool)
+	return ok
+}
+
+func ToBool(v any) (b bool, ok bool) {
+	ok = true
+	switch x := v.(type) {
+	case string:
+		b = len(x) > 0
+	case float64:
+		b = x != 0.0
+	case int64:
+		b = x != 0
+	case bool:
+		b = x
+	default:
+		ok = false
+	}
+	return
+}

kern/common-errors.go

@@ -2,7 +2,7 @@
 // All rights reserved.
 
 // common-errors.go
-package expr
+package kern
 
 import (
 	"fmt"
@@ -34,7 +34,7 @@ func ErrCantConvert(funcName string, value any, kind string) 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 {
@@ -52,7 +52,7 @@ func ErrFuncDivisionByZero(funcName string) error {
 // }
 
 func ErrInvalidParameterValue(funcName, paramName string, paramValue any) error {
-	return fmt.Errorf("%s(): invalid value %s (%v) for parameter %q", funcName, TypeName(paramValue), paramValue, paramName)
+	return fmt.Errorf("%s(): invalid value %s (%#v) for parameter %q", funcName, TypeName(paramValue), paramValue, paramName)
 }
 
 func undefArticle(s string) (article string) {
@@ -80,8 +80,12 @@ func ErrUnknownParam(funcName, paramName string) error {
 	return fmt.Errorf("%s(): unknown parameter %q", funcName, paramName)
 }
 
+func ErrUnknownVar(funcName, varName string) error {
+	return fmt.Errorf("%s(): unknown variable %q", funcName, varName)
+}
+
 // --- Operator errors
 
-func ErrLeftOperandMustBeVariable(leftTerm, opTerm *term) error {
+func ErrLeftOperandMustBeVariable(leftTerm, opTerm Term) error {
-	return leftTerm.Errorf("left operand of %q must be a variable", opTerm.source())
+	return leftTerm.Errorf("left operand of %q must be a variable", opTerm.Source())
 }

kern/common-params.go

@@ -2,7 +2,7 @@
 // All rights reserved.
 
 // common-params.go
-package expr
+package kern
 
 const (
 	ParamArgs      = "args"

kern/common-type-names.go

@@ -2,7 +2,7 @@
 // All rights reserved.
 
 // common-type-names.go
-package expr
+package kern
 
 const (
 	TypeAny           = "any"
@@ -13,6 +13,7 @@ const (
 	TypeFileHandle    = "file-handle"
 	TypeInt           = "integer"
 	TypeItem          = "item"
+	TypeIterator      = "iterator"
 	TypeNumber        = "number"
 	TypePair          = "pair"
 	TypeString        = "string"

kern/compare.go

@@ -0,0 +1,37 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+package kern
+
+import "reflect"
+
+func Equal(value1, value2 any) (equal bool) {
+	if value1 == nil && value2 == nil {
+		equal = true
+	} else if value1 == nil || value2 == nil {
+		equal = false
+	} else if IsBool(value1) && IsBool(value2) {
+		equal = value1.(bool) == value2.(bool)
+	} else if IsList(value1) && IsList(value2) {
+		ls1 := value1.(*ListType)
+		ls2 := value2.(*ListType)
+		equal = ls1.Equals(*ls2)
+	} else if IsDict(value1) && IsDict(value2) {
+		d1 := value1.(*DictType)
+		d2 := value2.(*DictType)
+		equal = d1.Equals(*d2)
+	} else if IsInteger(value1) && IsInteger(value2) {
+		equal = value1.(int64) == value2.(int64)
+	} else if IsString(value1) && IsString(value2) {
+		equal = value1.(string) == value2.(string)
+	} else if IsFloat(value1) && IsFloat(value2) {
+		equal = value1.(float64) == value2.(float64)
+	} else if IsNumOrFract(value1) && IsNumOrFract(value2) {
+		if eq, err := CmpAnyFract(value1, value2); err == nil {
+			equal = eq == 0
+		}
+	} else if !reflect.DeepEqual(value1, value2) {
+		equal = false
+	}
+	return
+}

kern/context-helpers.go

@@ -2,9 +2,9 @@
 // All rights reserved.
 
 // context-helpers.go
-package expr
+package kern
 
-func cloneContext(sourceCtx ExprContext) (clonedCtx ExprContext) {
+func CloneContext(sourceCtx ExprContext) (clonedCtx ExprContext) {
 	if sourceCtx != nil {
 		clonedCtx = sourceCtx.Clone()
 	}
@@ -25,8 +25,8 @@ func exportFunc(ctx ExprContext, name string, info ExprFunc) {
 	ctx.RegisterFunc(name, info.Functor(), info.ReturnType(), info.Params())
 }
 
-func exportObjects(destCtx, sourceCtx ExprContext) {
+func ExportObjects(destCtx, sourceCtx ExprContext) {
-	exportAll := CtrlIsEnabled(sourceCtx, control_export_all)
+	exportAll := CtrlIsEnabled(sourceCtx, ControlExportAll)
 	// fmt.Printf("Exporting from sourceCtx [%p] to destCtx [%p] -- exportAll=%t\n", sourceCtx, destCtx, exportAll)
 	// Export variables
 	for _, refName := range sourceCtx.EnumVars(func(name string) bool { return (exportAll || name[0] == '@') && !(name[0] == '_') }) {
@@ -44,6 +44,6 @@ func exportObjects(destCtx, sourceCtx ExprContext) {
 
 func exportObjectsToParent(sourceCtx ExprContext) {
 	if parentCtx := sourceCtx.GetParent(); parentCtx != nil {
-		exportObjects(parentCtx, sourceCtx)
+		ExportObjects(parentCtx, sourceCtx)
 	}
 }

kern/control.go

@@ -2,7 +2,9 @@
 // All rights reserved.
 
 // control.go
-package expr
+package kern
+
+import "strings"
 
 // Preset control variables
 const (
@@ -16,7 +18,7 @@ const (
 
 // Other control variables
 const (
-	control_export_all = "_export_all"
+	ControlExportAll = "_export_all"
 )
 
 // Initial values
@@ -24,13 +26,34 @@ const (
 	init_search_path = "~/.local/lib/go-pkg/expr:/usr/local/lib/go-pkg/expr:/usr/lib/go-pkg/expr"
 )
 
+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 {
+		if globalCtx := ctx.GetGlobal(); globalCtx != nil {
+			v, exists = globalCtx.GetVar(name)
+		}
+	}
+
+	if exists {
+		if b, ok := v.(bool); ok {
+			status = b
+		}
+	}
+	return
+}
 func SetCtrl(ctx ExprContext, name string, value any) (current any) {
 	current, _ = ctx.GetVar(name)
 	ctx.UnsafeSetVar(name, value)
 	return
 }
 
-func initDefaultVars(ctx ExprContext) {
+func InitDefaultVars(ctx ExprContext) {
 	if _, exists := ctx.GetVar(ControlPreset); exists {
 		return
 	}

kern/dict-type.go

@@ -2,7 +2,7 @@
 // All rights reserved.
 
 // dict-type.go
-package expr
+package kern
 
 import (
 	"fmt"
@@ -12,6 +12,11 @@ import (
 
 type DictType map[any]any
 
+func IsDict(v any) (ok bool) {
+	_, ok = v.(*DictType)
+	return ok
+}
+
 func MakeDict() (dict *DictType) {
 	d := make(DictType)
 	dict = &d
@@ -32,7 +37,7 @@ func NewDict(dictAny map[any]any) (dict *DictType) {
 	return
 }
 
-func newDict(dictAny map[any]*term) (dict *DictType) {
+func newDict(dictAny map[any]Term) (dict *DictType) {
 	// TODO Change with a call to NewDict()
 	var d DictType
 	if dictAny != nil {
@@ -110,7 +115,7 @@ func (dict *DictType) ToString(opt FmtOpt) string {
 			sb.WriteString(": ")
 			if formatter, ok := value.(Formatter); ok {
 				sb.WriteString(formatter.ToString(opt))
-			} else if t, ok := value.(*term); ok {
+			} else if t, ok := value.(Term); ok {
 				sb.WriteString(t.String())
 			} else {
 				sb.WriteString(fmt.Sprintf("%#v", value))
@@ -129,7 +134,7 @@ func (dict *DictType) TypeName() string {
 	return "dict"
 }
 
-func (dict *DictType) hasKey(target any) (ok bool) {
+func (dict *DictType) HasKey(target any) (ok bool) {
 	for key := range *dict {
 		if ok = reflect.DeepEqual(key, target); ok {
 			break
@@ -138,7 +143,16 @@ func (dict *DictType) hasKey(target any) (ok bool) {
 	return
 }
 
-func (dict *DictType) clone() (c *DictType) {
+func (dict *DictType) SetItem(key any, value any) {
+	(*dict)[key] = value
+}
+
+func (dict *DictType) GetItem(key any) (value any, exists bool) {
+	value, exists = (*dict)[key]
+	return
+}
+
+func (dict *DictType) Clone() (c *DictType) {
 	c = newDict(nil)
 	for k, v := range *dict {
 		(*c)[k] = v
@@ -146,7 +160,7 @@ func (dict *DictType) clone() (c *DictType) {
 	return
 }
 
-func (dict *DictType) merge(second *DictType) {
+func (dict *DictType) Merge(second *DictType) {
 	if second != nil {
 		for k, v := range *second {
 			(*dict)[k] = v
@@ -154,8 +168,21 @@ func (dict *DictType) merge(second *DictType) {
 	}
 }
 
-func (dict *DictType) setItem(key any, value any) (err error) {
+func (dict *DictType) Equals(dict2 DictType) (answer bool) {
-	(*dict)[key] = value
+	if dict2 != nil && len(*dict) == len(dict2) {
+		answer = true
+		for key, value1 := range *dict {
+			if value2, exists := dict2.GetItem(key); exists {
+				if !Equal(value1, value2) {
+					answer = false
+					break
+				}
+			} else {
+				answer = false
+				break
+			}
+		}
+	}
 	return
 }
 

kern/expr-context.go

@@ -2,13 +2,14 @@
 // All rights reserved.
 
 // expr-context.go
-package expr
+package kern
 
 // ----Expression Context
 type ExprContext interface {
 	Clone() ExprContext
 	SetParent(ctx ExprContext)
 	GetParent() (ctx ExprContext)
+	GetGlobal() (ctx ExprContext)
 	GetVar(varName string) (value any, exists bool)
 	GetLast() any
 	SetVar(varName string, value any)
@@ -22,6 +23,7 @@ type ExprContext interface {
 	FuncCount() int
 	DeleteFunc(funcName string)
 
+	GetLocalFuncInfo(name string) (info ExprFunc, exists bool)
 	GetFuncInfo(name string) (item ExprFunc, exists bool)
 	Call(name string, args map[string]any) (result any, err error)
 	RegisterFuncInfo(info ExprFunc)

kern/expr-function.go

@@ -2,7 +2,7 @@
 // All rights reserved.
 
 // expr-function.go
-package expr
+package kern
 
 // ---- Functor interface
 type Functor interface {

kern/float.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// float.go
+package kern
+
+func IsFloat(v any) (ok bool) {
+	_, ok = v.(float64)
+	return ok
+}
+
+func AnyFloat(v any) (float float64, ok bool) {
+	ok = true
+	switch floatval := v.(type) {
+	case float32:
+		float = float64(floatval)
+	case float64:
+		float = floatval
+	default:
+		ok = false
+	}
+	return
+}

kern/formatter.go

@@ -2,7 +2,7 @@
 // All rights reserved.
 
 // formatter.go
-package expr
+package kern
 
 import "fmt"
 
@@ -46,7 +46,7 @@ type Formatter interface {
 	ToString(options FmtOpt) string
 }
 
-func getFormatted(v any, opt FmtOpt) (text string) {
+func GetFormatted(v any, opt FmtOpt) (text string) {
 	if v == nil {
 		text = "(nil)"
 	} else if s, ok := v.(string); ok {

kern/fraction-type.go

@@ -2,7 +2,7 @@
 // All rights reserved.
 
 // fraction-type.go
-package expr
+package kern
 
 //https://www.youmath.it/lezioni/algebra-elementare/lezioni-di-algebra-e-aritmetica-per-scuole-medie/553-dalle-frazioni-a-numeri-decimali.html
 
@@ -18,12 +18,12 @@ type FractionType struct {
 	num, den int64
 }
 
-func newFraction(num, den int64) *FractionType {
+func NewFraction(num, den int64) *FractionType {
 	num, den = simplifyIntegers(num, den)
 	return &FractionType{num, den}
 }
 
-func float64ToFraction(f float64) (fract *FractionType, err error) {
+func Float64ToFraction(f float64) (fract *FractionType, err error) {
 	var sign string
 	intPart, decPart := math.Modf(f)
 	if decPart < 0.0 {
@@ -33,11 +33,11 @@ func float64ToFraction(f float64) (fract *FractionType, err error) {
 	}
 	dec := fmt.Sprintf("%.12f", decPart)
 	s := fmt.Sprintf("%s%.f%s", sign, intPart, dec[1:])
-	return makeGeneratingFraction(s)
+	return MakeGeneratingFraction(s)
 }
 
 // Based on https://cs.opensource.google/go/go/+/refs/tags/go1.22.3:src/math/big/rat.go;l=39
-func makeGeneratingFraction(s string) (f *FractionType, err error) {
+func MakeGeneratingFraction(s string) (f *FractionType, err error) {
 	var num, den int64
 	var sign int64 = 1
 	var parts []string
@@ -59,7 +59,7 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
 		return
 	}
 	if len(parts) == 1 {
-		f = newFraction(sign*num, 1)
+		f = NewFraction(sign*num, 1)
 	} else if len(parts) == 2 {
 		subParts := strings.SplitN(parts[1], "(", 2)
 		if len(subParts) == 1 {
@@ -76,7 +76,7 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
 				num = num*10 + int64(c-'0')
 				den = den * 10
 			}
-			f = newFraction(sign*num, den)
+			f = NewFraction(sign*num, den)
 		} else if len(subParts) == 2 {
 			sub := num
 			mul := int64(1)
@@ -103,7 +103,7 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
 				den *= mul
 			}
 			num -= sub
-			f = newFraction(sign*num, den)
+			f = NewFraction(sign*num, den)
 		}
 	}
 exit:
@@ -113,7 +113,15 @@ exit:
 	return
 }
 
-func (f *FractionType) toFloat() float64 {
+func (f *FractionType) N() int64 {
+	return f.num
+}
+
+func (f *FractionType) D() int64 {
+	return f.den
+}
+
+func (f *FractionType) ToFloat() float64 {
 	return float64(f.num) / float64(f.den)
 }
 
@@ -168,7 +176,7 @@ func (f *FractionType) TypeName() string {
 // -------- fraction utility functions
 
 // greatest common divider
-func gcd(a, b int64) (g int64) {
+func Gcd(a, b int64) (g int64) {
 	if a < 0 {
 		a = -a
 	}
@@ -189,21 +197,21 @@ func gcd(a, b int64) (g int64) {
 
 // lower common multiple
 func lcm(a, b int64) (l int64) {
-	g := gcd(a, b)
+	g := Gcd(a, b)
 	l = a * b / g
 	return
 }
 
 // Sum two fractions
-func sumFract(f1, f2 *FractionType) (sum *FractionType) {
+func SumFract(f1, f2 *FractionType) (sum *FractionType) {
 	m := lcm(f1.den, f2.den)
-	sum = newFraction(f1.num*(m/f1.den)+f2.num*(m/f2.den), m)
+	sum = NewFraction(f1.num*(m/f1.den)+f2.num*(m/f2.den), m)
 	return
 }
 
 // Multiply two fractions
-func mulFract(f1, f2 *FractionType) (prod *FractionType) {
+func MulFract(f1, f2 *FractionType) (prod *FractionType) {
-	prod = newFraction(f1.num*f2.num, f1.den*f2.den)
+	prod = NewFraction(f1.num*f2.num, f1.den*f2.den)
 	return
 }
 
@@ -212,11 +220,12 @@ func anyToFract(v any) (f *FractionType, err error) {
 	if f, ok = v.(*FractionType); !ok {
 		if n, ok := v.(int64); ok {
 			f = intToFraction(n)
-		}
+		} else if dec, ok := v.(float64); ok {
-	}
+			f, err = Float64ToFraction(dec)
-	if f == nil {
+		} else {
 			err = ErrExpectedGot("fract", TypeFraction, v)
 		}
+	}
 	return
 }
 
@@ -230,12 +239,12 @@ func anyPairToFract(v1, v2 any) (f1, f2 *FractionType, err error) {
 	return
 }
 
-func sumAnyFract(af1, af2 any) (sum any, err error) {
+func SumAnyFract(af1, af2 any) (sum any, err error) {
 	var f1, f2 *FractionType
 	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
 		return
 	}
-	f := sumFract(f1, f2)
+	f := SumFract(f1, f2)
 	if f.num == 0 {
 		sum = 0
 	} else {
@@ -250,7 +259,7 @@ func sumAnyFract(af1, af2 any) (sum any, err error) {
 //		 =0 if af1 == af2
 //		 >0 if af1 > af2
 //	 err if af1 or af2 is not convertible to fraction
-func cmpAnyFract(af1, af2 any) (result int, err error) {
+func CmpAnyFract(af1, af2 any) (result int, err error) {
 	var f1, f2 *FractionType
 	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
 		return
@@ -265,8 +274,9 @@ func cmpAnyFract(af1, af2 any) (result int, err error) {
 //	=0 if af1 == af2
 //	>0 if af1 > af2
 func cmpFract(f1, f2 *FractionType) (result int) {
+	if f1 != nil && f2 != nil {
 		f2.num = -f2.num
-	f := sumFract(f1, f2)
+		f := SumFract(f1, f2)
 		if f.num < 0 {
 			result = -1
 		} else if f.num > 0 {
@@ -274,16 +284,17 @@ func cmpFract(f1, f2 *FractionType) (result int) {
 		} else {
 			result = 0
 		}
+	}
 	return
 }
 
-func subAnyFract(af1, af2 any) (sum any, err error) {
+func SubAnyFract(af1, af2 any) (sum any, err error) {
 	var f1, f2 *FractionType
 	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
 		return
 	}
 	f2.num = -f2.num
-	f := sumFract(f1, f2)
+	f := SumFract(f1, f2)
 	if f.num == 0 {
 		sum = 0
 	} else {
@@ -292,7 +303,7 @@ func subAnyFract(af1, af2 any) (sum any, err error) {
 	return
 }
 
-func mulAnyFract(af1, af2 any) (prod any, err error) {
+func MulAnyFract(af1, af2 any) (prod any, err error) {
 	var f1, f2 *FractionType
 	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
 		return
@@ -306,7 +317,7 @@ func mulAnyFract(af1, af2 any) (prod any, err error) {
 	return
 }
 
-func divAnyFract(af1, af2 any) (quot any, err error) {
+func DivAnyFract(af1, af2 any) (quot any, err error) {
 	var f1, f2 *FractionType
 	if f1, f2, err = anyPairToFract(af1, af2); err != nil {
 		return
@@ -345,7 +356,7 @@ func simplifyIntegers(num, den int64) (a, b int64) {
 		den = -den
 		num = -num
 	}
-	g := gcd(num, den)
+	g := Gcd(num, den)
 	a = num / g
 	b = den / g
 	return
@@ -355,7 +366,19 @@ func intToFraction(n int64) *FractionType {
 	return &FractionType{n, 1}
 }
 
-func isFraction(v any) (ok bool) {
+func IsFraction(v any) (ok bool) {
 	_, ok = v.(*FractionType)
 	return ok
 }
+
+// func IsFract(v any) (ok bool) {
+// 	_, ok = v.(*FractionType)
+// 	return ok
+// }
+
+func IsRational(v any) (ok bool) {
+	if _, ok = v.(*FractionType); !ok {
+		_, ok = v.(int64)
+	}
+	return ok
+}

kern/function.go

@@ -0,0 +1,278 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// function.go
+package kern
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// ---- Function templates
+type FuncTemplate func(ctx ExprContext, name string, args map[string]any) (result any, err error)
+
+type DeepFuncTemplate func(a, b any) (eq bool, err error)
+
+func IsFunctor(v any) (ok bool) {
+	_, ok = v.(Functor)
+	return
+}
+
+// ---- Common functor definition
+type BaseFunctor struct {
+	info ExprFunc
+}
+
+func (functor *BaseFunctor) ToString(opt FmtOpt) (s string) {
+	if functor.info != nil {
+		s = functor.info.ToString(opt)
+	} else {
+		s = "func(){}"
+	}
+	return s
+}
+
+func (functor *BaseFunctor) GetParams() (params []ExprFuncParam) {
+	if functor.info != nil {
+		return functor.info.Params()
+	} else {
+		return []ExprFuncParam{}
+	}
+}
+
+func (functor *BaseFunctor) SetFunc(info ExprFunc) {
+	functor.info = info
+}
+
+func (functor *BaseFunctor) GetFunc() ExprFunc {
+	return functor.info
+}
+
+func (functor *BaseFunctor) GetDefinitionContext() ExprContext {
+	return nil
+}
+
+// ---- Function Parameters
+type paramFlags uint16
+
+const (
+	PfDefault paramFlags = 1 << iota
+	PfOptional
+	PfRepeat
+)
+
+type funcParamInfo struct {
+	name         string
+	flags        paramFlags
+	defaultValue any
+}
+
+func NewFuncParam(name string) ExprFuncParam {
+	return &funcParamInfo{name: name}
+}
+
+func NewFuncParamFlag(name string, flags paramFlags) ExprFuncParam {
+	return &funcParamInfo{name: name, flags: flags}
+}
+
+func NewFuncParamFlagDef(name string, flags paramFlags, defValue any) *funcParamInfo {
+	return &funcParamInfo{name: name, flags: flags, defaultValue: defValue}
+}
+
+func (param *funcParamInfo) Name() string {
+	return param.name
+}
+
+func (param *funcParamInfo) Type() string {
+	return TypeAny
+}
+
+func (param *funcParamInfo) IsDefault() bool {
+	return (param.flags & PfDefault) != 0
+}
+
+func (param *funcParamInfo) IsOptional() bool {
+	return (param.flags & PfOptional) != 0
+}
+
+func (param *funcParamInfo) IsRepeat() bool {
+	return (param.flags & PfRepeat) != 0
+}
+
+func (param *funcParamInfo) DefaultValue() any {
+	return param.defaultValue
+}
+
+func initActualParams(ctx ExprContext, info ExprFunc, callTerm Term) (actualParams map[string]any, err error) {
+	var varArgs []any
+	var varName string
+
+	namedParamsStarted := false
+
+	formalParams := info.Params()
+	actualParams = make(map[string]any, len(formalParams))
+	if callTerm == nil {
+		return
+	}
+
+	childCount := callTerm.GetChildCount()
+	for i := range childCount {
+		tree := callTerm.GetChild(i)
+		// for i, tree := range callTerm.Children() {
+		var paramValue any
+		paramCtx := ctx.Clone()
+		if paramValue, err = tree.Compute(paramCtx); err != nil {
+			break
+		}
+		if paramName, namedParam := GetAssignVarName(tree); namedParam {
+			if info.ParamSpec(paramName) == nil {
+				err = fmt.Errorf("%s(): unknown param %q", info.Name(), paramName)
+				break
+			}
+			actualParams[paramName] = paramValue
+			namedParamsStarted = true
+		} else if !namedParamsStarted {
+			if varArgs != nil {
+				varArgs = append(varArgs, paramValue)
+			} else if i < len(formalParams) {
+				spec := formalParams[i]
+				if spec.IsRepeat() {
+					varArgs = make([]any, 0, childCount-i)
+					varArgs = append(varArgs, paramValue)
+					varName = spec.Name()
+				} else {
+					actualParams[spec.Name()] = paramValue
+				}
+			} else {
+				err = ErrTooManyParams(info.Name(), len(formalParams), childCount)
+				break
+			}
+		} else {
+			err = fmt.Errorf("%s(): positional param nr %d not allowed after named params", info.Name(), i+1)
+			break
+		}
+	}
+	if err == nil {
+		if varArgs != nil {
+			actualParams[varName] = varArgs
+		}
+	}
+	return
+}
+
+// func (info *funcInfo) PrepareCall(name string, actualParams map[string]any) (err error) {
+// 	passedCount := len(actualParams)
+// 	if info.MinArgs() > passedCount {
+// 		err = ErrTooFewParams(name, info.MinArgs(), info.MaxArgs(), passedCount)
+// 		return
+// 	}
+
+// 	if passedCount < len(info.formalParams) {
+// 		for _, p := range info.formalParams {
+// 			if _, exists := actualParams[p.Name()]; !exists {
+// 				if !p.IsDefault() {
+// 					break
+// 				}
+// 				if p.IsRepeat() {
+// 					varArgs := make([]any, 1)
+// 					varArgs[0] = p.DefaultValue()
+// 					actualParams[p.Name()] = varArgs
+// 				} else {
+// 					actualParams[p.Name()] = p.DefaultValue()
+// 				}
+// 			}
+// 		}
+// 	}
+
+// 	if info.MaxArgs() >= 0 && info.MaxArgs() < len(actualParams) {
+// 		err = ErrTooManyParams(name, info.MaxArgs(), len(actualParams))
+// 	}
+// 	return
+// }
+
+// ----- Call a function ---
+
+// func getAssignVarName(t *term) (name string, ok bool) {
+// 	if ok = t.symbol() == SymEqual; ok {
+// 		name = t.children[0].source()
+// 	}
+// 	return
+// }
+
+func GetAssignVarName(t Term) (name string, ok bool) {
+	if ok = t.IsAssign(); ok {
+		name = t.GetChildSource(0)
+	}
+	return
+}
+
+func CallFunctionByTerm(parentCtx ExprContext, name string, callTerm Term) (result any, err error) {
+	var actualParams map[string]any
+	if info, exists := parentCtx.GetFuncInfo(name); exists {
+		if actualParams, err = initActualParams(parentCtx, info, callTerm); err == nil {
+			ctx := info.AllocContext(parentCtx)
+			if err = info.PrepareCall(name, actualParams); err == nil {
+				functor := info.Functor()
+				result, err = functor.InvokeNamed(ctx, name, actualParams)
+				exportObjectsToParent(ctx)
+			}
+		}
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}
+
+func CallFunctionByArgs(parentCtx ExprContext, name string, args []any) (result any, err error) {
+	var actualParams map[string]any
+	if info, exists := parentCtx.GetFuncInfo(name); exists {
+		functor := info.Functor()
+		actualParams = BindActualParams(functor, args)
+		ctx := info.AllocContext(parentCtx)
+		if err = info.PrepareCall(name, actualParams); err == nil {
+			result, err = functor.InvokeNamed(ctx, name, actualParams)
+			exportObjectsToParent(ctx)
+		}
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}
+
+func CallFunctionByParams(parentCtx ExprContext, name string, actualParams map[string]any) (result any, err error) {
+	//var actualParams map[string]any
+	if info, exists := parentCtx.GetFuncInfo(name); exists {
+		functor := info.Functor()
+		ctx := info.AllocContext(parentCtx)
+		if err = info.PrepareCall(name, actualParams); err == nil {
+			result, err = functor.InvokeNamed(ctx, name, actualParams)
+			exportObjectsToParent(ctx)
+		}
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}
+
+func GetParam(args map[string]any, paramName string, paramNum int) (value any, exists bool) {
+	if value, exists = args[paramName]; !exists {
+		if paramNum > 0 && paramNum <= len(args) {
+			value, exists = args["arg"+strconv.Itoa(paramNum)]
+		}
+	}
+	return
+}
+
+func BindActualParams(functor Functor, args []any) (actualParams map[string]any) {
+	formalParams := functor.GetParams()
+	actualParams = make(map[string]any, len(args))
+	for i, arg := range args {
+		if i < len(formalParams) {
+			actualParams[formalParams[i].Name()] = arg
+		} else {
+			actualParams["arg"+strconv.Itoa(i+1)] = arg
+		}
+	}
+	return
+}

kern/iterator.go

@@ -2,7 +2,7 @@
 // All rights reserved.
 
 // iterator.go
-package expr
+package kern
 
 import (
 	// "errors"
@@ -21,28 +21,32 @@ const (
 	CountName   = "count"
 	FilterName  = "filter"
 	MapName     = "map"
+	KeyName     = "key"
+	ValueName   = "value"
 )
 
 type Iterator interface {
 	Typer
+	fmt.Stringer
 	Next() (item any, err error) // must return io.EOF after the last item
 	Current() (item any, err error)
-	Index() int
+	Index() int64
-	Count() int
+	Count() int64
+	HasOperation(name string) bool
+	CallOperation(name string, args map[string]any) (value any, err error)
 }
 
 type ExtIterator interface {
 	Iterator
 	Reset() error
 	Clean() error
-	HasOperation(name string) bool
-	CallOperation(name string, args map[string]any) (value any, err error)
 }
 
-func errNoOperation(name string) error {
+func ErrNoOperation(name string) error {
 	return fmt.Errorf("no %s() function defined in the data-source", name)
 }
 
-// func errInvalidDataSource() error {
+func IsIterator(v any) (ok bool) {
-// 	return errors.New("invalid data-source")
+	_, ok = v.(Iterator)
-// }
+	return
+}

kern/list-type.go

@@ -2,7 +2,7 @@
 // All rights reserved.
 
 // list-type.go
-package expr
+package kern
 
 import (
 	"fmt"
@@ -12,23 +12,21 @@ import (
 
 type ListType []any
 
-func newListA(listAny ...any) (list *ListType) {
+func IsList(v any) (ok bool) {
+	_, ok = v.(*ListType)
+	return ok
+}
+
+func NewListA(listAny ...any) (list *ListType) {
 	if listAny == nil {
 		listAny = []any{}
 	}
-	return newList(listAny)
-}
-
-func newList(listAny []any) (list *ListType) {
 	return NewList(listAny)
 }
 
 func NewList(listAny []any) (list *ListType) {
 	if listAny != nil {
 		ls := make(ListType, len(listAny))
-//		for i, item := range listAny {
-//			ls[i] = item
-//		}
 		copy(ls, listAny)
 		list = &ls
 	}
@@ -52,13 +50,13 @@ func ListFromStrings(stringList []string) (list *ListType) {
 	return
 }
 
-func (ls *ListType) ToString(opt FmtOpt) (s string) {
+func (dict *ListType) ToString(opt FmtOpt) (s string) {
 	indent := GetFormatIndent(opt)
 	flags := GetFormatFlags(opt)
 
 	var sb strings.Builder
 	sb.WriteByte('[')
-	if len(*ls) > 0 {
+	if len(*dict) > 0 {
 		innerOpt := MakeFormatOptions(flags, indent+1)
 		nest := strings.Repeat("  ", indent+1)
 
@@ -66,7 +64,7 @@ func (ls *ListType) ToString(opt FmtOpt) (s string) {
 			sb.WriteByte('\n')
 			sb.WriteString(nest)
 		}
-		for i, item := range []any(*ls) {
+		for i, item := range []any(*dict) {
 			if i > 0 {
 				if flags&MultiLine != 0 {
 					sb.WriteString(",\n")
@@ -98,30 +96,19 @@ func (ls *ListType) ToString(opt FmtOpt) (s string) {
 	return
 }
 
-func (ls *ListType) String() string {
+func (dict *ListType) String() string {
-	return ls.ToString(0)
+	return dict.ToString(0)
 }
 
-func (ls *ListType) TypeName() string {
+func (dict *ListType) TypeName() string {
 	return "list"
 }
 
-// func (list *ListType) indexDeepCmp(target any) (index int) {
+func (dict *ListType) Contains(t *ListType) (answer bool) {
-// 	index = -1
+	if len(*dict) >= len(*t) {
-// 	for i, item := range *list {
-// 		if reflect.DeepEqual(item, target) {
-// 			index = i
-// 			break
-// 		}
-// 	}
-// 	return
-// }
-
-func (ls *ListType) contains(t *ListType) (answer bool) {
-	if len(*ls) >= len(*t) {
 		answer = true
 		for _, item := range *t {
-			if answer = ls.indexDeepSameCmp(item) >= 0; !answer {
+			if answer = dict.IndexDeepSameCmp(item) >= 0; !answer {
 				break
 			}
 		}
@@ -129,12 +116,29 @@ func (ls *ListType) contains(t *ListType) (answer bool) {
 	return
 }
 
-func (list *ListType) indexDeepSameCmp(target any) (index int) {
+func (ls1 *ListType) Equals(ls2 ListType) (answer bool) {
+	if ls2 != nil && len(*ls1) == len(ls2) {
+		answer = true
+		for index, i1 := range *ls1 {
+			// if !reflect.DeepEqual(i1, ls2[index]) {
+			// 	answer = false
+			// 	break
+			// }
+			if !Equal(i1, ls2[index]) {
+				answer = false
+				break
+			}
+		}
+	}
+	return
+}
+
+func (dict *ListType) IndexDeepSameCmp(target any) (index int) {
 	var eq bool
 	var err error
 	index = -1
-	for i, item := range *list {
+	for i, item := range *dict {
-		if eq, err = deepSame(item, target, sameContent); err != nil {
+		if eq, err = deepSame(item, target, SameContent); err != nil {
 			break
 		} else if eq {
 			index = i
@@ -144,13 +148,13 @@ func (list *ListType) indexDeepSameCmp(target any) (index int) {
 	return
 }
 
-func sameContent(a, b any) (same bool, err error) {
+func SameContent(a, b any) (same bool, err error) {
 	la, _ := a.(*ListType)
 	lb, _ := b.(*ListType)
 	if len(*la) == len(*lb) {
 		same = true
 		for _, item := range *la {
-			if pos := lb.indexDeepSameCmp(item); pos < 0 {
+			if pos := lb.IndexDeepSameCmp(item); pos < 0 {
 				same = false
 				break
 			}
@@ -159,19 +163,19 @@ func sameContent(a, b any) (same bool, err error) {
 	return
 }
 
-func deepSame(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
+func deepSame(a, b any, deepCmp DeepFuncTemplate) (eq bool, err error) {
-	if isNumOrFract(a) && isNumOrFract(b) {
+	if IsNumOrFract(a) && IsNumOrFract(b) {
 		if IsNumber(a) && IsNumber(b) {
 			if IsInteger(a) && IsInteger(b) {
 				li, _ := a.(int64)
 				ri, _ := b.(int64)
 				eq = li == ri
 			} else {
-				eq = numAsFloat(a) == numAsFloat(b)
+				eq = NumAsFloat(a) == NumAsFloat(b)
 			}
 		} else {
 			var cmp int
-			if cmp, err = cmpAnyFract(a, b); err == nil {
+			if cmp, err = CmpAnyFract(a, b); err == nil {
 				eq = cmp == 0
 			}
 		}
@@ -184,12 +188,15 @@ func deepSame(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
 	return
 }
 
-func (list *ListType) setItem(index int64, value any) (err error) {
+func (dict *ListType) SetItem(index int64, value any) (err error) {
-	if index >= 0 && index < int64(len(*list)) {
+	if index >= 0 && index < int64(len(*dict)) {
-		(*list)[index] = value
+		(*dict)[index] = value
 	} else {
-		err = fmt.Errorf("index %d out of bounds (0, %d)", index, len(*list)-1)
+		err = fmt.Errorf("index %d out of bounds (0, %d)", index, len(*dict)-1)
 	}
 	return
 }
 
+func (dict *ListType) AppendItem(value any) {
+	*dict = append(*dict, value)
+}

kern/number.go

@@ -0,0 +1,88 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// number.go
+package kern
+
+import (
+	"fmt"
+)
+
+func IsInteger(v any) (ok bool) {
+	_, ok = v.(int64)
+	return ok
+}
+
+func IsNumber(v any) (ok bool) {
+	return IsFloat(v) || IsInteger(v)
+}
+
+func IsNumOrFract(v any) (ok bool) {
+	return IsFloat(v) || IsInteger(v) || IsFraction(v)
+}
+
+func IsNumberString(v any) (ok bool) {
+	return IsString(v) || IsNumber(v)
+}
+
+func NumAsFloat(v any) (f float64) {
+	var ok bool
+	if f, ok = v.(float64); !ok {
+		if fract, ok := v.(*FractionType); ok {
+			f = fract.ToFloat()
+		} else {
+			i, _ := v.(int64)
+			f = float64(i)
+		}
+	}
+	return
+}
+
+func AnyInteger(v any) (i int64, ok bool) {
+	ok = true
+	switch intval := v.(type) {
+	case int:
+		i = int64(intval)
+	case uint8:
+		i = int64(intval)
+	case uint16:
+		i = int64(intval)
+	case uint64:
+		i = int64(intval)
+	case uint32:
+		i = int64(intval)
+	case int8:
+		i = int64(intval)
+	case int16:
+		i = int64(intval)
+	case int32:
+		i = int64(intval)
+	case int64:
+		i = intval
+	default:
+		ok = false
+	}
+	return
+}
+
+func ToGoInt(value any, description string) (i int, err error) {
+	if valueInt64, ok := value.(int64); ok {
+		i = int(valueInt64)
+	} else if valueInt, ok := value.(int); ok {
+		i = valueInt
+	} else {
+		err = fmt.Errorf("%s expected integer, got %s (%v)", description, TypeName(value), value)
+	}
+	return
+}
+
+func ToGoInt64(value any, description string) (i int64, err error) {
+	if valueInt64, ok := value.(int64); ok {
+		i = valueInt64
+	} else if valueInt, ok := value.(int); ok {
+		i = int64(valueInt)
+	} else {
+		err = fmt.Errorf("%s expected integer, got %s (%v)", description, TypeName(value), value)
+	}
+	return
+}

kern/string.go

@@ -0,0 +1,23 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// string.go
+package kern
+
+import (
+	"fmt"
+)
+
+func IsString(v any) (ok bool) {
+	_, ok = v.(string)
+	return ok
+}
+
+func ToGoString(value any, description string) (s string, err error) {
+	if s, ok := value.(string); ok {
+		return s, nil
+	} else {
+		err = fmt.Errorf("%s expected string, got %s (%v)", description, TypeName(value), value)
+	}
+	return
+}

kern/term.go

@@ -0,0 +1,21 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// term.go
+package kern
+
+import (
+	"fmt"
+)
+
+type Term interface {
+	fmt.Stringer
+	// Children() []Term
+	Source() string
+	GetChildCount() (count int)
+	GetChild(index int) Term
+	GetChildSource(index int) string
+	Compute(ctx ExprContext) (result any, err error)
+	IsAssign() bool
+	Errorf(template string, args ...any) (err error)
+}

lib-ext-darwin.go

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

lib-ext-linux.go

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

lib-ext-windows.go

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

list-iterator.go

@@ -7,40 +7,43 @@ package expr
 import (
 	"fmt"
 	"io"
+	"slices"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 type ListIterator struct {
-	a     *ListType
+	a     *kern.ListType
-	count int
+	count int64
-	index int
+	index int64
-	start int
+	start int64
-	stop  int
+	stop  int64
-	step  int
+	step  int64
 }
 
-func NewListIterator(list *ListType, args []any) (it *ListIterator) {
+func NewListIterator(list *kern.ListType, args []any) (it *ListIterator) {
 	var argc int = 0
-	listLen := len(([]any)(*list))
+	listLen := int64(len(([]any)(*list)))
 	if args != nil {
 		argc = len(args)
 	}
 	it = &ListIterator{a: list, count: 0, index: -1, start: 0, stop: listLen - 1, step: 1}
 	if argc >= 1 {
-		if i, err := ToGoInt(args[0], "start index"); err == nil {
+		if i, err := kern.ToGoInt64(args[0], "start index"); err == nil {
 			if i < 0 {
 				i = listLen + i
 			}
 			it.start = i
 		}
 		if argc >= 2 {
-			if i, err := ToGoInt(args[1], "stop index"); err == nil {
+			if i, err := kern.ToGoInt64(args[1], "stop index"); err == nil {
 				if i < 0 {
 					i = listLen + i
 				}
 				it.stop = i
 			}
 			if argc >= 3 {
-				if i, err := ToGoInt(args[2], "step"); err == nil {
+				if i, err := kern.ToGoInt64(args[2], "step"); err == nil {
 					if i < 0 {
 						i = -i
 					}
@@ -58,31 +61,16 @@ func NewListIterator(list *ListType, args []any) (it *ListIterator) {
 }
 
 func NewArrayIterator(array []any) (it *ListIterator) {
-	it = &ListIterator{a: (*ListType)(&array), count: 0, index: -1, start: 0, stop: len(array) - 1, step: 1}
+	it = &ListIterator{a: (*kern.ListType)(&array), count: 0, index: -1, start: 0, stop: int64(len(array)) - 1, step: 1}
-	return
-}
-
-func NewAnyIterator(value any) (it *ListIterator) {
-	if value == nil {
-		it = NewArrayIterator([]any{})
-	} else if list, ok := value.(*ListType); ok {
-		it = NewListIterator(list, nil)
-	} else if array, ok := value.([]any); ok {
-		it = NewArrayIterator(array)
-	} else if it1, ok := value.(*ListIterator); ok {
-		it = it1
-	} else {
-		it = NewArrayIterator([]any{value})
-	}
 	return
 }
 
 func (it *ListIterator) String() string {
-	var l = 0
+	var l = int64(0)
 	if it.a != nil {
-		l = len(*it.a)
+		l = int64(len(*it.a))
 	}
-	return fmt.Sprintf("$(#%d)", l)
+	return fmt.Sprintf("$([#%d])", l)
 }
 
 func (it *ListIterator) TypeName() string {
@@ -90,26 +78,27 @@ func (it *ListIterator) TypeName() string {
 }
 
 func (it *ListIterator) HasOperation(name string) bool {
-	yes := name == NextName || name == ResetName || name == IndexName || name == CountName || name == CurrentName
+	//yes := name == expr.NextName || name == expr.ResetName || name == expr.IndexName || name == expr.CountName || name == expr.CurrentName
+	yes := slices.Contains([]string{kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName}, name)
 	return yes
 }
 
 func (it *ListIterator) CallOperation(name string, args map[string]any) (v any, err error) {
 	switch name {
-	case NextName:
+	case kern.NextName:
 		v, err = it.Next()
-	case ResetName:
+	case kern.ResetName:
 		err = it.Reset()
-	case CleanName:
+	case kern.CleanName:
 		err = it.Clean()
-	case IndexName:
+	case kern.IndexName:
 		v = int64(it.Index())
-	case CurrentName:
+	case kern.CurrentName:
 		v, err = it.Current()
-	case CountName:
+	case kern.CountName:
 		v = it.count
 	default:
-		err = errNoOperation(name)
+		err = kern.ErrNoOperation(name)
 	}
 	return
 }
@@ -117,13 +106,13 @@ func (it *ListIterator) CallOperation(name string, args map[string]any) (v any,
 func (it *ListIterator) Current() (item any, err error) {
 	a := *(it.a)
 	if it.start <= it.stop {
-		if it.stop < len(a) && it.index >= it.start && it.index <= it.stop {
+		if it.stop < int64(len(a)) && it.index >= it.start && it.index <= it.stop {
 			item = a[it.index]
 		} else {
 			err = io.EOF
 		}
 	} else {
-		if it.start < len(a) && it.index >= it.stop && it.index <= it.start {
+		if it.start < int64(len(a)) && it.index >= it.stop && it.index <= it.start {
 			item = a[it.index]
 		} else {
 			err = io.EOF
@@ -141,20 +130,20 @@ func (it *ListIterator) Next() (item any, err error) {
 	return
 }
 
-func (it *ListIterator) Index() int {
+func (it *ListIterator) Index() int64 {
 	return it.index
 }
 
-func (it *ListIterator) Count() int {
+func (it *ListIterator) Count() int64 {
 	return it.count
 }
 
-func (it *ListIterator) Reset() (error) {
+func (it *ListIterator) Reset() error {
 	it.index = it.start - it.step
 	it.count = 0
 	return nil
 }
 
-func (it *ListIterator) Clean() (error) {
+func (it *ListIterator) Clean() error {
 	return nil
 }

operand-dict.go

@@ -4,6 +4,9 @@
 // operand-dict.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
 
 // -------- dict term
 func newDictTerm(args map[any]*term) *term {
@@ -18,12 +21,12 @@ func newDictTerm(args map[any]*term) *term {
 }
 
 // -------- dict func
-func evalDict(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalDict(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	dict, _ := opTerm.value().(map[any]*term)
-	items := make(DictType, len(dict))
+	items := make(kern.DictType, len(dict))
 	for key, tree := range dict {
 		var param any
-		if param, err = tree.compute(ctx); err != nil {
+		if param, err = tree.Compute(ctx); err != nil {
 			break
 		}
 		items[key] = param

operand-expr.go

@@ -4,11 +4,15 @@
 // operand-expr.go
 package expr
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
 
 // -------- expr term
 func newExprTerm(root *term) *term {
-	tk := NewValueToken(root.tk.row, root.tk.col, SymExpression, root.source(), root)
+	tk := NewValueToken(root.tk.row, root.tk.col, SymExpression, root.Source(), root)
 	return &term{
 		tk:       *tk,
 		parent:   nil,
@@ -20,9 +24,9 @@ func newExprTerm(root *term) *term {
 }
 
 // -------- eval expr
-func evalExpr(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalExpr(ctx kern.ExprContext, opTerm *term) (v any, err error) {
-	if expr, ok := opTerm.value().(*term); ok {
+	if ast, ok := opTerm.value().(*term); ok {
-		v, err = expr.compute(ctx)
+		v, err = ast.Compute(ctx)
 	} else {
 		err = fmt.Errorf("expression expected, got %T", opTerm.value())
 	}

operand-func.go

@@ -6,15 +6,21 @@ package expr
 
 import (
 	"errors"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 // -------- function call term
 func newFuncCallTerm(tk *Token, args []*term) *term {
+	var pos termPosition = posLeaf
+	if len(args) > 0 {
+		pos = posMultifix
+	}
 	return &term{
 		tk:       *tk,
 		parent:   nil,
 		children: args,
-		position: posLeaf,
+		position: pos,
 		priority: priValue,
 		evalFunc: evalFuncCall,
 	}
@@ -38,9 +44,9 @@ func newFuncCallTerm(tk *Token, args []*term) *term {
 // 	return
 // }
 
-func evalFuncCall(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalFuncCall(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	name, _ := opTerm.tk.Value.(string)
-	v, err = CallFunctionByTerm(ctx, name, opTerm)
+	v, err = kern.CallFunctionByTerm(ctx, name, opTerm)
 	return
 }
 
@@ -57,23 +63,23 @@ func newFuncDefTerm(tk *Token, args []*term) *term {
 }
 
 // -------- eval func def
-func evalFuncDef(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalFuncDef(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	bodySpec := opTerm.value()
-	if expr, ok := bodySpec.(*ast); ok {
+	if ast, ok := bodySpec.(*ast); ok {
-		paramList := make([]ExprFuncParam, 0, len(opTerm.children))
+		paramList := make([]kern.ExprFuncParam, 0, len(opTerm.children))
 		for _, param := range opTerm.children {
 			var defValue any
 			flags := paramFlags(0)
 			if len(param.children) > 0 {
 				flags |= PfDefault
-				if defValue, err = param.children[0].compute(ctx); err != nil {
+				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)
+		v = newExprFunctor(ast, paramList, ctx)
 	} else {
 		err = errors.New("invalid function definition: the body specification must be an expression")
 	}

operand-iterator.go

@@ -7,6 +7,8 @@ package expr
 import (
 	"slices"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 // -------- iterator term
@@ -25,11 +27,11 @@ func newIteratorTerm(tk *Token, args []*term) *term {
 
 // -------- eval iterator
 
-func evalTermArray(ctx ExprContext, terms []*term) (values []any, err error) {
+func evalTermArray(ctx kern.ExprContext, terms []*term) (values []any, err error) {
 	values = make([]any, len(terms))
 	for i, t := range terms {
 		var value any
-		if value, err = t.compute(ctx); err == nil {
+		if value, err = t.Compute(ctx); err == nil {
 			values[i] = value
 		} else {
 			break
@@ -38,25 +40,25 @@ func evalTermArray(ctx ExprContext, terms []*term) (values []any, err error) {
 	return
 }
 
-func evalFirstChild(ctx ExprContext, iteratorTerm *term) (value any, err error) {
+func evalFirstChild(ctx kern.ExprContext, iteratorTerm *term) (value any, err error) {
 	if len(iteratorTerm.children) < 1 || iteratorTerm.children[0] == nil {
 		err = iteratorTerm.Errorf("missing the data-source parameter")
 		return
 	}
 
-	value, err = iteratorTerm.children[0].compute(ctx)
+	value, err = iteratorTerm.children[0].Compute(ctx)
 	return
 }
 
-func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]Functor, err error) {
+func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]kern.Functor, err error) {
-	if dictAny, ok := firstChildValue.(*DictType); ok {
+	if dictAny, ok := firstChildValue.(*kern.DictType); ok {
-		requiredFields := []string{NextName}
+		requiredFields := []string{kern.NextName}
 		fieldsMask := 0b1
 		foundFields := 0
-		ds = make(map[string]Functor)
+		ds = make(map[string]kern.Functor)
 		for keyAny, item := range *dictAny {
 			if key, ok := keyAny.(string); ok {
-				if functor, ok := item.(Functor); ok {
+				if functor, ok := item.(kern.Functor); ok {
 					ds[key] = functor
 					if index := slices.Index(requiredFields, key); index >= 0 {
 						foundFields |= 1 << index
@@ -78,22 +80,24 @@ func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]F
 	return
 }
 
-func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalIterator(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var firstChildValue any
-	var ds map[string]Functor
+	var ds map[string]kern.Functor
 
 	if firstChildValue, err = evalFirstChild(ctx, opTerm); err != nil {
 		return
 	}
 
-	if ds, err = getDataSourceDict(opTerm, firstChildValue); err != nil {
+	if ds, err = getDataSourceDict(opTerm, firstChildValue); err != nil && ds == nil {
 		return
 	}
+	err = nil
 
 	if ds != nil {
+		if len(ds) > 0 {
 			var dc *dataCursor
 			dcCtx := ctx.Clone()
-		if initFunc, exists := ds[InitName]; exists && initFunc != nil {
+			if initFunc, exists := ds[kern.InitName]; exists && initFunc != nil {
 				var args []any
 				var resource any
 				if len(opTerm.children) > 1 {
@@ -104,24 +108,39 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
 					args = []any{}
 				}
 
-			actualParams := bindActualParams(initFunc, args)
+				actualParams := kern.BindActualParams(initFunc, args)
 
 				initCtx := ctx.Clone()
-			if resource, err = initFunc.InvokeNamed(initCtx, InitName, actualParams); err != nil {
+				if resource, err = initFunc.InvokeNamed(initCtx, kern.InitName, actualParams); err != nil {
 					return
 				}
-			exportObjects(dcCtx, initCtx)
+				kern.ExportObjects(dcCtx, initCtx)
 				dc = NewDataCursor(dcCtx, ds, resource)
 			} else {
 				dc = NewDataCursor(dcCtx, ds, nil)
 			}
 
 			v = dc
-	} else if list, ok := firstChildValue.(*ListType); ok {
+		} else {
+			if dictIt, ok := firstChildValue.(*kern.DictType); ok {
+				var args []any
+				if args, err = evalSibling(ctx, opTerm.children, nil); err == nil {
+					v, err = NewDictIterator(dictIt, args)
+				}
+			} else {
+				err = opTerm.children[0].Errorf("the data-source must be a dictionary")
+			}
+		}
+	} else if list, ok := firstChildValue.(*kern.ListType); ok {
 		var args []any
 		if args, err = evalSibling(ctx, opTerm.children, nil); err == nil {
 			v = NewListIterator(list, args)
 		}
+	} else if intVal, ok := firstChildValue.(int64); ok {
+		var args []any
+		if args, err = evalSibling(ctx, opTerm.children, intVal); err == nil {
+			v, err = NewIntIterator(args)
+		}
 	} else {
 		var list []any
 		if list, err = evalSibling(ctx, opTerm.children, firstChildValue); err == nil {
@@ -131,7 +150,7 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
 	return
 }
 
-func evalSibling(ctx ExprContext, terms []*term, firstChildValue any) (list []any, err error) {
+func evalSibling(ctx kern.ExprContext, terms []*term, firstChildValue any) (list []any, err error) {
 	items := make([]any, 0, len(terms))
 	for i, tree := range terms {
 		var param any
@@ -140,7 +159,7 @@ func evalSibling(ctx ExprContext, terms []*term, firstChildValue any) (list []an
 				continue
 			}
 			param = firstChildValue
-		} else if param, err = tree.compute(ctx); err != nil {
+		} else if param, err = tree.Compute(ctx); err != nil {
 			break
 		}
 		items = append(items, param)

operand-list.go

@@ -4,6 +4,10 @@
 // operand-list.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 // -------- list term
 func newListTermA(args ...*term) *term {
 	return newListTerm(0, 0, args)
@@ -21,12 +25,12 @@ func newListTerm(row, col int, args []*term) *term {
 }
 
 // -------- list func
-func evalList(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalList(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	list, _ := opTerm.value().([]*term)
-	items := make(ListType, len(list))
+	items := make(kern.ListType, len(list))
 	for i, tree := range list {
 		var param any
-		if param, err = tree.compute(ctx); err != nil {
+		if param, err = tree.Compute(ctx); err != nil {
 			break
 		}
 		items[i] = param

operand-literal.go

@@ -4,6 +4,10 @@
 // operand-literal.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 // -------- literal term
 func newLiteralTerm(tk *Token) *term {
 	return &term{
@@ -17,7 +21,7 @@ func newLiteralTerm(tk *Token) *term {
 }
 
 // -------- eval func
-func evalLiteral(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalLiteral(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	v = opTerm.tk.Value
 	return
 }

operand-selector-case.go

@@ -7,6 +7,8 @@ package expr
 import (
 	"fmt"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 // -------- selector case term
@@ -41,7 +43,7 @@ func newSelectorCaseTerm(row, col int, filterList *term, caseExpr Expr) *term {
 }
 
 // -------- eval selector case
-func evalSelectorCase(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalSelectorCase(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var ok bool
 	if v, ok = opTerm.value().(*selectorCase); !ok {
 		err = fmt.Errorf("selector-case expected, got %T", opTerm.value())

operand-var.go

@@ -4,7 +4,11 @@
 // operand-var.go
 package expr
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
 
 // -------- variable term
 func newVarTerm(tk *Token) *term {
@@ -21,11 +25,11 @@ func newVarTerm(tk *Token) *term {
 }
 
 // -------- eval func
-func evalVar(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalVar(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var exists bool
-	name := opTerm.source()
+	name := opTerm.Source()
-	if v, exists = GetVar(ctx, name); !exists {
+	if v, exists = ctx.GetVar(name); !exists {
-		if info, exists := GetFuncInfo(ctx, name); exists {
+		if info, exists := ctx.GetFuncInfo(name); exists {
 			v = info.Functor()
 		} else {
 			err = fmt.Errorf("undefined variable or function %q", name)

operator-assign.go

@@ -4,6 +4,11 @@
 // operator-assign.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+	"git.portale-stac.it/go-pkg/expr/util"
+)
+
 //-------- assign term
 
 func newAssignTerm(tk *Token) (inst *term) {
@@ -16,19 +21,19 @@ func newAssignTerm(tk *Token) (inst *term) {
 	}
 }
 
-func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, value any) (err error) {
+func assignCollectionItem(ctx kern.ExprContext, collectionTerm, keyListTerm *term, value any) (err error) {
 	var collectionValue, keyListValue, keyValue any
-	var keyList *ListType
+	var keyList *kern.ListType
 	var ok bool
 
-	if collectionValue, err = collectionTerm.compute(ctx); err != nil {
+	if collectionValue, err = collectionTerm.Compute(ctx); err != nil {
 		return
 	}
 
-	if keyListValue, err = keyListTerm.compute(ctx); err != nil {
+	if keyListValue, err = keyListTerm.Compute(ctx); err != nil {
 		return
-	} else if keyList, ok = keyListValue.(*ListType); !ok || len(*keyList) != 1 {
+	} else if keyList, ok = keyListValue.(*kern.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, kern.TypeName(keyListValue))
 		return
 	}
 	if keyValue = (*keyList)[0]; keyValue == nil {
@@ -37,30 +42,30 @@ func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, va
 	}
 
 	switch collection := collectionValue.(type) {
-	case *ListType:
+	case *kern.ListType:
 		if index, ok := keyValue.(int64); ok {
-			err = collection.setItem(index, value)
+			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, kern.TypeName(keyValue))
 		}
-	case *DictType:
+	case *kern.DictType:
-		err = collection.setItem(keyValue, value)
+		collection.SetItem(keyValue, value)
 	default:
 		err = collectionTerm.Errorf("collection expected")
 	}
 	return
 }
 
-func assignValue(ctx ExprContext, leftTerm *term, v any) (err error) {
+func assignValue(ctx kern.ExprContext, leftTerm *term, v any) (err error) {
 	if leftTerm.symbol() == SymIndex {
 		err = assignCollectionItem(ctx, leftTerm.children[0], leftTerm.children[1], v)
 	} else {
-		ctx.UnsafeSetVar(leftTerm.source(), v)
+		ctx.UnsafeSetVar(leftTerm.Source(), v)
 	}
 	return
 }
 
-func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalAssign(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	if err = opTerm.checkOperands(); err != nil {
 		return
 	}
@@ -74,17 +79,17 @@ func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) {
 
 	rightChild := opTerm.children[1]
 
-	if v, err = rightChild.compute(ctx); err == nil {
+	if v, err = rightChild.Compute(ctx); err == nil {
-		if functor, ok := v.(Functor); ok {
+		if functor, ok := v.(kern.Functor); ok {
 			if leftSym == SymVariable {
 				if info := functor.GetFunc(); info != nil {
-					ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
+					ctx.RegisterFunc(leftTerm.Source(), info.Functor(), info.ReturnType(), info.Params())
 				} else if funcDef, ok := functor.(*exprFunctor); ok {
-					paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })
+					paramSpecs := util.ForAll(funcDef.params, func(p kern.ExprFuncParam) kern.ExprFuncParam { return p })
 
-					ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, paramSpecs)
+					ctx.RegisterFunc(leftTerm.Source(), functor, kern.TypeAny, paramSpecs)
 				} else {
-					err = opTerm.Errorf("unknown function %s()", rightChild.source())
+					err = opTerm.Errorf("unknown function %s()", rightChild.Source())
 				}
 			} else {
 				err = assignValue(ctx, leftTerm, v)
@@ -111,19 +116,19 @@ func newOpAssignTerm(tk *Token) (inst *term) {
 	}
 }
 
-func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term) (value any, err error) {
+func getCollectionItemValue(ctx kern.ExprContext, collectionTerm, keyListTerm *term) (value any, err error) {
 	var collectionValue, keyListValue, keyValue any
-	var keyList *ListType
+	var keyList *kern.ListType
 	var ok bool
 
-	if collectionValue, err = collectionTerm.compute(ctx); err != nil {
+	if collectionValue, err = collectionTerm.Compute(ctx); err != nil {
 		return
 	}
 
-	if keyListValue, err = keyListTerm.compute(ctx); err != nil {
+	if keyListValue, err = keyListTerm.Compute(ctx); err != nil {
 		return
-	} else if keyList, ok = keyListValue.(*ListType); !ok || len(*keyList) != 1 {
+	} else if keyList, ok = keyListValue.(*kern.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, kern.TypeName(keyListValue))
 		return
 	}
 	if keyValue = (*keyList)[0]; keyValue == nil {
@@ -132,13 +137,13 @@ func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term)
 	}
 
 	switch collection := collectionValue.(type) {
-	case *ListType:
+	case *kern.ListType:
 		if index, ok := keyValue.(int64); ok {
 			value = (*collection)[index]
 		} else {
-			err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, TypeName(keyValue))
+			err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, kern.TypeName(keyValue))
 		}
-	case *DictType:
+	case *kern.DictType:
 		value = (*collection)[keyValue]
 	default:
 		err = collectionTerm.Errorf("collection expected")
@@ -146,16 +151,16 @@ func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term)
 	return
 }
 
-func getAssignValue(ctx ExprContext, leftTerm *term) (value any, err error) {
+func getAssignValue(ctx kern.ExprContext, leftTerm *term) (value any, err error) {
 	if leftTerm.symbol() == SymIndex {
 		value, err = getCollectionItemValue(ctx, leftTerm.children[0], leftTerm.children[1])
 	} else {
-		value, _ = ctx.GetVar(leftTerm.source())
+		value, _ = ctx.GetVar(leftTerm.Source())
 	}
 	return
 }
 
-func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalOpAssign(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var rightValue, leftValue any
 	if err = opTerm.checkOperands(); err != nil {
 		return
@@ -170,7 +175,7 @@ func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
 
 	rightChild := opTerm.children[1]
 
-	if rightValue, err = rightChild.compute(ctx); err == nil {
+	if rightValue, err = rightChild.Compute(ctx); err == nil {
 		if leftValue, err = getAssignValue(ctx, leftTerm); err == nil {
 			switch opTerm.symbol() {
 			case SymPlusEqual:
@@ -194,7 +199,7 @@ func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
 			case SymDoubleGreaterEqual:
 				v, err = bitRightShift(opTerm, leftValue, rightValue)
 			default:
-				err = opTerm.Errorf("unsupported assign operator %q", opTerm.source())
+				err = opTerm.Errorf("unsupported assign operator %q", opTerm.Source())
 			}
 			if err == nil {
 				err = assignValue(ctx, leftTerm, v)

operator-bitwise.go

@@ -4,6 +4,10 @@
 // operator-bitwise.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- Bitwise NOT term
 
 func newBitwiseNotTerm(tk *Token) (inst *term) {
@@ -16,18 +20,18 @@ func newBitwiseNotTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalBitwiseNot(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalBitwiseNot(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var value any
 
 	if value, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
-	if IsInteger(value) {
+	if kern.IsInteger(value) {
 		i, _ := value.(int64)
 		v = ^i
 	} else {
-		err = opTerm.errIncompatibleType(value)
+		err = opTerm.errIncompatiblePrefixPostfixType(value)
 	}
 	return
 }
@@ -59,7 +63,7 @@ func bitwiseAnd(opTerm *term, leftValue, rightValue any) (v any, err error) {
 	return
 }
 
-func evalBitwiseAnd(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalBitwiseAnd(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@@ -96,7 +100,7 @@ func bitwiseOr(opTerm *term, leftValue, rightValue any) (v any, err error) {
 	return
 }
 
-func evalBitwiseOr(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalBitwiseOr(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@@ -134,7 +138,7 @@ func bitwiseXor(opTerm *term, leftValue, rightValue any) (v any, err error) {
 	return
 }
 
-func evalBitwiseXor(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalBitwiseXor(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {

operator-bool.go

@@ -4,7 +4,11 @@
 // operator-bool.go
 package expr
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
 
 //-------- NOT term
 
@@ -18,17 +22,17 @@ func newNotTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalNot(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalNot(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var rightValue any
 
 	if rightValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
-	if b, ok := ToBool(rightValue); ok {
+	if b, ok := kern.ToBool(rightValue); ok {
 		v = !b
 	} else {
-		err = opTerm.errIncompatibleType(rightValue)
+		err = opTerm.errIncompatiblePrefixPostfixType(rightValue)
 	}
 	return
 }
@@ -45,8 +49,8 @@ func newAndTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalAnd(ctx ExprContext, self *term) (v any, err error) {
+func evalAnd(ctx kern.ExprContext, self *term) (v any, err error) {
-	if CtrlIsEnabled(ctx, ControlBoolShortcut) {
+	if kern.CtrlIsEnabled(ctx, kern.ControlBoolShortcut) {
 		v, err = evalAndWithShortcut(ctx, self)
 	} else {
 		v, err = evalAndWithoutShortcut(ctx, self)
@@ -54,7 +58,7 @@ func evalAnd(ctx ExprContext, self *term) (v any, err error) {
 	return
 }
 
-func evalAndWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
+func evalAndWithoutShortcut(ctx kern.ExprContext, self *term) (v any, err error) {
 	var leftValue, rightValue any
 	var leftBool, rightBool bool
 	var lok, rok bool
@@ -63,8 +67,8 @@ func evalAndWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	leftBool, lok = ToBool(leftValue)
+	leftBool, lok = kern.ToBool(leftValue)
-	rightBool, rok = ToBool(rightValue)
+	rightBool, rok = kern.ToBool(rightValue)
 
 	if lok && rok {
 		v = leftBool && rightBool
@@ -74,24 +78,25 @@ func evalAndWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
 	return
 }
 
-func evalAndWithShortcut(ctx ExprContext, self *term) (v any, err error) {
+func evalAndWithShortcut(ctx kern.ExprContext, self *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if err = self.checkOperands(); err != nil {
 		return
 	}
 
-	if leftValue, err = self.children[0].compute(ctx); err != nil {
+	if leftValue, err = self.children[0].Compute(ctx); err != nil {
 		return
 	}
 
-	if leftBool, lok := ToBool(leftValue); !lok {
+	if leftBool, lok := kern.ToBool(leftValue); !lok {
-		err = fmt.Errorf("got %s as left operand type of 'AND' operator, it must be bool", TypeName(leftValue))
+		// err = fmt.Errorf("got %s as left operand type of 'AND' operator, it must be bool", expr.TypeName(leftValue))
-		return
+		// return
+		err = self.errIncompatibleType(leftValue, "left")
 	} else if !leftBool {
 		v = false
-	} else if rightValue, err = self.children[1].compute(ctx); err == nil {
+	} else if rightValue, err = self.children[1].Compute(ctx); err == nil {
-		if rightBool, rok := ToBool(rightValue); rok {
+		if rightBool, rok := kern.ToBool(rightValue); rok {
 			v = rightBool
 		} else {
 			err = self.errIncompatibleTypes(leftValue, rightValue)
@@ -112,8 +117,8 @@ func newOrTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalOr(ctx ExprContext, self *term) (v any, err error) {
+func evalOr(ctx kern.ExprContext, self *term) (v any, err error) {
-	if CtrlIsEnabled(ctx, ControlBoolShortcut) {
+	if kern.CtrlIsEnabled(ctx, kern.ControlBoolShortcut) {
 		v, err = evalOrWithShortcut(ctx, self)
 	} else {
 		v, err = evalOrWithoutShortcut(ctx, self)
@@ -121,7 +126,7 @@ func evalOr(ctx ExprContext, self *term) (v any, err error) {
 	return
 }
 
-func evalOrWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
+func evalOrWithoutShortcut(ctx kern.ExprContext, self *term) (v any, err error) {
 	var leftValue, rightValue any
 	var leftBool, rightBool bool
 	var lok, rok bool
@@ -130,8 +135,8 @@ func evalOrWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
 		return
 	}
 
-	leftBool, lok = ToBool(leftValue)
+	leftBool, lok = kern.ToBool(leftValue)
-	rightBool, rok = ToBool(rightValue)
+	rightBool, rok = kern.ToBool(rightValue)
 
 	if lok && rok {
 		v = leftBool || rightBool
@@ -141,24 +146,24 @@ func evalOrWithoutShortcut(ctx ExprContext, self *term) (v any, err error) {
 	return
 }
 
-func evalOrWithShortcut(ctx ExprContext, self *term) (v any, err error) {
+func evalOrWithShortcut(ctx kern.ExprContext, self *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if err = self.checkOperands(); err != nil {
 		return
 	}
 
-	if leftValue, err = self.children[0].compute(ctx); err != nil {
+	if leftValue, err = self.children[0].Compute(ctx); err != nil {
 		return
 	}
 
-	if leftBool, lok := ToBool(leftValue); !lok {
+	if leftBool, lok := kern.ToBool(leftValue); !lok {
-		err = fmt.Errorf("got %s as left operand type of 'OR' operator, it must be bool", TypeName(leftValue))
+		err = fmt.Errorf("got %s as left operand type of 'OR' operator, it must be bool", kern.TypeName(leftValue))
 		return
 	} else if leftBool {
 		v = true
-	} else if rightValue, err = self.children[1].compute(ctx); err == nil {
+	} else if rightValue, err = self.children[1].Compute(ctx); err == nil {
-		if rightBool, rok := ToBool(rightValue); rok {
+		if rightBool, rok := kern.ToBool(rightValue); rok {
 			v = rightBool
 		} else {
 			err = self.errIncompatibleTypes(leftValue, rightValue)

operator-builtin.go

@@ -4,7 +4,11 @@
 // operator-builtin.go
 package expr
 
-import "io"
+import (
+	"io"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
 
 //-------- builtin term
 
@@ -18,7 +22,7 @@ func newBuiltinTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalBuiltin(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalBuiltin(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 
 	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
@@ -26,22 +30,25 @@ func evalBuiltin(ctx ExprContext, opTerm *term) (v any, err error) {
 	}
 
 	count := 0
-	if IsString(childValue) {
+	if kern.IsString(childValue) {
 		module, _ := childValue.(string)
-		count, err = ImportInContextByGlobPattern(module)
+		count, err = ImportInContextByGlobPattern(ctx, module)
 	} else {
 		var moduleSpec any
-		it := NewAnyIterator(childValue)
+		var it kern.Iterator
+		if it, err = NewIterator(childValue); err != nil {
+			return
+		}
 		for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() {
 			if module, ok := moduleSpec.(string); ok {
-				if ImportInContext(module) {
+				if ImportInContext(ctx, module) {
 					count++
 				} else {
 					err = opTerm.Errorf("unknown builtin module %q", module)
 					break
 				}
 			} else {
-				err = opTerm.Errorf("expected string at item nr %d, got %s", it.Index()+1, TypeName(moduleSpec))
+				err = opTerm.Errorf("expected string at item nr %d, got %s", it.Index()+1, kern.TypeName(moduleSpec))
 				break
 			}
 		}

operator-but.go

@@ -4,6 +4,10 @@
 // operator-but.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- but term
 
 func newButTerm(tk *Token) (inst *term) {
@@ -16,7 +20,7 @@ func newButTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalBut(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalBut(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	_, v, err = opTerm.evalInfix(ctx)
 	return
 }

operator-context.go

@@ -4,6 +4,10 @@
 // operator-context-value.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- context term
 
 func newContextTerm(tk *Token) (inst *term) {
@@ -16,14 +20,14 @@ func newContextTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalContextValue(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalContextValue(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 
-	var sourceCtx ExprContext
+	var sourceCtx kern.ExprContext
 	if len(opTerm.children) == 0 {
 		sourceCtx = ctx
-	} else if opTerm.children[0].symbol() == SymVariable && opTerm.children[0].source() == "global" {
+	} else if opTerm.children[0].symbol() == SymVariable && opTerm.children[0].Source() == "global" {
-		sourceCtx = globalCtx
+		sourceCtx = ctx.GetGlobal()
 	} else if childValue, err = opTerm.evalPrefix(ctx); err == nil {
 		if dc, ok := childValue.(*dataCursor); ok {
 			sourceCtx = dc.ctx
@@ -31,9 +35,9 @@ func evalContextValue(ctx ExprContext, opTerm *term) (v any, err error) {
 	}
 
 	if sourceCtx != nil {
-		if formatter, ok := sourceCtx.(DictFormat); ok {
+		if formatter, ok := sourceCtx.(kern.DictFormat); ok {
 			v = formatter.ToDict()
-		} else if formatter, ok := sourceCtx.(Formatter); ok {
+		} else if formatter, ok := sourceCtx.(kern.Formatter); ok {
 			v = formatter.ToString(0)
 		} else {
 			// keys := sourceCtx.EnumVars(func(name string) bool { return name[0] != '_' })
@@ -49,7 +53,7 @@ func evalContextValue(ctx ExprContext, opTerm *term) (v any, err error) {
 			v = d
 		}
 	} else {
-		err = opTerm.errIncompatibleType(childValue)
+		err = opTerm.errIncompatiblePrefixPostfixType(childValue)
 	}
 	return
 }

operator-ctrl.go

@@ -4,6 +4,10 @@
 // operator-ctrl.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- export all term
 
 func newExportAllTerm(tk *Token) (inst *term) {
@@ -16,8 +20,8 @@ func newExportAllTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalExportAll(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalExportAll(ctx kern.ExprContext, opTerm *term) (v any, err error) {
-	CtrlEnable(ctx, control_export_all)
+	CtrlEnable(ctx, kern.ControlExportAll)
 	return
 }
 

operator-default.go

@@ -4,6 +4,10 @@
 // operator-default.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- default term
 
 func newDefaultTerm(tk *Token) (inst *term) {
@@ -16,7 +20,7 @@ func newDefaultTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalDefault(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalDefault(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var rightValue any
 
 	if err = opTerm.checkOperands(); err != nil {
@@ -26,13 +30,13 @@ func evalDefault(ctx ExprContext, opTerm *term) (v any, err error) {
 	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)
+		err = kern.ErrLeftOperandMustBeVariable(leftTerm, opTerm)
 		return
 	}
 
-	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
+	if leftValue, exists := ctx.GetVar(leftTerm.Source()); exists {
 		v = leftValue
-	} else if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
+	} else if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
 		v = rightValue
 	}
 	return
@@ -50,7 +54,7 @@ func newAlternateTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalAlternate(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalAlternate(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var rightValue any
 
 	if err = opTerm.checkOperands(); err != nil {
@@ -60,12 +64,12 @@ func evalAlternate(ctx ExprContext, opTerm *term) (v any, err error) {
 	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)
+		err = kern.ErrLeftOperandMustBeVariable(leftTerm, opTerm)
 		return
 	}
 
-	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists && leftValue != nil {
+	if leftValue, exists := ctx.GetVar(leftTerm.Source()); exists && leftValue != nil {
-		if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
+		if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
 			v = rightValue
 		}
 	} else {
@@ -86,7 +90,7 @@ func newDefaultAssignTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalAssignDefault(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalAssignDefault(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var rightValue any
 
 	if err = opTerm.checkOperands(); err != nil {
@@ -96,21 +100,21 @@ func evalAssignDefault(ctx ExprContext, opTerm *term) (v any, err error) {
 	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)
+		err = kern.ErrLeftOperandMustBeVariable(leftTerm, opTerm)
 		return
 	}
 
-	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
+	if leftValue, exists := ctx.GetVar(leftTerm.Source()); exists {
 		v = leftValue
-	} else if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
+	} else if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
-		if functor, ok := rightValue.(Functor); ok {
+		if functor, ok := rightValue.(kern.Functor); ok {
 			//ctx.RegisterFunc(leftTerm.source(), functor, 0, -1)
-			ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, []ExprFuncParam{
+			ctx.RegisterFunc(leftTerm.Source(), functor, kern.TypeAny, []kern.ExprFuncParam{
-				NewFuncParamFlag(ParamValue, PfDefault|PfRepeat),
+				NewFuncParamFlag(kern.ParamValue, PfDefault|PfRepeat),
 			})
 		} else {
 			v = rightValue
-			ctx.UnsafeSetVar(leftTerm.source(), rightValue)
+			ctx.UnsafeSetVar(leftTerm.Source(), rightValue)
 		}
 	}
 	return

operator-digest.go

@@ -0,0 +1,72 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-digest.go
+package expr
+
+import (
+	"fmt"
+	"io"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
+//-------- digest term
+
+func newDigestTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priIterOp,
+		evalFunc: evalDigest,
+	}
+}
+
+func evalDigest(ctx kern.ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+	var it kern.Iterator
+	var item, lastValue any
+
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
+		return
+	}
+
+	if it, err = NewIterator(leftValue); err != nil {
+		return nil, fmt.Errorf("left operand of DIGEST must be an iterable data-source; got %s", kern.TypeName(leftValue))
+	}
+
+	lastValue = nil
+	for item, err = it.Next(); err == nil; item, err = it.Next() {
+		ctx.SetVar("_", item)
+		ctx.SetVar("__", it.Index())
+		ctx.SetVar("_#", it.Count())
+		if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
+			if rightValue == nil {
+				break
+			} else {
+				lastValue = rightValue
+			}
+		}
+		ctx.DeleteVar("_#")
+		ctx.DeleteVar("__")
+		ctx.DeleteVar("_")
+		if err != nil {
+			break
+		}
+	}
+	if err == io.EOF {
+		err = nil
+	}
+	v = lastValue
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwDigest, newDigestTerm)
+}

operator-dot.go

@@ -4,6 +4,10 @@
 // operator-dot.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 // -------- dot term
 func newDotTerm(tk *Token) (inst *term) {
 	return &term{
@@ -15,22 +19,22 @@ func newDotTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalDot(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalDot(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if err = opTerm.checkOperands(); err != nil {
 		return
 	}
-	if leftValue, err = opTerm.children[0].compute(ctx); err != nil {
+	if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
 		return
 	}
 
 	indexTerm := opTerm.children[1]
 
 	switch unboxedValue := leftValue.(type) {
-	case ExtIterator:
+	case kern.ExtIterator:
 		if indexTerm.symbol() == SymVariable /*|| indexTerm.symbol() == SymString */ {
-			opName := indexTerm.source()
+			opName := indexTerm.Source()
 			if unboxedValue.HasOperation(opName) {
 				v, err = unboxedValue.CallOperation(opName, map[string]any{})
 			} else {
@@ -40,8 +44,24 @@ func evalDot(ctx ExprContext, opTerm *term) (v any, err error) {
 		} else {
 			err = indexTerm.tk.ErrorExpectedGot("identifier")
 		}
+	case *kern.DictType:
+		var ok bool
+		s := opTerm.children[1].symbol()
+		if s == SymVariable || s == SymString {
+			src := opTerm.children[1].Source()
+			if len(src) > 1 && src[0] == '"' && src[len(src)-1] == '"' {
+				src = src[1 : len(src)-1]
+			}
+			if v, ok = unboxedValue.GetItem(src); !ok {
+				err = opTerm.errKeyNotFound(src)
+			}
+		} else if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
+			if v, ok = unboxedValue.GetItem(rightValue); !ok {
+				err = opTerm.errKeyNotFound(rightValue)
+			}
+		}
 	default:
-		if rightValue, err = opTerm.children[1].compute(ctx); err == nil {
+		if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
 			err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 		}
 	}

operator-fact.go

@@ -4,7 +4,11 @@
 // operator-fact.go
 package expr
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
 
 //-------- fact term
 
@@ -18,14 +22,14 @@ func newFactTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalFact(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalFact(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue any
 
 	if leftValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
-	if IsInteger(leftValue) {
+	if kern.IsInteger(leftValue) {
 		if i, _ := leftValue.(int64); i >= 0 {
 			f := int64(1)
 			for k := int64(1); k <= i; k++ {
@@ -36,7 +40,7 @@ func evalFact(ctx ExprContext, opTerm *term) (v any, err error) {
 			err = fmt.Errorf("factorial of a negative integer (%d) is not allowed", i)
 		}
 	} else {
-		err = opTerm.errIncompatibleType(leftValue)
+		err = opTerm.errIncompatiblePrefixPostfixType(leftValue)
 	}
 	return
 }

operator-filter.go

@@ -0,0 +1,74 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-filter.go
+package expr
+
+import (
+	"fmt"
+	"io"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
+//-------- map term
+
+func newFilterTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priIterOp,
+		evalFunc: evalFilter,
+	}
+}
+
+func evalFilter(ctx kern.ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+	var it kern.Iterator
+	var item any
+
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
+		return
+	}
+
+	if it, err = NewIterator(leftValue); err != nil {
+		return nil, fmt.Errorf("left operand of FILTER must be an iterable data-source; got %s", kern.TypeName(leftValue))
+	}
+
+	values := kern.NewListA()
+	for item, err = it.Next(); err == nil; item, err = it.Next() {
+		ctx.SetVar("_", item)
+		ctx.SetVar("__", it.Index())
+		ctx.SetVar("_#", it.Count())
+		if rightValue, err = opTerm.children[1].Compute(ctx); err == nil {
+			if success, valid := kern.ToBool(rightValue); valid {
+				if success {
+					values.AppendItem(item)
+				}
+			} else {
+				err = fmt.Errorf("filter expression must return a boolean or a castable to boolean, got %v [%T]", rightValue, rightValue)
+			}
+		}
+		ctx.DeleteVar("_#")
+		ctx.DeleteVar("__")
+		ctx.DeleteVar("_")
+		if err != nil {
+			break
+		}
+	}
+	if err == io.EOF {
+		err = nil
+	}
+	v = values
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwFilter, newFilterTerm)
+}

operator-fraction.go

@@ -8,6 +8,8 @@ package expr
 
 import (
 	"fmt"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 // -------- fraction term
@@ -23,7 +25,7 @@ func newFractionTerm(tk *Token) *term {
 }
 
 // -------- eval func
-func evalFraction(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalFraction(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var numValue, denValue any
 	var num, den int64
 	var ok bool
@@ -49,16 +51,19 @@ func evalFraction(ctx ExprContext, opTerm *term) (v any, err error) {
 		num = -num
 	}
 	if num != 0 {
-		g := gcd(num, den)
+		if g := kern.Gcd(num, den); g != 1 {
 			num = num / g
 			den = den / g
+		}
 		if den == 1 {
 			v = num
 		} else {
-			v = &FractionType{num, den}
+			// v = &expr.FractionType{num, den}
+			v = kern.NewFraction(num, den)
 		}
 	} else {
-		v = &FractionType{0, den}
+		// v = &FractionType{0, den}
+		v = kern.NewFraction(0, den)
 	}
 	return
 }

operator-groupby.go

@@ -0,0 +1,105 @@
+// Copyright (c) 2024-2026 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-groupby.go
+package expr
+
+import (
+	"fmt"
+	"io"
+	"strconv"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
+//-------- group by term
+
+func newGroupByTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priIterOp,
+		evalFunc: evalGroupBy,
+	}
+}
+
+func evalGroupBy(ctx kern.ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+	var it kern.Iterator
+	var item any
+	var sKey string
+	var keyByIndex bool
+
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
+		return
+	}
+
+	if it, err = NewIterator(leftValue); err != nil {
+		return nil, fmt.Errorf("left operand of MAP must be an iterable data-source; got %s", kern.TypeName(leftValue))
+	}
+
+	rightTk := opTerm.children[1].tk
+	if rightTk.IsSymbol(SymVariable) && rightTk.source == "__" {
+		keyByIndex = true
+	} else if rightValue, err = opTerm.children[1].Compute(ctx); err != nil {
+		return
+	} else if kern.IsString(rightValue) {
+		sKey = rightValue.(string)
+	} else {
+		return nil, fmt.Errorf("right operand of GROUPBY must be a string or identifier '__'; got %s", kern.TypeName(rightValue))
+	}
+
+	values := kern.MakeDict()
+	for item, err = it.Next(); err == nil; item, err = it.Next() {
+		ctx.SetVar("_", item)
+		ctx.SetVar("__", it.Index())
+		ctx.SetVar("_#", it.Count())
+
+		var sItemKey string
+
+		if d, ok := item.(*kern.DictType); ok {
+			if keyByIndex || len(sKey) == 0 {
+				sItemKey = strconv.Itoa(int(it.Index()))
+			} else if d.HasKey(sKey) {
+				if keyValue, exists := d.GetItem(sKey); exists {
+					sItemKey = fmt.Sprintf("%v", keyValue)
+				} else {
+					sItemKey = "_"
+				}
+			} else {
+				sItemKey = "_"
+			}
+		} else {
+			sItemKey = strconv.Itoa(int(it.Index()))
+		}
+
+		var ls *kern.ListType
+		if lsAny, exists := values.GetItem(sItemKey); exists && lsAny != nil {
+			ls = lsAny.(*kern.ListType)
+		}
+		if ls == nil {
+			ls = kern.NewListA()
+		}
+		ls.AppendItem(item)
+		values.SetItem(sItemKey, ls)
+
+		ctx.DeleteVar("_#")
+		ctx.DeleteVar("__")
+		ctx.DeleteVar("_")
+	}
+	if err == io.EOF {
+		err = nil
+	}
+	v = values
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwGroupBy, newGroupByTerm)
+}

operator-in.go

@@ -4,6 +4,10 @@
 // operator-in.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- in term
 
 func newInTerm(tk *Token) (inst *term) {
@@ -21,19 +25,19 @@ func newInTerm(tk *Token) (inst *term) {
 // 	return
 // }
 
-func evalIn(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalIn(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
-	if IsList(rightValue) {
+	if kern.IsList(rightValue) {
-		list, _ := rightValue.(*ListType)
+		list, _ := rightValue.(*kern.ListType)
-		v = list.indexDeepSameCmp(leftValue) >= 0
+		v = list.IndexDeepSameCmp(leftValue) >= 0
-	} else if IsDict(rightValue) {
+	} else if kern.IsDict(rightValue) {
-		dict, _ := rightValue.(*DictType)
+		dict, _ := rightValue.(*kern.DictType)
-		v = dict.hasKey(leftValue)
+		v = dict.HasKey(leftValue)
 	} else {
 		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}

operator-include.go

@@ -4,6 +4,10 @@
 // operator-include.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- include term
 
 func newIncludeTerm(tk *Token) (inst *term) {
@@ -16,7 +20,7 @@ func newIncludeTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalInclude(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalInclude(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 
 	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
@@ -24,8 +28,8 @@ func evalInclude(ctx ExprContext, opTerm *term) (v any, err error) {
 	}
 
 	count := 0
-	if IsList(childValue) {
+	if kern.IsList(childValue) {
-		list, _ := childValue.(*ListType)
+		list, _ := childValue.(*kern.ListType)
 		for i, filePathSpec := range *list {
 			if filePath, ok := filePathSpec.(string); ok {
 				if v, err = EvalFile(ctx, filePath); err == nil {
@@ -39,13 +43,13 @@ func evalInclude(ctx ExprContext, opTerm *term) (v any, err error) {
 				break
 			}
 		}
-	} else if IsString(childValue) {
+	} else if kern.IsString(childValue) {
 		filePath, _ := childValue.(string)
 		if v, err = EvalFile(ctx, filePath); err == nil {
 			count++
 		}
 	} else {
-		err = opTerm.errIncompatibleType(childValue)
+		err = opTerm.errIncompatiblePrefixPostfixType(childValue)
 	}
 	if err != nil {
 		//v = count

operator-index.go

@@ -4,6 +4,10 @@
 // operator-index.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 // -------- index term
 func newIndexTerm(tk *Token) (inst *term) {
 	return &term{
@@ -15,15 +19,15 @@ func newIndexTerm(tk *Token) (inst *term) {
 	}
 }
 
-func verifyKey(indexList *ListType) (index any, err error) {
+func verifyKey(indexList *kern.ListType) (index any, err error) {
 	index = (*indexList)[0]
 	return
 }
 
-func verifyIndex(indexTerm *term, indexList *ListType, maxValue int) (index int, err error) {
+func verifyIndex(indexTerm *term, indexList *kern.ListType, maxValue int) (index int, err error) {
 	var v int
 
-	if v, err = ToGoInt((*indexList)[0], "index expression"); err == nil {
+	if v, err = kern.ToGoInt((*indexList)[0], "index expression"); err == nil {
 		if v < 0 && v >= -maxValue {
 			v = maxValue + v
 		}
@@ -36,11 +40,11 @@ func verifyIndex(indexTerm *term, indexList *ListType, maxValue int) (index int,
 	return
 }
 
-func verifyRange(indexTerm *term, indexList *ListType, maxValue int) (startIndex, endIndex int, err error) {
+func verifyRange(indexTerm *term, indexList *kern.ListType, maxValue int) (startIndex, endIndex int, err error) {
 	v, _ := ((*indexList)[0]).(*intPair)
 	startIndex = v.a
 	endIndex = v.b
-	if endIndex == ConstLastIndex {
+	if endIndex == kern.ConstLastIndex {
 		endIndex = maxValue
 	}
 	if startIndex < 0 && startIndex >= -maxValue {
@@ -59,9 +63,9 @@ func verifyRange(indexTerm *term, indexList *ListType, maxValue int) (startIndex
 	return
 }
 
-func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalIndex(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
-	var indexList *ListType
+	var indexList *kern.ListType
 	var ok bool
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@@ -69,7 +73,7 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
 	}
 
 	indexTerm := opTerm.children[1]
-	if indexList, ok = rightValue.(*ListType); !ok {
+	if indexList, ok = rightValue.(*kern.ListType); !ok {
 		err = opTerm.Errorf("invalid index expression")
 		return
 	} else if len(*indexList) != 1 {
@@ -77,9 +81,9 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
 		return
 	}
 
-	if IsInteger((*indexList)[0]) {
+	if kern.IsInteger((*indexList)[0]) {
 		switch unboxedValue := leftValue.(type) {
-		case *ListType:
+		case *kern.ListType:
 			var index int
 			if index, err = verifyIndex(indexTerm, indexList, len(*unboxedValue)); err == nil {
 				v = (*unboxedValue)[index]
@@ -89,17 +93,17 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
 			if index, err = verifyIndex(indexTerm, indexList, len(unboxedValue)); err == nil {
 				v = string(unboxedValue[index])
 			}
-		case *DictType:
+		case *kern.DictType:
 			v, err = getDictItem(unboxedValue, indexTerm, indexList, rightValue)
 		default:
 			err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 		}
 	} else if isIntPair((*indexList)[0]) {
 		switch unboxedValue := leftValue.(type) {
-		case *ListType:
+		case *kern.ListType:
 			var start, end int
 			if start, end, err = verifyRange(indexTerm, indexList, len(*unboxedValue)); err == nil {
-				sublist := ListType((*unboxedValue)[start:end])
+				sublist := kern.ListType((*unboxedValue)[start:end])
 				v = &sublist
 			}
 		case string:
@@ -110,8 +114,8 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
 		default:
 			err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 		}
-	} else if IsDict(leftValue) {
+	} else if kern.IsDict(leftValue) {
-		d := leftValue.(*DictType)
+		d := leftValue.(*kern.DictType)
 		v, err = getDictItem(d, indexTerm, indexList, rightValue)
 	} else {
 		rightChild := opTerm.children[1]
@@ -120,7 +124,7 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
 	return
 }
 
-func getDictItem(d *DictType, indexTerm *term, indexList *ListType, rightValue any) (v any, err error) {
+func getDictItem(d *kern.DictType, indexTerm *term, indexList *kern.ListType, rightValue any) (v any, err error) {
 	var ok bool
 	var indexValue any
 

operator-insert.go

@@ -4,6 +4,10 @@
 // operator-insert.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- prepend term
 
 func newPrependTerm(tk *Token) (inst *term) {
@@ -26,19 +30,19 @@ func newAppendTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalPrepend(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalPrepend(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
-	if IsList(rightValue) {
+	if kern.IsList(rightValue) {
-		list, _ := rightValue.(*ListType)
+		list, _ := rightValue.(*kern.ListType)
-		newList := append(ListType{leftValue}, *list...)
+		newList := append(kern.ListType{leftValue}, *list...)
 		v = &newList
 		if opTerm.children[1].symbol() == SymVariable {
-			ctx.UnsafeSetVar(opTerm.children[1].source(), v)
+			ctx.UnsafeSetVar(opTerm.children[1].Source(), v)
 		}
 	} else {
 		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
@@ -46,19 +50,19 @@ func evalPrepend(ctx ExprContext, opTerm *term) (v any, err error) {
 	return
 }
 
-func evalAppend(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalAppend(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
-	if IsList(leftValue) {
+	if kern.IsList(leftValue) {
-		list, _ := leftValue.(*ListType)
+		list, _ := leftValue.(*kern.ListType)
 		newList := append(*list, rightValue)
 		v = &newList
 		if opTerm.children[0].symbol() == SymVariable {
-			ctx.UnsafeSetVar(opTerm.children[0].source(), v)
+			ctx.UnsafeSetVar(opTerm.children[0].Source(), v)
 		}
 	} else {
 		err = opTerm.errIncompatibleTypes(leftValue, rightValue)

operator-iter-value.go

@@ -4,6 +4,10 @@
 // operator-iter-value.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- iter value term
 
 func newIterValueTerm(tk *Token) (inst *term) {
@@ -16,17 +20,17 @@ func newIterValueTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalIterValue(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalIterValue(ctx kern.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 {
+	if it, ok := childValue.(kern.Iterator); ok {
 		v, err = it.Current()
 	} else {
-		err = opTerm.errIncompatibleType(childValue)
+		err = opTerm.errIncompatiblePrefixPostfixType(childValue)
 	}
 	return
 }

operator-join.go

@@ -0,0 +1,67 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-join.go
+package expr
+
+import (
+	"fmt"
+	"io"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
+//-------- join term
+
+func newJoinTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priIterOp,
+		evalFunc: evalJoin,
+	}
+}
+
+func evalJoin(ctx kern.ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+	var itLeft, itRight kern.Iterator
+	var item any
+
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
+		return
+	}
+
+	if rightValue, err = opTerm.children[1].Compute(ctx); err != nil {
+		return
+	}
+
+	if itLeft, err = NewIterator(leftValue); err != nil {
+		return nil, fmt.Errorf("left operand of JOIN must be an iterable data-source; got %s", kern.TypeName(leftValue))
+	}
+
+	if itRight, err = NewIterator(rightValue); err != nil {
+		return nil, fmt.Errorf("right operand of JOIN must be an iterable data-source; got %s", kern.TypeName(rightValue))
+	}
+
+	values := kern.NewListA()
+	for _, it := range []kern.Iterator{itLeft, itRight} {
+		for item, err = it.Next(); err == nil; item, err = it.Next() {
+			values.AppendItem(item)
+		}
+	}
+	if err == io.EOF {
+		err = nil
+	}
+	v = values
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwJoin, newJoinTerm)
+}

operator-length.go

@@ -4,6 +4,10 @@
 // operator-length.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- length term
 
 func newLengthTerm(tk *Token) (inst *term) {
@@ -16,23 +20,23 @@ func newLengthTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalLength(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalLength(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 
 	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
-	if IsList(childValue) {
+	if kern.IsList(childValue) {
-		ls, _ := childValue.(*ListType)
+		ls, _ := childValue.(*kern.ListType)
 		v = int64(len(*ls))
-	} else if IsString(childValue) {
+	} else if kern.IsString(childValue) {
 		s, _ := childValue.(string)
 		v = int64(len(s))
-	} else if IsDict(childValue) {
+	} else if kern.IsDict(childValue) {
-		m, _ := childValue.(*DictType)
+		m, _ := childValue.(*kern.DictType)
 		v = int64(len(*m))
-	} else if it, ok := childValue.(Iterator); ok {
+	} else if it, ok := childValue.(kern.Iterator); ok {
 		v = int64(it.Count())
 		// if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(CountName) {
 		// 	count, _ := extIt.CallOperation(CountName, nil)
@@ -41,7 +45,7 @@ func evalLength(ctx ExprContext, opTerm *term) (v any, err error) {
 		// 	v = int64(it.Index() + 1)
 		// }
 	} else {
-		err = opTerm.errIncompatibleType(childValue)
+		err = opTerm.errIncompatiblePrefixPostfixType(childValue)
 	}
 	return
 }

operator-map.go

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

operator-plugin.go

@@ -4,6 +4,10 @@
 // operator-plugin.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- plugin term
 
 func newPluginTerm(tk *Token) (inst *term) {
@@ -16,7 +20,7 @@ func newPluginTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalPlugin(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalPlugin(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 	var count int
 
@@ -24,7 +28,7 @@ func evalPlugin(ctx ExprContext, opTerm *term) (v any, err error) {
 		return
 	}
 
-	if count, err = importPluginFromSearchPath(childValue); err == nil {
+	if count, err = importPluginFromSearchPath(ctx, childValue); err == nil {
 		v = int64(count)
 	}
 	return

operator-post-inc-dec.go

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

operator-post-inc.go

@@ -1,73 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-post-inc.go
-package expr
-
-// -------- post increment term
-
-func newPostIncTerm(tk *Token) *term {
-	return &term{
-		tk:       *tk,
-		parent:   nil,
-		children: make([]*term, 0, 1),
-		position: posPostfix,
-		priority: priIncDec,
-		evalFunc: evalPostInc,
-	}
-}
-
-func evalPostInc(ctx ExprContext, opTerm *term) (v any, err error) {
-	var childValue any
-	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
-		return
-	}
-
-	if it, ok := childValue.(Iterator); ok {
-		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
-}
-
-// -------- post decrement term
-
-func newPostDecTerm(tk *Token) *term {
-	return &term{
-		tk:       *tk,
-		parent:   nil,
-		children: make([]*term, 0, 1),
-		position: posPostfix,
-		priority: priIncDec,
-		evalFunc: evalPostDec,
-	}
-}
-
-func evalPostDec(ctx ExprContext, opTerm *term) (v any, err error) {
-	var childValue any
-	if childValue, err = opTerm.evalPrefix(ctx); err != nil {
-		return
-	}
-
-	/* if it, ok := childValue.(Iterator); ok {
-		v, err = it.Next()
-	} else  */if IsInteger(childValue) && opTerm.children[0].symbol() == SymVariable {
-		v = childValue
-		i, _ := childValue.(int64)
-		ctx.SetVar(opTerm.children[0].source(), i-1)
-	} else {
-		err = opTerm.errIncompatibleType(childValue)
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymDoublePlus, newPostIncTerm)
-	registerTermConstructor(SymDoubleMinus, newPostDecTerm)
-}

operator-pre-inc-dec.go

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

operator-prod.go

@@ -6,6 +6,8 @@ package expr
 
 import (
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 //-------- multiply term
@@ -21,15 +23,15 @@ func newMultiplyTerm(tk *Token) (inst *term) {
 }
 
 func mulValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
-	if IsString(leftValue) && IsInteger(rightValue) {
+	if kern.IsString(leftValue) && kern.IsInteger(rightValue) {
 		s, _ := leftValue.(string)
 		n, _ := rightValue.(int64)
 		v = strings.Repeat(s, int(n))
-	} else if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+	} else if kern.IsNumOrFract(leftValue) && kern.IsNumOrFract(rightValue) {
-		if IsFloat(leftValue) || IsFloat(rightValue) {
+		if kern.IsFloat(leftValue) || kern.IsFloat(rightValue) {
-			v = numAsFloat(leftValue) * numAsFloat(rightValue)
+			v = kern.NumAsFloat(leftValue) * kern.NumAsFloat(rightValue)
-		} else if isFraction(leftValue) || isFraction(rightValue) {
+		} else if kern.IsFraction(leftValue) || kern.IsFraction(rightValue) {
-			v, err = mulAnyFract(leftValue, rightValue)
+			v, err = kern.MulAnyFract(leftValue, rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			rightInt, _ := rightValue.(int64)
@@ -41,7 +43,7 @@ func mulValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
 	return
 }
 
-func evalMultiply(ctx ExprContext, prodTerm *term) (v any, err error) {
+func evalMultiply(ctx kern.ExprContext, prodTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = prodTerm.evalInfix(ctx); err != nil {
@@ -64,16 +66,16 @@ func newDivideTerm(tk *Token) (inst *term) {
 }
 
 func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
-	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+	if kern.IsNumOrFract(leftValue) && kern.IsNumOrFract(rightValue) {
-		if IsFloat(leftValue) || IsFloat(rightValue) {
+		if kern.IsFloat(leftValue) || kern.IsFloat(rightValue) {
-			d := numAsFloat(rightValue)
+			d := kern.NumAsFloat(rightValue)
 			if d == 0.0 {
 				err = opTerm.errDivisionByZero()
 			} else {
-				v = numAsFloat(leftValue) / d
+				v = kern.NumAsFloat(leftValue) / d
 			}
-		} else if isFraction(leftValue) || isFraction(rightValue) {
+		} else if kern.IsFraction(leftValue) || kern.IsFraction(rightValue) {
-			v, err = divAnyFract(leftValue, rightValue)
+			v, err = kern.DivAnyFract(leftValue, rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			if rightInt, _ := rightValue.(int64); rightInt == 0 {
@@ -82,11 +84,11 @@ func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
 				v = leftInt / rightInt
 			}
 		}
-	} else if IsString(leftValue) && IsString(rightValue) {
+	} else if kern.IsString(leftValue) && kern.IsString(rightValue) {
 		source := leftValue.(string)
 		sep := rightValue.(string)
-		v = ListFromStrings(strings.Split(source, sep))
+		v = kern.ListFromStrings(strings.Split(source, sep))
-	} else if IsString(leftValue) && IsInteger(rightValue) {
+	} else if kern.IsString(leftValue) && kern.IsInteger(rightValue) {
 		source := leftValue.(string)
 		partSize := int(rightValue.(int64))
 		if partSize == 0 {
@@ -105,7 +107,7 @@ func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
 			if remainder > 0 {
 				parts = append(parts, source[len(source)-remainder:])
 			}
-			v = newList(parts)
+			v = kern.NewList(parts)
 		}
 	} else {
 		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
@@ -113,7 +115,7 @@ func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
 	return
 }
 
-func evalDivide(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalDivide(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@@ -135,19 +137,19 @@ func newDivideAsFloatTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalDivideAsFloat(ctx ExprContext, floatDivTerm *term) (v any, err error) {
+func evalDivideAsFloat(ctx kern.ExprContext, floatDivTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = floatDivTerm.evalInfix(ctx); err != nil {
 		return
 	}
 
-	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+	if kern.IsNumOrFract(leftValue) && kern.IsNumOrFract(rightValue) {
-		d := numAsFloat(rightValue)
+		d := kern.NumAsFloat(rightValue)
 		if d == 0.0 {
 			err = floatDivTerm.errDivisionByZero()
 		} else {
-			v = numAsFloat(leftValue) / d
+			v = kern.NumAsFloat(leftValue) / d
 		}
 	} else {
 		err = floatDivTerm.errIncompatibleTypes(leftValue, rightValue)
@@ -167,7 +169,7 @@ func newRemainderTerm(tk *Token) (inst *term) {
 	}
 }
 func remainderValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
-	if IsInteger(leftValue) && IsInteger(rightValue) {
+	if kern.IsInteger(leftValue) && kern.IsInteger(rightValue) {
 		rightInt, _ := rightValue.(int64)
 		if rightInt == 0 {
 			err = opTerm.errDivisionByZero()
@@ -181,7 +183,7 @@ func remainderValues(opTerm *term, leftValue, rightValue any) (v any, err error)
 	return
 }
 
-func evalRemainder(ctx ExprContext, remainderTerm *term) (v any, err error) {
+func evalRemainder(ctx kern.ExprContext, remainderTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = remainderTerm.evalInfix(ctx); err != nil {

operator-range.go

@@ -4,7 +4,11 @@
 // operator-range.go
 package expr
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
 
 // -------- range term
 type intPair struct {
@@ -12,10 +16,10 @@ type intPair struct {
 }
 
 func (p *intPair) TypeName() string {
-	return TypePair
+	return kern.TypePair
 }
 
-func (p *intPair) ToString(opt FmtOpt) string {
+func (p *intPair) ToString(opt kern.FmtOpt) string {
 	return fmt.Sprintf("(%d, %d)", p.a, p.b)
 }
 
@@ -41,21 +45,21 @@ func changeColonToRange(t *term) {
 	}
 }
 
-func evalRange(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalRange(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if len(opTerm.children) == 0 {
 		leftValue = int64(0)
 		rightValue = int64(-1)
 	} else if len(opTerm.children) == 1 {
-		if leftValue, err = opTerm.children[0].compute(ctx); err != nil {
+		if leftValue, err = opTerm.children[0].Compute(ctx); err != nil {
 			return
 		}
-		rightValue = int64(ConstLastIndex)
+		rightValue = int64(kern.ConstLastIndex)
 	} else if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
 		return
 	}
-	if !(IsInteger(leftValue) && IsInteger(rightValue)) {
+	if !(kern.IsInteger(leftValue) && kern.IsInteger(rightValue)) {
 		// err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 		err = errRangeInvalidSpecification(opTerm)
 		return

operator-rel.go

@@ -4,7 +4,11 @@
 // operator-rel.go
 package expr
 
-import "reflect"
+import (
+	"reflect"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
 
 //-------- equal term
 
@@ -18,25 +22,25 @@ func newEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-type deepFuncTemplate func(a, b any) (eq bool, err error)
+// type deepFuncTemplate func(a, b any) (eq bool, err error)
 
-func equals(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
+func equals(a, b any, deepCmp kern.DeepFuncTemplate) (eq bool, err error) {
-	if isNumOrFract(a) && isNumOrFract(b) {
+	if kern.IsNumOrFract(a) && kern.IsNumOrFract(b) {
-		if IsNumber(a) && IsNumber(b) {
+		if kern.IsNumber(a) && kern.IsNumber(b) {
-			if IsInteger(a) && IsInteger(b) {
+			if kern.IsInteger(a) && kern.IsInteger(b) {
 				li, _ := a.(int64)
 				ri, _ := b.(int64)
 				eq = li == ri
 			} else {
-				eq = numAsFloat(a) == numAsFloat(b)
+				eq = kern.NumAsFloat(a) == kern.NumAsFloat(b)
 			}
 		} else {
 			var cmp int
-			if cmp, err = cmpAnyFract(a, b); err == nil {
+			if cmp, err = kern.CmpAnyFract(a, b); err == nil {
 				eq = cmp == 0
 			}
 		}
-	} else if deepCmp != nil && IsList(a) && IsList(b) {
+	} else if deepCmp != nil && kern.IsList(a) && kern.IsList(b) {
 		eq, err = deepCmp(a, b)
 	} else {
 		eq = reflect.DeepEqual(a, b)
@@ -45,7 +49,7 @@ func equals(a, b any, deepCmp deepFuncTemplate) (eq bool, err error) {
 	return
 }
 
-func evalEqual(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalEqual(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@@ -68,9 +72,9 @@ func newNotEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalNotEqual(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalNotEqual(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	if v, err = evalEqual(ctx, opTerm); err == nil {
-		b, _ := ToBool(v)
+		b, _ := kern.ToBool(v)
 		v = !b
 	}
 	return
@@ -89,37 +93,37 @@ func newLessTerm(tk *Token) (inst *term) {
 }
 
 func lessThan(self *term, a, b any) (isLess bool, err error) {
-	if isNumOrFract(a) && isNumOrFract(b) {
+	if kern.IsNumOrFract(a) && kern.IsNumOrFract(b) {
-		if IsNumber(a) && IsNumber(b) {
+		if kern.IsNumber(a) && kern.IsNumber(b) {
-			if IsInteger(a) && IsInteger(b) {
+			if kern.IsInteger(a) && kern.IsInteger(b) {
 				li, _ := a.(int64)
 				ri, _ := b.(int64)
 				isLess = li < ri
 			} else {
-				isLess = numAsFloat(a) < numAsFloat(b)
+				isLess = kern.NumAsFloat(a) < kern.NumAsFloat(b)
 			}
 		} else {
 			var cmp int
-			if cmp, err = cmpAnyFract(a, b); err == nil {
+			if cmp, err = kern.CmpAnyFract(a, b); err == nil {
 				isLess = cmp < 0
 			}
 		}
-	} else if IsString(a) && IsString(b) {
+	} else if kern.IsString(a) && kern.IsString(b) {
 		ls, _ := a.(string)
 		rs, _ := b.(string)
 		isLess = ls < rs
 		// Inclusion test
-	} else if IsList(a) && IsList(b) {
+	} else if kern.IsList(a) && kern.IsList(b) {
-		aList, _ := a.(*ListType)
+		aList, _ := a.(*kern.ListType)
-		bList, _ := b.(*ListType)
+		bList, _ := b.(*kern.ListType)
-		isLess = len(*aList) < len(*bList) && bList.contains(aList)
+		isLess = len(*aList) < len(*bList) && bList.Contains(aList)
 	} else {
 		err = self.errIncompatibleTypes(a, b)
 	}
 	return
 }
 
-func evalLess(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalLess(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@@ -144,8 +148,8 @@ func newLessEqualTerm(tk *Token) (inst *term) {
 func lessThanOrEqual(self *term, a, b any) (isLessEq bool, err error) {
 	if isLessEq, err = lessThan(self, a, b); err == nil {
 		if !isLessEq {
-			if IsList(a) && IsList(b) {
+			if kern.IsList(a) && kern.IsList(b) {
-				isLessEq, err = sameContent(a, b)
+				isLessEq, err = kern.SameContent(a, b)
 			} else {
 				isLessEq, err = equals(a, b, nil)
 			}
@@ -154,7 +158,7 @@ func lessThanOrEqual(self *term, a, b any) (isLessEq bool, err error) {
 	return
 }
 
-func evalLessEqual(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalLessEqual(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@@ -178,7 +182,7 @@ func newGreaterTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalGreater(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalGreater(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@@ -201,7 +205,7 @@ func newGreaterEqualTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalGreaterEqual(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalGreaterEqual(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {

operator-selector.go

@@ -4,6 +4,10 @@
 // operator-selector.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- selector term
 
 func newSelectorTerm(tk *Token) (inst *term) {
@@ -16,7 +20,7 @@ func newSelectorTerm(tk *Token) (inst *term) {
 	}
 }
 
-func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (match bool, selectedValue any, err error) {
+func trySelectorCase(ctx kern.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)
@@ -38,7 +42,7 @@ func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (ma
 		} else {
 			var caseValue any
 			for _, caseTerm := range filterList {
-				if caseValue, err = caseTerm.compute(ctx); err != nil || caseValue == exprValue {
+				if caseValue, err = caseTerm.Compute(ctx); err != nil || caseValue == exprValue {
 					selectedValue, err = caseData.caseExpr.Eval(ctx)
 					match = true
 					break
@@ -49,7 +53,7 @@ func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (ma
 	return
 }
 
-func evalSelector(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalSelector(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var exprValue any
 	var match bool
 
@@ -57,7 +61,7 @@ func evalSelector(ctx ExprContext, opTerm *term) (v any, err error) {
 		return
 	}
 	exprTerm := opTerm.children[0]
-	if exprValue, err = exprTerm.compute(ctx); err != nil {
+	if exprValue, err = exprTerm.Compute(ctx); err != nil {
 		return
 	}
 

operator-shift.go

@@ -4,6 +4,10 @@
 // operator-shift.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- bit right shift term
 
 func newRightShiftTerm(tk *Token) (inst *term) {
@@ -17,7 +21,7 @@ func newRightShiftTerm(tk *Token) (inst *term) {
 }
 
 func bitRightShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
-	if IsInteger(leftValue) && IsInteger(rightValue) {
+	if kern.IsInteger(leftValue) && kern.IsInteger(rightValue) {
 		leftInt := leftValue.(int64)
 		rightInt := rightValue.(int64)
 		v = leftInt >> rightInt
@@ -27,7 +31,7 @@ func bitRightShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
 	return
 }
 
-func evalRightShift(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalRightShift(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
@@ -49,7 +53,7 @@ func newLeftShiftTerm(tk *Token) (inst *term) {
 }
 
 func bitLeftShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
-	if IsInteger(leftValue) && IsInteger(rightValue) {
+	if kern.IsInteger(leftValue) && kern.IsInteger(rightValue) {
 		leftInt := leftValue.(int64)
 		rightInt := rightValue.(int64)
 		v = leftInt << rightInt
@@ -59,7 +63,7 @@ func bitLeftShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
 	return
 }
 
-func evalLeftShift(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalLeftShift(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {

operator-sign.go

@@ -4,6 +4,10 @@
 // operator-sign.go
 package expr
 
+import (
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
+
 //-------- plus sign term
 
 func newPlusSignTerm(tk *Token) (inst *term) {
@@ -28,21 +32,21 @@ func newMinusSignTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalSign(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalSign(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var rightValue any
 
 	if rightValue, err = opTerm.evalPrefix(ctx); err != nil {
 		return
 	}
 
-	if IsFloat(rightValue) {
+	if kern.IsFloat(rightValue) {
 		if opTerm.tk.Sym == SymChangeSign {
 			f, _ := rightValue.(float64)
 			v = -f
 		} else {
 			v = rightValue
 		}
-	} else if IsInteger(rightValue) {
+	} else if kern.IsInteger(rightValue) {
 		if opTerm.tk.Sym == SymChangeSign {
 			i, _ := rightValue.(int64)
 			v = -i
@@ -50,7 +54,7 @@ func evalSign(ctx ExprContext, opTerm *term) (v any, err error) {
 			v = rightValue
 		}
 	} else {
-		err = opTerm.errIncompatibleType(rightValue)
+		err = opTerm.errIncompatiblePrefixPostfixType(rightValue)
 	}
 	return
 }

operator-sum.go

@@ -7,6 +7,8 @@ package expr
 import (
 	"fmt"
 	"slices"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 //-------- plus term
@@ -22,46 +24,46 @@ func newPlusTerm(tk *Token) (inst *term) {
 }
 
 func sumValues(plusTerm *term, leftValue, rightValue any) (v any, err error) {
-	if (IsString(leftValue) && isNumberString(rightValue)) || (IsString(rightValue) && isNumberString(leftValue)) {
+	if (kern.IsString(leftValue) && kern.IsNumberString(rightValue)) || (kern.IsString(rightValue) && kern.IsNumberString(leftValue)) {
 		v = fmt.Sprintf("%v%v", leftValue, rightValue)
-	} else if IsNumber(leftValue) && IsNumber(rightValue) {
+	} else if kern.IsNumber(leftValue) && kern.IsNumber(rightValue) {
-		if IsFloat(leftValue) || IsFloat(rightValue) {
+		if kern.IsFloat(leftValue) || kern.IsFloat(rightValue) {
-			v = numAsFloat(leftValue) + numAsFloat(rightValue)
+			v = kern.NumAsFloat(leftValue) + kern.NumAsFloat(rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			rightInt, _ := rightValue.(int64)
 			v = leftInt + rightInt
 		}
-	} else if IsList(leftValue) && IsList(rightValue) {
+	} else if kern.IsList(leftValue) && kern.IsList(rightValue) {
-		var leftList, rightList *ListType
+		var leftList, rightList *kern.ListType
-		leftList, _ = leftValue.(*ListType)
+		leftList, _ = leftValue.(*kern.ListType)
-		rightList, _ = rightValue.(*ListType)
+		rightList, _ = rightValue.(*kern.ListType)
 
-		sumList := make(ListType, 0, len(*leftList)+len(*rightList))
+		sumList := make(kern.ListType, 0, len(*leftList)+len(*rightList))
 		sumList = append(sumList, *leftList...)
 		sumList = append(sumList, *rightList...)
 		v = &sumList
-	} else if (isFraction(leftValue) && IsNumber(rightValue)) || (isFraction(rightValue) && IsNumber(leftValue)) {
+	} else if (kern.IsFraction(leftValue) && kern.IsNumber(rightValue)) || (kern.IsFraction(rightValue) && kern.IsNumber(leftValue)) {
-		if IsFloat(leftValue) || IsFloat(rightValue) {
+		if kern.IsFloat(leftValue) || kern.IsFloat(rightValue) {
-			v = numAsFloat(leftValue) + numAsFloat(rightValue)
+			v = kern.NumAsFloat(leftValue) + kern.NumAsFloat(rightValue)
 		} else {
-			v, err = sumAnyFract(leftValue, rightValue)
+			v, err = kern.SumAnyFract(leftValue, rightValue)
 		}
-	} else if IsDict(leftValue) && IsDict(rightValue) {
+	} else if kern.IsDict(leftValue) && kern.IsDict(rightValue) {
-		leftDict, _ := leftValue.(*DictType)
+		leftDict, _ := leftValue.(*kern.DictType)
-		rightDict, _ := rightValue.(*DictType)
+		rightDict, _ := rightValue.(*kern.DictType)
-		c := leftDict.clone()
+		c := leftDict.Clone()
-		c.merge(rightDict)
+		c.Merge(rightDict)
 		v = c
-	} else if isFraction(leftValue) && isFraction(rightValue) {
+	} else if kern.IsFraction(leftValue) && kern.IsFraction(rightValue) {
-		v, err = sumAnyFract(leftValue, rightValue)
+		v, err = kern.SumAnyFract(leftValue, rightValue)
 	} else {
 		err = plusTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return v, err
 }
 
-func evalPlus(ctx ExprContext, plusTerm *term) (v any, err error) {
+func evalPlus(ctx kern.ExprContext, plusTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = plusTerm.evalInfix(ctx); err != nil {
@@ -84,20 +86,20 @@ func newMinusTerm(tk *Token) (inst *term) {
 }
 
 func diffValues(minusTerm *term, leftValue, rightValue any) (v any, err error) {
-	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
+	if kern.IsNumOrFract(leftValue) && kern.IsNumOrFract(rightValue) {
-		if IsFloat(leftValue) || IsFloat(rightValue) {
+		if kern.IsFloat(leftValue) || kern.IsFloat(rightValue) {
-			v = numAsFloat(leftValue) - numAsFloat(rightValue)
+			v = kern.NumAsFloat(leftValue) - kern.NumAsFloat(rightValue)
-		} else if isFraction(leftValue) || isFraction(rightValue) {
+		} else if kern.IsFraction(leftValue) || kern.IsFraction(rightValue) {
-			v, err = subAnyFract(leftValue, rightValue)
+			v, err = kern.SubAnyFract(leftValue, rightValue)
 		} else {
 			leftInt, _ := leftValue.(int64)
 			rightInt, _ := rightValue.(int64)
 			v = leftInt - rightInt
 		}
-	} else if IsList(leftValue) && IsList(rightValue) {
+	} else if kern.IsList(leftValue) && kern.IsList(rightValue) {
-		leftList, _ := leftValue.(*ListType)
+		leftList, _ := leftValue.(*kern.ListType)
-		rightList, _ := rightValue.(*ListType)
+		rightList, _ := rightValue.(*kern.ListType)
-		diffList := make(ListType, 0, len(*leftList)-len(*rightList))
+		diffList := make(kern.ListType, 0, len(*leftList)-len(*rightList))
 		for _, item := range *leftList {
 			if slices.Index(*rightList, item) < 0 {
 				diffList = append(diffList, item)
@@ -110,7 +112,7 @@ func diffValues(minusTerm *term, leftValue, rightValue any) (v any, err error) {
 	return
 }
 
-func evalMinus(ctx ExprContext, minusTerm *term) (v any, err error) {
+func evalMinus(ctx kern.ExprContext, minusTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
 	if leftValue, rightValue, err = minusTerm.evalInfix(ctx); err != nil {

operator-unset.go

@@ -4,7 +4,11 @@
 // operator-unset.go
 package expr
 
-import "strings"
+import (
+	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+)
 
 //-------- unset term
 
@@ -18,7 +22,7 @@ func newUnsetTerm(tk *Token) (inst *term) {
 	}
 }
 
-func deleteContextItem(ctx ExprContext, opTerm *term, item any) (deleted bool, err error) {
+func deleteContextItem(ctx kern.ExprContext, opTerm *term, item any) (deleted bool, err error) {
 	if name, ok := item.(string); ok {
 		var size int
 		if strings.HasSuffix(name, "()") {
@@ -31,12 +35,12 @@ func deleteContextItem(ctx ExprContext, opTerm *term, item any) (deleted bool, e
 			deleted = ctx.VarCount() < size
 		}
 	} else {
-		err = opTerm.errIncompatibleType(item)
+		err = opTerm.errIncompatiblePrefixPostfixType(item)
 	}
 	return
 }
 
-func evalUnset(ctx ExprContext, opTerm *term) (v any, err error) {
+func evalUnset(ctx kern.ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 	var deleted bool
 
@@ -45,8 +49,8 @@ func evalUnset(ctx ExprContext, opTerm *term) (v any, err error) {
 	}
 
 	count := 0
-	if IsList(childValue) {
+	if kern.IsList(childValue) {
-		list, _ := childValue.(*ListType)
+		list, _ := childValue.(*kern.ListType)
 		for _, item := range *list {
 			if deleted, err = deleteContextItem(ctx, opTerm, item); err != nil {
 				break

parser.go

@@ -104,7 +104,7 @@ func (parser *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 			param := newTerm(tk)
 			if len(args) > 0 {
 				if pos := paramAlreadyDefined(args, param); pos > 0 {
-					err = tk.Errorf("parameter %q at position %d already defined at position %d", param.source(), len(args)+1, pos)
+					err = tk.Errorf("parameter %q at position %d already defined at position %d", param.Source(), len(args)+1, pos)
 					break
 				}
 			}
@@ -155,7 +155,7 @@ func (parser *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 func paramAlreadyDefined(args []*term, param *term) (position int) {
 	position = 0
 	for i, arg := range args {
-		if arg.source() == param.source() {
+		if arg.Source() == param.Source() {
 			position = i + 1
 		}
 	}
@@ -382,6 +382,15 @@ func (parser *parser) parseItem(scanner *scanner, ctx parserContext, termSymbols
 }
 
 func (parser *parser) Parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			if errVal, ok := r.(error); ok {
+				err = errVal
+			} else {
+				err = errors.New("unexpected error while parsing the expression")
+			}
+		}
+	}()
 	termSymbols = append(termSymbols, SymEos)
 	return parser.parseGeneral(scanner, allowMultiExpr, termSymbols...)
 }
@@ -397,7 +406,7 @@ func couldBeACollection(t *term) bool {
 func listSubTree(tree *ast, listTerm *term, allowIndeces bool) (root *term, err error) {
 	var tk *Token
 	if allowIndeces {
-		tk = NewToken(listTerm.tk.row, listTerm.tk.col, SymIndex, listTerm.source())
+		tk = NewToken(listTerm.tk.row, listTerm.tk.col, SymIndex, listTerm.Source())
 		root = newTerm(tk)
 		if err = tree.addTerm(root); err == nil {
 			err = tree.addTerm(listTerm)
@@ -409,6 +418,23 @@ func listSubTree(tree *ast, listTerm *term, allowIndeces bool) (root *term, err
 	return
 }
 
+func changePrefix(tk *Token) {
+	switch tk.Sym {
+	case SymMinus:
+		tk.SetSymbol(SymChangeSign)
+	case SymPlus:
+		tk.SetSymbol(SymUnchangeSign)
+	case SymStar:
+		tk.SetSymbol(SymDereference)
+	case SymExclamation:
+		tk.SetSymbol(SymNot)
+	case SymDoublePlus:
+		tk.SetSymbol(SymPreInc)
+	case SymDoubleMinus:
+		tk.SetSymbol(SymPreDec)
+	}
+}
+
 func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymbols ...Symbol) (tree *ast, err error) {
 	var selectorTerm *term = nil
 	var currentTerm *term = nil
@@ -437,16 +463,7 @@ func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymb
 
 		//fmt.Println("Token:", tk)
 		if firstToken {
-			if tk.Sym == SymMinus {
+			changePrefix(tk)
-				tk.Sym = SymChangeSign
-			} else if tk.Sym == SymPlus {
-				tk.Sym = SymUnchangeSign
-			} else if tk.IsSymbol(SymStar) {
-				tk.SetSymbol(SymDereference)
-			} else if tk.IsSymbol(SymExclamation) {
-				err = tk.Errorf("postfix opertor %q requires an operand on its left side", tk)
-				break
-			}
 			firstToken = false
 		}
 
@@ -454,12 +471,13 @@ func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymb
 		case SymOpenRound:
 			var subTree *ast
 			if subTree, err = parser.parseGeneral(scanner, ctx, SymClosedRound); err == nil {
+				if subTree.root == nil {
+					err = tk.ErrorExpectedGotString("expression", "()")
+				} else {
 					exprTerm := newExprTerm(subTree.root)
 					err = tree.addTerm(exprTerm)
 					currentTerm = exprTerm
-				// subTree.root.priority = priValue
+				}
-				// err = tree.addTerm(newExprTerm(subTree.root))
-				// currentTerm = subTree.root
 			}
 		case SymFuncCall:
 			var funcCallTerm *term

plugins.go

@@ -10,6 +10,8 @@ import (
 	"os"
 	"plugin"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 var pluginRegister map[string]*plugin.Plugin
@@ -31,20 +33,20 @@ func pluginExists(name string) (exists bool) {
 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"
+		template = "expr-%s-plugin%s"
 	} else {
-		template = "expr-%s-plugin.so.debug"
+		template = "expr-%s-plugin%s.debug"
 	}
-	decorated = fmt.Sprintf(template, name)
+	decorated = fmt.Sprintf(template, name, SHAREDLIBRARY_EXTENSION)
 	return
 }
 
-func importPlugin( /*ctx ExprContext,*/ dirList []string, name string) (err error) {
+func importPlugin(ctx kern.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 importFunc func(kern.ExprContext)
 	var ok bool
 
 	decoratedName := makePluginName(name)
@@ -71,7 +73,7 @@ func importPlugin( /*ctx ExprContext,*/ dirList []string, name string) (err erro
 	}
 	if deps := *sym.(*[]string); len(deps) > 0 {
 		// var count int
-		if err = loadModules(dirList, deps); err != nil {
+		if err = loadModules(ctx, dirList, deps); err != nil {
 			return
 		}
 	}
@@ -80,31 +82,35 @@ func importPlugin( /*ctx ExprContext,*/ dirList []string, name string) (err erro
 		return
 	}
 
-	if importFunc, ok = sym.(func(ExprContext)); !ok {
+	if importFunc, ok = sym.(func(kern.ExprContext)); !ok {
 		err = fmt.Errorf("plugin %q does not provide a valid import function", decoratedName)
 		return
 	}
 
 	registerPlugin(moduleName, p)
+	if globalCtx := ctx.GetGlobal(); globalCtx != nil {
 		importFunc(globalCtx)
+	}
 
 	return
 }
 
-func importPluginFromSearchPath(name any) (count int, err error) {
+func importPluginFromSearchPath(ctx kern.ExprContext, name any) (count int, err error) {
 	var moduleSpec any
-
+	var it kern.Iterator
-	dirList := buildSearchDirList("plugin", ENV_EXPR_PLUGIN_PATH)
+	dirList := buildSearchDirList(ctx, "plugin", ENV_EXPR_PLUGIN_PATH)
 	count = 0
-	it := NewAnyIterator(name)
+	if it, err = NewIterator(name); err != nil {
+		return
+	}
 	for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() {
 		if module, ok := moduleSpec.(string); ok {
-			if err = importPlugin(dirList, module); err != nil {
+			if err = importPlugin(ctx, dirList, module); err != nil {
 				break
 			}
 			count++
 		} else {
-			err = fmt.Errorf("expected string as item nr %d, got %s", it.Index()+1, TypeName(moduleSpec))
+			err = fmt.Errorf("expected string as item nr %d, got %s", it.Index()+1, kern.TypeName(moduleSpec))
 			break
 		}
 	}
@@ -114,10 +120,10 @@ func importPluginFromSearchPath(name any) (count int, err error) {
 	return
 }
 
-func loadModules(dirList []string, moduleNames []string) (err error) {
+func loadModules(ctx kern.ExprContext, dirList []string, moduleNames []string) (err error) {
 	for _, name := range moduleNames {
-		if err1 := importPlugin(dirList, name); err1 != nil {
+		if err1 := importPlugin(ctx, dirList, name); err1 != nil {
-			if !ImportInContext(name) {
+			if !ImportInContext(ctx, name) {
 				err = err1
 				break
 			}

scanner.go

@@ -11,6 +11,8 @@ import (
 	"io"
 	"strconv"
 	"strings"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 type scanner struct {
@@ -210,14 +212,14 @@ func (scanner *scanner) fetchNextToken() (tk *Token) {
 				tk = scanner.makeToken(SymQuote, ch)
 				escape = false
 			} else {
-				tk = scanner.fetchString(ch)
+				tk = scanner.fetchString(ch, true)
 			}
 		case '"':
 			if escape {
 				tk = scanner.makeToken(SymDoubleQuote, ch)
 				escape = false
 			} else {
-				tk = scanner.fetchString(ch)
+				tk = scanner.fetchString(ch, true)
 			}
 		case '`':
 			tk = scanner.makeToken(SymBackTick, ch)
@@ -315,6 +317,14 @@ func (scanner *scanner) fetchNextToken() (tk *Token) {
 				tk.source += ")"
 			} else if next == '$' {
 				tk = scanner.moveOn(SymDoubleDollar, ch, next)
+			} else if next == '{' {
+				scanner.readChar()
+				if tk = scanner.fetchString('}', false); tk != nil {
+					tk.Sym = SymIdentifier
+				}
+			} else if next == '_' || (next >= 'a' && next <= 'z') || (next >= 'A' && next <= 'Z') {
+				scanner.readChar()
+				tk = scanner.fetchIdentifier(next)
 			} else {
 				tk = scanner.makeToken(SymDollar, ch)
 			}
@@ -495,7 +505,7 @@ func (scanner *scanner) parseNumber(firstCh byte) (tk *Token) {
 		if sym == SymFloat {
 			value, err = strconv.ParseFloat(txt, 64)
 		} else if sym == SymFraction {
-			value, err = makeGeneratingFraction(txt)
+			value, err = kern.MakeGeneratingFraction(txt)
 		} else {
 			value, err = strconv.ParseInt(txt, numBase, 64)
 		}
@@ -590,7 +600,7 @@ func (scanner *scanner) fetchUntil(sym Symbol, allowEos bool, endings ...byte) (
 	return
 }
 
-func (scanner *scanner) fetchString(termCh byte) (tk *Token) {
+func (scanner *scanner) fetchString(termCh byte, addQuote bool) (tk *Token) {
 	var err error
 	var ch, prev byte
 	var sb strings.Builder
@@ -628,7 +638,11 @@ func (scanner *scanner) fetchString(termCh byte) (tk *Token) {
 		}
 	} else {
 		txt := sb.String()
+		if addQuote {
 			tk = scanner.makeValueToken(SymString, `"`+txt+`"`, txt)
+		} else {
+			tk = scanner.makeValueToken(SymString, txt, txt)
+		}
 	}
 	return
 }

simple-store.go

@@ -7,38 +7,63 @@ package expr
 import (
 	"fmt"
 	"slices"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
+	"git.portale-stac.it/go-pkg/expr/util"
 	// "strings"
 )
 
 type SimpleStore struct {
-	parent    ExprContext
+	global    kern.ExprContext
+	parent    kern.ExprContext
 	varStore  map[string]any
-	funcStore map[string]ExprFunc
+	funcStore map[string]kern.ExprFunc
 }
 
 func NewSimpleStore() *SimpleStore {
+	global := InitGlobal()
 	ctx := &SimpleStore{
+		global:    global,
 		varStore:  make(map[string]any),
-		funcStore: make(map[string]ExprFunc),
+		funcStore: make(map[string]kern.ExprFunc),
 	}
 	return ctx
 }
 
+func NewSimpleStoreWithoutGlobalContext() *SimpleStore {
+	ctx := &SimpleStore{
+		varStore:  make(map[string]any),
+		funcStore: make(map[string]kern.ExprFunc),
+	}
+	return ctx
+}
+
+func (ss *SimpleStore) Init() {
+	ss.varStore = make(map[string]any)
+	ss.funcStore = make(map[string]kern.ExprFunc)
+}
+
 func filterRefName(name string) bool { return name[0] != '@' }
+
 //func filterPrivName(name string) bool { return name[0] != '_' }
 
-func (ctx *SimpleStore) SetParent(parentCtx ExprContext) {
+func (ctx *SimpleStore) SetParent(parentCtx kern.ExprContext) {
 	ctx.parent = parentCtx
 }
 
-func (ctx *SimpleStore) GetParent() ExprContext {
+func (ctx *SimpleStore) GetParent() kern.ExprContext {
 	return ctx.parent
 }
 
-func (ctx *SimpleStore) Clone() ExprContext {
+func (ctx *SimpleStore) GetGlobal() (globalCtx kern.ExprContext) {
+	return ctx.global
+}
+
+func (ctx *SimpleStore) Clone() kern.ExprContext {
 	clone := &SimpleStore{
-		varStore:  CloneFilteredMap(ctx.varStore, filterRefName),
+		global:    ctx.global,
-		funcStore: CloneFilteredMap(ctx.funcStore, filterRefName),
+		varStore:  util.CloneFilteredMap(ctx.varStore, filterRefName),
+		funcStore: util.CloneFilteredMap(ctx.funcStore, filterRefName),
 	}
 	return clone
 }
@@ -52,19 +77,19 @@ func (ctx *SimpleStore) Clone() ExprContext {
 // 	}
 // }
 
-func (ctx *SimpleStore) ToString(opt FmtOpt) string {
+func (ctx *SimpleStore) ToString(opt kern.FmtOpt) string {
 	dict := ctx.ToDict()
 	return dict.ToString(opt)
 }
 
-func (ctx *SimpleStore) varsToDict(dict *DictType) *DictType {
+func (ctx *SimpleStore) varsToDict(dict *kern.DictType) *kern.DictType {
 	names := ctx.EnumVars(nil)
 	slices.Sort(names)
 	for _, name := range ctx.EnumVars(nil) {
 		value, _ := ctx.GetVar(name)
-		if f, ok := value.(Formatter); ok {
+		if f, ok := value.(kern.Formatter); ok {
 			(*dict)[name] = f.ToString(0)
-		} else if _, ok = value.(Functor); ok {
+		} else if _, ok = value.(kern.Functor); ok {
 			(*dict)[name] = "func(){}"
 		} else {
 			(*dict)[name] = fmt.Sprintf("%v", value)
@@ -73,12 +98,12 @@ func (ctx *SimpleStore) varsToDict(dict *DictType) *DictType {
 	return dict
 }
 
-func (ctx *SimpleStore) funcsToDict(dict *DictType) *DictType {
+func (ctx *SimpleStore) funcsToDict(dict *kern.DictType) *kern.DictType {
 	names := ctx.EnumFuncs(func(name string) bool { return true })
 	slices.Sort(names)
 	for _, name := range names {
 		value, _ := ctx.GetFuncInfo(name)
-		if formatter, ok := value.(Formatter); ok {
+		if formatter, ok := value.(kern.Formatter); ok {
 			(*dict)[name] = formatter.ToString(0)
 		} else {
 			(*dict)[name] = fmt.Sprintf("%v", value)
@@ -87,20 +112,23 @@ func (ctx *SimpleStore) funcsToDict(dict *DictType) *DictType {
 	return dict
 }
 
-func (ctx *SimpleStore) ToDict() (dict *DictType) {
+func (ctx *SimpleStore) ToDict() (dict *kern.DictType) {
-	dict = MakeDict()
+	dict = kern.MakeDict()
-	(*dict)["variables"] = ctx.varsToDict(MakeDict())
+	(*dict)["variables"] = ctx.varsToDict(kern.MakeDict())
-	(*dict)["functions"] = ctx.funcsToDict(MakeDict())
+	(*dict)["functions"] = ctx.funcsToDict(kern.MakeDict())
 	return
 }
 
-func (ctx *SimpleStore) GetVar(varName string) (v any, exists bool) {
+func (ctx *SimpleStore) GetVar(varName string) (value any, exists bool) {
-	v, exists = ctx.varStore[varName]
+	if value, exists = ctx.varStore[varName]; !exists && ctx.global != nil {
+		value, exists = ctx.global.GetVar(varName)
+	}
+
 	return
 }
 
 func (ctx *SimpleStore) GetLast() (v any) {
-	v = ctx.varStore["last"]
+	v = ctx.varStore[kern.ControlLastResult]
 	return
 }
 
@@ -111,7 +139,7 @@ func (ctx *SimpleStore) UnsafeSetVar(varName string, value any) {
 
 func (ctx *SimpleStore) SetVar(varName string, value any) {
 	// fmt.Printf("[%p] SetVar(%v, %v)\n", ctx, varName, value)
-	if allowedValue, ok := fromGenericAny(value); ok {
+	if allowedValue, ok := util.FromGenericAny(value); ok {
 		ctx.varStore[varName] = allowedValue
 	} else {
 		panic(fmt.Errorf("unsupported type %T of value %v", value, value))
@@ -140,16 +168,42 @@ func (ctx *SimpleStore) DeleteVar(varName string) {
 	delete(ctx.varStore, varName)
 }
 
-func (ctx *SimpleStore) GetFuncInfo(name string) (info ExprFunc, exists bool) {
+func (ctx *SimpleStore) GetFuncInfo(name string) (info kern.ExprFunc, exists bool) {
-	info, exists = ctx.funcStore[name]
+	info, exists, _ = ctx.GetFuncInfoAndOwner(name)
 	return
 }
 
-func (ctx *SimpleStore) RegisterFuncInfo(info ExprFunc) {
+func (ctx *SimpleStore) GetFuncInfoAndOwner(name string) (info kern.ExprFunc, exists bool, ownerCtx kern.ExprContext) {
+	if len(name) > 0 {
+		if info, exists = ctx.GetLocalFuncInfo(name); exists {
+			ownerCtx = ctx
+		} else if globalCtx := ctx.GetGlobal(); globalCtx != nil {
+			if info, exists = globalCtx.GetFuncInfo(name); exists {
+				ownerCtx = globalCtx
+			}
+		}
+	}
+	return
+}
+
+func (ctx *SimpleStore) GetLocalFuncInfo(name string) (info kern.ExprFunc, exists bool) {
+	var v any
+	if len(name) > 0 {
+		if v, exists = ctx.GetVar(name); exists && kern.IsFunctor(v) {
+			f, _ := v.(kern.Functor)
+			info = f.GetFunc()
+		} else {
+			info, exists = ctx.funcStore[name]
+		}
+	}
+	return
+}
+
+func (ctx *SimpleStore) RegisterFuncInfo(info kern.ExprFunc) {
 	ctx.funcStore[info.Name()], _ = info.(*funcInfo)
 }
 
-func (ctx *SimpleStore) RegisterFunc(name string, functor Functor, returnType string, params []ExprFuncParam)  (exprFunc ExprFunc, err error) {
+func (ctx *SimpleStore) RegisterFunc(name string, functor kern.Functor, returnType string, params []kern.ExprFuncParam) (exprFunc kern.ExprFunc, err error) {
 	var info *funcInfo
 	if info, err = newFuncInfo(name, functor, returnType, params); err == nil {
 		ctx.funcStore[name] = info
@@ -181,7 +235,7 @@ func (ctx *SimpleStore) DeleteFunc(funcName string) {
 }
 
 func (ctx *SimpleStore) Call(name string, args map[string]any) (result any, err error) {
-	if info, exists := GetLocalFuncInfo(ctx, name); exists {
+	if info, exists := ctx.GetLocalFuncInfo(name); exists {
 		functor := info.Functor()
 		result, err = functor.InvokeNamed(ctx, name, args)
 	} else {

symbol-map.go

@@ -103,6 +103,8 @@ func init() {
 		SymCaretEqual:         {"^=", symClassOperator, posInfix},     //  66: '^='
 		SymPlusGreater:        {"+>", symClassOperator, posInfix},     //  67: '+>'
 		SymLessPlus:           {"<+", symClassOperator, posInfix},     //  68: '<+'
+		SymPreInc:             {"++", symClassOperator, posPrefix},    //    : '++'
+		SymPreDec:             {"--", symClassOperator, posPrefix},    //    : '--'
 		// SymChangeSign
 		// SymUnchangeSign
 		// SymIdentifier
@@ -133,6 +135,11 @@ func init() {
 		SymKwNot:     {"not", symClassOperator, posInfix},
 		SymKwOr:      {"or", symClassOperator, posInfix},
 		SymKwBut:     {"but", symClassOperator, posInfix},
+		SymKwMap:     {"map", symClassOperator, posInfix},
+		SymKwFilter:  {"filter", symClassOperator, posInfix},
+		SymKwDigest:  {"digest", symClassOperator, posInfix},
+		SymKwJoin:    {"join", symClassOperator, posInfix},
+		SymKwGroupBy: {"groupby", symClassOperator, posInfix},
 		SymKwFunc:    {"func(", symClassDeclaration, posPrefix},
 		SymKwBuiltin: {"builtin", symClassOperator, posPrefix},
 		SymKwPlugin:  {"plugin", symClassOperator, posPrefix},
@@ -176,21 +183,49 @@ func StringEndsWithOperator(s string) bool {
 	return endingOperator(s) != SymNone
 }
 
+// func endingOperator(s string) (sym Symbol) {
+// 	var matchLength = 0
+// 	sym = SymNone
+// 	lower := strings.TrimRight(strings.ToLower(s), " \t")
+// 	for symbol, spec := range symbolMap {
+// 		if strings.HasSuffix(lower, spec.repr) {
+// 			if len(spec.repr) > matchLength {
+// 				matchLength = len(spec.repr)
+// 				if spec.kind == symClassOperator && (spec.opType == posInfix || spec.opType == posPrefix) {
+// 					sym = symbol
+// 				} else {
+// 					sym = SymNone
+// 				}
+// 			}
+// 		}
+// 	}
+// 	return
+// }
+
 func endingOperator(s string) (sym Symbol) {
 	var matchLength = 0
+	var repr string
 	sym = SymNone
 	lower := strings.TrimRight(strings.ToLower(s), " \t")
 	for symbol, spec := range symbolMap {
+		if len(spec.repr) > matchLength || repr == spec.repr {
 			if strings.HasSuffix(lower, spec.repr) {
-			if len(spec.repr) > matchLength {
+				if isNotEndingSymbol(spec) && repr != spec.repr {
+					repr = spec.repr
 					matchLength = len(spec.repr)
-				if spec.kind == symClassOperator && (spec.opType == posInfix || spec.opType == posPrefix) {
 					sym = symbol
 				} else {
 					sym = SymNone
+					break
+					// matchLength = 0
 				}
 			}
 		}
 	}
 	return
 }
+
+func isNotEndingSymbol(spec symbolSpec) bool {
+	return (spec.kind == symClassOperator && (spec.opType == posInfix || spec.opType == posPrefix)) ||
+		(spec.kind == symClassParenthesis && spec.opType == posPrefix)
+}

symbol.go

@@ -81,6 +81,8 @@ const (
 	SymChangeSign
 	SymUnchangeSign
 	SymDereference
+	SymPreInc
+	SymPreDec
 	SymIdentifier
 	SymBool
 	SymInteger
@@ -117,6 +119,11 @@ const (
 	SymKwPlugin
 	SymKwIn
 	SymKwInclude
+	SymKwMap
+	SymKwFilter
+	SymKwDigest
+	SymKwGroupBy
+	SymKwJoin
 	SymKwNil
 	SymKwUnset
 )
@@ -133,9 +140,14 @@ func init() {
 		"FUNC":    SymKwFunc,
 		"IN":      SymKwIn,
 		"INCLUDE": SymKwInclude,
+		"MAP":     SymKwMap,
+		"FILTER":  SymKwFilter,
 		"NOT":     SymKwNot,
 		"OR":      SymKwOr,
 		"NIL":     SymKwNil,
 		"UNSET":   SymKwUnset,
+		"DIGEST":  SymKwDigest,
+		"JOIN":    SymKwJoin,
+		"GROUPBY": SymKwGroupBy,
 	}
 }

t_bool_test.go

@@ -7,6 +7,8 @@ package expr
 import (
 	"errors"
 	"testing"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 func TestBool(t *testing.T) {
@@ -19,19 +21,20 @@ func TestBool(t *testing.T) {
 		/*   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]`)},
+		/*   8 */ {`not []`, nil, errors.New(`[1:4] prefix/postfix operator "NOT" does 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`)},
+		/*  11 */ {`[] and false`, nil, errors.New(`[1:7] operator "AND" does not support operand '[]' [list] on its left side`)},
 		/*  12 */ {`true or false`, true, nil},
 		/*  13 */ {`true or []`, true, nil},
 		/*  14 */ {`[] or false`, nil, errors.New(`got list as left operand type of 'OR' operator, it must be bool`)},
+		/*  15 */ {`!true`, false, nil},
 		/*  13 */ //{`true or []`, nil, errors.New(`[1:8] left operand 'true' [bool] and right operand '[]' [list] are not compatible with operator "OR"`)},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")
 
-	// runTestSuiteSpec(t, section, inputs, 1)
+	// runTestSuiteSpec(t, section, inputs, 13)
 	runTestSuite(t, section, inputs)
 }
 
@@ -45,7 +48,7 @@ func TestBoolNoShortcut(t *testing.T) {
 		/*   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]`},
+		/*   8 */ {`not []`, nil, `[1:4] prefix/postfix operator "NOT" does 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"`},
@@ -57,10 +60,10 @@ func TestBoolNoShortcut(t *testing.T) {
 	// t.Setenv("EXPR_PATH", ".")
 
 	ctx := NewSimpleStore()
-	current := SetCtrl(ctx, ControlBoolShortcut, false)
+	current := kern.SetCtrl(ctx, kern.ControlBoolShortcut, false)
 
 	// runCtxTestSuiteSpec(t, ctx, section, inputs, 1)
 	runCtxTestSuite(t, ctx, section, inputs)
 
-	SetCtrl(ctx, ControlBoolShortcut, current)
+	kern.SetCtrl(ctx, kern.ControlBoolShortcut, current)
 }

t_builtin-base_test.go

@@ -6,6 +6,8 @@ package expr
 
 import (
 	"testing"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 func TestFuncBase(t *testing.T) {
@@ -33,10 +35,10 @@ func TestFuncBase(t *testing.T) {
 		/*  19 */ {`isFract(1:3)`, true, nil},
 		/*  20 */ {`isFract(3:1)`, false, nil},
 		/*  21 */ {`isRational(3:1)`, true, nil},
-		/*  22 */ {`fract("2.2(3)")`, newFraction(67, 30), nil},
+		/*  22 */ {`fract("2.2(3)")`, kern.NewFraction(67, 30), nil},
-		/*  23 */ {`fract("1.21(3)")`, newFraction(91, 75), nil},
+		/*  23 */ {`fract("1.21(3)")`, kern.NewFraction(91, 75), nil},
-		/*  24 */ {`fract(1.21(3))`, newFraction(91, 75), nil},
+		/*  24 */ {`fract(1.21(3))`, kern.NewFraction(91, 75), nil},
-		/*  25 */ {`fract(1.21)`, newFraction(121, 100), nil},
+		/*  25 */ {`fract(1.21)`, kern.NewFraction(121, 100), nil},
 		/*  26 */ {`dec(2)`, float64(2), nil},
 		/*  27 */ {`dec(2.0)`, float64(2), nil},
 		/*  28 */ {`dec("2.0")`, float64(2), nil},
@@ -45,23 +47,81 @@ func TestFuncBase(t *testing.T) {
 		/*  31 */ {`dec()`, nil, `dec(): too few params -- expected 1, got 0`},
 		/*  32 */ {`dec(1,2,3)`, nil, `dec(): too many params -- expected 1, got 3`},
 		/*  33 */ {`isBool(false)`, true, nil},
-		/*  34 */ {`fract(1:2)`, newFraction(1, 2), nil},
+		/*  34 */ {`fract(1:2)`, kern.NewFraction(1, 2), nil},
-		/*  35 */ {`fract(12,2)`, newFraction(6, 1), nil},
+		/*  35 */ {`fract(12,2)`, kern.NewFraction(6, 1), nil},
 		/*  36 */ {`bool(2)`, true, nil},
 		/*  37 */ {`bool(1:2)`, true, nil},
 		/*  38 */ {`bool(1.0)`, true, nil},
 		/*  39 */ {`bool("1")`, true, nil},
 		/*  40 */ {`bool(false)`, false, nil},
-		/*  41 */ {`bool([1])`, nil, `bool(): can't convert list to bool`},
+		/*  41 */ {`bool([1])`, true, nil},
-		/*  42 */ {`dec(false)`, float64(0), nil},
+		/*  42 */ {`bool([])`, false, nil},
-		/*  43 */ {`dec(1:2)`, float64(0.5), nil},
+		/*  43 */ {`bool({})`, false, nil},
-		/*  44 */ {`dec([1])`, nil, `dec(): can't convert list to float`},
+		/*  44 */ {`bool({1:"one"})`, true, nil},
-		/*  45 */ {`eval("a=3"); a`, int64(3), nil},
+		/*  45 */ {`dec(false)`, float64(0), nil},
+		/*  46 */ {`dec(1:2)`, float64(0.5), nil},
+		/*  47 */ {`dec([1])`, nil, `dec(): can't convert list to float`},
+		/*  48 */ {`eval("a=3"); a`, int64(3), nil},
+		/*  49 */ {`int(5:2)`, int64(2), nil},
+
 		// /*  45 */ {`string([1])`, nil, `string(): can't convert list to string`},
 	}
 
 	t.Setenv("EXPR_PATH", ".")
 
-	// runTestSuiteSpec(t, section, inputs, 45)
+	// runTestSuiteSpec(t, section, inputs, 49)
+	runTestSuite(t, section, inputs)
+}
+
+func TestFuncBaseString(t *testing.T) {
+	section := "Builtin-Base-String"
+
+	inputs := []inputType{
+		/*   1 */ {`string(3)`, "3", nil},
+		/*   2 */ {`string(3.5)`, "3.5", nil},
+		/*   3 */ {`string(true)`, "true", nil},
+		/*   4 */ {`string(false)`, "false", nil},
+		/*   5 */ {`string("123")`, "123", nil},
+		/*   6 */ {`string(1:2)`, "1:2", nil},
+	}
+
+	// t.Setenv("EXPR_PATH", ".")
+
+	// runTestSuiteSpec(t, section, inputs, 49)
+	runTestSuite(t, section, inputs)
+}
+
+func TestFuncBaseFraction(t *testing.T) {
+	section := "Builtin-Base-Fraction"
+
+	inputs := []inputType{
+		/*   1 */ {`fract(-0.5)`, kern.NewFraction(-1, 2), nil},
+		/*   2 */ {`fract("")`, (*kern.FractionType)(nil), `bad syntax`},
+		/*   3 */ {`fract("-1")`, kern.NewFraction(-1, 1), nil},
+		/*   4 */ {`fract("+1")`, kern.NewFraction(1, 1), nil},
+		/*   5 */ {`fract("1a")`, (*kern.FractionType)(nil), `strconv.ParseInt: parsing "1a": invalid syntax`},
+		/*   6 */ {`fract(1,0)`, nil, `fract(): division by zero`},
+		/*   7 */ {`fract(5, "1")`, nil, `fract(): expected integer, got string ("1")`},
+		/*   8 */ {`fract(true)`, kern.NewFraction(1, 1), nil},
+		/*   9 */ {`fract(false)`, kern.NewFraction(0, 1), nil},
+	}
+
+	// t.Setenv("EXPR_PATH", ".")
+
+	// runTestSuiteSpec(t, section, inputs, 8)
+	runTestSuite(t, section, inputs)
+}
+
+func TestFuncBaseOthers(t *testing.T) {
+	section := "Builtin-Base-Others"
+
+	inputs := []inputType{
+		/*   1 */ {`set("a", 3); a`, int64(3), nil},
+		/*   2 */ {`set(true, 3)`, nil, `set(): the "name" parameter must be a string, got a bool (true)`},
+		// /*   3 */ {`a=3; unset("a"); a`, nil, `undefined variable or function "a"`},
+		// /*   4 */ {`unset("a")`, nil, `undefined variable or function "a"`},
+	}
+
+	// runTestSuiteSpec(t, section, inputs, 4)
 	runTestSuite(t, section, inputs)
 }

t_builtin-fmt_test.go

@@ -9,6 +9,8 @@ import (
 	"bytes"
 	"fmt"
 	"testing"
+
+	"git.portale-stac.it/go-pkg/expr/kern"
 )
 
 func TestFuncFmt(t *testing.T) {
@@ -37,11 +39,11 @@ func TestFmt(t *testing.T) {
 
 	var b bytes.Buffer
 	ctx := NewSimpleStore()
-	currentStdout := SetCtrl(ctx, ControlStdout, &b)
+	currentStdout := kern.SetCtrl(ctx, kern.ControlStdout, &b)
 
 	runCtxTestSuite(t, ctx, section, inputs)
 
-	SetCtrl(ctx, ControlStdout, currentStdout)
+	kern.SetCtrl(ctx, kern.ControlStdout, currentStdout)
 	if b.String() != text+"\n" {
 		t.Errorf("println(): Got: %q, Want: %q", b.String(), text+"\n")
 	}

t_builtin-iterator_test.go

@@ -14,17 +14,18 @@ func TestFuncRun(t *testing.T) {
 	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},
+		/*   3 */ {`builtin "iterator"; run($(4), func(index,item){status=status+item; true}, {"status":0})`, int64(6), nil},
 		/*   4 */ {`builtin ["iterator", "fmt"]; run($(1,2,3), func(index,item){println(item+10)})`, nil, nil},
 		/*   5 */ {`builtin "iterator"; run(nil)`, nil, `paramter "iterator" must be an iterator, passed <nil> [nil]`},
 		/*   6 */ {`builtin "iterator"; run($(1,2,3), nil)`, nil, nil},
 		/*   7 */ {`builtin "iterator"; run($(1,2,3), func(){1}, "prrr")`, nil, `paramter "vars" must be a dictionary, passed prrr [string]`},
 		/*   8 */ {`builtin "iterator"; run($(1,2,3), operator=nil)`, nil, nil},
 		/*   9 */ {`builtin "iterator"; run($(1,2,3), operatorx=nil)`, nil, `run(): unknown param "operatorx"`},
+		/*   10 */ {`builtin ["os.file", "iterator"]; it = fileReadIterator("test-file.txt"); run(it)`, nil, nil},
 	}
 
 	//t.Setenv("EXPR_PATH", ".")
 
-	//runTestSuiteSpec(t, section, inputs, 1)
+	// runTestSuiteSpec(t, section, inputs, 3)
 	runTestSuite(t, section, inputs)
 }