CallFunction() has been replaced by three new functions:

CallFunctionByTerm(), CallFunctionByArgs() and CallFunctionByParams()

ast.go

@@ -45,19 +45,19 @@ func (expr *ast) String() string {
 
 func (expr *ast) addTokens(tokens ...*Token) (err error) {
 	for _, tk := range tokens {
-		if err = expr.addToken(tk); err != nil {
+		if _, err = expr.addToken(tk); err != nil {
 			break
 		}
 	}
 	return
 }
 
-func (expr *ast) addToken(tk *Token) (err error) {
+// func (expr *ast) addToken(tk *Token) (err error) {
-	_, err = expr.addToken2(tk)
+// 	_, err = expr.addToken2(tk)
-	return
+// 	return
-}
+// }
 
-func (expr *ast) addToken2(tk *Token) (t *term, err error) {
+func (expr *ast) addToken(tk *Token) (t *term, err error) {
 	if t = newTerm(tk); t != nil {
 		err = expr.addTerm(t)
 	} else {

bind-expr-functions.go

@@ -12,19 +12,14 @@ type exprFunctor struct {
 	defCtx ExprContext
 }
 
-// func newExprFunctor(e Expr, params []string, ctx ExprContext) *exprFunctor {
+func (functor *exprFunctor) GetParams() (params []ExprFuncParam) {
-// 	return &exprFunctor{expr: e, params: params, defCtx: ctx}
+	return functor.params
-// }
+}
 
 func newExprFunctor(e Expr, params []ExprFuncParam, ctx ExprContext) *exprFunctor {
 	var defCtx ExprContext
 	if ctx != nil {
-//		if ctx.GetParent() != nil {
+		defCtx = ctx
-//			defCtx = ctx.Clone()
-//			defCtx.SetParent(ctx)
-//		} else {
-			defCtx = ctx
-//		}
 	}
 	return &exprFunctor{expr: e, params: params, defCtx: defCtx}
 }
@@ -37,14 +32,10 @@ func (functor *exprFunctor) GetDefinitionContext() ExprContext {
 	return functor.defCtx
 }
 
-func (functor *exprFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
+func (functor *exprFunctor) InvokeNamed(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	// if functor.defCtx != nil {
+	var missing []string
-	// 	ctx.Merge(functor.defCtx)
+	for _, p := range functor.params {
-	// }
+		if arg, exists := args[p.Name()]; exists {
-
-	for i, p := range functor.params {
-		if i < len(args) {
-			arg := args[i]
 			if funcArg, ok := arg.(Functor); ok {
 				paramSpecs := funcArg.GetParams()
 				ctx.RegisterFunc(p.Name(), funcArg, TypeAny, paramSpecs)
@@ -52,9 +43,17 @@ func (functor *exprFunctor) Invoke(ctx ExprContext, name string, args []any) (re
 				ctx.UnsafeSetVar(p.Name(), arg)
 			}
 		} else {
-			ctx.UnsafeSetVar(p.Name(), nil)
+			if missing == nil {
+				missing = make([]string, 0, 1)
+			}
+			missing = append(missing, p.Name())
+			// ctx.UnsafeSetVar(p.Name(), nil)
 		}
 	}
-	result, err = functor.expr.Eval(ctx)
+	if missing != nil {
+		err = ErrMissingParams(name, missing)
+	} else {
+		result, err = functor.expr.Eval(ctx)
+	}
 	return
 }

bind-go-functions.go

@@ -18,6 +18,6 @@ func (functor *golangFunctor) TypeName() string {
 	return "GoFunctor"
 }
 
-func (functor *golangFunctor) Invoke(ctx ExprContext, name string, args []any) (result any, err error) {
+func (functor *golangFunctor) InvokeNamed(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	return functor.f(ctx, name, args)
 }

builtin-base.go

@@ -10,53 +10,57 @@ import (
 	"strconv"
 )
 
-func isNilFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+const (
-	result = args[0] == nil
+	ParamDenominator = "denominator"
+)
+
+func isNilFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	result = args[ParamValue] == nil
 	return
 }
 
-func isIntFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func isIntFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsInteger(args[0])
+	result = IsInteger(args[ParamValue])
 	return
 }
 
-func isFloatFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func isFloatFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsFloat(args[0])
+	result = IsFloat(args[ParamValue])
 	return
 }
 
-func isBoolFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func isBoolFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsBool(args[0])
+	result = IsBool(args[ParamValue])
 	return
 }
 
-func isStringFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func isStringFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsString(args[0])
+	result = IsString(args[ParamValue])
 	return
 }
 
-func isFractionFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func isFractionFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsFract(args[0])
+	result = IsFract(args[ParamValue])
 	return
 }
 
-func isRationalFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func isRationalFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsRational(args[0])
+	result = IsRational(args[ParamValue])
 	return
 }
 
-func isListFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func isListFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsList(args[0])
+	result = IsList(args[ParamValue])
 	return
 }
 
-func isDictionaryFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func isDictionaryFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	result = IsDict(args[0])
+	result = IsDict(args[ParamValue])
 	return
 }
 
-func boolFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func boolFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	switch v := args[0].(type) {
+	switch v := args[ParamValue].(type) {
 	case int64:
 		result = (v != 0)
 	case *FractionType:
@@ -73,8 +77,8 @@ func boolFunc(ctx ExprContext, name string, args []any) (result any, err error)
 	return
 }
 
-func intFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func intFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	switch v := args[0].(type) {
+	switch v := args[ParamValue].(type) {
 	case int64:
 		result = v
 	case float64:
@@ -96,8 +100,8 @@ func intFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	return
 }
 
-func decFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func decFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	switch v := args[0].(type) {
+	switch v := args[ParamValue].(type) {
 	case int64:
 		result = float64(v)
 	case float64:
@@ -121,8 +125,8 @@ func decFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	return
 }
 
-func stringFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func stringFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	switch v := args[0].(type) {
+	switch v := args[ParamValue].(type) {
 	case int64:
 		result = strconv.FormatInt(v, 10)
 	case float64:
@@ -147,18 +151,18 @@ func stringFunc(ctx ExprContext, name string, args []any) (result any, err error
 	return
 }
 
-func fractFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func fractFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	switch v := args[0].(type) {
+	switch v := args[ParamValue].(type) {
 	case int64:
 		var den int64 = 1
-		if len(args) > 1 {
+
-			var ok bool
+		var ok bool
-			if den, ok = args[1].(int64); !ok {
+		if den, ok = args[ParamDenominator].(int64); !ok {
-				err = ErrExpectedGot(name, "integer", args[1])
+			err = ErrExpectedGot(name, "integer", args[ParamDenominator])
-			} else if den == 0 {
+		} else if den == 0 {
-				err = ErrFuncDivisionByZero(name)
+			err = ErrFuncDivisionByZero(name)
-			}
 		}
+
 		if err == nil {
 			result = newFraction(v, den)
 		}
@@ -205,7 +209,7 @@ func ImportBuiltinsFuncs(ctx ExprContext) {
 	ctx.RegisterFunc("string", NewGolangFunctor(stringFunc), TypeString, anyParams)
 	ctx.RegisterFunc("fract", NewGolangFunctor(fractFunc), TypeFraction, []ExprFuncParam{
 		NewFuncParam(ParamValue),
-		NewFuncParamFlagDef("denominator", PfDefault, 1),
+		NewFuncParamFlagDef(ParamDenominator, PfDefault, int64(1)),
 	})
 }
 

builtin-fmt.go

@@ -21,19 +21,25 @@ func getStdout(ctx ExprContext) io.Writer {
 	return w
 }
 
-func printFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func printFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	var n int
+	var n int = 0
-	if n, err = fmt.Fprint(getStdout(ctx), args...); err == nil {
+	if v, exists := args[ParamItem]; exists && v != nil {
-		result = int64(n)
+		argv := v.([]any)
+		n, err = fmt.Fprint(getStdout(ctx), argv...)
 	}
+	result = int64(n)
 	return
 }
 
-func printLnFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func printLnFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	var n int
+	var n int = 0
-	if n, err = fmt.Fprintln(getStdout(ctx), args...); err == nil {
+	if v, exists := args[ParamItem]; exists && v != nil {
-		result = int64(n)
+		argv := v.([]any)
+		n, err = fmt.Fprintln(getStdout(ctx), argv...)
+	} else {
+		n, err = fmt.Fprintln(getStdout(ctx))
 	}
+	result = int64(n)
 	return
 }
 

builtin-import.go

@@ -9,18 +9,21 @@ import (
 	"os"
 )
 
-func importFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func importFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	return importGeneral(ctx, name, args)
 }
 
-func importAllFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func importAllFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	CtrlEnable(ctx, control_export_all)
 	return importGeneral(ctx, name, args)
 }
 
-func importGeneral(ctx ExprContext, name string, args []any) (result any, err error) {
+func importGeneral(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	dirList := buildSearchDirList("sources", ENV_EXPR_SOURCE_PATH)
-	result, err = doImport(ctx, name, dirList, NewArrayIterator(args))
+	if v, exists := args[ParamFilepath]; exists && v != nil {
+		argv := v.([]any)
+		result, err = doImport(ctx, name, dirList, NewArrayIterator(argv))
+	}
 	return
 }
 

builtin-iterator.go

@@ -15,43 +15,44 @@ const (
 	iterVarStatus     = "status"
 )
 
-func parseRunArgs(localCtx ExprContext, args []any) (it Iterator, op Functor, err error) {
+func parseRunArgs(localCtx ExprContext, args map[string]any) (it Iterator, op Functor, err error) {
 	var ok bool
 
-	if it, ok = args[0].(Iterator); !ok {
+	if it, ok = args[ParamIterator].(Iterator); !ok {
-		err = fmt.Errorf("paramter %q must be an iterator, passed %v [%s]", ParamIterator, args[0], TypeName(args[0]))
+		err = fmt.Errorf("paramter %q must be an iterator, passed %v [%s]", ParamIterator, args[ParamIterator], TypeName(args[ParamIterator]))
 		return
 	}
 
-	if len(args) > 1 {
+	if op, ok = args[iterParamOperator].(Functor); !ok && args[iterParamOperator] != nil {
-		if op, ok = args[1].(Functor); !ok || op == nil {
+		err = fmt.Errorf("paramter %q must be a function, passed %v [%s]", iterParamOperator, args[iterParamOperator], TypeName(args[iterParamOperator]))
-			err = fmt.Errorf("paramter %q must be a function, passed %v [%s]", iterParamOperator, args[1], TypeName(args[1]))
+		return
-			return
+	}
-		}
+
-		if len(args) > 2 {
+	var vars *DictType
-			var vars *DictType
+	if vars, ok = args[iterParamVars].(*DictType); !ok && args[iterParamVars] != nil {
-			if vars, ok = args[2].(*DictType); !ok || vars == 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[2], TypeName(args[2]))
+		return
-				return
+	}
-			}
+
-			for key, value := range *vars {
+	if vars != nil {
-				var varName string
+		for key, value := range *vars {
-				if varName, ok = key.(string); ok {
+			var varName string
-					localCtx.UnsafeSetVar(varName, value)
+			if varName, ok = key.(string); ok {
-				}
+				localCtx.UnsafeSetVar(varName, value)
 			}
 		}
 	}
+
 	return
 }
 
-func runFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func runFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	var it Iterator
 	var ok bool
 	var op Functor
 	var v any
 	var usingDefaultOp = false
-	var params []any
+	var params map[string]any
 	var item any
 
 	localCtx := ctx.Clone()
@@ -66,12 +67,12 @@ func runFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 
 	for item, err = it.Next(); err == nil; item, err = it.Next() {
 		if usingDefaultOp {
-			params = []any{item}
+			params = map[string]any{ParamItem: []any{item}}
 		} else {
-			params = []any{it.Index(), item}
+			params = map[string]any{ParamIndex: it.Index(), ParamItem: item}
 		}
 
-		if v, err = op.Invoke(localCtx, iterParamOperator, params); err != nil {
+		if v, err = op.InvokeNamed(localCtx, iterParamOperator, params); err != nil {
 			break
 		} else {
 			var success bool

builtin-math-arith.go

@@ -86,8 +86,9 @@ func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result
 	return
 }
 
-func addFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func addFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	result, err = doAdd(ctx, name, NewArrayIterator(args), 0, -1)
+	argv := args[ParamValue].([]any)
+	result, err = doAdd(ctx, name, NewArrayIterator(argv), 0, -1)
 	return
 }
 
@@ -161,17 +162,18 @@ func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result
 	return
 }
 
-func mulFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func mulFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	result, err = doMul(ctx, name, NewArrayIterator(args), 0, -1)
+	argv := args[ParamValue].([]any)
+	result, err = doMul(ctx, name, NewArrayIterator(argv), 0, -1)
 	return
 }
 
 func ImportMathFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("add", &golangFunctor{f: addFunc}, TypeNumber, []ExprFuncParam{
+	ctx.RegisterFunc("add", NewGolangFunctor(addFunc), TypeNumber, []ExprFuncParam{
 		NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(0)),
 	})
 
-	ctx.RegisterFunc("mul", &golangFunctor{f: mulFunc}, TypeNumber, []ExprFuncParam{
+	ctx.RegisterFunc("mul", NewGolangFunctor(mulFunc), TypeNumber, []ExprFuncParam{
 		NewFuncParamFlagDef(ParamValue, PfDefault|PfRepeat, int64(1)),
 	})
 }

builtin-os-file.go

@@ -11,6 +11,10 @@ import (
 	"os"
 )
 
+const (
+	osLimitCh = "limitCh"
+)
+
 type osHandle interface {
 	getFile() *os.File
 }
@@ -61,8 +65,8 @@ func errInvalidFileHandle(funcName string, v any) error {
 	}
 }
 
-func createFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func createFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	if filePath, ok := args[0].(string); ok && len(filePath) > 0 {
+	if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 {
 		var fh *os.File
 		if fh, err = os.Create(filePath); err == nil {
 			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
@@ -73,8 +77,8 @@ func createFileFunc(ctx ExprContext, name string, args []any) (result any, err e
 	return
 }
 
-func openFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func openFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	if filePath, ok := args[0].(string); ok && len(filePath) > 0 {
+	if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 {
 		var fh *os.File
 		if fh, err = os.Open(filePath); err == nil {
 			result = &osReader{fh: fh, reader: bufio.NewReader(fh)}
@@ -85,8 +89,8 @@ func openFileFunc(ctx ExprContext, name string, args []any) (result any, err err
 	return
 }
 
-func appendFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func appendFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	if filePath, ok := args[0].(string); ok && len(filePath) > 0 {
+	if filePath, ok := args[ParamFilepath].(string); ok && len(filePath) > 0 {
 		var fh *os.File
 		if fh, err = os.OpenFile(filePath, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0660); err == nil {
 			result = &osWriter{fh: fh, writer: bufio.NewWriter(fh)}
@@ -97,13 +101,13 @@ func appendFileFunc(ctx ExprContext, name string, args []any) (result any, err e
 	return
 }
 
-func closeFileFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func closeFileFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	var handle osHandle
 	var invalidFileHandle any
 	var ok bool
 
-	if handle, ok = args[0].(osHandle); !ok {
+	if handle, ok = args[ParamHandle].(osHandle); !ok {
-		invalidFileHandle = args[0]
+		invalidFileHandle = args[ParamHandle]
 	}
 
 	if handle != nil {
@@ -124,18 +128,21 @@ func closeFileFunc(ctx ExprContext, name string, args []any) (result any, err er
 	return
 }
 
-func fileWriteTextFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func fileWriteTextFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	var handle osHandle
 	var invalidFileHandle any
 	var ok bool
 
-	if handle, ok = args[0].(osHandle); !ok {
+	if handle, ok = args[ParamHandle].(osHandle); !ok {
-		invalidFileHandle = args[0]
+		invalidFileHandle = args[ParamHandle]
 	}
 
 	if handle != nil {
 		if w, ok := handle.(*osWriter); ok {
-			result, err = fmt.Fprint(w.writer, args[1:]...)
+			if v, exists := args[ParamItem]; exists {
+				argv := v.([]any)
+				result, err = fmt.Fprint(w.writer, argv...)
+			}
 		} else {
 			invalidFileHandle = handle
 		}
@@ -147,21 +154,21 @@ func fileWriteTextFunc(ctx ExprContext, name string, args []any) (result any, er
 	return
 }
 
-func fileReadTextFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func fileReadTextFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	var handle osHandle
 	var invalidFileHandle any
 	var ok bool
 
 	result = nil
-	if handle, ok = args[0].(osHandle); !ok || args[0] == nil {
+	if handle, ok = args[ParamHandle].(osHandle); !ok || args[ParamHandle] == nil {
-		invalidFileHandle = args[0]
+		invalidFileHandle = args[ParamHandle]
 	}
 
 	if handle != nil {
 		if r, ok := handle.(*osReader); ok {
 			var limit byte = '\n'
 			var v string
-			if s, ok := args[1].(string); ok && len(s) > 0 {
+			if s, ok := args[osLimitCh].(string); ok && len(s) > 0 {
 				limit = s[0]
 			}
 
@@ -187,14 +194,14 @@ func fileReadTextFunc(ctx ExprContext, name string, args []any) (result any, err
 	return
 }
 
-func fileReadTextAllFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func fileReadTextAllFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	var handle osHandle
 	var invalidFileHandle any
 	var ok bool
 
 	result = nil
-	if handle, ok = args[0].(osHandle); !ok || args[0] == nil {
+	if handle, ok = args[ParamHandle].(osHandle); !ok || args[ParamHandle] == nil {
-		invalidFileHandle = args[0]
+		invalidFileHandle = args[ParamHandle]
 	}
 
 	if handle != nil {
@@ -214,34 +221,34 @@ func fileReadTextAllFunc(ctx ExprContext, name string, args []any) (result any,
 }
 
 func ImportOsFuncs(ctx ExprContext) {
-	ctx.RegisterFunc("fileOpen", NewGolangFunctor(openFileFunc), TypeHandle, []ExprFuncParam{
+	ctx.RegisterFunc("fileOpen", NewGolangFunctor(openFileFunc), TypeFileHandle, []ExprFuncParam{
 		NewFuncParam(ParamFilepath),
 	})
 
-	ctx.RegisterFunc("fileAppend", NewGolangFunctor(appendFileFunc), TypeHandle, []ExprFuncParam{
+	ctx.RegisterFunc("fileAppend", NewGolangFunctor(appendFileFunc), TypeFileHandle, []ExprFuncParam{
 		NewFuncParam(ParamFilepath),
 	})
 
-	ctx.RegisterFunc("fileCreate", NewGolangFunctor(createFileFunc), TypeHandle, []ExprFuncParam{
+	ctx.RegisterFunc("fileCreate", NewGolangFunctor(createFileFunc), TypeFileHandle, []ExprFuncParam{
 		NewFuncParam(ParamFilepath),
 	})
 
 	ctx.RegisterFunc("fileClose", NewGolangFunctor(closeFileFunc), TypeBoolean, []ExprFuncParam{
-		NewFuncParam(TypeHandle),
+		NewFuncParam(ParamHandle),
 	})
 
 	ctx.RegisterFunc("fileWriteText", NewGolangFunctor(fileWriteTextFunc), TypeInt, []ExprFuncParam{
-		NewFuncParam(TypeHandle),
+		NewFuncParam(ParamHandle),
-		NewFuncParamFlagDef(TypeItem, PfDefault|PfRepeat, ""),
+		NewFuncParamFlagDef(ParamItem, PfDefault|PfRepeat, ""),
 	})
 
 	ctx.RegisterFunc("fileReadText", NewGolangFunctor(fileReadTextFunc), TypeString, []ExprFuncParam{
-		NewFuncParam(TypeHandle),
+		NewFuncParam(ParamHandle),
-		NewFuncParamFlagDef("limitCh", PfDefault, "\n"),
+		NewFuncParamFlagDef(osLimitCh, PfDefault, "\n"),
 	})
 
 	ctx.RegisterFunc("fileReadTextAll", NewGolangFunctor(fileReadTextAllFunc), TypeString, []ExprFuncParam{
-		NewFuncParam(TypeHandle),
+		NewFuncParam(ParamHandle),
 	})
 }
 

builtin-string.go

@@ -10,6 +10,10 @@ import (
 	"strings"
 )
 
+const (
+	strParamOther = "other"
+)
+
 // --- Start of function definitions
 func doJoinStr(funcName string, sep string, it Iterator) (result any, err error) {
 	var sb strings.Builder
@@ -32,45 +36,45 @@ func doJoinStr(funcName string, sep string, it Iterator) (result any, err error)
 	return
 }
 
-func joinStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func joinStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	//	if len(args) < 1 {
+	if sep, ok := args[ParamSeparator].(string); ok {
-	//		return nil, errMissingRequiredParameter(name, paramSeparator)
+		if v, exists := args[ParamItem]; exists {
-	//	}
+			argv := v.([]any)
-	if sep, ok := args[0].(string); ok {
+			if len(argv) == 1 {
-		if len(args) == 1 {
+				if ls, ok := argv[0].(*ListType); ok {
-			result = ""
+					result, err = doJoinStr(name, sep, NewListIterator(ls, nil))
-		} else if len(args) == 2 {
+				} else if it, ok := argv[0].(Iterator); ok {
-			if ls, ok := args[1].(*ListType); ok {
+					result, err = doJoinStr(name, sep, it)
-				result, err = doJoinStr(name, sep, NewListIterator(ls, nil))
+				} else if s, ok := argv[0].(string); ok {
-			} else if it, ok := args[1].(Iterator); ok {
+					result = s
-				result, err = doJoinStr(name, sep, it)
+				} else {
+					err = ErrInvalidParameterValue(name, ParamItem, v)
+				}
 			} else {
-				err = ErrInvalidParameterValue(name, ParamParts, args[1])
+				result, err = doJoinStr(name, sep, NewArrayIterator(argv))
 			}
-		} else {
-			result, err = doJoinStr(name, sep, NewArrayIterator(args[1:]))
 		}
 	} else {
-		err = ErrWrongParamType(name, ParamSeparator, TypeString, args[0])
+		err = ErrWrongParamType(name, ParamSeparator, TypeString, args[ParamSeparator])
 	}
 	return
 }
 
-func subStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func subStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	var start = 0
 	var count = -1
 	var source string
 	var ok bool
 
-	if source, ok = args[0].(string); !ok {
+	if source, ok = args[ParamSource].(string); !ok {
-		return nil, ErrWrongParamType(name, ParamSource, TypeString, args[0])
+		return nil, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
 	}
 
-	if start, err = ToGoInt(args[1], name+"()"); err != nil {
+	if start, err = ToGoInt(args[ParamStart], name+"()"); err != nil {
 		return
 	}
 
-	if count, err = ToGoInt(args[2], name+"()"); err != nil {
+	if count, err = ToGoInt(args[ParamCount], name+"()"); err != nil {
 		return
 	}
 
@@ -86,81 +90,99 @@ func subStrFunc(ctx ExprContext, name string, args []any) (result any, err error
 	return
 }
 
-func trimStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func trimStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	var source string
 	var ok bool
 
-	if source, ok = args[0].(string); !ok {
+	if source, ok = args[ParamSource].(string); !ok {
-		return nil, ErrWrongParamType(name, ParamSource, TypeString, args[0])
+		return nil, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
 	}
 	result = strings.TrimSpace(source)
 	return
 }
 
-func startsWithStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func startsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	var source string
+	var source, prefix string
 	var ok bool
 
 	result = false
 
-	if source, ok = args[0].(string); !ok {
+	if source, ok = args[ParamSource].(string); !ok {
-		return result, ErrWrongParamType(name, ParamSource, TypeString, args[0])
+		return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
 	}
-	for i, targetSpec := range args[1:] {
+
-		if target, ok := targetSpec.(string); ok {
+	if prefix, ok = args[ParamPrefix].(string); !ok {
-			if strings.HasPrefix(source, target) {
+		return result, ErrWrongParamType(name, ParamPrefix, TypeString, args[ParamPrefix])
-				result = true
+	}
+	if strings.HasPrefix(source, prefix) {
+		result = true
+	} else if v, exists := args[strParamOther]; exists {
+		argv := v.([]any)
+		for i, targetSpec := range argv {
+			if target, ok := targetSpec.(string); ok {
+				if strings.HasPrefix(source, target) {
+					result = true
+					break
+				}
+			} else {
+				err = fmt.Errorf("target item nr %d is %s, string expected", i+1, TypeName(targetSpec))
 				break
 			}
-		} else {
-			err = fmt.Errorf("target item nr %d is %T, expected string", i+1, targetSpec)
-			break
 		}
 	}
 	return
 }
 
-func endsWithStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func endsWithStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-	var source string
+	var source, suffix string
 	var ok bool
 
 	result = false
 
-	if source, ok = args[0].(string); !ok {
+	if source, ok = args[ParamSource].(string); !ok {
-		return result, ErrWrongParamType(name, ParamSource, TypeString, args[0])
+		return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
 	}
-	for i, targetSpec := range args[1:] {
+
-		if target, ok := targetSpec.(string); ok {
+	if suffix, ok = args[ParamSuffix].(string); !ok {
-			if strings.HasSuffix(source, target) {
+		return result, ErrWrongParamType(name, ParamSuffix, TypeString, args[ParamSuffix])
-				result = true
+	}
+	if strings.HasPrefix(source, suffix) {
+		result = true
+	} else if v, exists := args[strParamOther]; exists {
+		argv := v.([]any)
+		for i, targetSpec := range argv {
+			if target, ok := targetSpec.(string); ok {
+				if strings.HasSuffix(source, target) {
+					result = true
+					break
+				}
+			} else {
+				err = fmt.Errorf("target item nr %d is %s, string expected", i+1, TypeName(targetSpec))
 				break
 			}
-		} else {
-			err = fmt.Errorf("target item nr %d is %T, expected string", i+1, targetSpec)
-			break
 		}
 	}
 	return
 }
 
-func splitStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+func splitStrFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	var source, sep string
 	var count int = -1
 	var parts []string
 	var ok bool
 
-	if source, ok = args[0].(string); !ok {
+	if source, ok = args[ParamSource].(string); !ok {
-		return result, ErrWrongParamType(name, ParamSource, TypeString, args[0])
+		return result, ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
 	}
 
-	if sep, ok = args[1].(string); !ok {
+	if sep, ok = args[ParamSeparator].(string); !ok {
-		return nil, fmt.Errorf("separator param must be string, got %T (%v)", args[1], args[1])
+		return nil, fmt.Errorf("separator param must be string, got %s (%v)", TypeName(args[ParamSeparator]), args[ParamSeparator])
 	}
 
-	if count64, ok := args[2].(int64); ok { // TODO replace type assertion with toInt()
+	if count64, ok := args[ParamCount].(int64); ok { // TODO replace type assertion with toInt()
 		count = int(count64)
 	} else {
-		return nil, fmt.Errorf("part count must be integer, got %T (%v)", args[2], args[2])
+		return nil, fmt.Errorf("part count must be integer, got %s (%v)", TypeName(args[ParamCount]), args[ParamCount])
 	}
 
 	if count > 0 {
@@ -206,13 +228,13 @@ func ImportStringFuncs(ctx ExprContext) {
 	ctx.RegisterFunc("strStartsWith", NewGolangFunctor(startsWithStrFunc), TypeBoolean, []ExprFuncParam{
 		NewFuncParam(ParamSource),
 		NewFuncParam(ParamPrefix),
-		NewFuncParamFlag("other "+ParamPrefix, PfRepeat),
+		NewFuncParamFlag(strParamOther, PfRepeat),
 	})
 
 	ctx.RegisterFunc("strEndsWith", NewGolangFunctor(endsWithStrFunc), TypeBoolean, []ExprFuncParam{
 		NewFuncParam(ParamSource),
 		NewFuncParam(ParamSuffix),
-		NewFuncParamFlag("other "+ParamSuffix, PfRepeat),
+		NewFuncParamFlag(strParamOther, PfRepeat),
 	})
 }
 

common-errors.go

@@ -6,8 +6,13 @@ package expr
 
 import (
 	"fmt"
+	"strings"
 )
 
+func ErrMissingParams(funcName string, missing []string) (err error) {
+	return fmt.Errorf("%s(): missing params -- %s", funcName, strings.Join(missing, ", "))
+}
+
 func ErrTooFewParams(funcName string, minArgs, maxArgs, argCount int) (err error) {
 	if maxArgs < 0 {
 		err = fmt.Errorf("%s(): too few params -- expected %d or more, got %d", funcName, minArgs, argCount)
@@ -17,8 +22,8 @@ func ErrTooFewParams(funcName string, minArgs, maxArgs, argCount int) (err error
 	return
 }
 
-func ErrTooMuchParams(funcName string, maxArgs, argCount int) (err error) {
+func ErrTooManyParams(funcName string, maxArgs, argCount int) (err error) {
-	err = fmt.Errorf("%s(): too much params -- expected %d, got %d", funcName, maxArgs, argCount)
+	err = fmt.Errorf("%s(): too many params -- expected %d, got %d", funcName, maxArgs, argCount)
 	return
 }
 
@@ -54,6 +59,10 @@ func ErrWrongParamType(funcName, paramName, paramType string, paramValue any) er
 	return fmt.Errorf("%s(): the %q parameter must be a %s, got a %s (%v)", funcName, paramName, paramType, TypeName(paramValue), paramValue)
 }
 
+func ErrUnknownParam(funcName, paramName string) error {
+	return fmt.Errorf("%s(): unknown parameter %q", funcName, paramName)
+}
+
 // --- Operator errors
 
 func ErrLeftOperandMustBeVariable(leftTerm, opTerm *term) error {

common-params.go

@@ -5,8 +5,10 @@
 package expr
 
 const (
+	ParamArgs      = "args"
 	ParamCount     = "count"
 	ParamItem      = "item"
+	ParamIndex     = "index"
 	ParamParts     = "parts"
 	ParamSeparator = "separator"
 	ParamSource    = "source"
@@ -19,6 +21,8 @@ const (
 	ParamEllipsis  = "..."
 	ParamFilepath  = "filepath"
 	ParamDirpath   = "dirpath"
+	ParamHandle    = "handle"
+	ParamResource  = "resource"
 	ParamIterator  = "iterator"
 )
 

common-type-names.go

@@ -5,16 +5,16 @@
 package expr
 
 const (
-	TypeAny      = "any"
+	TypeAny           = "any"
-	TypeBoolean  = "boolean"
+	TypeBoolean       = "boolean"
-	TypeFloat    = "float"
+	TypeFloat         = "float"
-	TypeFraction = "fraction"
+	TypeFraction      = "fraction"
-	TypeHandle   = "handle"
+	TypeFileHandle    = "file-handle"
-	TypeInt      = "integer"
+	TypeInt           = "integer"
-	TypeItem     = "item"
+	TypeItem          = "item"
-	TypeNumber   = "number"
+	TypeNumber        = "number"
-	TypePair     = "pair"
+	TypePair          = "pair"
-	TypeString   = "string"
+	TypeString        = "string"
-	TypeListOf = "list-of-"
+	TypeListOf        = "list-of-"
 	TypeListOfStrings = "list-of-strings"
 )

data-cursor.go

@@ -85,7 +85,7 @@ func (dc *dataCursor) HasOperation(name string) (exists bool) {
 	return
 }
 
-func (dc *dataCursor) CallOperation(name string, args []any) (value any, err error) {
+func (dc *dataCursor) CallOperation(name string, args map[string]any) (value any, err error) {
 	if name == IndexName {
 		value = int64(dc.Index())
 	} else if functor, ok := dc.ds[name]; ok && isFunctor(functor) {
@@ -95,7 +95,7 @@ func (dc *dataCursor) CallOperation(name string, args []any) (value any, err err
 			value, err = dc.Reset()
 		} else {
 			ctx := cloneContext(dc.ctx)
-			value, err = functor.Invoke(ctx, name, []any{})
+			value, err = functor.InvokeNamed(ctx, name, args)
 			exportObjects(dc.ctx, ctx)
 		}
 	} else {
@@ -108,7 +108,8 @@ func (dc *dataCursor) Reset() (success bool, err error) {
 	if dc.resetFunc != nil {
 		if dc.resource != nil {
 			ctx := cloneContext(dc.ctx)
-			_, err = dc.resetFunc.Invoke(ctx, ResetName, []any{dc.resource})
+			actualParams := bindActualParams(dc.resetFunc, []any{dc.resource})
+			_, err = dc.resetFunc.InvokeNamed(ctx, ResetName, actualParams)
 			exportObjects(dc.ctx, ctx)
 			dc.index = -1
 			dc.count = 0
@@ -130,7 +131,8 @@ func (dc *dataCursor) Clean() (success bool, err error) {
 	if dc.cleanFunc != nil {
 		if dc.resource != nil {
 			ctx := cloneContext(dc.ctx)
-			_, err = dc.cleanFunc.Invoke(ctx, CleanName, []any{dc.resource})
+			actualParams := bindActualParams(dc.cleanFunc, []any{dc.resource})
+			_, err = dc.cleanFunc.InvokeNamed(ctx, CleanName, actualParams)
 			//			dc.resource = nil
 			exportObjects(dc.ctx, ctx)
 		} else {
@@ -158,7 +160,9 @@ func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err
 	var v any
 	var ok bool
 	ctx := cloneContext(dc.ctx)
-	if v, err = filter.Invoke(ctx, FilterName, []any{item, dc.index}); err == nil && v != nil {
+
+	actualParams := bindActualParams(filter, []any{item, dc.index})
+	if v, err = filter.InvokeNamed(ctx, FilterName, actualParams); err == nil && v != nil {
 		if accepted, ok = v.(bool); !ok {
 			accepted = true // NOTE: A non-boolean value that is not nil means the item has been accepted
 		}
@@ -168,7 +172,8 @@ func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err
 
 func (dc *dataCursor) mapItem(mapper Functor, item any) (mappedItem any, err error) {
 	ctx := cloneContext(dc.ctx)
-	mappedItem, err = mapper.Invoke(ctx, MapName, []any{item, dc.index})
+	actualParams := bindActualParams(mapper, []any{item, dc.index})
+	mappedItem, err = mapper.InvokeNamed(ctx, MapName, actualParams)
 	return
 }
 
@@ -193,7 +198,9 @@ func (dc *dataCursor) Next() (current any, err error) { // must return io.EOF af
 		for item == nil && dc.lastErr == nil {
 			ctx := cloneContext(dc.ctx)
 			dc.index++
-			if item, dc.lastErr = dc.nextFunc.Invoke(ctx, NextName, []any{dc.resource, dc.index}); dc.lastErr == nil {
+
+			actualParams := bindActualParams(dc.nextFunc, []any{dc.resource, dc.index})
+			if item, dc.lastErr = dc.nextFunc.InvokeNamed(ctx, NextName, actualParams); dc.lastErr == nil {
 				if item == nil {
 					dc.lastErr = io.EOF
 				} else {

expr-context.go

@@ -7,7 +7,6 @@ package expr
 // ----Expression Context
 type ExprContext interface {
 	Clone() ExprContext
-	// Merge(ctx ExprContext)
 	SetParent(ctx ExprContext)
 	GetParent() (ctx ExprContext)
 	GetVar(varName string) (value any, exists bool)
@@ -24,7 +23,7 @@ type ExprContext interface {
 	DeleteFunc(funcName string)
 
 	GetFuncInfo(name string) (item ExprFunc, exists bool)
-	Call(name string, args []any) (result any, err error)
+	Call(name string, args map[string]any) (result any, err error)
 	RegisterFuncInfo(info ExprFunc)
-	RegisterFunc(name string, f Functor, returnType string, param []ExprFuncParam) error
+	RegisterFunc(name string, f Functor, returnType string, param []ExprFuncParam) (funcInfo ExprFunc, err error)
 }

expr-function.go

@@ -7,7 +7,7 @@ package expr
 // ---- Functor interface
 type Functor interface {
 	Typer
-	Invoke(ctx ExprContext, name string, args []any) (result any, err error)
+	InvokeNamed(ctx ExprContext, name string, args map[string]any) (result any, err error)
 	SetFunc(info ExprFunc)
 	GetFunc() ExprFunc
 	GetParams() []ExprFuncParam
@@ -32,7 +32,8 @@ type ExprFunc interface {
 	MaxArgs() int
 	Functor() Functor
 	Params() []ExprFuncParam
+	ParamSpec(paramName string) ExprFuncParam
 	ReturnType() string
-	PrepareCall(parentCtx ExprContext, name string, varParams *[]any) (ctx ExprContext, err error)
+	PrepareCall(name string, actualParams map[string]any) (err error)
 	AllocContext(parentCtx ExprContext) (ctx ExprContext)
 }

function.go

@@ -6,11 +6,12 @@ package expr
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
 )
 
 // ---- Function template
-type FuncTemplate func(ctx ExprContext, name string, args []any) (result any, err error)
+type FuncTemplate func(ctx ExprContext, name string, args map[string]any) (result any, err error)
 
 // ---- Common functor definition
 type baseFunctor struct {
@@ -137,10 +138,6 @@ func newFuncInfo(name string, functor Functor, returnType string, params []ExprF
 	return info, nil
 }
 
-// func newUnnamedFuncInfo(functor Functor, returnType string, params []ExprFuncParam) (info *funcInfo, err error) {
-// 	return newFuncInfo("unnamed", functor, returnType, params)
-// }
-
 func (info *funcInfo) Params() []ExprFuncParam {
 	return info.formalParams
 }
@@ -216,37 +213,133 @@ func (info *funcInfo) AllocContext(parentCtx ExprContext) (ctx ExprContext) {
 	return
 }
 
-func (info *funcInfo) PrepareCall(parentCtx ExprContext, name string, varActualParams *[]any) (ctx ExprContext, err error) {
+func (info *funcInfo) ParamSpec(paramName string) ExprFuncParam {
-	passedCount := len(*varActualParams)
+	for _, spec := range info.formalParams {
-	if info.MinArgs() > passedCount {
+		if spec.Name() == paramName {
-		err = ErrTooFewParams(name, info.MinArgs(), info.MaxArgs(), passedCount)
+			return spec
+		}
+	}
+	return nil
+}
+
+func initActualParams(ctx ExprContext, info ExprFunc, callTerm *term) (actualParams map[string]any, err error) {
+	var varArgs []any
+	var varName string
+
+	namedParamsStarted := false
+
+	formalParams := info.Params()
+	actualParams = make(map[string]any, len(formalParams))
+	if callTerm == nil {
+		return
 	}
 
-	for i := passedCount; i < len(info.formalParams); i++ {
+	for i, tree := range callTerm.children {
-		p := info.formalParams[i]
+		var paramValue any
-		if !p.IsDefault() {
+		paramCtx := ctx.Clone()
+		if paramValue, err = tree.compute(paramCtx); err != nil {
+			break
+		}
+		if paramName, namedParam := getAssignVarName(tree); namedParam {
+			if info.ParamSpec(paramName) == nil {
+				err = fmt.Errorf("%s(): unknown param %q", info.Name(), paramName)
+				break
+			}
+			actualParams[paramName] = paramValue
+			namedParamsStarted = true
+		} else if !namedParamsStarted {
+			if varArgs != nil {
+				varArgs = append(varArgs, paramValue)
+			} else if i < len(formalParams) {
+				spec := formalParams[i]
+				if spec.IsRepeat() {
+					varArgs = make([]any, 0, len(callTerm.children)-i)
+					varArgs = append(varArgs, paramValue)
+					varName = spec.Name()
+				} else {
+					actualParams[spec.Name()] = paramValue
+				}
+			} else {
+				err = ErrTooManyParams(info.Name(), len(formalParams), len(callTerm.children))
+				break
+			}
+		} else {
+			err = fmt.Errorf("%s(): positional param nr %d not allowed after named params", info.Name(), i+1)
 			break
 		}
-		*varActualParams = append(*varActualParams, p.DefaultValue())
 	}
-	if err == nil && info.MaxArgs() >= 0 && info.MaxArgs() < len(*varActualParams) {
+	if err == nil {
-		err = ErrTooMuchParams(name, info.MaxArgs(), len(*varActualParams))
+		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 err == nil {
+	if passedCount < len(info.formalParams) {
-		ctx = info.AllocContext(parentCtx)
+		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 CallFunction(parentCtx ExprContext, name string, actualParams []any) (result any, err error) {
+func getAssignVarName(t *term) (name string, ok bool) {
-	if info, exists, _ := GetFuncInfo(parentCtx, name); exists {
+	if ok = t.symbol() == SymEqual; ok {
-		var ctx ExprContext
+		name = t.children[0].source()
-		if ctx, err = info.PrepareCall(parentCtx, name, &actualParams); err == nil {
+	}
-			functor := info.Functor()
+	return
-			result, err = functor.Invoke(ctx, name, actualParams)
+}
+
+func CallFunctionByTerm(parentCtx ExprContext, name string, callTerm *term) (result any, err error) {
+	var actualParams map[string]any
+	if info, exists := GetFuncInfo(parentCtx, name); exists {
+		if actualParams, err = initActualParams(parentCtx, info, callTerm); err == nil {
+			ctx := info.AllocContext(parentCtx)
+			if err = info.PrepareCall(name, actualParams); err == nil {
+				functor := info.Functor()
+				result, err = functor.InvokeNamed(ctx, name, actualParams)
+				exportObjectsToParent(ctx)
+			}
+		}
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}
+
+func CallFunctionByArgs(parentCtx ExprContext, name string, args []any) (result any, err error) {
+	var actualParams map[string]any
+	if info, exists := GetFuncInfo(parentCtx, name); exists {
+		functor := info.Functor()
+		actualParams = bindActualParams(functor, args)
+		ctx := info.AllocContext(parentCtx)
+		if err = info.PrepareCall(name, actualParams); err == nil {
+			result, err = functor.InvokeNamed(ctx, name, actualParams)
 			exportObjectsToParent(ctx)
 		}
 	} else {
@@ -254,3 +347,40 @@ func CallFunction(parentCtx ExprContext, name string, actualParams []any) (resul
 	}
 	return
 }
+
+func CallFunctionByParams(parentCtx ExprContext, name string, params map[string]any) (result any, err error) {
+	var actualParams map[string]any
+	if info, exists := GetFuncInfo(parentCtx, name); exists {
+		functor := info.Functor()
+		ctx := info.AllocContext(parentCtx)
+		if err = info.PrepareCall(name, actualParams); err == nil {
+			result, err = functor.InvokeNamed(ctx, name, actualParams)
+			exportObjectsToParent(ctx)
+		}
+	} else {
+		err = fmt.Errorf("unknown function %s()", name)
+	}
+	return
+}
+
+func GetParam(args map[string]any, paramName string, paramNum int) (value any, exists bool) {
+	if value, exists = args[paramName]; !exists {
+		if paramNum > 0 && paramNum <= len(args) {
+			value, exists = args["arg"+strconv.Itoa(paramNum)]
+		}
+	}
+	return
+}
+
+func bindActualParams(functor Functor, args []any) (actualParams map[string]any) {
+	formalParams := functor.GetParams()
+	actualParams = make(map[string]any, len(args))
+	for i, arg := range args {
+		if i < len(formalParams) {
+			actualParams[formalParams[i].Name()] = arg
+		} else {
+			actualParams["arg"+strconv.Itoa(i+1)] = arg
+		}
+	}
+	return
+}

global-context.go

@@ -55,7 +55,20 @@ func GetLocalFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool)
 	}
 	return
 }
-func GetFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool, ownerCtx ExprContext) {
+
+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

iterator.go

@@ -34,7 +34,7 @@ type Iterator interface {
 type ExtIterator interface {
 	Iterator
 	HasOperation(name string) bool
-	CallOperation(name string, args []any) (value any, err error)
+	CallOperation(name string, args map[string]any) (value any, err error)
 }
 
 func errNoOperation(name string) error {

list-iterator.go

@@ -94,7 +94,7 @@ func (it *ListIterator) HasOperation(name string) bool {
 	return yes
 }
 
-func (it *ListIterator) CallOperation(name string, args []any) (v any, err error) {
+func (it *ListIterator) CallOperation(name string, args map[string]any) (v any, err error) {
 	switch name {
 	case NextName:
 		v, err = it.Next()

operand-func.go

@@ -21,20 +21,26 @@ func newFuncCallTerm(tk *Token, args []*term) *term {
 }
 
 // -------- eval func call
+// func _evalFuncCall(ctx ExprContext, opTerm *term) (v any, err error) {
+// 	name, _ := opTerm.tk.Value.(string)
+// 	params := make([]any, len(opTerm.children), len(opTerm.children)+5)
+// 	for i, tree := range opTerm.children {
+// 		var param any
+// 		if param, err = tree.compute(ctx); err != nil {
+// 			break
+// 		}
+// 		params[i] = param
+// 	}
+
+// 	if err == nil {
+// 		v, err = CallFunction(ctx, name, params)
+// 	}
+// 	return
+// }
+
 func evalFuncCall(ctx ExprContext, opTerm *term) (v any, err error) {
 	name, _ := opTerm.tk.Value.(string)
-	params := make([]any, len(opTerm.children), len(opTerm.children)+5)
+	v, err = CallFunctionByTerm(ctx, name, opTerm)
-	for i, tree := range opTerm.children {
-		var param any
-		if param, err = tree.compute(ctx); err != nil {
-			break
-		}
-		params[i] = param
-	}
-
-	if err == nil {
-		v, err = CallFunction(ctx, name, params)
-	}
 	return
 }
 

operand-iterator.go

@@ -11,22 +11,6 @@ import (
 
 // -------- iterator term
 
-// func newDsIteratorTerm(tk *Token, dsTerm *term, args []*term) *term {
-// 	tk.Sym = SymIterator
-
-// 	children := make([]*term, 0, 1+len(args))
-// 	children = append(children, dsTerm)
-// 	children = append(children, args...)
-// 	return &term{
-// 		tk:       *tk,
-// 		parent:   nil,
-// 		children: children,
-// 		position: posLeaf,
-// 		priority: priValue,
-// 		evalFunc: evalIterator,
-// 	}
-// }
-
 func newIteratorTerm(tk *Token, args []*term) *term {
 	tk.Sym = SymIterator
 	return &term{
@@ -119,8 +103,10 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
 				args = []any{}
 			}
 
+			actualParams := bindActualParams(initFunc, args)
+
 			initCtx := ctx.Clone()
-			if resource, err = initFunc.Invoke(initCtx, InitName, args); err != nil {
+			if resource, err = initFunc.InvokeNamed(initCtx, InitName, actualParams); err != nil {
 				return
 			}
 			dcCtx := ctx.Clone()

operand-var.go

@@ -25,7 +25,7 @@ func evalVar(ctx ExprContext, opTerm *term) (v any, err error) {
 	var exists bool
 	name := opTerm.source()
 	if v, exists = GetVar(ctx, name); !exists {
-		if info, exists, _ := GetFuncInfo(ctx, name); exists {
+		if info, exists := GetFuncInfo(ctx, name); exists {
 			v = info.Functor()
 		} else {
 			err = fmt.Errorf("undefined variable or function %q", name)

operator-dot.go

@@ -32,7 +32,7 @@ func evalDot(ctx ExprContext, opTerm *term) (v any, err error) {
 		if indexTerm.symbol() == SymVariable /*|| indexTerm.symbol() == SymString */ {
 			opName := indexTerm.source()
 			if unboxedValue.HasOperation(opName) {
-				v, err = unboxedValue.CallOperation(opName, []any{})
+				v, err = unboxedValue.CallOperation(opName, map[string]any{})
 			} else {
 				err = indexTerm.Errorf("this iterator do not support the %q command", opName)
 				v = false

operator-post-inc.go

@@ -35,7 +35,39 @@ func evalPostInc(ctx ExprContext, opTerm *term) (v any, err error) {
 	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)
 }

parser.go

@@ -19,7 +19,8 @@ func NewParser() (p *parser) {
 }
 
 func (parser *parser) Next(scanner *scanner) (tk *Token) {
-	for tk=scanner.Next(); tk.IsSymbol(SymComment); tk=scanner.Next() {}
+	for tk = scanner.Next(); tk.IsSymbol(SymComment); tk = scanner.Next() {
+	}
 	return
 }
 
@@ -304,7 +305,7 @@ func addSelectorCase(selectorTerm, caseTerm *term) {
 func (parser *parser) parseSelector(scanner *scanner, tree *ast, allowVarRef bool) (selectorTerm *term, err error) {
 	var caseTerm *term
 	tk := scanner.makeToken(SymSelector, '?')
-	if selectorTerm, err = tree.addToken2(tk); err != nil {
+	if selectorTerm, err = tree.addToken(tk); err != nil {
 		return
 	}
 
@@ -342,13 +343,14 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 	var selectorTerm *term = nil
 	var currentTerm *term = nil
 	var tk *Token
+
 	tree = NewAst()
 	firstToken := true
 	// lastSym := SymUnknown
 	for tk = parser.Next(scanner); err == nil && tk != nil && !tk.IsTerm(termSymbols); /*&& !areSymbolsOutOfCtx(tk, selectorTerm, SymColon, SymDoubleColon)*/ tk = parser.Next(scanner) {
-		if tk.Sym == SymComment {
+		// if tk.Sym == SymComment {
-			continue
+		// 	continue
-		}
+		// }
 
 		if tk.Sym == SymSemiColon {
 			if allowForest {
@@ -414,7 +416,7 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 			}
 		case SymEqual:
 			// if err = checkPrevSymbol(lastSym, SymIdentifier, tk); err == nil {
-			currentTerm, err = tree.addToken2(tk)
+			currentTerm, err = tree.addToken(tk)
 			// }
 		case SymFuncDef:
 			var funcDefTerm *term
@@ -432,7 +434,7 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 			if tk.source[0] == '@' && !allowVarRef {
 				err = tk.Errorf("variable references are not allowed in top level expressions: %q", tk.source)
 			} else {
-				currentTerm, err = tree.addToken2(tk)
+				currentTerm, err = tree.addToken(tk)
 			}
 		case SymQuestion:
 			if selectorTerm, err = parser.parseSelector(scanner, tree, allowVarRef); err == nil {
@@ -449,14 +451,16 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 					}
 				}
 			} else {
-				currentTerm, err = tree.addToken2(tk)
+				currentTerm, err = tree.addToken(tk)
 			}
 			if tk.IsSymbol(SymColon) {
 				// Colon outside a selector term acts like a separator
 				firstToken = true
 			}
+		case SymPlusEqual, SymMinusEqual, SymStarEqual:
+			currentTerm, err = parser.expandOpAssign(scanner, tree, tk, allowVarRef)
 		default:
-			currentTerm, err = tree.addToken2(tk)
+			currentTerm, err = tree.addToken(tk)
 		}
 
 		if currentTerm != nil && currentTerm.tk.Sym != SymSelector && currentTerm.parent != nil && currentTerm.parent.tk.Sym != SymSelector {
@@ -465,6 +469,7 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 		}
 		// lastSym = tk.Sym
 	}
+
 	if err == nil {
 		err = tk.Error()
 	}
@@ -477,3 +482,49 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 // 	}
 // 	return
 // }
+
+func (parser *parser) expandOpAssign(scanner * scanner, tree *ast, tk *Token, allowVarRef bool) (t *term, err error) {
+	var opSym Symbol
+	var opString string
+
+	if tree.root != nil {
+		switch tk.Sym {
+		case SymPlusEqual:
+			opString = "+"
+			opSym = SymPlus
+		case SymMinusEqual:
+			opString = "-"
+			opSym = SymMinus
+		case SymStarEqual:
+			opString = "*"
+			opSym = SymStar
+		default:
+			err = tk.Errorf("unsopported operator %q", tk.source)
+			return
+		}
+		leftExpr := tree.root.Clone()
+		leftExpr.setParent(nil)
+		if t, err = tree.addToken(NewToken(tk.row, tk.col, SymEqual, "=")); err == nil {
+			t = leftExpr
+			if err = tree.addTerm(leftExpr); err == nil {
+				if t, err = tree.addToken(NewToken(tk.row, tk.col, opSym, opString)); err == nil {
+
+					var subTree *ast
+					if subTree, err = parser.parseGeneral(scanner, false, allowVarRef, SymSemiColon, SymClosedRound, SymClosedBrace, SymClosedSquare); err == nil {
+						if scanner.Previous().IsOneOfA(SymSemiColon, SymClosedRound, SymClosedBrace, SymClosedSquare) {
+							if err = scanner.UnreadToken(); err != nil {
+								return
+							}
+						}
+						subTree.root.priority = priValue
+						err = tree.addTerm(newExprTerm(subTree.root))
+						t = subTree.root
+					}
+				}
+			}
+		}
+	} else {
+		err = tk.Errorf("left operand of %q must be a variable or a variable expression", tk)
+	}
+	return
+}

scanner.go

@@ -16,6 +16,7 @@ import (
 type scanner struct {
 	current      *Token
 	prev         *Token
+	stage        *Token
 	stream       *bufio.Reader
 	row          int
 	column       int
@@ -74,6 +75,16 @@ func (scanner *scanner) unreadChar() (err error) {
 	return
 }
 
+func (scanner *scanner) UnreadToken() (err error) {
+	if scanner.stage == nil {
+		scanner.stage = scanner.current
+		scanner.current = scanner.prev
+	} else {
+		err = fmt.Errorf("staging already present, currently one level only of staging is allowed")
+	}
+	return
+}
+
 func (scanner *scanner) lastPos() (r, c int) {
 	if scanner.prev != nil {
 		r = scanner.prev.row
@@ -89,7 +100,12 @@ func (scanner *scanner) Previous() *Token {
 func (scanner *scanner) Next() (tk *Token) {
 	scanner.prev = scanner.current
 	tk = scanner.current
-	scanner.current = scanner.fetchNextToken()
+	if scanner.stage != nil {
+		scanner.current = scanner.stage
+		scanner.stage = nil
+	} else {
+		scanner.current = scanner.fetchNextToken()
+	}
 	return tk
 }
 
@@ -124,6 +140,8 @@ func (scanner *scanner) fetchNextToken() (tk *Token) {
 				tk = scanner.moveOn(SymDoubleStar, ch, next)
 				// } else if next == '/' {
 				// 	tk = self.moveOn(SymClosedComment, ch, next)
+			} else if next, _ = scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymStarEqual, ch, next)
 			} else {
 				tk = scanner.makeToken(SymStar, ch)
 			}
@@ -269,11 +287,11 @@ func (scanner *scanner) fetchNextToken() (tk *Token) {
 				tk = scanner.makeToken(SymDollar, ch)
 			}
 		case '(':
-//			if next, _ := scanner.peek(); next == ')' {
+			//			if next, _ := scanner.peek(); next == ')' {
-//				tk = scanner.moveOn(SymOpenClosedRound, ch, next)
+			//				tk = scanner.moveOn(SymOpenClosedRound, ch, next)
-//			} else {
+			//			} else {
-				tk = scanner.makeToken(SymOpenRound, ch)
+			tk = scanner.makeToken(SymOpenRound, ch)
-//			}
+			//			}
 		case ')':
 			tk = scanner.makeToken(SymClosedRound, ch)
 		case '[':
@@ -440,7 +458,7 @@ func (scanner *scanner) parseNumber(firstCh byte) (tk *Token) {
 		tk = scanner.makeErrorToken(err)
 	} else {
 		var value any
-		err = scanner.sync(err)	// TODO: Check this function
+		err = scanner.sync(err) // TODO: Check this function
 		txt := sb.String()
 		if sym == SymFloat {
 			value, err = strconv.ParseFloat(txt, 64)

simple-store.go

@@ -149,10 +149,11 @@ func (ctx *SimpleStore) RegisterFuncInfo(info ExprFunc) {
 	ctx.funcStore[info.Name()], _ = info.(*funcInfo)
 }
 
-func (ctx *SimpleStore) RegisterFunc(name string, functor Functor, returnType string, params []ExprFuncParam) (err error) {
+func (ctx *SimpleStore) RegisterFunc(name string, functor Functor, returnType string, params []ExprFuncParam)  (exprFunc ExprFunc, err error) {
 	var info *funcInfo
 	if info, err = newFuncInfo(name, functor, returnType, params); err == nil {
 		ctx.funcStore[name] = info
+		exprFunc = info
 	}
 	return
 }
@@ -179,10 +180,10 @@ func (ctx *SimpleStore) DeleteFunc(funcName string) {
 	delete(ctx.funcStore, funcName)
 }
 
-func (ctx *SimpleStore) Call(name string, args []any) (result any, err error) {
+func (ctx *SimpleStore) Call(name string, args map[string]any) (result any, err error) {
 	if info, exists := GetLocalFuncInfo(ctx, name); exists {
 		functor := info.Functor()
-		result, err = functor.Invoke(ctx, name, args)
+		result, err = functor.InvokeNamed(ctx, name, args)
 	} else {
 		err = fmt.Errorf("unknown function %s()", name)
 	}

symbol.go

@@ -68,6 +68,7 @@ const (
 	SymDoubleDollar                      //  57: '$$'
 	SymDoubleDot                         //  58: '..'
 	SymTripleDot                         //  59: '...'
+	SymStarEqual                         //  60: '*='
 	SymChangeSign
 	SymUnchangeSign
 	SymIdentifier

t_ast_test.go

@@ -47,7 +47,7 @@ func TestAddUnknownTokens(t *testing.T) {
 	wantErr := errors.New(`unexpected token "%"`)
 
 	tree := NewAst()
-	if gotErr := tree.addToken(tk0); gotErr != nil && gotErr.Error() != wantErr.Error() {
+	if _, gotErr := tree.addToken(tk0); gotErr != nil && gotErr.Error() != wantErr.Error() {
 		t.Errorf("err: got <%v>, want <%v>", gotErr, wantErr)
 	}
 }

t_builtin-base_test.go

@@ -21,7 +21,7 @@ func TestFuncBase(t *testing.T) {
 		/*   7 */ {`int(3.9)`, int64(3), nil},
 		/*   8 */ {`int("432")`, int64(432), nil},
 		/*   9 */ {`int("1.5")`, nil, `strconv.Atoi: parsing "1.5": invalid syntax`},
-		/*  10 */ {`int("432", 4)`, nil, `int(): too much params -- expected 1, got 2`},
+		/*  10 */ {`int("432", 4)`, nil, `int(): too many params -- expected 1, got 2`},
 		/*  11 */ {`int(nil)`, nil, `int(): can't convert nil to int`},
 		/*  12 */ {`isInt(2+1)`, true, nil},
 		/*  13 */ {`isInt(3.1)`, false, nil},
@@ -43,7 +43,7 @@ func TestFuncBase(t *testing.T) {
 		/*  29 */ {`dec(true)`, float64(1), nil},
 		/*  30 */ {`dec(true")`, nil, `[1:11] missing string termination "`},
 		/*  31 */ {`dec()`, nil, `dec(): too few params -- expected 1, got 0`},
-		/*  32 */ {`dec(1,2,3)`, nil, `dec(): too much params -- expected 1, got 3`},
+		/*  32 */ {`dec(1,2,3)`, nil, `dec(): too many params -- expected 1, got 3`},
 		/*  33 */ {`isBool(false)`, true, nil},
 		/*  34 */ {`fract(1|2)`, newFraction(1, 2), nil},
 		/*  35 */ {`fract(12,2)`, newFraction(6, 1), nil},
@@ -61,5 +61,6 @@ func TestFuncBase(t *testing.T) {
 
 	t.Setenv("EXPR_PATH", ".")
 
+	//runTestSuiteSpec(t, section, inputs, 10)
 	runTestSuite(t, section, inputs)
 }

t_builtin-fmt_test.go

@@ -30,7 +30,7 @@ func TestFmt(t *testing.T) {
 
 	text := "ciao mondo"
 	inputs := []inputType{
-		/*   1 */ {fmt.Sprintf(`println("%s")`, text), int64(11), nil},
+		/*   1 */ {fmt.Sprintf(`builtin "fmt"; println("%s")`, text), int64(11), nil},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")

t_builtin-import_test.go

@@ -19,6 +19,6 @@ func TestFuncImport(t *testing.T) {
 
 	t.Setenv("EXPR_PATH", "test-resources")
 
-	// runTestSuiteSpec(t, section, inputs, 1)
+	//runTestSuiteSpec(t, section, inputs, 1)
 	runTestSuite(t, section, inputs)
 }

t_builtin-iterator_test.go

@@ -17,12 +17,14 @@ func TestFuncRun(t *testing.T) {
 		/*   3 */ {`builtin "iterator"; run($(1,2,3), func(index,item){status=status+item; true}, {"status":0})`, int64(6), nil},
 		/*   4 */ {`builtin ["iterator", "fmt"]; run($(1,2,3), func(index,item){println(item+10)})`, nil, nil},
 		/*   5 */ {`builtin "iterator"; run(nil)`, nil, `paramter "iterator" must be an iterator, passed <nil> [nil]`},
-		/*   6 */ {`builtin "iterator"; run($(1,2,3), nil)`, nil, `paramter "operator" must be a function, passed <nil> [nil]`},
+		/*   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"`},
 	}
 
 	//t.Setenv("EXPR_PATH", ".")
 
-	//runTestSuiteSpec(t, section, inputs, 3)
+	//runTestSuiteSpec(t, section, inputs, 1)
 	runTestSuite(t, section, inputs)
 }

t_builtin-math-arith_test.go

@@ -19,10 +19,15 @@ func TestFuncMathArith(t *testing.T) {
 		/*   6 */ {`builtin "math.arith"; add(add(1,4),/*3+2,*/5*(3-2))`, int64(10), nil},
 		/*   7 */ {`builtin "math.arith"; a=5; b=2; add(a, b*3)`, int64(11), nil},
 		/*   8 */ {`builtin "math.arith"; var2="abc"; add(1,2) but var2`, "abc", nil},
+		/*   9 */ {`builtin "math.arith"; add()`, int64(0), nil},
+		/*  10 */ {`builtin "math.arith"; mul()`, int64(1), nil},
+		/*  11 */ {`builtin "math.arith"; add([1,2,3])`, int64(6), nil},
+		/*  12 */ {`builtin "math.arith"; mul([2,2,3])`, int64(12), nil},
+		/*  13 */ {`builtin "math.arith"; mul(2,2,3)`, int64(12), nil},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")
 
-	// runTestSuiteSpec(t, section, inputs, 1)
+	//runTestSuiteSpec(t, section, inputs, 10)
 	runTestSuite(t, section, inputs)
 }

t_builtin-os-file_test.go

@@ -30,6 +30,6 @@ func TestFuncOs(t *testing.T) {
 
 	// t.Setenv("EXPR_PATH", ".")
 
-	// runTestSuiteSpec(t, section, inputs, 1)
+	//runTestSuiteSpec(t, section, inputs, 2)
 	runTestSuite(t, section, inputs)
 }

t_common_test.go

@@ -42,6 +42,8 @@ func runCtxTestSuite(t *testing.T, ctx ExprContext, section string, inputs []inp
 	failed := 0
 
 	for i, input := range inputs {
+		// fmt.Printf("%3d: %s\n", i+1, input.source)
+
 		good := doTest(t, ctx, section, &input, i+1)
 		if good {
 			succeeded++
@@ -91,7 +93,7 @@ func doTest(t *testing.T, ctx ExprContext, section string, input *inputType, cou
 	eq := reflect.DeepEqual(gotResult, input.wantResult)
 
 	if !eq /*gotResult != input.wantResult*/ {
-		t.Errorf("%d: %q -> result = %v [%s], want = %v [%s]", count, input.source, gotResult, TypeName(gotResult), input.wantResult, TypeName(input.wantResult))
+		t.Errorf("%d: `%s` -> result = %v [%s], want = %v [%s]", count, input.source, gotResult, TypeName(gotResult), input.wantResult, TypeName(input.wantResult))
 		good = false
 	}
 
@@ -106,8 +108,8 @@ func doTest(t *testing.T, ctx ExprContext, section string, input *inputType, cou
 
 func logTest(t *testing.T, n int, section, source string, wantResult any, wantErr error) {
 	if wantErr == nil {
-		t.Logf("[+]%s nr %3d -- %q  --> %v", section, n, source, wantResult)
+		t.Logf("[+]%s nr %3d -- `%s`  --> %v", section, n, source, wantResult)
 	} else {
-		t.Logf("[-]%s nr %3d -- %q  --> %v", section, n, source, wantErr)
+		t.Logf("[-]%s nr %3d -- `%s`  --> %v", section, n, source, wantErr)
 	}
 }

t_expr_test.go

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

t_funcs_test.go

@@ -24,24 +24,29 @@ func TestFuncs(t *testing.T) {
 		/*  11 */ {`f=func(@y){g=func(){@x=5}; g(); @z=x; @y=@y+@z}; f(2); y+z`, int64(12), nil},
 		/*  12 */ {`f=func(@y){g=func(){@x=5}; g(); @z=x; @x=@y+@z}; f(2); y+x`, int64(9), nil},
 		/*  13 */ {`two=func(){2}; four=func(f){f()+f()}; four(two)`, int64(4), nil},
-		/*  14 */ {`two=func(){2}; two(123)`, nil, `two(): too much params -- expected 0, got 1`},
+		/*  14 */ {`two=func(){2}; two(123)`, nil, `two(): too many params -- expected 0, got 1`},
 		/*  15 */ {`f=func(x,n=2){x+n}; f(3)`, int64(5), nil},
 		/*  16 */ {`f=func(x,n=2,y){x+n}`, nil, `[1:16] can't mix default and non-default parameters`},
 		/*  17 */ {`f=func(x,n){1}; f(3,4,)`, nil, "[1:24] expected `function-param-value`, got `)`"},
 		/*  18 */ {`factory=func(base){func(){@base=base+1}}; inc10=factory(10); inc5=factory(5); inc10(); inc5(); inc10()`, int64(12), nil},
 		/*  19 */ {`f=func(a,y=1,z="sos"){}; string(f)`, `f(a, y=1, z="sos"):any{}`, nil},
-//		/*  20 */ {`a=[func(){3}]; a[0]()`, int64(3), nil},
+		/*  20 */ {`f=func(a,b){a*2+b}; f(1,10)`, int64(12), nil},
-//		/*  20 */ {`m={}; m["f"]=func(){3}; m["f"]()`, int64(3), nil},
+		/*  21 */ {`f=func(a,b){a*2+b}; f(a=2,b=1)`, int64(5), nil},
+		/*  22 */ {`f=func(a,b){a*2+b}; f(b=2,a=1)`, int64(4), nil},
+		/*  23 */ {`f=func(a=10,b=10){a*2+b}; f(b=1)`, int64(21), nil},
+		/*  24 */ {`f=func(a,b){a*2+b}; f(a=1,2)`, nil, `f(): positional param nr 2 not allowed after named params`},
+		//		/*  20 */ {`a=[func(){3}]; a[0]()`, int64(3), nil},
+		//		/*  20 */ {`m={}; m["f"]=func(){3}; m["f"]()`, int64(3), nil},
 		// /*  18 */ {`f=func(a){a*2}`, nil, errors.New(`[1:24] expected "function-param-value", got ")"`)},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")
 
-	//runTestSuiteSpec(t, section, inputs, 20)
+	//runTestSuiteSpec(t, section, inputs, 19)
 	runTestSuite(t, section, inputs)
 }
 
-func dummy(ctx ExprContext, name string, args []any) (result any, err error) {
+func dummy(ctx ExprContext, name string, args map[string]any) (result any, err error) {
 	return
 }
 
@@ -54,7 +59,6 @@ func TestFunctionToStringSimple(t *testing.T) {
 	}
 }
 
-
 func TestFunctionGetFunc(t *testing.T) {
 	source := NewGolangFunctor(dummy)
 	want := ExprFunc(nil)

t_helpers_test.go

@@ -5,50 +5,51 @@
 package expr
 
 import (
-	"fmt"
 	"testing"
 )
 
-func subtract(ctx ExprContext, name string, args []any) (result any, err error) {
+// TODO The new function param model does not allow this kind of test
-	if len(args) != 2 {
+// ------------------------------------------------------------------
-		err = fmt.Errorf("%s(): requires exactly two arguments", name)
+// func subtract(ctx ExprContext, name string, args map[string]any) (result any, err error) {
-		return
+// 	if len(args) != 2 {
-	}
+// 		err = fmt.Errorf("%s(): requires exactly two arguments", name)
-	x, xok := args[0].(int64)
+// 		return
-	y, yok := args[1].(int64)
+// 	}
-	if xok && yok {
+// 	x, xok := args[0].(int64)
-		result = x - y
+// 	y, yok := args[1].(int64)
-	} else {
+// 	if xok && yok {
-		err = fmt.Errorf("expected integer (int64) arguments, got %T and %T values", x, y)
+// 		result = x - y
-	}
+// 	} else {
-	return
+// 		err = fmt.Errorf("expected integer (int64) arguments, got %T and %T values", x, y)
-}
+// 	}
+// 	return
+// }
 
-func TestEvalStringA(t *testing.T) {
+// func TestEvalStringA(t *testing.T) {
 
-	source := `a + b * subtract(4,2)`
+// 	source := `a + b * subtract(4,2)`
-	args := []Arg{
+// 	args := []Arg{
-		{"a", uint8(1)},
+// 		{"a", uint8(1)},
-		{"b", int8(2)},
+// 		{"b", int8(2)},
-		{"subtract", FuncTemplate(subtract)},
+// 		{"subtract", FuncTemplate2(subtract)},
-		// force coverage
+// 		// force coverage
-		{"a16", uint16(1)},
+// 		{"a16", uint16(1)},
-		{"b16", int16(2)},
+// 		{"b16", int16(2)},
-		{"a32", uint32(1)},
+// 		{"a32", uint32(1)},
-		{"b32", int32(2)},
+// 		{"b32", int32(2)},
-		{"a64", uint64(1)},
+// 		{"a64", uint64(1)},
-		{"b64", int64(2)},
+// 		{"b64", int64(2)},
-		{"f32", float32(1.0)},
+// 		{"f32", float32(1.0)},
-		{"f64", float64(1.0)},
+// 		{"f64", float64(1.0)},
-	}
+// 	}
 
-	wantResult := int64(5)
+// 	wantResult := int64(5)
-	gotResult, gotErr := EvalStringA(source, args...)
+// 	gotResult, gotErr := EvalStringA(source, args...)
-	if value, ok := gotResult.(int64); ok && value != wantResult {
+// 	if value, ok := gotResult.(int64); ok && value != wantResult {
-		t.Errorf("Source %q got %v, want %v", source, gotResult, wantResult)
+// 		t.Errorf("Source %q got %v, want %v", source, gotResult, wantResult)
-		t.Errorf("Error: %v", gotErr)
+// 		t.Errorf("Error: %v", gotErr)
-	}
+// 	}
-}
+// }
 
 func TestEvalString(t *testing.T) {
 
@@ -68,7 +69,7 @@ func TestEvalString(t *testing.T) {
 
 	// force coverage
 	ctx.GetFuncInfo("dummy")
-	ctx.Call("dummy", []any{})
+	ctx.Call("dummy", map[string]any{})
 
 	source := `a + b * f`
 

t_iterator_test.go

@@ -27,6 +27,6 @@ func TestIteratorParser(t *testing.T) {
 		/*  16 */ {`include "test-resources/filter.expr"; it=$(ds,10); it++`, int64(2), nil},
 	}
 
-	//runTestSuiteSpec(t, section, inputs, 3)
+	// runTestSuiteSpec(t, section, inputs, 11)
 	runTestSuite(t, section, inputs)
 }

term.go

@@ -53,6 +53,25 @@ type term struct {
 	evalFunc evalFuncType
 }
 
+func (s *term) Clone() (d *term) {
+	var children []*term
+	if s.children != nil {
+		children = make([]*term, len(s.children))
+		for i, c := range s.children {
+			children[i] = c.Clone()
+		}
+	}
+	d = &term{
+		tk: *s.tk.Clone(),
+		parent: s.parent,
+		children: children,
+		position: s.position,
+		priority: s.priority,
+		evalFunc: s.evalFunc,
+	}
+	return
+}
+
 func (term *term) String() string {
 	var sb strings.Builder
 	term.toString(&sb)

token.go

@@ -51,6 +51,10 @@ func NewErrorToken(row, col int, err error) *Token {
 	return NewValueToken(row, col, SymError, fmt.Sprintf("[%d:%d]", row, col), err)
 }
 
+func (tk *Token) Clone() (c *Token) {
+	return NewValueToken(tk.row, tk.col, tk.Sym, tk.source, tk.Value)
+}
+
 func (tk *Token) IsEos() bool {
 	return tk.Sym == SymEos
 }
@@ -67,6 +71,10 @@ func (tk *Token) IsOneOf(termSymbols []Symbol) bool {
 	return termSymbols != nil && slices.Index(termSymbols, tk.Sym) >= 0
 }
 
+func (tk *Token) IsOneOfA(termSymbols ...Symbol) bool {
+	return slices.Index(termSymbols, tk.Sym) >= 0
+}
+
 func (tk *Token) IsSymbol(sym Symbol) bool {
 	return tk.Sym == sym
 }