solved a number of problems highlighted by the syntax analyzer

Also, fixed and improved some parsing sections concerning collection indeces and ranges

builtin-base.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"math"
 	"strconv"
+	"strings"
 )
 
 const (
@@ -188,6 +189,30 @@ func fractFunc(ctx ExprContext, name string, args map[string]any) (result any, e
 // 	return
 // }
 
+func evalFunc(ctx ExprContext, name string, args map[string]any) (result any, err error) {
+	if source, ok := args[ParamSource].(string); ok {
+		var expr Expr
+
+		parser := NewParser()
+		if ctx == nil {
+			ctx = NewSimpleStore()
+		}
+
+		r := strings.NewReader(source)
+		scanner := NewScanner(r, DefaultTranslations())
+
+		if expr, err = parser.Parse(scanner); err == nil {
+			CtrlEnable(ctx, control_export_all)
+			result, err = expr.Eval(ctx)
+		}
+	} else {
+		err = ErrWrongParamType(name, ParamSource, TypeString, args[ParamSource])
+	}
+	return
+}
+
+//// import
+
 func ImportBuiltinsFuncs(ctx ExprContext) {
 	anyParams := []ExprFuncParam{
 		NewFuncParam(ParamValue),
@@ -211,6 +236,10 @@ func ImportBuiltinsFuncs(ctx ExprContext) {
 		NewFuncParam(ParamValue),
 		NewFuncParamFlagDef(ParamDenominator, PfDefault, int64(1)),
 	})
+
+	ctx.RegisterFunc("eval", NewGolangFunctor(evalFunc), TypeAny, []ExprFuncParam{
+		NewFuncParam(ParamSource),
+	})
 }
 
 func init() {

builtin-import.go

@@ -44,7 +44,7 @@ func doImport(ctx ExprContext, name string, dirList []string, it Iterator) (resu
 			var expr *ast
 			scanner := NewScanner(file, DefaultTranslations())
 			parser := NewParser()
-			if expr, err = parser.parseGeneral(scanner, true, true); err == nil {
+			if expr, err = parser.parseGeneral(scanner, allowMultiExpr|allowVarRef, SymEos); err == nil {
 				result, err = expr.Eval(ctx)
 			}
 			if err != nil {

common-errors.go

@@ -55,8 +55,25 @@ func ErrInvalidParameterValue(funcName, paramName string, paramValue any) error
 	return fmt.Errorf("%s(): invalid value %s (%v) for parameter %q", funcName, TypeName(paramValue), paramValue, paramName)
 }
 
+func undefArticle(s string) (article string) {
+	if len(s) > 0 && strings.Contains("aeiou", s[0:1]) {
+		article = "an"
+	} else {
+		article = "a"
+	}
+	return
+}
+
+func prependUndefArticle(s string) (result string) {
+	return undefArticle(s) + " " + s
+}
+
 func ErrWrongParamType(funcName, paramName, paramType string, paramValue any) error {
-	return fmt.Errorf("%s(): the %q parameter must be a %s, got a %s (%v)", funcName, paramName, paramType, TypeName(paramValue), paramValue)
+	var artWantType, artGotType string
+	gotType := TypeName(paramValue)
+	artGotType = prependUndefArticle(gotType)
+	artWantType = prependUndefArticle(paramType)
+	return fmt.Errorf("%s(): the %q parameter must be %s, got %s (%v)", funcName, paramName, artWantType, artGotType, paramValue)
 }
 
 func ErrUnknownParam(funcName, paramName string) error {

common-type-names.go

@@ -6,6 +6,7 @@ package expr
 
 const (
 	TypeAny           = "any"
+	TypeNil           = "nil"
 	TypeBoolean       = "boolean"
 	TypeFloat         = "float"
 	TypeFraction      = "fraction"
@@ -15,6 +16,7 @@ const (
 	TypeNumber        = "number"
 	TypePair          = "pair"
 	TypeString        = "string"
+	TypeDict          = "dict"
 	TypeListOf        = "list-of-"
 	TypeListOfStrings = "list-of-strings"
 )

context-helpers.go

@@ -29,7 +29,7 @@ func exportObjects(destCtx, sourceCtx ExprContext) {
 	exportAll := CtrlIsEnabled(sourceCtx, control_export_all)
 	// fmt.Printf("Exporting from sourceCtx [%p] to destCtx [%p] -- exportAll=%t\n", sourceCtx, destCtx, exportAll)
 	// Export variables
-	for _, refName := range sourceCtx.EnumVars(func(name string) bool { return exportAll || name[0] == '@' }) {
+	for _, refName := range sourceCtx.EnumVars(func(name string) bool { return (exportAll || name[0] == '@') && !(name[0] == '_') }) {
 		// fmt.Printf("\tExporting %q\n", refName)
 		refValue, _ := sourceCtx.GetVar(refName)
 		exportVar(destCtx, refName, refValue)

data-cursor.go

@@ -6,12 +6,14 @@ package expr
 
 import (
 	"io"
+	"slices"
 )
 
 type dataCursor struct {
 	ds        map[string]Functor
 	ctx       ExprContext
-	initState bool // true if no item has prodiced yet (this replace di initial Next() call in the contructor)
+	initState bool // true if no item has produced yet (this replace di initial Next() call in the contructor)
+	// cursorValid bool // true if resource is nil or if clean has not yet been called
 	index     int
 	count     int
 	current   any
@@ -26,6 +28,7 @@ func NewDataCursor(ctx ExprContext, ds map[string]Functor, resource any) (dc *da
 	dc = &dataCursor{
 		ds:        ds,
 		initState: true,
+		// cursorValid: true,
 		index:     -1,
 		count:     0,
 		current:   nil,
@@ -36,7 +39,6 @@ func NewDataCursor(ctx ExprContext, ds map[string]Functor, resource any) (dc *da
 		cleanFunc: ds[CleanName],
 		resetFunc: ds[ResetName],
 	}
-	//dc.Next()
 	return
 }
 
@@ -77,7 +79,7 @@ func (dc *dataCursor) String() string {
 }
 
 func (dc *dataCursor) HasOperation(name string) (exists bool) {
-	exists = name == IndexName
+	exists = slices.Contains([]string{CleanName, ResetName, CurrentName, IndexName}, name)
 	if !exists {
 		f, ok := dc.ds[name]
 		exists = ok && isFunctor(f)
@@ -88,63 +90,83 @@ func (dc *dataCursor) HasOperation(name string) (exists bool) {
 func (dc *dataCursor) CallOperation(name string, args map[string]any) (value any, err error) {
 	if name == IndexName {
 		value = int64(dc.Index())
+	} else if name == CleanName {
+		err = dc.Clean()
+	} else if name == ResetName {
+		err = dc.Reset()
 	} else if functor, ok := dc.ds[name]; ok && isFunctor(functor) {
-		if functor == dc.cleanFunc {
+		ctx := cloneContext(dc.ctx)
-			value, err = dc.Clean()
+		value, err = functor.InvokeNamed(ctx, name, args)
-		} else if functor == dc.resetFunc {
+		exportObjects(dc.ctx, ctx)
-			value, err = dc.Reset()
-		} else {
-			ctx := cloneContext(dc.ctx)
-			value, err = functor.InvokeNamed(ctx, name, args)
-			exportObjects(dc.ctx, ctx)
-		}
 	} else {
 		err = errNoOperation(name)
 	}
 	return
 }
 
-func (dc *dataCursor) Reset() (success bool, err error) {
+// func (dc *dataCursor) Reset() (err error) {
+// 	if dc.resetFunc != nil {
+// 		if dc.resource != nil {
+// 			ctx := cloneContext(dc.ctx)
+// 			actualParams := bindActualParams(dc.resetFunc, []any{dc.resource})
+// 			_, err = dc.resetFunc.InvokeNamed(ctx, ResetName, actualParams)
+// 			exportObjects(dc.ctx, ctx)
+// 			dc.index = -1
+// 			dc.count = 0
+// 			dc.initState = true
+// 			dc.current = nil
+// 			dc.lastErr = nil
+// 		} else {
+// 			err = errInvalidDataSource()
+// 		}
+// 	} else {
+// 		err = errNoOperation(ResetName)
+// 	}
+// 	return
+// }
+
+func (dc *dataCursor) Reset() (err error) {
 	if dc.resetFunc != nil {
-		if dc.resource != nil {
+		ctx := cloneContext(dc.ctx)
-			ctx := cloneContext(dc.ctx)
+		actualParams := bindActualParams(dc.resetFunc, []any{dc.resource})
-			actualParams := bindActualParams(dc.resetFunc, []any{dc.resource})
+		_, err = dc.resetFunc.InvokeNamed(ctx, ResetName, actualParams)
-			_, err = dc.resetFunc.InvokeNamed(ctx, ResetName, actualParams)
+		exportObjects(dc.ctx, ctx)
-			exportObjects(dc.ctx, ctx)
-			dc.index = -1
-			dc.count = 0
-			dc.initState = true
-			dc.current = nil
-			dc.lastErr = nil
-			//dc.Next()
-		} else {
-			err = errInvalidDataSource()
-		}
-	} else {
-		err = errNoOperation(ResetName)
 	}
-	success = err == nil
+	dc.index = -1
+	dc.count = 0
+	dc.initState = true
+	dc.current = nil
+	dc.lastErr = nil
 	return
 }
 
-func (dc *dataCursor) Clean() (success bool, err error) {
+func (dc *dataCursor) Clean() (err error) {
 	if dc.cleanFunc != nil {
-		if dc.resource != nil {
+		ctx := cloneContext(dc.ctx)
-			ctx := cloneContext(dc.ctx)
+		actualParams := bindActualParams(dc.cleanFunc, []any{dc.resource})
-			actualParams := bindActualParams(dc.cleanFunc, []any{dc.resource})
+		_, err = dc.cleanFunc.InvokeNamed(ctx, CleanName, actualParams)
-			_, err = dc.cleanFunc.InvokeNamed(ctx, CleanName, actualParams)
+		exportObjects(dc.ctx, ctx)
-			//			dc.resource = nil
-			exportObjects(dc.ctx, ctx)
-		} else {
-			err = errInvalidDataSource()
-		}
-	} else {
-		err = errNoOperation(CleanName)
 	}
-	success = err == nil
+	dc.lastErr = io.EOF
 	return
 }
 
+// func (dc *dataCursor) Clean() (err error) {
+// 	if dc.cleanFunc != nil {
+// 		if dc.resource != nil {
+// 			ctx := cloneContext(dc.ctx)
+// 			actualParams := bindActualParams(dc.cleanFunc, []any{dc.resource})
+// 			_, err = dc.cleanFunc.InvokeNamed(ctx, CleanName, actualParams)
+// 			exportObjects(dc.ctx, ctx)
+// 		} else {
+// 			err = errInvalidDataSource()
+// 		}
+// 	} else {
+// 		err = errNoOperation(CleanName)
+// 	}
+// 	return
+// }
+
 func (dc *dataCursor) Current() (item any, err error) { // must return io.EOF at the last item
 	dc.init()
 
@@ -191,46 +213,89 @@ func (dc *dataCursor) Next() (current any, err error) { // must return io.EOF af
 		return
 	}
 	current = dc.current
-	if dc.resource != nil {
+	filter := dc.ds[FilterName]
-		filter := dc.ds[FilterName]
+	mapper := dc.ds[MapName]
-		mapper := dc.ds[MapName]
+	var item any
-		var item any
+	for item == nil && dc.lastErr == nil {
-		for item == nil && dc.lastErr == nil {
+		ctx := cloneContext(dc.ctx)
-			ctx := cloneContext(dc.ctx)
+		dc.index++
-			dc.index++
 
-			actualParams := bindActualParams(dc.nextFunc, []any{dc.resource, dc.index})
+		actualParams := bindActualParams(dc.nextFunc, []any{dc.resource, dc.index})
-			if item, dc.lastErr = dc.nextFunc.InvokeNamed(ctx, NextName, actualParams); dc.lastErr == nil {
+		if item, dc.lastErr = dc.nextFunc.InvokeNamed(ctx, NextName, actualParams); dc.lastErr == nil {
-				if item == nil {
+			if item == nil {
-					dc.lastErr = io.EOF
+				dc.lastErr = io.EOF
-				} else {
+			} else {
-					accepted := true
+				accepted := true
-					if filter != nil {
+				if filter != nil {
-						if accepted, dc.lastErr = dc.checkFilter(filter, item); dc.lastErr != nil || !accepted {
+					if accepted, dc.lastErr = dc.checkFilter(filter, item); dc.lastErr != nil || !accepted {
-							item = nil
+						item = nil
-						}
-					}
-					if accepted {
-						dc.count++
-					}
-					if item != nil && mapper != nil {
-						item, dc.lastErr = dc.mapItem(mapper, item)
 					}
 				}
+				if accepted {
+					dc.count++
+				}
+				if item != nil && mapper != nil {
+					item, dc.lastErr = dc.mapItem(mapper, item)
+				}
 			}
-			exportObjects(dc.ctx, ctx)
 		}
-		dc.current = item
+		exportObjects(dc.ctx, ctx)
-		if dc.lastErr != nil {
+	}
-			dc.index--
+	dc.current = item
-			dc.Clean()
+	if dc.lastErr != nil {
-		}
+		dc.index--
-	} else {
+		dc.Clean()
-		dc.lastErr = errInvalidDataSource()
 	}
 	return
 }
 
+// func (dc *dataCursor) Next() (current any, err error) { // must return io.EOF after the last item
+// 	if dc.initState {
+// 		dc.init()
+// 	} else if err = dc.lastErr; err != nil {
+// 		return
+// 	}
+// 	current = dc.current
+// 	if dc.resource != nil {
+// 		filter := dc.ds[FilterName]
+// 		mapper := dc.ds[MapName]
+// 		var item any
+// 		for item == nil && dc.lastErr == nil {
+// 			ctx := cloneContext(dc.ctx)
+// 			dc.index++
+
+// 			actualParams := bindActualParams(dc.nextFunc, []any{dc.resource, dc.index})
+// 			if item, dc.lastErr = dc.nextFunc.InvokeNamed(ctx, NextName, actualParams); dc.lastErr == nil {
+// 				if item == nil {
+// 					dc.lastErr = io.EOF
+// 				} else {
+// 					accepted := true
+// 					if filter != nil {
+// 						if accepted, dc.lastErr = dc.checkFilter(filter, item); dc.lastErr != nil || !accepted {
+// 							item = nil
+// 						}
+// 					}
+// 					if accepted {
+// 						dc.count++
+// 					}
+// 					if item != nil && mapper != nil {
+// 						item, dc.lastErr = dc.mapItem(mapper, item)
+// 					}
+// 				}
+// 			}
+// 			exportObjects(dc.ctx, ctx)
+// 		}
+// 		dc.current = item
+// 		if dc.lastErr != nil {
+// 			dc.index--
+// 			dc.Clean()
+// 		}
+// 	} else {
+// 		dc.lastErr = errInvalidDataSource()
+// 	}
+// 	return
+// }
+
 func (dc *dataCursor) Index() int {
 	return dc.index - 1
 }

doc/Expr.adoc

@@ -58,7 +58,7 @@ 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 calling program must provide its own context; this is the _main context_. All calculations take place in this context. As mentioned eralier, when a function is called, a new context is created by cloning the calling context. The createt context can be called _function context_.
+_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_.
 
 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_.
 
@@ -79,20 +79,20 @@ Here are some examples of execution.
 # Type 'exit' or Ctrl+D to quit the program.
 
 [user]$ ./dev-expr
-dev-expr -- Expressions calculator v1.10.0(build 14),2024/06/17 (celestino.amoroso@portale-stac.it)
+dev-expr -- Expressions calculator v1.12.0(build 1),2024/09/14 (celestino.amoroso@portale-stac.it)
-	Based on the Expr package v0.19.0
+	Based on the Expr package v0.26.0
 	Type help to get the list of available commands
 	See also https://git.portale-stac.it/go-pkg/expr/src/branch/main/README.adoc
 >>> help
 --- REPL commands:
-      source -- Load a file as input
-         tty -- Enable/Disable ansi output <1>
         base -- Set the integer output base: 2, 8, 10, or 16
         exit -- Exit the program
         help -- Show command list
           ml -- Enable/Disable multi-line output
         mods -- List builtin modules
       output -- Enable/Disable printing expression results. Options 'on', 'off', 'status'
+      source -- Load a file as input
+         tty -- Enable/Disable ansi output <1>
 
 --- Command line options:
     -b <builtin>       Import builtin modules.
@@ -127,22 +127,22 @@ dev-expr -- Expressions calculator v1.10.0(build 14),2024/06/17 (celestino.amoro
 9.5
 >>> 0xFD + 0b1 + 0o1 <1>
 255
->>> 1|2 + 2|3 <2>
+>>> 1:2 + 2:3 <2>
-7|6
+7:6
 >>> ml <3>
->>> 1|2 + 2|3
+>>> 1:2 + 2:3
 7
 -
 6
->>> 4+2 but 5|2+0.5 <4>
+>>> 4+2 but 5:2+0.5 <4>
 3
->>> 4+2; 5|2+0.5 <5>
+>>> 4+2; 5:2+0.5 <5>
 3
 >>>
 ----
 
 <1> Number bases: 0x = _hexadecimal_, 0o = _octal_, 0b = _binary_.
-<2> Fractions: _numerator_ | _denominator_.
+<2> Fractions: _numerator_ : _denominator_.
 <3> Activate multi-line output of fractions.
 <4> But operator, see <<_but_operator>>.
 <5> Multi-expression: the same result of the previous single expression but this it is obtained with two separated calculations.
@@ -155,9 +155,9 @@ _Expr_ supports three type of numbers:
 
 . [blue]#Integers#
 . [blue]#Floats#
-. [blue]#Factions#
+. [blue]#Fractions#
 
-In mixed operations involving integers, fractions and floats, automatic type promotion to the largest type take place.
+In mixed operations involving integers, fractions and floats, automatic type promotion to the largest type is performed.
 
 ==== Integers
 __Expr__'s integers are a subset of the integer set. Internally they are stored as Golang _int64_ values.
@@ -183,11 +183,11 @@ Value range: *-9223372036854775808* to *9223372036854775807*
 [cols="^1,^2,6,4"]
 |===
 | Symbol    | Operation     | Description               | Examples
-| [blue]`+` | _sum_         | Add two values            | [blue]`-1 + 2` -> 1
+| [blue]`+` | _Sum_         | Add two values            | [blue]`-1 + 2` -> _1_
-| [blue]`-` | _subtraction_ | Subtract the right value from the left one | [blue]`3 - 1` -> 2
+| [blue]`-` | _Subtraction_ | Subtract the right value from the left one | [blue]`3 - 1` -> _2_
-| [blue]`*` | _product_     | Multiply two values       | [blue]`-1 * 2` -> -2
+| [blue]`*` | _Product_     | Multiply two values       | [blue]`-1 * 2` -> _-2_
-| [blue]`/` | _Division_    | Divide the left value by the right one^(*)^ | [blue]`-10 / 2` -> 5
+| [blue]`/` | _Integer division_    | Divide the left value by the right one^(*)^ | [blue]`-11 / 2` -> _-5_
-| [blue]`%` | _Modulo_      | Remainder of the integer division | [blue]`5 % 2` -> 1
+| [blue]`%` | _Modulo_      | Remainder of the integer division | [blue]`5 % 2` -> _1_
 |===
 
 ^(*)^ See also the _float division_ [blue]`./` below.
@@ -228,19 +228,19 @@ _dec-seq_ = _see-integer-literal-syntax_
 [cols="^1,^2,6,4"]
 |===
 | Symbol    | Operation     | Description               | Examples
-| [blue]`+` | _sum_         | Add two values            | [blue]`4 + 0.5` -> 4.5
+| [blue]`+` | _Sum_         | Add two values            | [blue]`4 + 0.5` -> 4.5
-| [blue]`-` | _subtraction_ | Subtract the right value from the left one | [blue]`4 - 0.5` -> 3.5
+| [blue]`-` | _Subtraction_ | Subtract the right value from the left one | [blue]`4 - 0.5` -> 3.5
-| [blue]`*` | _product_     | Multiply two values       | [blue]`4 * 0.5` -> 2.0
+| [blue]`*` | _Product_     | Multiply two values       | [blue]`4 * 0.5` -> 2.0
-| [blue]`/` | _Division_    | Divide the left value by the right one | [blue]`1.0 / 2` -> 0.5
+| [blue]`/` | _Float division_    | Divide the left value by the right one | [blue]`1.0 / 2` -> 0.5
-| [blue]`./`| _Float division_ | Force float division   | [blue]`-1 ./ 2` -> -0.5
+| [blue]`./`| _Forced float division_ | Force float division   | [blue]`-1 ./ 2` -> -0.5
 |===
 
 ==== Fractions
-_Expr_ also supports fractions. Fraction literals are made with two integers separated by a vertical bar `|`.
+_Expr_ also supports fractions. Fraction literals are made with two integers separated by a colon character `:`.
 
 .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_ +
 _float-spec_ = _dec-seq_ "**.**" [_dec-seq_] "**(**" _dec-seq_ "**)**" +
@@ -249,44 +249,44 @@ _digit-seq_ = _see-integer-literal-syntax_
 ====
 
 .Examples
-`>>>` [blue]`1 | 2` +
+`>>>` [blue]`1 : 2` +
-[green]`1|2`
+[green]`1:2`
 
-`>>>` [blue]`4|6`  [gray]_// Fractions are always reduced to their lowest terms_ +
+`>>>` [blue]`4:6`  [gray]_// Fractions are always reduced to their lowest terms_ +
-[green]`2|3`
+[green]`2:3`
 
-`>>>` [blue]`1|2 + 2|3` +
+`>>>` [blue]`1:2 + 2:3` +
-[green]`7|6`
+[green]`7:6`
 
-`>>>` [blue]`1|2 * 2|3` +
+`>>>` [blue]`1:2 * 2:3` +
-[green]`1|3`
+[green]`1:3`
 
-`>>>` [blue]`1|2 / 1|3` +
+`>>>` [blue]`1:2 / 1:3` +
-[green]`3|2`
+[green]`3:2`
 
-`>>>` [blue]`1|2 ./ 1|3` [gray]_// Force decimal division_ +
+`>>>` [blue]`1:2 ./ 1:3` [gray]_// Force decimal division_ +
 [green]`1.5`
 
-`>>>` [blue]`-1|2` +
+`>>>` [blue]`-1:2` +
-[green]`-1|2`
+[green]`-1:2`
 
-`>>>` [blue]`1|-2` [gray]_// Invalid sign specification_ +
+`>>>` [blue]`1:-2` [gray]_// Invalid sign specification_ +
-[red]_Eval Error: [1:3] infix operator "|" requires two non-nil operands, got 1_
+[red]_Eval Error: [1:3] infix operator ":" requires two non-nil operands, got 1_
 
-`>>>` [blue]`1|(-2)` +
+`>>>` [blue]`1:(-2)` +
-[green]`-1|2`
+[green]`-1:2`
 
 
 Fractions can be used together with integers and floats in expressions.
 
 .Examples
-`>>>` [blue]`1|2 + 5` +
+`>>>` [blue]`1:2 + 5` +
-[green]`11|2`
+[green]`11:2`
 
-`>>>` [blue]`4 - 1|2` +
+`>>>` [blue]`4 - 1:2` +
-[green]`7|2`
+[green]`7:2`
 
-`>>>` [blue]`1.0 + 1|2` +
+`>>>` [blue]`1.0 + 1:2` +
 [green]`1.5`
 
 
@@ -308,7 +308,7 @@ Strings are character sequences enclosed between two double quote [blue]`"`.
 `>>>` [blue]`"123\tabc"` +
 [green]`123{nbsp}{nbsp}{nbsp}{nbsp}abc`
 
-Some arithmetic operators can also be used with strings.
+Some arithmetic operators also apply to strings.
 
 .String operators
 [cols="^1,^2,6,4"]
@@ -321,7 +321,7 @@ Some arithmetic operators can also be used with strings.
 | [blue]`*` | _repeat_ | Make _n_ copy of a string  | [blue]`"one" * 2` -> _"oneone"_
 |===
 
-The items of strings can be accessed using the square `[]` operator.
+The charanters in a string can be accessed using the square `[]` operator.
 
 .Item access syntax
 ====
@@ -340,10 +340,10 @@ The items of strings can be accessed using the square `[]` operator.
 `>>>` [blue]`s[1]`      [gray]_// char at position 1 (starting from 0)_ +
 [green]`"b"`
 
-`>>>` [blue]`s.[-1]`    [gray]_// char at position -1, the rightmost one_ +
+`>>>` [blue]`s[-1]`    [gray]_// char at position -1, the rightmost one_ +
 [green]`"d"`
 
-`>>>` [blue]`\#s`       [gray]_// number of chars_ +
+`>>>` [blue]`#s`       [gray]_// number of chars_ +
 [gren]`4`
 
 `>>>` [blue]`#"abc"`    [gray]_// number of chars_ +
@@ -369,9 +369,9 @@ Boolean data type has two values only: [blue]_true_ and [blue]_false_. Relationa
 | [blue]`\<=` | _Less or Equal_ | True if the left value is less than or equal to the right one | [blue]`5 \<= 2` -> _false_ +
 [blue]`"b" \<= "b"` -> _true_
 | [blue]`>` | _Greater_ | True if the left value is greater than the right one | [blue]`5 > 2` -> _true_ +
-[blue]`"a" < "b"` -> _false_
+[blue]`"a" > "b"` -> _false_
 | [blue]`>=` | _Greater or Equal_ | True if the left value is greater than or equal to the right one | [blue]`5 >= 2` -> _true_ +
-[blue]`"b" \<= "b"` -> _true_
+[blue]`"b" >= "b"` -> _true_
 |===
 
 ^(*)^ See also the  [blue]`in` operator in the _list_ and _dictionary_ sections.
@@ -388,7 +388,7 @@ Boolean data type has two values only: [blue]_true_ and [blue]_false_. Relationa
 | [blue]`AND` / [blue]`&&` | _And_ | True if both left and right values are true  | [blue]`false && true` -> _false_ +
 [blue]`"a" < "b" AND NOT (2 < 1)` -> _true_
 
-| [blue]`OR` / [blue]`\|\|` | _Or_ | True if at least one of the left and right values integers true| [blue]`false or true` -> _true_ +
+| [blue]`OR` / [blue]`\|\|` | _Or_ | True if at least one of the left and right values integers is true| [blue]`false or true` -> _true_ +
 [blue]`"a" == "b" OR (2 == 1)` -> _false_
 |===
 
@@ -413,7 +413,7 @@ _Expr_ supports list of mixed-type values, also specified by normal expressions.
 ====
 *_list_* = _empty-list_ | _non-empty-list_ +
 _empty-list_ = "**[]**" +
-_non-empty-list_ = "**[**" _any-value_ {"**,**" _any-value} "**]**" +
+_non-empty-list_ = "**[**" _any-value_ {"**,**" _any-value_} "**]**" +
 ====
 
 .Examples
@@ -444,6 +444,7 @@ _non-empty-list_ = "**[**" _any-value_ {"**,**" _any-value} "**]**" +
 | [blue]`[]` | _Item at index_ | Item at given position | [blue]`[1,2,3][1]` -> _2_
 | [blue]`in` | _Item in list_ | True if item is in list | [blue]`2 in [1,2,3]` -> _true_ +
 [blue]`6 in [1,2,3]` -> _false_
+| [blue]`#` | _Size_ | Number of items in a list | [blue]`#[1,2,3]` -> _3_
 |===
 
 Array's items can be accessed using the index `[]` operator.
@@ -458,38 +459,63 @@ Array's items can be accessed using the index `[]` operator.
 *_slice_* = _string-expr_ "**[**" _integer-expr_ "**:**" _integer-expr_ "**]**"
 ====
 
-.Items of list
+.Examples: Getting items from lists
-`>>>` [blue]`[1,2,3].1` +
+`>>>` [blue]`[1,2,3][1]` +
 [green]`2`
 
-`>>>` [blue]`list=[1,2,3]; list.1` +
-[green]`2`
-
-`>>>` [blue]`["one","two","three"].1` +
-[green]`two`
-
-`>>>` [blue]`list=["one","two","three"]; list.(2-1)` +
-[green]`two`
-
-`>>>` [blue]`list.(-1)` +
-[green]`three`
-
-`>>>` [blue]`list.(10)` +
-[red]`Eval Error: [1:9] index 10 out of bounds`
-
-`>>>` [blue]`#list` +
-[green]`3`
-
 `>>>` [blue]`index=2; ["a", "b", "c", "d"][index]` +
 [green]`c`
 
-
 `>>>` [blue]`["a", "b", "c", "d"][2:]` +
 [green]`["c", "d"]`
 
+`>>>` [blue]`list=[1,2,3]; list[1]` +
+[green]`2`
+
+`>>>` [blue]`["one","two","three"][1]` +
+[green]`two`
+
+`>>>` [blue]`list=["one","two","three"]; list[2-1]` +
+[green]`two`
+
+`>>>` [blue]`list[1]="six"; list` +
+[green]`["one", "six", "three"]`
+
+`>>>` [blue]`list[-1]` +
+[green]`three`
+
+`>>>` [blue]`list[10]` +
+[red]`Eval Error: [1:9] index 10 out of bounds`
+
+.Example: Number of elements in a list
+`>>>` [blue]`#list` +
+[green]`3`
+
+.Examples: Element insertion
+`>>>` [blue]`"first" >> list` +
+[green]`["first", "one", "six", "three"]`
+
+`>>>` [blue]`list << "last"` +
+[green]`["first", "one", "six", "three", "last"]`
+
+.Examples: Element in list
+`>>>` [blue]`"six" in list` +
+[green]`true`
+
+`>>>` [blue]`"ten" in list` +
+[green]`false`
+
+.Examples: Concatenation and filtering
+`>>>` [blue]`[1,2,3] + ["one", "two", "three"]` +
+[green]`[1, 2, 3, "one", "two", "three"]`
+
+`>>>` [blue]`[1,2,3,4] - [2,4]` +
+[green]`[1, 3]`
+
+
 
 === Dictionaries
-The _dictionary_, or _dict_, data-type is set of pairs _key/value_. It is also known as _map_ or _associative array_.
+The _dictionary_, or _dict_, data-type represents sets  of pairs _key/value_. It is also known as _map_ or _associative array_.
 
 Dictionary literals are sequences of pairs separated by comma [blue]`,` enclosed between brace brackets.
 
@@ -497,7 +523,7 @@ Dictionary literals are sequences of pairs separated by comma [blue]`,` enclosed
 ====
 *_dict_* = _empty-dict_ | _non-empty-dict_ +
 _empty-dict_ = "**{}**" +
-_non-empty-dict_ = "**{**" _key-scalar_ "**:**" _any-value_ {"**,**" _key-scalar_ "**:**" _any-value} "**}**" +
+_non-empty-dict_ = "**{**" _key-scalar_ "**:**" _any-value_ {"**,**" _key-scalar_ "**:**" _any-value_} "**}**" +
 ====
 
 
@@ -515,6 +541,7 @@ _non-empty-dict_ = "**{**" _key-scalar_ "**:**" _any-value_ {"**,**" _key-scalar
 | [blue]`[]` | _Dict item value_ | Item value of given key | [blue]`{"one":1, "two":2}["two"]` -> _2_
 | [blue]`in` | _Key in dict_ | True if key is in dict | [blue]`"one" in {"one":1, "two":2}` -> _true_ +
 [blue]`"six" in {"one":1, "two":2}` -> _false_
+| [blue]`#` | _Size_ | Number of items in a dict | [blue]`#{1:"a",2:"b",3:"c"}` -> _3_
 |===
 
 .Examples
@@ -533,6 +560,9 @@ _non-empty-dict_ = "**{**" _key-scalar_ "**:**" _any-value_ {"**,**" _key-scalar
 `>>>` [blue]`d={"one":1, "two":2}; d["six"]=6; d` +
 [green]`{"two": 2, "one": 1, "six": 6}`
 
+`>>>` [blue]`#d` +
+[green]`3`
+
 
 == Variables
 _Expr_, like most programming languages, supports variables. A variable is an identifier with an assigned value. Variables are stored in _contexts_.
@@ -551,18 +581,18 @@ NOTE: The assign operator [blue]`=` returns the value assigned to the variable.
 [green]`1`
 
 `>>>` [blue]`a_b=1+2` +
-[green]`1+2`
+[green]`3`
 
 `>>>` [blue]`a_b` +
 [green]`3`
 
-`>>>` [blue]`x = 5.2 * (9-3)`  [gray]_// The assigned value has the typical approximation error of the float data-type_ +
+`>>>` [blue]`x = 5.2 * (9-3)`  [gray]_// The assigned value here has the typical approximation error of the float data-type_ +
 [green]`31.200000000000003`
 
 `>>>` [blue]`x = 1; y = 2*x` +
 [green]`2`
 
-`>>>` [blue]`_a=2` +
+`>>>` [blue]`\_a=2` +
 [red]`Parse Error: [1:2] unexpected token "_"`
 
 `>>>` [blue]`1=2` +
@@ -574,12 +604,12 @@ NOTE: The assign operator [blue]`=` returns the value assigned to the variable.
 === [blue]`;` operator
 The semicolon operator [blue]`;` is an infixed pseudo-operator. It evaluates the left expression first and then the right expression. The value of the latter is the final result.
 
-.Mult-expression syntax
+.Multi-expression syntax
 ====
 *_multi-expression_* = _expression_ {"**;**" _expression_ }
 ====
 
-An expression that contains [blue]`;` is called a _multi-expression_ and each component expressione is called a _sub-expression_.
+An expression that contains [blue]`;` is called a _multi-expression_ and each component expression is called a _sub-expression_.
 
 IMPORTANT: Technically [blue]`;` is not treated as a real operator. It acts as a separator in lists of expressions.
 
@@ -589,7 +619,7 @@ TIP: [blue]`;` can be used to set some variables before the final calculation.
 `>>>` [blue]`a=1; b=2; c=3; a+b+c` +
 [green]`6`
 
-The value of each sub-expression is stored in the automatica variable _last_.
+The value of each sub-expression is stored in the automatic variable _last_.
 
 .Example
 `>>>` [blue]`2+3; b=last+10; last` +
@@ -600,9 +630,10 @@ The value of each sub-expression is stored in the automatica variable _last_.
 [blue]`but` is an infixed operator. Its operands can be expressions of any type. It evaluates the left expression first, then the right expression. The value of the right expression is the final result.
 
 .Examples
-[blue]`5 but 2` +
+`>>>` [blue]`5 but 2` +
-[green]`2` +
+[green]`2`
-[blue]`x=2*3 but x-1` +
+
+`>>>` [blue]`x=2*3 but x-1` +
 [green]`5`.
 
 [blue]`but` behavior is very similar to [blue]`;`. The only difference is that [blue]`;` is not a true operator and can't be used inside parenthesis [blue]`(` and [blue]`)`.
@@ -610,17 +641,21 @@ The value of each sub-expression is stored in the automatica variable _last_.
 === Assignment operator [blue]`=`
 The assignment operator [blue]`=` is used to define variables or to change their value in the evaluation context (see _ExprContext_).
 
-The value on the left side of [blue]`=` must be an identifier. The value on the right side can be any expression and it becomes the result of the assignment operation.
+The value on the left side of [blue]`=` must be a variable identifier or an expression that evalutes to a variable. The value on the right side can be any expression and it becomes the result of the assignment operation.
 
-.Example
+.Examples
-`>>>` [blue]`a=15+1`
+`>>>` [blue]`a=15+1` +
 [green]`16`
 
+`>>>` [blue]`L=[1,2,3]; L[1]=5; L` +
+[green]`[1, 5, 3]`
+
 
 === Selector operator [blue]`? : ::`
 The _selector operator_ is very similar to the _switch/case/default_ statement available in many programming languages.
 
 .Selector literal Syntax
+====
 _selector-operator_ = _select-expression_ "*?*" _selector-case_ { "*:*" _selector-case_ } ["*::*" _default-multi-expression_] +
 _selector-case_ = [_match-list_] _case-value_ +
 _match-list_ = "*[*" _item_ {"*,*" _items_} "*]*" +
@@ -628,6 +663,7 @@ _item_ = _expression_ +
 _case-multi-expression_ = "*{*" _multi-expression_ "*}*" +
 _multi-expression_ = _expression_ { "*;*" _expression_ } +
 _default-multi-expression_ = _multi-expression_
+====
 
 In other words, the selector operator evaluates the _select-expression_ on the left-hand side of the [blue]`?` symbol; it then compares the result obtained with the values listed in the __match-list__'s, from left to right. If the comparision finds a match with a value in a _match-list_, the associated _case-multi-expression_ is evaluted, and its result will be the final result of the selection operation.
 
@@ -658,8 +694,8 @@ The [blue]`:` symbol (colon) is the separator of the selector-cases. Note that i
 [red]`Eval Error: [1:3] no case catches the value (10) of the selection expression`
 
 
-=== Variable default value [blue]`??` and [blue]`?=`
+=== Variable default value [blue]`??`, [blue]`?=`, and [blue]`?!`
-The left operand of these two operators must be a variable. The right operator can be any expression. They return the value of the variable if this is defined; otherwise they return the value of the right expression.
+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.
 
 IMPORTANT: If the left variable is defined, the right expression is not evaluated at all.
 
@@ -667,8 +703,12 @@ The [blue]`??` operator do not change the status of the left variable.
 
 The [blue]`?=` assigns the calculated value of the right expression to the left variable.
 
+The third one, [blue]`?!`, is the alternate operator. If the variable on the left size is not defined, it returns [blue]_nil_. Otherwise it returns the result of the expressione on the right side.
+
+IMPORTANT: If the left variable is NOT defined, the right expression is not evaluated at all.
+
 .Examples
-`>>>` [blue]`var ?? (1+2)`' +
+`>>>` [blue]`var ?? (1+2)` +
 [green]`3`
 
 `>>>` [blue]`var` +
@@ -677,9 +717,18 @@ The [blue]`?=` assigns the calculated value of the right expression to the left
 `>>>` [blue]`var ?= (1+2)` +
 [green]`3`
 
-`>>>` [blue]`var`
+`>>>` [blue]`var` +
 [green]`3`
 
+`>>>` [blue]`x ?! 5` +
+[green]`nil`
+
+`>>>` [blue]`x=1; x ?! 5` +
+[green]`5`
+
+`>>>` [blue]`y ?! (c=5); c` +
+[red]`Eval Error: undefined variable or function "c"`
+
 NOTE: These operators have a high priority, in particular higher than the operator [blue]`=`.
 
 == Priorities of operators
@@ -694,16 +743,17 @@ The table below shows all supported operators by decreasing priorities.
 | [blue]`[`...`]` | _Postfix_ | _Dict item_ | _dict_ `[` _any_ `]` -> _any_
 .2+|*INC*| [blue]`++` | _Postfix_ | _Post increment_| _integer-variable_ `++` -> _integer_
 | [blue]`++` | _Postfix_ | _Next item_ | _iterator_ `++` -> _any_
-.2+|*DEFAULT*| [blue]`??` | _Infix_ | _Default value_| _variable_ `??` _any-expr_ -> _any_
+.3+|*DEFAULT*| [blue]`??` | _Infix_ | _Default value_| _variable_ `??` _any-expr_ -> _any_
 | [blue]`?=` | _Infix_ | _Default/assign value_| _variable_ `?=` _any-expr_ -> _any_
-.1+| *ITER*^1^| [blue]`()` | _Prefix_ | _Iterator value_ | `()` _iterator_ -> _any_
+| [blue]`?!` | _Infix_ | _Alternate value_| _variable_ `?!` _any-expr_ -> _any_
+//.1+| *ITER*^1^| [blue]`()` | _Prefix_ | _Iterator value_ | `()` _iterator_ -> _any_
 .1+|*FACT*| [blue]`!` | _Postfix_ | _Factorial_| _integer_ `!` -> _integer_
 .3+|*SIGN*| [blue]`+`, [blue]`-` | _Prefix_ | _Change-sign_| (`+`\|`-`) _number_ -> _number_
 | [blue]`#` | _Prefix_ | _Lenght-of_ | `#` _collection_ -> _integer_
 | [blue]`#` | _Prefix_ | _Size-of_ | `#` _iterator_ -> _integer_
 .2+|*SELECT*| [blue]`? : ::` | _Multi-Infix_ | _Case-Selector_ | _any-expr_ `?` _case-list_ _case-expr_ `:` _case-list_ _case-expr_ ... `::` _default-expr_ -> _any_
 | [blue]`? : ::` | _Multi-Infix_ | _Index-Selector_ | _int-expr_ `?` _case-expr_ `:` _case-expr_ ... `::` _default-expr_ -> _any_
-.1+|*FRACT*| [blue]`\|` | _Infix_ | _Fraction_ | _integer_ `\|` _integer_ -> _fraction_
+.1+|*FRACT*| [blue]`:` | _Infix_ | _Fraction_ | _integer_ `:` _integer_ -> _fraction_
 .5+|*PROD*| [blue]`*` | _Infix_ | _Product_ | _number_ `*` _number_ -> _number_
 | [blue]`*` | _Infix_ | _String-repeat_ | _string_ `*` _integer_ -> _string_
 | [blue]`/` | _Infix_ | _Division_ | _number_ `/` _number_ -> _number_
@@ -715,6 +765,9 @@ 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_
+.3+|*BINARY*| [blue]`&` | _Infix_ | _Binary And_ | _number_ `&` _number_ -> _number_
+| [blue]`\|` | _Infix_ | _Binary Or_ | _number_ `\|` _number_ -> _number_
+| [blue]`~` | _Prefix_ | _Binary Not_ | `~` _number_ -> _number_
 .8+|*RELATION*| [blue]`<` | _Infix_ | _Less_ | _comparable_ `<` _comparable_ -> _boolean_
 | [blue]`\<=` | _Infix_ |  _less-equal_ | _comparable_ `\<=` _comparable_ -> _boolean_
 | [blue]`>` | _Infix_ |  _Greater_ | _comparable_ `>` _comparable_ -> _boolean_
@@ -735,39 +788,161 @@ The table below shows all supported operators by decreasing priorities.
 .1+|*RANGE*| [blue]`:` | _Infix_ | _Index-range_ | _integer_ `:` _integer_ -> _integer-pair_
 |===
 
-^1^ Experimental
+//^1^ Experimental
 
 
 == Functions
-Functions in _Expr_ are very similar to functions available in many programming languages. Actually, _Expr_ supports two types of function, _expr-functions_ and _go-functions_.
+Functions in _Expr_ are very similar to functions available in many programming languages. Currently, _Expr_ supports two types of function, _expr-functions_ and _go-functions_.
 
 * _expr-functions_ are defined using _Expr_'s syntax. They can be passed as arguments to other functions and can be returned from functions. Moreover, they bind themselves to the defining context, thus becoming closures.
-* _go-functions_ are regular Golang functions callable from _Expr_ expressions. They are defined in Golang source files called _modules_ and compiled within the _Expr_ package. To make Golang functions available in _Expr_ contextes, it is required to _import_ the module in which they are defined.
+* _go-functions_ are regular Golang functions callable from _Expr_ expressions. They are defined in Golang source files called _modules_ and compiled within the _Expr_ package. To make Golang functions available in _Expr_ contextes, it is required to activate the builtin module or to load the plugin module in which they are defined.
 
 
 === _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.
+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.
 
-. Expr's function definition syntax
+.Expr's function definition syntax
 ====
-*_function-definition_* = _identifier_ "**=**"  "**func(**" [_param-list_] "**)**"  "**{**" _multi-expression_ "**}**"
+*_function-definition_* = _identifier_ "**=**"  "**func(**" [_formal-param-list_] "**)**"  "**{**" _multi-expression_ "**}**" +
-_param_list_ = _required-param-list_ [ "**,**" _optional-param-list_ ]
+_formal-param_list_ = _required-param-list_ [ "**,**" _optional-param-list_ ] +
-_required-param-list_ = _identifier_ { "**,**" _identifier_ }
+_required-param-list_ = _identifier_ { "**,**" _identifier_ } +
-_optional-param-list_ = _optional-parm_ { "**,**" _optional-param_ }
+_optional-param-list_ = _optional-parm_ { "**,**" _optional-param_ } +
-_optional-param_ = _identifier_ "**=**" _any-expr_
+_optional-param_ = _param-name_ "**=**" _any-expr_ +
+_param-name_ = _identifier_
 ====
 
 .Examples
-#TODO#
+`>>>` [gray]_// A simple function: it takes two parameters and returns their "sum"_**^(*)^** +
+`>>>` [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.
+
+`>>>` [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)} }` +
+[green]`fib(n):any{}`
+
+
+`>>>` [gray]_// Same function fib() but entered by splitting it over mulple text lines_ +
+`>>>` [blue]`fib = func(n){ \` +
+`\...` [blue]`{nbsp}{nbsp}n ? \` +
+`\...` [blue]`{nbsp}{nbsp}{nbsp}{nbsp}[0] {0} : \` +
+`\...` [blue]`{nbsp}{nbsp}{nbsp}{nbsp}[1] {1} :: \` +
+`\...` [blue]`{nbsp}{nbsp}{nbsp}{nbsp}{ \` +
+`\...` [blue]`{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}{nbsp}fib(n-1) + fib(n-2) \` +
+`\...` [blue]`{nbsp}{nbsp}{nbsp}{nbsp}} \` +
+`\...` [blue]`}` +
+[green]`fib(n):any{}`
+
+`>>>` [gray]_// Required and optional parameters_ +
+`>>>` [blue]`measure = func(value, unit="meter"){ value + " " + unit + (value > 1) ? [true] {"s"} :: {""}}` +
+[green]`measure(value, unit="meter"):any{}`
+
 
 === _Golang_ function definition
 Description of how to define Golan functions and how to bind them to _Expr_ are topics treated in another document that I'll write, one day, maybe.
 
 === Function calls
-#TODO: function calls operations#
+To call a function, either Expr or Golang type, it is necessary to specify its name and, at least, its required parameters.
 
-Functions compute values in a local context (scope) that do not make effects on the calling context. This is the normal behavior. Using the reference operator [blue]`@` it is possibile to export local definition to the calling context.
+.Function invocation syntax
+====
+*_function-call_* = _identifier_ "**(**" _actual-param-list_ "**)**" +
+_actual-param-list_ = [_positional-params_] [_named-parameters_] +
+_positional-params_ = _any-value_ { "*,*" _any-value_ } +
+_named-params_ = _param-name_ "**=**" _any-value_ { "*,*" _param-name_ "**=**" _any-value_ } +
+_param-name_ = _identifier_
+====
 
+.Examples of calling the `sum()` functions defined above
+`>>>` [gray]_// sum of two integers_ +
+`>>>` [blue]`sum(-6, 2)` +
+[green]`-4` +
+`>>>` [gray]_// same as above but passing the parameters by name_ +
+`>>>` [blue]`sum(a=-6, b=2)` +
+[green]`-4` +
+`>>>` [gray]_// again, but swapping parameter positions (see the diff() examples below)_ +
+`>>>` [blue]`sum(b=2, a=-6)` +
+[green]`-4` +
+`>>>` [gray]_// sum of a fraction and an integer_ +
+`>>>` [blue]`sum(3|2, 2)` +
+[green]`7|2` +
+`>>>` [gray]_// sum of two strings_ +
+`>>>` [blue]`sum("bye", "-bye")` +
+[green]`"bye-bye"` +
+`>>>` [gray]_// sum of two lists_ +
+`>>>` [blue]`sum(["one", 1], ["two", 2])` +
+[green]`["one", 1, "two", 2]`
+
+.Examples of calling a function with parameters passed by name
+`>>>` [gray]_// diff(a,b) calculates a-b_ +
+`>>>` [blue]`diff = func(a,b){a-b}` +
+[green]`diff(a, b):any{}` +
+`>>>` [gray]_// simple invocation_ +
+`>>>` [blue]`diff(10,8)` +
+[green]`2` +
+`>>>` [gray]_// swapped parameters passed by name_ +
+`>>>` [blue]`diff(b=8,a=10)` +
+[green]`2`
+
+.Examples of calling the `fib()` function defined above
+`>>>` [gray]_// Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ..._ +
+`>>>` [blue]`fib(6)` +
+[green]`8` +
+`>>>` [blue]`fib(9)` +
+[green]`34`
+
+.Examples of calling the `measure()` functions defined above
+`>>>` [gray]_// simple call_ +
+`>>>` [blue]`measure(10,"litre")` +
+[green]`"10 litres"` +
+`>>>` [gray]_// accept the default unit_ +
+`>>>` [blue]`measure(8)` +
+[green]`"8 meters"` +
+`>>>` [gray]_// without the required parameter 'value'_ +
+`>>>` [blue]`measure(unit="degrees"))` +
+[red]`Eval Error: measure(): missing params -- value`
+
+.Examples of context binding (closures)
+`>>>` [blue]`factory = func(n=2){ func(x){x*n} }` +
+[green]`factory(n=2):any{}` +
+`>>>` [blue]`double = factory()` +
+[green]`double(x):any{}` +
+`>>>` [blue]`triple = factory(3)` +
+[green]`triple(x):any{}` +
+`>>>` [blue]`double(5)` +
+[green]`10` +
+`>>>` [blue]`triple(5)` +
+[green]`15`
+
+
+=== 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 un related 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.
+
+.Example
+`>>>` [blue]`f = func() { @x = 3; x = 5 }` [gray]_// f() declares two *different* local variables: ``@x`` and ``x``_ +
+[green]`f():any{}` +
+`>>>` [blue]`f()` [gray]_// The multi-expression (two) in f() is calculated and the last result is returned_ +
+[green]`5` +
+`>>>` [blue]`x` [gray]_// The `x` variable was not defined in the main context before the f() invocation. It appears in the main context by cloning the `@x` variable, local to f() after its termnation._ +
+[green]`3`
+
+NOTE: The clone modifier [blue]`@` does not make a variable a reference variable, as the ampersand character `&` does in languages such as C and C++. 
+
+[IMPORTANT]
+====
+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}`
+g(@p):any{}`
+`>>>` [blue]`g(9)`
+11`
+`>>>` [blue]`p
+9
+====
 
 == Iterators
 #TODO: function calls operations#

doc/Expr.html

@@ -474,6 +474,16 @@ pre.rouge .gh {
   color: #b8bb26;
   font-weight: bold;
 }
+pre.rouge .ge {
+  font-style: italic;
+}
+pre.rouge .ges {
+  font-weight: bold;
+  font-style: italic;
+}
+pre.rouge .gs {
+  font-weight: bold;
+}
 pre.rouge .k, pre.rouge .kn, pre.rouge .kp, pre.rouge .kr, pre.rouge .kv {
   color: #fb4934;
 }
@@ -567,7 +577,7 @@ pre.rouge .ss {
 <li><a href="#_but_operator">4.2. <code class="blue">but</code> operator</a></li>
 <li><a href="#_assignment_operator">4.3. Assignment operator <code class="blue">=</code></a></li>
 <li><a href="#_selector_operator">4.4. Selector operator <code class="blue">? : ::</code></a></li>
-<li><a href="#_variable_default_value_and">4.5. Variable default value <code class="blue">??</code> and <code class="blue">?=</code></a></li>
+<li><a href="#_variable_default_value_and">4.5. Variable default value <code class="blue">??</code>, <code class="blue">?=</code>, and <code class="blue">?!</code></a></li>
 </ul>
 </li>
 <li><a href="#_priorities_of_operators">5. Priorities of operators</a></li>
@@ -576,6 +586,7 @@ pre.rouge .ss {
 <li><a href="#_expr_function_definition">6.1. <em>Expr</em> function definition</a></li>
 <li><a href="#_golang_function_definition">6.2. <em>Golang</em> function definition</a></li>
 <li><a href="#_function_calls">6.3. Function calls</a></li>
+<li><a href="#_function_context">6.4. Function context</a></li>
 </ul>
 </li>
 <li><a href="#_iterators">7. Iterators</a></li>
@@ -657,7 +668,7 @@ pre.rouge .ss {
 <p>Function contexts are created by cloning the calling context. More details on this topic are given later in this document.</p>
 </div>
 <div class="paragraph">
-<p><em>Expr</em> creates and keeps a inner <em>global context</em> where it stores imported functions, either from builtin or plugin modules. To perform calculations, the calling program must provide its own context; this is the <em>main context</em>. All calculations take place in this context. As mentioned eralier, when a function is called, a new context is created by cloning the calling context. The createt context can be called <em>function context</em>.</p>
+<p><em>Expr</em> creates and keeps a inner <em>global context</em> 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 <em>main context</em>. 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 <em>function context</em>.</p>
 </div>
 <div class="paragraph">
 <p>Imported functions are registerd in the <em>global context</em>. When an expression first calls an imported function, that function is linked to the current context; this can be the <em>main context</em> or a <em>function context</em>.</p>
@@ -687,20 +698,20 @@ pre.rouge .ss {
 <pre class="rouge highlight"><code data-lang="shell"><span class="c"># Type 'exit' or Ctrl+D to quit the program.</span>
 
 <span class="o">[</span>user]<span class="nv">$ </span>./dev-expr
-dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o">(</span>build 14<span class="o">)</span>,2024/06/17 <span class="o">(</span>celestino.amoroso@portale-stac.it<span class="o">)</span>
+dev-expr <span class="nt">--</span> Expressions calculator v1.12.0<span class="o">(</span>build 1<span class="o">)</span>,2024/09/14 <span class="o">(</span>celestino.amoroso@portale-stac.it<span class="o">)</span>
-	Based on the Expr package v0.19.0
+	Based on the Expr package v0.26.0
 	Type <span class="nb">help </span>to get the list of available commands
 	See also https://git.portale-stac.it/go-pkg/expr/src/branch/main/README.adoc
 <span class="o">&gt;&gt;&gt;</span> <span class="nb">help</span>
 <span class="nt">---</span> REPL commands:
-      <span class="nb">source</span> <span class="nt">--</span> Load a file as input
-         <span class="nb">tty</span> <span class="nt">--</span> Enable/Disable ansi output <i class="conum" data-value="1"></i><b>(1)</b>
         base <span class="nt">--</span> Set the integer output base: 2, 8, 10, or 16
         <span class="nb">exit</span> <span class="nt">--</span> Exit the program
         <span class="nb">help</span> <span class="nt">--</span> Show <span class="nb">command </span>list
           ml <span class="nt">--</span> Enable/Disable multi-line output
         mods <span class="nt">--</span> List <span class="nb">builtin </span>modules
       output <span class="nt">--</span> Enable/Disable printing expression results. Options <span class="s1">'on'</span>, <span class="s1">'off'</span>, <span class="s1">'status'</span>
+      <span class="nb">source</span> <span class="nt">--</span> Load a file as input
+         <span class="nb">tty</span> <span class="nt">--</span> Enable/Disable ansi output <i class="conum" data-value="1"></i><b>(1)</b>
 
 <span class="nt">---</span> Command line options:
     <span class="nt">-b</span> &lt;<span class="nb">builtin</span><span class="o">&gt;</span>       Import <span class="nb">builtin </span>modules.
@@ -744,16 +755,16 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 9.5
 <span class="o">&gt;&gt;&gt;</span> 0xFD + 0b1 + 0o1 <i class="conum" data-value="1"></i><b>(1)</b>
 255
-<span class="o">&gt;&gt;&gt;</span> 1|2 + 2|3 <i class="conum" data-value="2"></i><b>(2)</b>
+<span class="o">&gt;&gt;&gt;</span> 1:2 + 2:3 <i class="conum" data-value="2"></i><b>(2)</b>
-7|6
+7:6
 <span class="o">&gt;&gt;&gt;</span> ml <i class="conum" data-value="3"></i><b>(3)</b>
-<span class="o">&gt;&gt;&gt;</span> 1|2 + 2|3
+<span class="o">&gt;&gt;&gt;</span> 1:2 + 2:3
 7
 -
 6
-<span class="o">&gt;&gt;&gt;</span> 4+2 but 5|2+0.5 <i class="conum" data-value="4"></i><b>(4)</b>
+<span class="o">&gt;&gt;&gt;</span> 4+2 but 5:2+0.5 <i class="conum" data-value="4"></i><b>(4)</b>
 3
-<span class="o">&gt;&gt;&gt;</span> 4+2<span class="p">;</span> 5|2+0.5 <i class="conum" data-value="5"></i><b>(5)</b>
+<span class="o">&gt;&gt;&gt;</span> 4+2<span class="p">;</span> 5:2+0.5 <i class="conum" data-value="5"></i><b>(5)</b>
 3
 <span class="o">&gt;&gt;&gt;</span></code></pre>
 </div>
@@ -766,7 +777,7 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 </tr>
 <tr>
 <td><i class="conum" data-value="2"></i><b>2</b></td>
-<td>Fractions: <em>numerator</em> | <em>denominator</em>.</td>
+<td>Fractions: <em>numerator</em> : <em>denominator</em>.</td>
 </tr>
 <tr>
 <td><i class="conum" data-value="3"></i><b>3</b></td>
@@ -805,12 +816,12 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <p><span class="blue">Floats</span></p>
 </li>
 <li>
-<p><span class="blue">Factions</span></p>
+<p><span class="blue">Fractions</span></p>
 </li>
 </ol>
 </div>
 <div class="paragraph">
-<p>In mixed operations involving integers, fractions and floats, automatic type promotion to the largest type take place.</p>
+<p>In mixed operations involving integers, fractions and floats, automatic type promotion to the largest type is performed.</p>
 </div>
 <div class="sect3">
 <h4 id="_integers"><a class="anchor" href="#_integers"></a><a class="link" href="#_integers">2.1.1. Integers</a></h4>
@@ -855,33 +866,33 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">+</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>sum</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Sum</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Add two values</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 + 2</code> &#8594; 1</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 + 2</code> &#8594; <em>1</em></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">-</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>subtraction</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Subtraction</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Subtract the right value from the left one</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">3 - 1</code> &#8594; 2</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">3 - 1</code> &#8594; <em>2</em></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">*</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>product</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Product</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Multiply two values</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 * 2</code> &#8594; -2</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 * 2</code> &#8594; <em>-2</em></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">/</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Division</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Integer division</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Divide the left value by the right one<sup>(*)</sup></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-10 / 2</code> &#8594; 5</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-11 / 2</code> &#8594; <em>-5</em></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">%</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Modulo</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Remainder of the integer division</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">5 % 2</code> &#8594; 1</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">5 % 2</code> &#8594; <em>1</em></p></td>
 </tr>
 </tbody>
 </table>
@@ -946,31 +957,31 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">+</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>sum</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Sum</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Add two values</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">4 + 0.5</code> &#8594; 4.5</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">-</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>subtraction</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Subtraction</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Subtract the right value from the left one</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">4 - 0.5</code> &#8594; 3.5</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">*</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>product</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Product</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Multiply two values</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">4 * 0.5</code> &#8594; 2.0</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">/</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Division</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Float division</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Divide the left value by the right one</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">1.0 / 2</code> &#8594; 0.5</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">./</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Float division</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Forced float division</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Force float division</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 ./ 2</code> &#8594; -0.5</p></td>
 </tr>
@@ -980,13 +991,13 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <div class="sect3">
 <h4 id="_fractions"><a class="anchor" href="#_fractions"></a><a class="link" href="#_fractions">2.1.3. Fractions</a></h4>
 <div class="paragraph">
-<p><em>Expr</em> also supports fractions. Fraction literals are made with two integers separated by a vertical bar <code>|</code>.</p>
+<p><em>Expr</em> also supports fractions. Fraction literals are made with two integers separated by a colon character <code>:</code>.</p>
 </div>
 <div class="exampleblock">
 <div class="title">Example 3. Fraction literal syntax</div>
 <div class="content">
 <div class="paragraph">
-<p><strong><em>fraction</em></strong> = [<em>sign</em>] (<em>num-den-spec</em> | <em>float-spec</em>)<br>
+<p><strong><em>fraction</em></strong> = [<em>sign</em>] (<em>num-den-spec</em> "<strong>:</strong>" <em>float-spec</em>)<br>
 <em>sign</em> = "<strong>+</strong>" | "<strong>-</strong>"<br>
 <em>num-den-spec</em> = <em>digit-seq</em> "<strong>|</strong>" <em>digit-seq</em><br>
 <em>float-spec</em> = <em>dec-seq</em> "<strong>.</strong>" [<em>dec-seq</em>] "<strong>(</strong>" <em>dec-seq</em> "<strong>)</strong>"<br>
@@ -997,55 +1008,55 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 </div>
 <div class="paragraph">
 <div class="title">Examples</div>
-<p><code>&gt;&gt;&gt;</code> <code class="blue">1 | 2</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">1 : 2</code><br>
-<code class="green">1|2</code></p>
+<code class="green">1:2</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">4|6</code>  <em class="gray">// Fractions are always reduced to their lowest terms</em><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">4:6</code>  <em class="gray">// Fractions are always reduced to their lowest terms</em><br>
-<code class="green">2|3</code></p>
+<code class="green">2:3</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">1|2 + 2|3</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">1:2 + 2:3</code><br>
-<code class="green">7|6</code></p>
+<code class="green">7:6</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">1|2 * 2|3</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">1:2 * 2:3</code><br>
-<code class="green">1|3</code></p>
+<code class="green">1:3</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">1|2 / 1|3</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">1:2 / 1:3</code><br>
-<code class="green">3|2</code></p>
+<code class="green">3:2</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">1|2 ./ 1|3</code> <em class="gray">// Force decimal division</em><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">1:2 ./ 1:3</code> <em class="gray">// Force decimal division</em><br>
 <code class="green">1.5</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">-1|2</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">-1:2</code><br>
-<code class="green">-1|2</code></p>
+<code class="green">-1:2</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">1|-2</code> <em class="gray">// Invalid sign specification</em><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">1:-2</code> <em class="gray">// Invalid sign specification</em><br>
-<em class="red">Eval Error: [1:3] infix operator "|" requires two non-nil operands, got 1</em></p>
+<em class="red">Eval Error: [1:3] infix operator ":" requires two non-nil operands, got 1</em></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">1|(-2)</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">1:(-2)</code><br>
-<code class="green">-1|2</code></p>
+<code class="green">-1:2</code></p>
 </div>
 <div class="paragraph">
 <p>Fractions can be used together with integers and floats in expressions.</p>
 </div>
 <div class="paragraph">
 <div class="title">Examples</div>
-<p><code>&gt;&gt;&gt;</code> <code class="blue">1|2 + 5</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">1:2 + 5</code><br>
-<code class="green">11|2</code></p>
+<code class="green">11:2</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">4 - 1|2</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">4 - 1:2</code><br>
-<code class="green">7|2</code></p>
+<code class="green">7:2</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">1.0 + 1|2</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">1.0 + 1:2</code><br>
 <code class="green">1.5</code></p>
 </div>
 </div>
@@ -1074,7 +1085,7 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <code class="green">123&#160;&#160;&#160;&#160;abc</code></p>
 </div>
 <div class="paragraph">
-<p>Some arithmetic operators can also be used with strings.</p>
+<p>Some arithmetic operators also apply to strings.</p>
 </div>
 <table class="tableblock frame-all grid-all stretch">
 <caption class="title">Table 3. String operators</caption>
@@ -1109,7 +1120,7 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 </tbody>
 </table>
 <div class="paragraph">
-<p>The items of strings can be accessed using the square <code>[]</code> operator.</p>
+<p>The charanters in a string can be accessed using the square <code>[]</code> operator.</p>
 </div>
 <div class="exampleblock">
 <div class="title">Example 4. Item access syntax</div>
@@ -1137,11 +1148,11 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <code class="green">"b"</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">s.[-1]</code>    <em class="gray">// char at position -1, the rightmost one</em><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">s[-1]</code>    <em class="gray">// char at position -1, the rightmost one</em><br>
 <code class="green">"d"</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">\#s</code>       <em class="gray">// number of chars</em><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">#s</code>       <em class="gray">// number of chars</em><br>
 <code class="gren">4</code></p>
 </div>
 <div class="paragraph">
@@ -1208,14 +1219,14 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Greater</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">True if the left value is greater than the right one</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">5 &gt; 2</code> &#8594; <em>true</em><br>
-<code class="blue">"a" &lt; "b"</code> &#8594; <em>false</em></p></td>
+<code class="blue">"a" &gt; "b"</code> &#8594; <em>false</em></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&gt;=</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Greater or Equal</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">True if the left value is greater than or equal to the right one</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">5 &gt;= 2</code> &#8594; <em>true</em><br>
-<code class="blue">"b" &lt;= "b"</code> &#8594; <em>true</em></p></td>
+<code class="blue">"b" &gt;= "b"</code> &#8594; <em>true</em></p></td>
 </tr>
 </tbody>
 </table>
@@ -1256,7 +1267,7 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">OR</code> / <code class="blue">||</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Or</em></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">True if at least one of the left and right values integers true</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">True if at least one of the left and right values integers is true</p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">false or true</code> &#8594; <em>true</em><br>
 <code class="blue">"a" == "b" OR (2 == 1)</code> &#8594; <em>false</em></p></td>
 </tr>
@@ -1314,7 +1325,7 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <div class="paragraph">
 <p><strong><em>list</em></strong> = <em>empty-list</em> | <em>non-empty-list</em><br>
 <em>empty-list</em> = "<strong>[]</strong>"<br>
-<em>non-empty-list</em> = "<strong>[</strong>" <em>any-value</em> {"<strong>,</strong>" _any-value} "<strong>]</strong>"<br></p>
+<em>non-empty-list</em> = "<strong>[</strong>" <em>any-value</em> {"<strong>,</strong>" <em>any-value</em>} "<strong>]</strong>"<br></p>
 </div>
 </div>
 </div>
@@ -1393,6 +1404,12 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">2 in [1,2,3]</code> &#8594; <em>true</em><br>
 <code class="blue">6 in [1,2,3]</code> &#8594; <em>false</em></p></td>
 </tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">#</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Size</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Number of items in a list</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">#[1,2,3]</code> &#8594; <em>3</em></p></td>
+</tr>
 </tbody>
 </table>
 <div class="paragraph">
@@ -1415,35 +1432,11 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 </div>
 </div>
 <div class="paragraph">
-<div class="title">Items of list</div>
+<div class="title">Examples: Getting items from lists</div>
-<p><code>&gt;&gt;&gt;</code> <code class="blue">[1,2,3].1</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">[1,2,3][1]</code><br>
 <code class="green">2</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">list=[1,2,3]; list.1</code><br>
-<code class="green">2</code></p>
-</div>
-<div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">["one","two","three"].1</code><br>
-<code class="green">two</code></p>
-</div>
-<div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">list=["one","two","three"]; list.(2-1)</code><br>
-<code class="green">two</code></p>
-</div>
-<div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">list.(-1)</code><br>
-<code class="green">three</code></p>
-</div>
-<div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">list.(10)</code><br>
-<code class="red">Eval Error: [1:9] index 10 out of bounds</code></p>
-</div>
-<div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">#list</code><br>
-<code class="green">3</code></p>
-</div>
-<div class="paragraph">
 <p><code>&gt;&gt;&gt;</code> <code class="blue">index=2; ["a", "b", "c", "d"][index]</code><br>
 <code class="green">c</code></p>
 </div>
@@ -1451,11 +1444,67 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <p><code>&gt;&gt;&gt;</code> <code class="blue">["a", "b", "c", "d"][2:]</code><br>
 <code class="green">["c", "d"]</code></p>
 </div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">list=[1,2,3]; list[1]</code><br>
+<code class="green">2</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">["one","two","three"][1]</code><br>
+<code class="green">two</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">list=["one","two","three"]; list[2-1]</code><br>
+<code class="green">two</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">list[1]="six"; list</code><br>
+<code class="green">["one", "six", "three"]</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">list[-1]</code><br>
+<code class="green">three</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">list[10]</code><br>
+<code class="red">Eval Error: [1:9] index 10 out of bounds</code></p>
+</div>
+<div class="paragraph">
+<div class="title">Example: Number of elements in a list</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">#list</code><br>
+<code class="green">3</code></p>
+</div>
+<div class="paragraph">
+<div class="title">Examples: Element insertion</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">"first" &gt;&gt; list</code><br>
+<code class="green">["first", "one", "six", "three"]</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">list &lt;&lt; "last"</code><br>
+<code class="green">["first", "one", "six", "three", "last"]</code></p>
+</div>
+<div class="paragraph">
+<div class="title">Examples: Element in list</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">"six" in list</code><br>
+<code class="green">true</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">"ten" in list</code><br>
+<code class="green">false</code></p>
+</div>
+<div class="paragraph">
+<div class="title">Examples: Concatenation and filtering</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">[1,2,3] + ["one", "two", "three"]</code><br>
+<code class="green">[1, 2, 3, "one", "two", "three"]</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">[1,2,3,4] - [2,4]</code><br>
+<code class="green">[1, 3]</code></p>
+</div>
 </div>
 <div class="sect2">
 <h3 id="_dictionaries"><a class="anchor" href="#_dictionaries"></a><a class="link" href="#_dictionaries">2.5. Dictionaries</a></h3>
 <div class="paragraph">
-<p>The <em>dictionary</em>, or <em>dict</em>, data-type is set of pairs <em>key/value</em>. It is also known as <em>map</em> or <em>associative array</em>.</p>
+<p>The <em>dictionary</em>, or <em>dict</em>, data-type represents sets  of pairs <em>key/value</em>. It is also known as <em>map</em> or <em>associative array</em>.</p>
 </div>
 <div class="paragraph">
 <p>Dictionary literals are sequences of pairs separated by comma <code class="blue">,</code> enclosed between brace brackets.</p>
@@ -1466,7 +1515,7 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <div class="paragraph">
 <p><strong><em>dict</em></strong> = <em>empty-dict</em> | <em>non-empty-dict</em><br>
 <em>empty-dict</em> = "<strong>{}</strong>"<br>
-<em>non-empty-dict</em> = "<strong>{</strong>" <em>key-scalar</em> "<strong>:</strong>" <em>any-value</em> {"<strong>,</strong>" <em>key-scalar</em> "<strong>:</strong>" _any-value} "<strong>}</strong>"<br></p>
+<em>non-empty-dict</em> = "<strong>{</strong>" <em>key-scalar</em> "<strong>:</strong>" <em>any-value</em> {"<strong>,</strong>" <em>key-scalar</em> "<strong>:</strong>" <em>any-value</em>} "<strong>}</strong>"<br></p>
 </div>
 </div>
 </div>
@@ -1514,6 +1563,12 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">"one" in {"one":1, "two":2}</code> &#8594; <em>true</em><br>
 <code class="blue">"six" in {"one":1, "two":2}</code> &#8594; <em>false</em></p></td>
 </tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">#</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Size</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Number of items in a dict</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">#{1:"a",2:"b",3:"c"}</code> &#8594; <em>3</em></p></td>
+</tr>
 </tbody>
 </table>
 <div class="paragraph">
@@ -1537,6 +1592,10 @@ dev-expr <span class="nt">--</span> Expressions calculator v1.10.0<span class="o
 <p><code>&gt;&gt;&gt;</code> <code class="blue">d={"one":1, "two":2}; d["six"]=6; d</code><br>
 <code class="green">{"two": 2, "one": 1, "six": 6}</code></p>
 </div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">#d</code><br>
+<code class="green">3</code></p>
+</div>
 </div>
 </div>
 </div>
@@ -1575,14 +1634,14 @@ The assign operator <code class="blue">=</code> returns the value assigned to th
 </div>
 <div class="paragraph">
 <p><code>&gt;&gt;&gt;</code> <code class="blue">a_b=1+2</code><br>
-<code class="green">1+2</code></p>
+<code class="green">3</code></p>
 </div>
 <div class="paragraph">
 <p><code>&gt;&gt;&gt;</code> <code class="blue">a_b</code><br>
 <code class="green">3</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">x = 5.2 * (9-3)</code>  <em class="gray">// The assigned value has the typical approximation error of the float data-type</em><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">x = 5.2 * (9-3)</code>  <em class="gray">// The assigned value here has the typical approximation error of the float data-type</em><br>
 <code class="green">31.200000000000003</code></p>
 </div>
 <div class="paragraph">
@@ -1590,8 +1649,8 @@ The assign operator <code class="blue">=</code> returns the value assigned to th
 <code class="green">2</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue"><em>a=2</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">_a=2</code><br>
-<code class="red">Parse Error: [1:2] unexpected token "</em>"</code></p>
+<code class="red">Parse Error: [1:2] unexpected token "_"</code></p>
 </div>
 <div class="paragraph">
 <p><code>&gt;&gt;&gt;</code> <code class="blue">1=2</code><br>
@@ -1608,7 +1667,7 @@ The assign operator <code class="blue">=</code> returns the value assigned to th
 <p>The semicolon operator <code class="blue">;</code> is an infixed pseudo-operator. It evaluates the left expression first and then the right expression. The value of the latter is the final result.</p>
 </div>
 <div class="exampleblock">
-<div class="title">Example 12. Mult-expression syntax</div>
+<div class="title">Example 12. Multi-expression syntax</div>
 <div class="content">
 <div class="paragraph">
 <p><strong><em>multi-expression</em></strong> = <em>expression</em> {"<strong>;</strong>" <em>expression</em> }</p>
@@ -1616,7 +1675,7 @@ The assign operator <code class="blue">=</code> returns the value assigned to th
 </div>
 </div>
 <div class="paragraph">
-<p>An expression that contains <code class="blue">;</code> is called a <em>multi-expression</em> and each component expressione is called a <em>sub-expression</em>.</p>
+<p>An expression that contains <code class="blue">;</code> is called a <em>multi-expression</em> and each component expression is called a <em>sub-expression</em>.</p>
 </div>
 <div class="admonitionblock important">
 <table>
@@ -1648,7 +1707,7 @@ Technically <code class="blue">;</code> is not treated as a real operator. It ac
 <code class="green">6</code></p>
 </div>
 <div class="paragraph">
-<p>The value of each sub-expression is stored in the automatica variable <em>last</em>.</p>
+<p>The value of each sub-expression is stored in the automatic variable <em>last</em>.</p>
 </div>
 <div class="paragraph">
 <div class="title">Example</div>
@@ -1663,9 +1722,11 @@ Technically <code class="blue">;</code> is not treated as a real operator. It ac
 </div>
 <div class="paragraph">
 <div class="title">Examples</div>
-<p><code class="blue">5 but 2</code><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">5 but 2</code><br>
-<code class="green">2</code><br>
+<code class="green">2</code></p>
-<code class="blue">x=2*3 but x-1</code><br>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">x=2*3 but x-1</code><br>
 <code class="green">5</code>.</p>
 </div>
 <div class="paragraph">
@@ -1678,21 +1739,27 @@ Technically <code class="blue">;</code> is not treated as a real operator. It ac
 <p>The assignment operator <code class="blue">=</code> is used to define variables or to change their value in the evaluation context (see <em>ExprContext</em>).</p>
 </div>
 <div class="paragraph">
-<p>The value on the left side of <code class="blue">=</code> must be an identifier. The value on the right side can be any expression and it becomes the result of the assignment operation.</p>
+<p>The value on the left side of <code class="blue">=</code> must be a variable identifier or an expression that evalutes to a variable. The value on the right side can be any expression and it becomes the result of the assignment operation.</p>
 </div>
 <div class="paragraph">
-<div class="title">Example</div>
+<div class="title">Examples</div>
-<p><code>&gt;&gt;&gt;</code> <code class="blue">a=15+1</code>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">a=15+1</code><br>
 <code class="green">16</code></p>
 </div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">L=[1,2,3]; L[1]=5; L</code><br>
+<code class="green">[1, 5, 3]</code></p>
+</div>
 </div>
 <div class="sect2">
 <h3 id="_selector_operator"><a class="anchor" href="#_selector_operator"></a><a class="link" href="#_selector_operator">4.4. Selector operator <code class="blue">? : ::</code></a></h3>
 <div class="paragraph">
 <p>The <em>selector operator</em> is very similar to the <em>switch/case/default</em> statement available in many programming languages.</p>
 </div>
+<div class="exampleblock">
+<div class="title">Example 13. Selector literal Syntax</div>
+<div class="content">
 <div class="paragraph">
-<div class="title">Selector literal Syntax</div>
 <p><em>selector-operator</em> = <em>select-expression</em> "<strong>?</strong>" <em>selector-case</em> { "<strong>:</strong>" <em>selector-case</em> } ["<strong>::</strong>" <em>default-multi-expression</em>]<br>
 <em>selector-case</em> = [<em>match-list</em>] <em>case-value</em><br>
 <em>match-list</em> = "<strong>[</strong>" <em>item</em> {"<strong>,</strong>" <em>items</em>} "<strong>]</strong>"<br>
@@ -1701,6 +1768,8 @@ Technically <code class="blue">;</code> is not treated as a real operator. It ac
 <em>multi-expression</em> = <em>expression</em> { "<strong>;</strong>" <em>expression</em> }<br>
 <em>default-multi-expression</em> = <em>multi-expression</em></p>
 </div>
+</div>
+</div>
 <div class="paragraph">
 <p>In other words, the selector operator evaluates the <em>select-expression</em> on the left-hand side of the <code class="blue">?</code> symbol; it then compares the result obtained with the values listed in the <em>match-list</em>'s, from left to right. If the comparision finds a match with a value in a <em>match-list</em>, the associated <em>case-multi-expression</em> is evaluted, and its result will be the final result of the selection operation.</p>
 </div>
@@ -1741,9 +1810,9 @@ Technically <code class="blue">;</code> is not treated as a real operator. It ac
 </div>
 </div>
 <div class="sect2">
-<h3 id="_variable_default_value_and"><a class="anchor" href="#_variable_default_value_and"></a><a class="link" href="#_variable_default_value_and">4.5. Variable default value <code class="blue">??</code> and <code class="blue">?=</code></a></h3>
+<h3 id="_variable_default_value_and"><a class="anchor" href="#_variable_default_value_and"></a><a class="link" href="#_variable_default_value_and">4.5. Variable default value <code class="blue">??</code>, <code class="blue">?=</code>, and <code class="blue">?!</code></a></h3>
 <div class="paragraph">
-<p>The left operand of these two operators must be a variable. The right operator can be any expression. They return the value of the variable if this is defined; otherwise they return the value of the right expression.</p>
+<p>The left operand of first two operators, <code class="blue">??</code> and <code class="blue">?=</code>, 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.</p>
 </div>
 <div class="admonitionblock important">
 <table>
@@ -1764,9 +1833,24 @@ If the left variable is defined, the right expression is not evaluated at all.
 <p>The <code class="blue">?=</code> assigns the calculated value of the right expression to the left variable.</p>
 </div>
 <div class="paragraph">
+<p>The third one, <code class="blue">?!</code>, is the alternate operator. If the variable on the left size is not defined, it returns <em class="blue">nil</em>. Otherwise it returns the result of the expressione on the right side.</p>
+</div>
+<div class="admonitionblock important">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-important" title="Important"></i>
+</td>
+<td class="content">
+If the left variable is NOT defined, the right expression is not evaluated at all.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
 <div class="title">Examples</div>
-<p><code>&gt;&gt;&gt;</code> <code class="blue">var ?? (1+2)&#8217;<br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">var ?? (1+2)</code><br>
-[green]`3</code></p>
+<code class="green">3</code></p>
 </div>
 <div class="paragraph">
 <p><code>&gt;&gt;&gt;</code> <code class="blue">var</code><br>
@@ -1777,9 +1861,21 @@ If the left variable is defined, the right expression is not evaluated at all.
 <code class="green">3</code></p>
 </div>
 <div class="paragraph">
-<p><code>&gt;&gt;&gt;</code> <code class="blue">var</code>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">var</code><br>
 <code class="green">3</code></p>
 </div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">x ?! 5</code><br>
+<code class="green">nil</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">x=1; x ?! 5</code><br>
+<code class="green">5</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <code class="blue">y ?! (c=5); c</code><br>
+<code class="red">Eval Error: undefined variable or function "c"</code></p>
+</div>
 <div class="admonitionblock note">
 <table>
 <tr>
@@ -1847,7 +1943,7 @@ These operators have a high priority, in particular higher than the operator <co
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>iterator</em> <code>++</code> &#8594; <em>any</em></p></td>
 </tr>
 <tr>
-<td class="tableblock halign-center valign-top" rowspan="2"><p class="tableblock"><strong>DEFAULT</strong></p></td>
+<td class="tableblock halign-center valign-top" rowspan="3"><p class="tableblock"><strong>DEFAULT</strong></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">??</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Default value</em></p></td>
@@ -1860,11 +1956,10 @@ These operators have a high priority, in particular higher than the operator <co
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>variable</em> <code>?=</code> <em>any-expr</em> &#8594; <em>any</em></p></td>
 </tr>
 <tr>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><strong>ITER</strong><sup>1</sup></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">?!</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">()</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Prefix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Alternate value</em></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Iterator value</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>variable</em> <code>?!</code> <em>any-expr</em> &#8594; <em>any</em></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><code>()</code> <em>iterator</em> &#8594; <em>any</em></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><strong>FACT</strong></p></td>
@@ -1907,10 +2002,10 @@ These operators have a high priority, in particular higher than the operator <co
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><strong>FRACT</strong></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">|</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">:</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Fraction</em></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>integer</em> <code>|</code> <em>integer</em> &#8594; <em>fraction</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>integer</em> <code>:</code> <em>integer</em> &#8594; <em>fraction</em></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top" rowspan="5"><p class="tableblock"><strong>PROD</strong></p></td>
@@ -1981,6 +2076,25 @@ These operators have a high priority, in particular higher than the operator <co
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>list</em> <code>-</code> <em>list</em> &#8594; <em>list</em></p></td>
 </tr>
 <tr>
+<td class="tableblock halign-center valign-top" rowspan="3"><p class="tableblock"><strong>BINARY</strong></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&amp;</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Binary And</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>number</em> <code>&amp;</code> <em>number</em> &#8594; <em>number</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">|</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Binary Or</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>number</em> <code>|</code> <em>number</em> &#8594; <em>number</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">~</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Prefix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Binary Not</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code>~</code> <em>number</em> &#8594; <em>number</em></p></td>
+</tr>
+<tr>
 <td class="tableblock halign-center valign-top" rowspan="8"><p class="tableblock"><strong>RELATION</strong></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&lt;</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
@@ -2097,16 +2211,13 @@ These operators have a high priority, in particular higher than the operator <co
 </tr>
 </tbody>
 </table>
-<div class="paragraph">
-<p><sup>1</sup> Experimental</p>
-</div>
 </div>
 </div>
 <div class="sect1">
 <h2 id="_functions"><a class="anchor" href="#_functions"></a><a class="link" href="#_functions">6. Functions</a></h2>
 <div class="sectionbody">
 <div class="paragraph">
-<p>Functions in <em>Expr</em> are very similar to functions available in many programming languages. Actually, <em>Expr</em> supports two types of function, <em>expr-functions</em> and <em>go-functions</em>.</p>
+<p>Functions in <em>Expr</em> are very similar to functions available in many programming languages. Currently, <em>Expr</em> supports two types of function, <em>expr-functions</em> and <em>go-functions</em>.</p>
 </div>
 <div class="ulist">
 <ul>
@@ -2114,36 +2225,58 @@ These operators have a high priority, in particular higher than the operator <co
 <p><em>expr-functions</em> are defined using <em>Expr</em>'s syntax. They can be passed as arguments to other functions and can be returned from functions. Moreover, they bind themselves to the defining context, thus becoming closures.</p>
 </li>
 <li>
-<p><em>go-functions</em> are regular Golang functions callable from <em>Expr</em> expressions. They are defined in Golang source files called <em>modules</em> and compiled within the <em>Expr</em> package. To make Golang functions available in <em>Expr</em> contextes, it is required to <em>import</em> the module in which they are defined.</p>
+<p><em>go-functions</em> are regular Golang functions callable from <em>Expr</em> expressions. They are defined in Golang source files called <em>modules</em> and compiled within the <em>Expr</em> package. To make Golang functions available in <em>Expr</em> contextes, it is required to activate the builtin module or to load the plugin module in which they are defined.</p>
 </li>
 </ul>
 </div>
 <div class="sect2">
 <h3 id="_expr_function_definition"><a class="anchor" href="#_expr_function_definition"></a><a class="link" href="#_expr_function_definition">6.1. <em>Expr</em> function definition</a></h3>
 <div class="paragraph">
-<p>A function is identified and referenced by its name. It can have zero or more parameter. <em>Expr</em> functions also support optional parameters.</p>
+<p>A function is identified and referenced by its name. It can have zero or more parameter. <em>Expr</em> functions also support optional parameters and passing paramters by name.</p>
-</div>
-<div class="olist arabic">
-<ol class="arabic">
-<li>
-<p>Expr&#8217;s function definition syntax</p>
-</li>
-</ol>
 </div>
 <div class="exampleblock">
+<div class="title">Example 14. Expr&#8217;s function definition syntax</div>
 <div class="content">
 <div class="paragraph">
-<p><strong><em>function-definition</em></strong> = <em>identifier</em> "<strong>=</strong>"  "<strong>func(</strong>" [<em>param-list</em>] "<strong>)</strong>"  "<strong>{</strong>" <em>multi-expression</em> "<strong>}</strong>"
+<p><strong><em>function-definition</em></strong> = <em>identifier</em> "<strong>=</strong>"  "<strong>func(</strong>" [<em>formal-param-list</em>] "<strong>)</strong>"  "<strong>{</strong>" <em>multi-expression</em> "<strong>}</strong>"<br>
-<em>param_list</em> = <em>required-param-list</em> [ "<strong>,</strong>" <em>optional-param-list</em> ]
+<em>formal-param_list</em> = <em>required-param-list</em> [ "<strong>,</strong>" <em>optional-param-list</em> ]<br>
-<em>required-param-list</em> = <em>identifier</em> { "<strong>,</strong>" <em>identifier</em> }
+<em>required-param-list</em> = <em>identifier</em> { "<strong>,</strong>" <em>identifier</em> }<br>
-<em>optional-param-list</em> = <em>optional-parm</em> { "<strong>,</strong>" <em>optional-param</em> }
+<em>optional-param-list</em> = <em>optional-parm</em> { "<strong>,</strong>" <em>optional-param</em> }<br>
-<em>optional-param</em> = <em>identifier</em> "<strong>=</strong>" <em>any-expr</em></p>
+<em>optional-param</em> = <em>param-name</em> "<strong>=</strong>" <em>any-expr</em><br>
+<em>param-name</em> = <em>identifier</em></p>
 </div>
 </div>
 </div>
 <div class="paragraph">
 <div class="title">Examples</div>
-<p><mark>TODO</mark></p>
+<p><code>&gt;&gt;&gt;</code> <em class="gray">// A simple function: it takes two parameters and returns their "sum"</em><strong><sup>(*)</sup></strong><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">sum = func(a, b){ a + b }</code><br>
+<code class="green">sum(a, b):any{}</code></p>
+</div>
+<div class="paragraph">
+<p><sup>(*)</sup> Since the plus, *+*, operator is defined for multiple data-types, the <em>sum()</em> function can be used for any pair of that types.</p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <em class="gray">// A more complex example: recursive calculation of the n-th value of Fibonacci&#8217;s sequence</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">fib = func(n){ n ? [0] {0}: [1] {1} :: {fib(n-1)+fib(n-2)} }</code><br>
+<code class="green">fib(n):any{}</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <em class="gray">// Same function fib() but entered by splitting it over mulple text lines</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">fib = func(n){ \</code><br>
+<code>...</code> <code class="blue">&#160;&#160;n ? \</code><br>
+<code>...</code> <code class="blue">&#160;&#160;&#160;&#160;[0] {0} : \</code><br>
+<code>...</code> <code class="blue">&#160;&#160;&#160;&#160;[1] {1} :: \</code><br>
+<code>...</code> <code class="blue">&#160;&#160;&#160;&#160;{ \</code><br>
+<code>...</code> <code class="blue">&#160;&#160;&#160;&#160;&#160;&#160;fib(n-1) + fib(n-2) \</code><br>
+<code>...</code> <code class="blue">&#160;&#160;&#160;&#160;} \</code><br>
+<code>...</code> <code class="blue">}</code><br>
+<code class="green">fib(n):any{}</code></p>
+</div>
+<div class="paragraph">
+<p><code>&gt;&gt;&gt;</code> <em class="gray">// Required and optional parameters</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">measure = func(value, unit="meter"){ value + " " + unit + (value &gt; 1) ? [true] {"s"} :: {""}}</code><br>
+<code class="green">measure(value, unit="meter"):any{}</code></p>
 </div>
 </div>
 <div class="sect2">
@@ -2155,10 +2288,138 @@ These operators have a high priority, in particular higher than the operator <co
 <div class="sect2">
 <h3 id="_function_calls"><a class="anchor" href="#_function_calls"></a><a class="link" href="#_function_calls">6.3. Function calls</a></h3>
 <div class="paragraph">
-<p><mark>TODO: function calls operations</mark></p>
+<p>To call a function, either Expr or Golang type, it is necessary to specify its name and, at least, its required parameters.</p>
+</div>
+<div class="exampleblock">
+<div class="title">Example 15. Function invocation syntax</div>
+<div class="content">
+<div class="paragraph">
+<p><strong><em>function-call</em></strong> = <em>identifier</em> "<strong>(</strong>" <em>actual-param-list</em> "<strong>)</strong>"<br>
+<em>actual-param-list</em> = [<em>positional-params</em>] [<em>named-parameters</em>]<br>
+<em>positional-params</em> = <em>any-value</em> { "<strong>,</strong>" <em>any-value</em> }<br>
+<em>named-params</em> = <em>param-name</em> "<strong>=</strong>" <em>any-value</em> { "<strong>,</strong>" <em>param-name</em> "<strong>=</strong>" <em>any-value</em> }<br>
+<em>param-name</em> = <em>identifier</em></p>
+</div>
+</div>
 </div>
 <div class="paragraph">
-<p>Functions compute values in a local context (scope) that do not make effects on the calling context. This is the normal behavior. Using the reference operator <code class="blue">@</code> it is possibile to export local definition to the calling context.</p>
+<div class="title">Examples of calling the <code>sum()</code> functions defined above</div>
+<p><code>&gt;&gt;&gt;</code> <em class="gray">// sum of two integers</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">sum(-6, 2)</code><br>
+<code class="green">-4</code><br>
+<code>&gt;&gt;&gt;</code> <em class="gray">// same as above but passing the parameters by name</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">sum(a=-6, b=2)</code><br>
+<code class="green">-4</code><br>
+<code>&gt;&gt;&gt;</code> <em class="gray">// again, but swapping parameter positions (see the diff() examples below)</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">sum(b=2, a=-6)</code><br>
+<code class="green">-4</code><br>
+<code>&gt;&gt;&gt;</code> <em class="gray">// sum of a fraction and an integer</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">sum(3|2, 2)</code><br>
+<code class="green">7|2</code><br>
+<code>&gt;&gt;&gt;</code> <em class="gray">// sum of two strings</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">sum("bye", "-bye")</code><br>
+<code class="green">"bye-bye"</code><br>
+<code>&gt;&gt;&gt;</code> <em class="gray">// sum of two lists</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">sum(["one", 1], ["two", 2])</code><br>
+<code class="green">["one", 1, "two", 2]</code></p>
+</div>
+<div class="paragraph">
+<div class="title">Examples of calling a function with parameters passed by name</div>
+<p><code>&gt;&gt;&gt;</code> <em class="gray">// diff(a,b) calculates a-b</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">diff = func(a,b){a-b}</code><br>
+<code class="green">diff(a, b):any{}</code><br>
+<code>&gt;&gt;&gt;</code> <em class="gray">// simple invocation</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">diff(10,8)</code><br>
+<code class="green">2</code><br>
+<code>&gt;&gt;&gt;</code> <em class="gray">// swapped parameters passed by name</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">diff(b=8,a=10)</code><br>
+<code class="green">2</code></p>
+</div>
+<div class="paragraph">
+<div class="title">Examples of calling the <code>fib()</code> function defined above</div>
+<p><code>&gt;&gt;&gt;</code> <em class="gray">// Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, &#8230;&#8203;</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">fib(6)</code><br>
+<code class="green">8</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">fib(9)</code><br>
+<code class="green">34</code></p>
+</div>
+<div class="paragraph">
+<div class="title">Examples of calling the <code>measure()</code> functions defined above</div>
+<p><code>&gt;&gt;&gt;</code> <em class="gray">// simple call</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">measure(10,"litre")</code><br>
+<code class="green">"10 litres"</code><br>
+<code>&gt;&gt;&gt;</code> <em class="gray">// accept the default unit</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">measure(8)</code><br>
+<code class="green">"8 meters"</code><br>
+<code>&gt;&gt;&gt;</code> <em class="gray">// without the required parameter 'value'</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">measure(unit="degrees"))</code><br>
+<code class="red">Eval Error: measure(): missing params&#8201;&#8212;&#8201;value</code></p>
+</div>
+<div class="paragraph">
+<div class="title">Examples of context binding (closures)</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">factory = func(n=2){ func(x){x*n} }</code><br>
+<code class="green">factory(n=2):any{}</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">double = factory()</code><br>
+<code class="green">double(x):any{}</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">triple = factory(3)</code><br>
+<code class="green">triple(x):any{}</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">double(5)</code><br>
+<code class="green">10</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">triple(5)</code><br>
+<code class="green">15</code></p>
+</div>
+</div>
+<div class="sect2">
+<h3 id="_function_context"><a class="anchor" href="#_function_context"></a><a class="link" href="#_function_context">6.4. Function context</a></h3>
+<div class="paragraph">
+<p>Functions compute values in a local context (scope) that do not make effects on the calling context. This is the normal behavior. Using the <em>clone</em> modifier <code class="blue">@</code> 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. <code class="blue">@x</code> is not the same as <code class="blue">x</code>; they are two different and un related variables.</p>
+</div>
+<div class="paragraph">
+<p>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 <code class="blue">@</code> symbol.</p>
+</div>
+<div class="paragraph">
+<div class="title">Example</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">f = func() { @x = 3; x = 5 }</code> <em class="gray">// f() declares two <strong>different</strong> local variables: <code>@x</code> and <code>x</code></em><br>
+<code class="green">f():any{}</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">f()</code> <em class="gray">// The multi-expression (two) in f() is calculated and the last result is returned</em><br>
+<code class="green">5</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">x</code> <em class="gray">// The <code>x</code> variable was not defined in the main context before the f() invocation. It appears in the main context by cloning the <code>@x</code> variable, local to f() after its termnation.</em><br>
+<code class="green">3</code></p>
+</div>
+<div class="admonitionblock note">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-note" title="Note"></i>
+</td>
+<td class="content">
+The clone modifier <code class="blue">@</code> does not make a variable a reference variable, as the ampersand character <code>&amp;</code> does in languages such as C and C++.
+</td>
+</tr>
+</table>
+</div>
+<div class="admonitionblock important">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-important" title="Important"></i>
+</td>
+<td class="content">
+<div class="paragraph">
+<p>The clone modifier can also be used to declare the formal parameters of functions, because they are local variables too.</p>
+</div>
+<div class="paragraph">
+<div class="title">Example</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">g = func(@p) {2+@p}</code>
+g(@p):any{}`
+<code>&gt;&gt;&gt;</code> <code class="blue">g(9)</code>
+11`
+<code>&gt;&gt;&gt;</code> [blue]`p
+9</p>
+</div>
+</td>
+</tr>
+</table>
 </div>
 </div>
 </div>
@@ -2200,7 +2461,7 @@ These operators have a high priority, in particular higher than the operator <co
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2024-06-21 09:06:12 +0200
+Last updated 2024-12-23 07:20:48 +0100
 </div>
 </div>
 </body>

fraction-type.go

@@ -50,9 +50,9 @@ func makeGeneratingFraction(s string) (f *FractionType, err error) {
 	} else if s[0] == '+' {
 		s = s[1:]
 	}
-//	if strings.HasSuffix(s, "()") {
+	//	if strings.HasSuffix(s, "()") {
-//		s = s[0 : len(s)-2]
+	//		s = s[0 : len(s)-2]
-//	}
+	//	}
 	s = strings.TrimSuffix(s, "()")
 	parts = strings.SplitN(s, ".", 2)
 	if num, err = strconv.ParseInt(parts[0], 10, 64); err != nil {
@@ -124,36 +124,38 @@ func (f *FractionType) String() string {
 func (f *FractionType) ToString(opt FmtOpt) string {
 	var sb strings.Builder
 	if opt&MultiLine == 0 {
-		sb.WriteString(fmt.Sprintf("%d|%d", f.num, f.den))
+		sb.WriteString(fmt.Sprintf("%d:%d", f.num, f.den))
 	} else {
-		var s, num string
+		var sign, num string
 		if f.num < 0 && opt&TTY == 0 {
 			num = strconv.FormatInt(-f.num, 10)
-			s = "-"
+			sign = "-"
 		} else {
 			num = strconv.FormatInt(f.num, 10)
 		}
 		den := strconv.FormatInt(f.den, 10)
 		size := max(len(num), len(den))
 		if opt&TTY != 0 {
-			sb.WriteString(fmt.Sprintf("\x1b[4m%[1]*s\x1b[0m\n", -size, fmt.Sprintf("%[1]*s", (size+len(num))/2, s+num)))
+			sNum := fmt.Sprintf("\x1b[4m%[1]*s\x1b[0m\n", -size, fmt.Sprintf("%[1]*s", (size+len(num))/2, sign+num))
+			sb.WriteString(sNum)
 		} else {
-			if len(s) > 0 {
+			if len(sign) > 0 {
 				sb.WriteString("  ")
 			}
 			sb.WriteString(fmt.Sprintf("%[1]*s", -size, fmt.Sprintf("%[1]*s", (size+len(num))/2, num)))
 			sb.WriteByte('\n')
-			if len(s) > 0 {
+			if len(sign) > 0 {
-				sb.WriteString(s)
+				sb.WriteString(sign)
 				sb.WriteByte(' ')
 			}
 			sb.WriteString(strings.Repeat("-", size))
 			sb.WriteByte('\n')
-			if len(s) > 0 {
+			if len(sign) > 0 {
 				sb.WriteString("  ")
 			}
 		}
-		sb.WriteString(fmt.Sprintf("%[1]*s", -size, fmt.Sprintf("%[1]*s", (size+len(den))/2, den)))
+		sDen := fmt.Sprintf("%[1]*s", size, fmt.Sprintf("%[1]*s", (size+len(den))/2, den))
+		sb.WriteString(sDen)
 	}
 
 	return sb.String()

function.go

@@ -348,8 +348,8 @@ func CallFunctionByArgs(parentCtx ExprContext, name string, args []any) (result
 	return
 }
 
-func CallFunctionByParams(parentCtx ExprContext, name string, params map[string]any) (result any, err error) {
+func CallFunctionByParams(parentCtx ExprContext, name string, actualParams map[string]any) (result any, err error) {
-	var actualParams map[string]any
+	//var actualParams map[string]any
 	if info, exists := GetFuncInfo(parentCtx, name); exists {
 		functor := info.Functor()
 		ctx := info.AllocContext(parentCtx)

go.mod

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

go.sum

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

iterator.go

@@ -5,7 +5,7 @@
 package expr
 
 import (
-	"errors"
+	// "errors"
 	"fmt"
 )
 
@@ -33,6 +33,8 @@ type Iterator interface {
 
 type ExtIterator interface {
 	Iterator
+	Reset() error
+	Clean() error
 	HasOperation(name string) bool
 	CallOperation(name string, args map[string]any) (value any, err error)
 }
@@ -41,6 +43,6 @@ func errNoOperation(name string) error {
 	return fmt.Errorf("no %s() function defined in the data-source", name)
 }
 
-func errInvalidDataSource() error {
+// func errInvalidDataSource() error {
-	return errors.New("invalid data-source")
+// 	return errors.New("invalid data-source")
-}
+// }

list-iterator.go

@@ -99,7 +99,9 @@ func (it *ListIterator) CallOperation(name string, args map[string]any) (v any,
 	case NextName:
 		v, err = it.Next()
 	case ResetName:
-		v, err = it.Reset()
+		err = it.Reset()
+	case CleanName:
+		err = it.Clean()
 	case IndexName:
 		v = int64(it.Index())
 	case CurrentName:
@@ -147,8 +149,12 @@ func (it *ListIterator) Count() int {
 	return it.count
 }
 
-func (it *ListIterator) Reset() (bool, error) {
+func (it *ListIterator) Reset() (error) {
 	it.index = it.start - it.step
 	it.count = 0
-	return true, nil
+	return nil
+}
+
+func (it *ListIterator) Clean() (error) {
+	return nil
 }

operand-iterator.go

@@ -92,6 +92,7 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
 
 	if ds != nil {
 		var dc *dataCursor
+		dcCtx := ctx.Clone()
 		if initFunc, exists := ds[InitName]; exists && initFunc != nil {
 			var args []any
 			var resource any
@@ -109,9 +110,10 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
 			if resource, err = initFunc.InvokeNamed(initCtx, InitName, actualParams); err != nil {
 				return
 			}
-			dcCtx := ctx.Clone()
 			exportObjects(dcCtx, initCtx)
 			dc = NewDataCursor(dcCtx, ds, resource)
+		} else {
+			dc = NewDataCursor(dcCtx, ds, nil)
 		}
 
 		v = dc

operator-assign.go

@@ -99,7 +99,106 @@ func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) {
 	return
 }
 
+//-------- assign term
+
+func newOpAssignTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priAssign,
+		evalFunc: evalOpAssign,
+	}
+}
+
+func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term) (value any, err error) {
+	var collectionValue, keyListValue, keyValue any
+	var keyList *ListType
+	var ok bool
+
+	if collectionValue, err = collectionTerm.compute(ctx); err != nil {
+		return
+	}
+
+	if keyListValue, err = keyListTerm.compute(ctx); err != nil {
+		return
+	} else if keyList, ok = keyListValue.(*ListType); !ok || len(*keyList) != 1 {
+		err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, TypeName(keyListValue))
+		return
+	}
+	if keyValue = (*keyList)[0]; keyValue == nil {
+		err = keyListTerm.Errorf("index/key is nil")
+		return
+	}
+
+	switch collection := collectionValue.(type) {
+	case *ListType:
+		if index, ok := keyValue.(int64); ok {
+			value = (*collection)[index]
+		} else {
+			err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, TypeName(keyValue))
+		}
+	case *DictType:
+		value = (*collection)[keyValue]
+	default:
+		err = collectionTerm.Errorf("collection expected")
+	}
+	return
+}
+
+func getAssignValue(ctx ExprContext, leftTerm *term) (value any, err error) {
+	if leftTerm.symbol() == SymIndex {
+		value, err = getCollectionItemValue(ctx, leftTerm.children[0], leftTerm.children[1])
+	} else {
+		value, _ = ctx.GetVar(leftTerm.source())
+	}
+	return
+}
+
+func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
+	var rightValue, leftValue any
+	if err = opTerm.checkOperands(); err != nil {
+		return
+	}
+
+	leftTerm := opTerm.children[0]
+	leftSym := leftTerm.symbol()
+	if leftSym != SymVariable && leftSym != SymIndex {
+		err = leftTerm.tk.Errorf("left operand of %q must be a variable or a collection's item", opTerm.tk.source)
+		return
+	}
+
+	rightChild := opTerm.children[1]
+
+	if rightValue, err = rightChild.compute(ctx); err == nil {
+		if leftValue, err = getAssignValue(ctx, leftTerm); err == nil {
+			switch opTerm.symbol() {
+			case SymPlusEqual:
+				v, err = sumValues(opTerm, leftValue, rightValue)
+			case SymMinusEqual:
+				v, err = diffValues(opTerm, leftValue, rightValue)
+			case SymStarEqual:
+				v, err = mulValues(opTerm, leftValue, rightValue)
+			case SymSlashEqual:
+				v, err = divValues(opTerm, leftValue, rightValue)
+			case SymPercEqual:
+				v, err = remainderValues(opTerm, leftValue, rightValue)
+			default:
+				err = opTerm.Errorf("unsupported assign operator %q", opTerm.source())
+			}
+			if err == nil {
+				err = assignValue(ctx, leftTerm, v)
+			}
+		}
+	}
+	return
+}
+
 // init
 func init() {
 	registerTermConstructor(SymEqual, newAssignTerm)
+	registerTermConstructor(SymPlusEqual, newOpAssignTerm)
+	registerTermConstructor(SymMinusEqual, newOpAssignTerm)
+	registerTermConstructor(SymStarEqual, newOpAssignTerm)
+	registerTermConstructor(SymSlashEqual, newOpAssignTerm)
 }

operator-binary.go

@@ -0,0 +1,104 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-binary.go
+package expr
+
+//-------- NOT term
+
+func newBinNotTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priBinary,
+		evalFunc: evalBinaryNot,
+	}
+}
+
+func evalBinaryNot(ctx ExprContext, opTerm *term) (v any, err error) {
+	var value any
+
+	if value, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	if IsInteger(value) {
+		i, _ := value.(int64)
+		v = ^i
+	} else {
+		err = opTerm.errIncompatibleType(value)
+	}
+	return
+}
+
+//-------- Binary AND term
+
+func newBinAndTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBinary,
+		evalFunc: evalBinaryAnd,
+	}
+}
+
+func evalBinaryAnd(ctx ExprContext, self *term) (v any, err error) {
+	var leftValue, rightValue any
+	var leftInt, rightInt int64
+	var lok, rok bool
+
+	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+		return
+	}
+
+	leftInt, lok = leftValue.(int64)
+	rightInt, rok = rightValue.(int64)
+
+	if lok && rok {
+		v = leftInt & rightInt
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+//-------- Binary OR term
+
+func newBinOrTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBinary,
+		evalFunc: evalBinaryOr,
+	}
+}
+
+func evalBinaryOr(ctx ExprContext, self *term) (v any, err error) {
+	var leftValue, rightValue any
+	var leftInt, rightInt int64
+	var lok, rok bool
+
+	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+		return
+	}
+
+	leftInt, lok = leftValue.(int64)
+	rightInt, rok = rightValue.(int64)
+
+	if lok && rok {
+		v = leftInt | rightInt
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymTilde, newBinNotTerm)
+	registerTermConstructor(SymAmpersand, newBinAndTerm)
+	registerTermConstructor(SymVertBar, newBinOrTerm)
+}

operator-context.go

@@ -20,7 +20,7 @@ func evalContextValue(ctx ExprContext, opTerm *term) (v any, err error) {
 	var childValue any
 
 	var sourceCtx ExprContext
-	if opTerm.children == nil || len(opTerm.children) == 0 {
+	if len(opTerm.children) == 0 {
 		sourceCtx = ctx
 	} else if opTerm.children[0].symbol() == SymVariable && opTerm.children[0].source() == "global" {
 		sourceCtx = globalCtx

operator-fraction.go

@@ -49,18 +49,23 @@ func evalFraction(ctx ExprContext, opTerm *term) (v any, err error) {
 		den = -den
 		num = -num
 	}
-	g := gcd(num, den)
+	if num != 0 {
-	num = num / g
+		g := gcd(num, den)
-	den = den / g
+		num = num / g
-	if den == 1 {
+		den = den / g
-		v = num
+		if den == 1 {
+			v = num
+		} else {
+			v = &FractionType{num, den}
+		}
 	} else {
-		v = &FractionType{num, den}
+		v = &FractionType{0, den}
 	}
 	return
 }
 
 // init
 func init() {
-	registerTermConstructor(SymVertBar, newFractionTerm)
+	// registerTermConstructor(SymVertBar, newFractionTerm)
+	registerTermConstructor(SymColon, newFractionTerm)
 }

operator-index.go

@@ -113,6 +113,9 @@ func evalIndex(ctx ExprContext, opTerm *term) (v any, err error) {
 	} else if IsDict(leftValue) {
 		d := leftValue.(*DictType)
 		v, err = getDictItem(d, indexTerm, indexList, rightValue)
+	} else {
+		rightChild := opTerm.children[1]
+		err = rightChild.Errorf("invalid index type: %v", (*indexList)[0])
 	}
 	return
 }

operator-insert.go

@@ -40,6 +40,10 @@ func evalInsert(ctx ExprContext, opTerm *term) (v any, err error) {
 		if opTerm.children[1].symbol() == SymVariable {
 			ctx.UnsafeSetVar(opTerm.children[1].source(), v)
 		}
+	} else if IsInteger(leftValue) && IsInteger(rightValue) {
+		leftInt := leftValue.(int64)
+		rightInt := rightValue.(int64)
+		v = leftInt >> rightInt
 	} else {
 		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
@@ -60,6 +64,10 @@ func evalAppend(ctx ExprContext, opTerm *term) (v any, err error) {
 		if opTerm.children[0].symbol() == SymVariable {
 			ctx.UnsafeSetVar(opTerm.children[0].source(), v)
 		}
+	} else if IsInteger(leftValue) && IsInteger(rightValue) {
+		leftInt := leftValue.(int64)
+		rightInt := rightValue.(int64)
+		v = leftInt << rightInt
 	} else {
 		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}

operator-prod.go

@@ -13,7 +13,7 @@ import (
 
 func newMultiplyTerm(tk *Token) (inst *term) {
 	return &term{
-		tk: *tk,
+		tk:       *tk,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priProduct,
@@ -21,13 +21,7 @@ func newMultiplyTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalMultiply(ctx ExprContext, prodTerm *term) (v any, err error) {
+func mulValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = prodTerm.evalInfix(ctx); err != nil {
-		return
-	}
-
 	if IsString(leftValue) && IsInteger(rightValue) {
 		s, _ := leftValue.(string)
 		n, _ := rightValue.(int64)
@@ -43,16 +37,26 @@ func evalMultiply(ctx ExprContext, prodTerm *term) (v any, err error) {
 			v = leftInt * rightInt
 		}
 	} else {
-		err = prodTerm.errIncompatibleTypes(leftValue, rightValue)
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
 
+func evalMultiply(ctx ExprContext, prodTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = prodTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return mulValues(prodTerm, leftValue, rightValue)
+}
+
 //-------- divide term
 
 func newDivideTerm(tk *Token) (inst *term) {
 	return &term{
-		tk: *tk,
+		tk:       *tk,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priProduct,
@@ -60,13 +64,7 @@ func newDivideTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalDivide(ctx ExprContext, opTerm *term) (v any, err error) {
+func divValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
-		return
-	}
-
 	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
 		if IsFloat(leftValue) || IsFloat(rightValue) {
 			d := numAsFloat(rightValue)
@@ -91,6 +89,16 @@ func evalDivide(ctx ExprContext, opTerm *term) (v any, err error) {
 	return
 }
 
+func evalDivide(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return divValues(opTerm, leftValue, rightValue)
+}
+
 //-------- divide as float term
 
 func newDivideAsFloatTerm(tk *Token) (inst *term) {
@@ -127,21 +135,14 @@ func evalDivideAsFloat(ctx ExprContext, floatDivTerm *term) (v any, err error) {
 
 func newRemainderTerm(tk *Token) (inst *term) {
 	return &term{
-		tk: *tk,
+		tk:       *tk,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priProduct,
-		evalFunc: evalReminder,
+		evalFunc: evalRemainder,
 	}
 }
-
+func remainderValues(opTerm *term, leftValue, rightValue any) (v any, err error) {
-func evalReminder(ctx ExprContext, ramainderTerm *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = ramainderTerm.evalInfix(ctx); err != nil {
-		return
-	}
-
 	if IsInteger(leftValue) && IsInteger(rightValue) {
 		rightInt, _ := rightValue.(int64)
 		if rightInt == 0 {
@@ -151,11 +152,21 @@ func evalReminder(ctx ExprContext, ramainderTerm *term) (v any, err error) {
 			v = leftInt % rightInt
 		}
 	} else {
-		err = ramainderTerm.errIncompatibleTypes(leftValue, rightValue)
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }
 
+func evalRemainder(ctx ExprContext, remainderTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = remainderTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return remainderValues(remainderTerm, leftValue, rightValue)
+}
+
 // init
 func init() {
 	registerTermConstructor(SymStar, newMultiplyTerm)

operator-range.go

@@ -34,12 +34,16 @@ func newRangeTerm(tk *Token) (inst *term) {
 	}
 }
 
+func changeColonToRange(t *term) {
+	if t.tk.IsSymbol(SymColon) {
+		t.tk.Sym = SymRange
+		t.evalFunc = evalRange
+	}
+}
+
 func evalRange(ctx ExprContext, opTerm *term) (v any, err error) {
 	var leftValue, rightValue any
 
-	// if err = self.checkOperands(); err != nil {
-	// 	return
-	// }
 	if len(opTerm.children) == 0 {
 		leftValue = int64(0)
 		rightValue = int64(-1)
@@ -52,7 +56,8 @@ func evalRange(ctx ExprContext, opTerm *term) (v any, err error) {
 		return
 	}
 	if !(IsInteger(leftValue) && IsInteger(rightValue)) {
-		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+		// err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+		err = errRangeInvalidSpecification(opTerm)
 		return
 	}
 
@@ -63,7 +68,15 @@ func evalRange(ctx ExprContext, opTerm *term) (v any, err error) {
 	return
 }
 
+func errRangeInvalidSpecification(t *term) error {
+	return t.Errorf("invalid range specification")
+}
+
+func errRangeUnexpectedExpression(t *term) error {
+	return t.Errorf("unexpected range expression")
+}
+
 // init
 func init() {
-	registerTermConstructor(SymColon, newRangeTerm)
+	registerTermConstructor(SymRange, newRangeTerm)
 }

operator-selector.go

@@ -22,9 +22,19 @@ func trySelectorCase(ctx ExprContext, exprValue, caseSel any, caseIndex int) (ma
 		selectedValue, err = caseData.caseExpr.Eval(ctx)
 		match = true
 	} else if filterList, ok := caseData.filterList.value().([]*term); ok {
-		if len(filterList) == 0 && exprValue == int64(caseIndex) {
+		if len(filterList) == 0 {
-			selectedValue, err = caseData.caseExpr.Eval(ctx)
+			var valueAsInt = int64(0)
-			match = true
+			if b, ok := exprValue.(bool); ok {
+				if !b {
+					valueAsInt = 1
+				}
+			} else if valueAsInt, ok = exprValue.(int64); !ok {
+				return
+			}
+			if valueAsInt == int64(caseIndex) {
+				selectedValue, err = caseData.caseExpr.Eval(ctx)
+				match = true
+			}
 		} else {
 			var caseValue any
 			for _, caseTerm := range filterList {

operator-sum.go

@@ -21,13 +21,7 @@ func newPlusTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalPlus(ctx ExprContext, plusTerm *term) (v any, err error) {
+func sumValues(plusTerm *term, leftValue, rightValue any) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = plusTerm.evalInfix(ctx); err != nil {
-		return
-	}
-
 	if (IsString(leftValue) && isNumberString(rightValue)) || (IsString(rightValue) && isNumberString(leftValue)) {
 		v = fmt.Sprintf("%v%v", leftValue, rightValue)
 	} else if IsNumber(leftValue) && IsNumber(rightValue) {
@@ -59,10 +53,22 @@ func evalPlus(ctx ExprContext, plusTerm *term) (v any, err error) {
 		c := leftDict.clone()
 		c.merge(rightDict)
 		v = c
+	} else if isFraction(leftValue) && isFraction(rightValue) {
+		v, err = sumAnyFract(leftValue, rightValue)
 	} else {
 		err = plusTerm.errIncompatibleTypes(leftValue, rightValue)
 	}
-	return
+	return v, err
+}
+
+func evalPlus(ctx ExprContext, plusTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = plusTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return sumValues(plusTerm, leftValue, rightValue)
 }
 
 //-------- minus term
@@ -77,13 +83,7 @@ func newMinusTerm(tk *Token) (inst *term) {
 	}
 }
 
-func evalMinus(ctx ExprContext, minusTerm *term) (v any, err error) {
+func diffValues(minusTerm *term, leftValue, rightValue any) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = minusTerm.evalInfix(ctx); err != nil {
-		return
-	}
-
 	if isNumOrFract(leftValue) && isNumOrFract(rightValue) {
 		if IsFloat(leftValue) || IsFloat(rightValue) {
 			v = numAsFloat(leftValue) - numAsFloat(rightValue)
@@ -110,6 +110,16 @@ func evalMinus(ctx ExprContext, minusTerm *term) (v any, err error) {
 	return
 }
 
+func evalMinus(ctx ExprContext, minusTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = minusTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	return diffValues(minusTerm, leftValue, rightValue)
+}
+
 // init
 func init() {
 	registerTermConstructor(SymPlus, newPlusTerm)

parser.go

@@ -6,10 +6,46 @@ package expr
 
 import (
 	"errors"
+
+	"golang.org/x/exp/constraints"
 )
 
 //-------- parser
 
+type parserContext uint16
+
+const (
+	parserNoFlags                = 0
+	allowMultiExpr parserContext = 1 << iota
+	allowVarRef
+	selectorContext
+	listContext                                // squareContext for list
+	indexContext                               // squareContext for index
+	allowIndex                                 // allow index in squareContext
+	squareContext = listContext | indexContext // Square parenthesis for list or index
+)
+
+func hasFlag[T constraints.Unsigned](set T, singleFlag T) bool {
+	return (set & singleFlag) != 0
+}
+
+func addFlags[T constraints.Unsigned](set T, flags T) T {
+	return set | flags
+}
+
+func addFlagsCond[T constraints.Unsigned](set T, flags T, cond bool) (newSet T) {
+	if cond {
+		newSet = set | flags
+	} else {
+		newSet = set
+	}
+	return
+}
+
+func remFlags[T constraints.Unsigned](set T, flags T) T {
+	return set & (^flags)
+}
+
 type parser struct {
 }
 
@@ -24,13 +60,13 @@ func (parser *parser) Next(scanner *scanner) (tk *Token) {
 	return
 }
 
-func (parser *parser) parseFuncCall(scanner *scanner, allowVarRef bool, tk *Token) (tree *term, err error) {
+func (parser *parser) parseFuncCall(scanner *scanner, ctx parserContext, tk *Token) (tree *term, err error) {
 	args := make([]*term, 0, 10)
 	itemExpected := false
 	lastSym := SymUnknown
 	for lastSym != SymClosedRound && lastSym != SymEos {
 		var subTree *ast
-		if subTree, err = parser.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err != nil {
+		if subTree, err = parser.parseItem(scanner, ctx, SymComma, SymClosedRound); err != nil {
 			break
 		}
 		prev := scanner.Previous()
@@ -66,12 +102,18 @@ func (parser *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 		tk = parser.Next(scanner)
 		if tk.IsSymbol(SymIdentifier) {
 			param := newTerm(tk)
+			if len(args) > 0 {
+				if pos := paramAlreadyDefined(args, param); pos > 0 {
+					err = tk.Errorf("parameter %q at position %d already defined at position %d", param.source(), len(args)+1, pos)
+					break
+				}
+			}
 			args = append(args, param)
 			tk = parser.Next(scanner)
 			if tk.Sym == SymEqual {
 				var paramExpr *ast
 				defaultParamsStarted = true
-				if paramExpr, err = parser.parseItem(scanner, false, SymComma, SymClosedRound); err != nil {
+				if paramExpr, err = parser.parseItem(scanner, parserNoFlags, SymComma, SymClosedRound); err != nil {
 					break
 				}
 				param.forceChild(paramExpr.root)
@@ -94,7 +136,7 @@ func (parser *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 	if err == nil {
 		tk = parser.Next(scanner)
 		if tk.IsSymbol(SymOpenBrace) {
-			body, err = parser.parseGeneral(scanner, true, true, SymClosedBrace)
+			body, err = parser.parseGeneral(scanner, allowMultiExpr|allowVarRef, SymClosedBrace)
 		} else {
 			err = tk.ErrorExpectedGot("{")
 		}
@@ -110,27 +152,43 @@ func (parser *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 	return
 }
 
-func (parser *parser) parseList(scanner *scanner, parsingIndeces bool, allowVarRef bool) (subtree *term, err error) {
+func paramAlreadyDefined(args []*term, param *term) (position int) {
+	position = 0
+	for i, arg := range args {
+		if arg.source() == param.source() {
+			position = i + 1
+		}
+	}
+	return
+}
+
+func (parser *parser) parseList(scanner *scanner, ctx parserContext) (listTerm *term, err error) {
 	r, c := scanner.lastPos()
 	args := make([]*term, 0)
 	lastSym := SymUnknown
 	itemExpected := false
+	itemCtx := remFlags(ctx, allowIndex)
 	for lastSym != SymClosedSquare && lastSym != SymEos {
-		var subTree *ast
 		zeroRequired := scanner.current.Sym == SymColon
-		if subTree, err = parser.parseItem(scanner, allowVarRef, SymComma, SymClosedSquare); err == nil {
+		var itemTree *ast
-			root := subTree.root
+		if itemTree, err = parser.parseItem(scanner, itemCtx, SymComma, SymClosedSquare); err == nil {
+			root := itemTree.root
 			if root != nil {
-				if !parsingIndeces && root.symbol() == SymColon {
+				if hasFlag(ctx, allowIndex) && root.symbol() == SymColon {
-					err = root.Errorf("unexpected range expression")
+					changeColonToRange(root)
+				}
+				if !hasFlag(ctx, allowIndex) && root.symbol() == SymRange {
+					// err = root.Errorf("unexpected range expression")
+					err = errRangeUnexpectedExpression(root)
 					break
 				}
 				args = append(args, root)
-				if parsingIndeces && root.symbol() == SymColon && zeroRequired { //len(root.children) == 0 {
+				if hasFlag(ctx, allowIndex) && root.symbol() == SymRange && zeroRequired { //len(root.children) == 0 {
 					if len(root.children) == 1 {
 						root.children = append(root.children, root.children[0])
 					} else if len(root.children) > 1 {
-						err = root.Errorf("invalid range specification")
+						// err = root.Errorf("invalid range specification")
+						err = errRangeInvalidSpecification(root)
 						break
 					}
 					zeroTk := NewValueToken(root.tk.row, root.tk.col, SymInteger, "0", int64(0))
@@ -147,26 +205,28 @@ func (parser *parser) parseList(scanner *scanner, parsingIndeces bool, allowVarR
 			break
 		}
 		lastSym = scanner.Previous().Sym
-		itemExpected = lastSym == SymComma
+		if itemExpected = lastSym == SymComma; itemExpected {
+			remFlags(ctx, allowIndex)
+		}
 	}
 	if err == nil {
 		if lastSym != SymClosedSquare {
 			err = scanner.Previous().ErrorExpectedGot("]")
 		} else {
-			subtree = newListTerm(r, c, args)
+			listTerm = newListTerm(r, c, args)
 		}
 	}
 	return
 }
 
-func (parser *parser) parseIterDef(scanner *scanner, allowVarRef bool) (subtree *term, err error) {
+func (parser *parser) parseIterDef(scanner *scanner, ctx parserContext) (subtree *term, err error) {
 	tk := scanner.Previous()
 	args := make([]*term, 0)
 	lastSym := SymUnknown
 	itemExpected := false
 	for lastSym != SymClosedRound && lastSym != SymEos {
 		var subTree *ast
-		if subTree, err = parser.parseItem(scanner, allowVarRef, SymComma, SymClosedRound); err == nil {
+		if subTree, err = parser.parseItem(scanner, ctx, SymComma, SymClosedRound); err == nil {
 			if subTree.root != nil {
 				args = append(args, subTree.root)
 			} else if itemExpected {
@@ -212,7 +272,7 @@ func (parser *parser) parseDictKey(scanner *scanner) (key any, err error) {
 	return
 }
 
-func (parser *parser) parseDictionary(scanner *scanner, allowVarRef bool) (subtree *term, err error) {
+func (parser *parser) parseDictionary(scanner *scanner, ctx parserContext) (subtree *term, err error) {
 	args := make(map[any]*term, 0)
 	lastSym := SymUnknown
 	itemExpected := false
@@ -229,7 +289,7 @@ func (parser *parser) parseDictionary(scanner *scanner, allowVarRef bool) (subtr
 			}
 			break
 		}
-		if subTree, err = parser.parseItem(scanner, allowVarRef, SymComma, SymClosedBrace); err == nil {
+		if subTree, err = parser.parseItem(scanner, ctx, SymComma, SymClosedBrace); err == nil {
 			if subTree.root != nil {
 				args[key] = subTree.root
 			} else /*if key != nil*/ {
@@ -248,15 +308,15 @@ func (parser *parser) parseDictionary(scanner *scanner, allowVarRef bool) (subtr
 			err = scanner.Previous().ErrorExpectedGot("}")
 		} else {
 			subtree = newDictTerm(args)
-			// subtree = newMapTerm(args)
 		}
 	}
 	return
 }
 
-func (parser *parser) parseSelectorCase(scanner *scanner, allowVarRef bool, defaultCase bool) (caseTerm *term, err error) {
+func (parser *parser) parseSelectorCase(scanner *scanner, ctx parserContext, defaultCase bool) (caseTerm *term, err error) {
 	var filterList *term
 	var caseExpr *ast
+	ctx = remFlags(ctx, allowIndex)
 	tk := parser.Next(scanner)
 	startRow := tk.row
 	startCol := tk.col
@@ -265,7 +325,7 @@ func (parser *parser) parseSelectorCase(scanner *scanner, allowVarRef bool, defa
 			err = tk.Errorf("case list in default clause")
 			return
 		}
-		if filterList, err = parser.parseList(scanner, false, allowVarRef); err != nil {
+		if filterList, err = parser.parseList(scanner, remFlags(ctx, allowIndex)); err != nil {
 			return
 		}
 		tk = parser.Next(scanner)
@@ -276,7 +336,7 @@ func (parser *parser) parseSelectorCase(scanner *scanner, allowVarRef bool, defa
 	}
 
 	if tk.Sym == SymOpenBrace {
-		if caseExpr, err = parser.parseGeneral(scanner, true, allowVarRef, SymClosedBrace); err != nil {
+		if caseExpr, err = parser.parseGeneral(scanner, ctx|allowMultiExpr, SymClosedBrace); err != nil {
 			return
 		}
 	} else {
@@ -302,25 +362,28 @@ func addSelectorCase(selectorTerm, caseTerm *term) {
 	caseTerm.parent = selectorTerm
 }
 
-func (parser *parser) parseSelector(scanner *scanner, tree *ast, allowVarRef bool) (selectorTerm *term, err error) {
+func (parser *parser) parseSelector(scanner *scanner, tree *ast, ctx parserContext) (selectorTerm *term, err error) {
 	var caseTerm *term
+
+	ctx = remFlags(ctx, allowIndex)
 	tk := scanner.makeToken(SymSelector, '?')
 	if selectorTerm, err = tree.addToken(tk); err != nil {
 		return
 	}
 
-	if caseTerm, err = parser.parseSelectorCase(scanner, allowVarRef, false); err == nil {
+	if caseTerm, err = parser.parseSelectorCase(scanner, ctx|allowVarRef, false); err == nil {
 		addSelectorCase(selectorTerm, caseTerm)
 	}
 	return
 }
 
-func (parser *parser) parseItem(scanner *scanner, allowVarRef bool, termSymbols ...Symbol) (tree *ast, err error) {
+func (parser *parser) parseItem(scanner *scanner, ctx parserContext, termSymbols ...Symbol) (tree *ast, err error) {
-	return parser.parseGeneral(scanner, false, allowVarRef, termSymbols...)
+	return parser.parseGeneral(scanner, ctx|allowVarRef, termSymbols...)
 }
 
 func (parser *parser) Parse(scanner *scanner, termSymbols ...Symbol) (tree *ast, err error) {
-	return parser.parseGeneral(scanner, true, false, termSymbols...)
+	termSymbols = append(termSymbols, SymEos)
+	return parser.parseGeneral(scanner, allowMultiExpr, termSymbols...)
 }
 
 func couldBeACollection(t *term) bool {
@@ -331,15 +394,22 @@ func couldBeACollection(t *term) bool {
 	return sym == SymList || sym == SymString || sym == SymDict || sym == SymExpression || sym == SymVariable
 }
 
-// func areSymbolsOutOfCtx(tk *Token, ctxTerm *term, syms ...Symbol) bool {
+func listSubTree(tree *ast, listTerm *term, allowIndeces bool) (root *term, err error) {
-// 	var areOut = false
+	var tk *Token
-// 	if ctxTerm != nil {
+	if allowIndeces {
-// 		areOut = tk.IsOneOf(syms)
+		tk = NewToken(listTerm.tk.row, listTerm.tk.col, SymIndex, listTerm.source())
-// 	}
+		root = newTerm(tk)
-// 	return areOut
+		if err = tree.addTerm(root); err == nil {
-// }
+			err = tree.addTerm(listTerm)
+		}
+	} else {
+		root = listTerm
+		err = tree.addTerm(listTerm)
+	}
+	return
+}
 
-func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef bool, termSymbols ...Symbol) (tree *ast, err error) {
+func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymbols ...Symbol) (tree *ast, err error) {
 	var selectorTerm *term = nil
 	var currentTerm *term = nil
 	var tk *Token
@@ -353,7 +423,7 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 		// }
 
 		if tk.Sym == SymSemiColon {
-			if allowForest {
+			if hasFlag(ctx, allowMultiExpr) {
 				tree.ToForest()
 				firstToken = true
 				currentTerm = nil
@@ -371,6 +441,9 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 				tk.Sym = SymChangeSign
 			} else if tk.Sym == SymPlus {
 				tk.Sym = SymUnchangeSign
+			} else if tk.IsSymbol(SymExclamation) {
+				err = tk.Errorf("postfix opertor %q requires an operand on its left", tk)
+				break
 			}
 			firstToken = false
 		}
@@ -378,46 +451,36 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 		switch tk.Sym {
 		case SymOpenRound:
 			var subTree *ast
-			if subTree, err = parser.parseGeneral(scanner, false, allowVarRef, SymClosedRound); err == nil {
+			if subTree, err = parser.parseGeneral(scanner, ctx, SymClosedRound); err == nil {
 				subTree.root.priority = priValue
 				err = tree.addTerm(newExprTerm(subTree.root))
 				currentTerm = subTree.root
 			}
 		case SymFuncCall:
 			var funcCallTerm *term
-			if funcCallTerm, err = parser.parseFuncCall(scanner, allowVarRef, tk); err == nil {
+			if funcCallTerm, err = parser.parseFuncCall(scanner, ctx, tk); err == nil {
 				err = tree.addTerm(funcCallTerm)
 				currentTerm = funcCallTerm
 			}
 		case SymOpenSquare:
 			var listTerm *term
-			parsingIndeces := couldBeACollection(currentTerm)
+			newCtx := addFlagsCond(addFlags(ctx, squareContext), allowIndex, couldBeACollection(currentTerm))
-			if listTerm, err = parser.parseList(scanner, parsingIndeces, allowVarRef); err == nil {
+			if listTerm, err = parser.parseList(scanner, newCtx); err == nil {
-				if parsingIndeces {
+				currentTerm, err = listSubTree(tree, listTerm, hasFlag(newCtx, allowIndex))
-					indexTk := NewToken(listTerm.tk.row, listTerm.tk.col, SymIndex, listTerm.source())
-					indexTerm := newTerm(indexTk)
-					if err = tree.addTerm(indexTerm); err == nil {
-						err = tree.addTerm(listTerm)
-					}
-				} else {
-					err = tree.addTerm(listTerm)
-				}
-				currentTerm = listTerm
 			}
 		case SymOpenBrace:
 			if currentTerm != nil && currentTerm.symbol() == SymColon {
 				err = currentTerm.Errorf(`selector-case outside of a selector context`)
 			} else {
 				var mapTerm *term
-				if mapTerm, err = parser.parseDictionary(scanner, allowVarRef); err == nil {
+				if mapTerm, err = parser.parseDictionary(scanner, ctx); err == nil {
 					err = tree.addTerm(mapTerm)
 					currentTerm = mapTerm
 				}
 			}
-		case SymEqual:
+		case SymEqual, SymPlusEqual, SymMinusEqual, SymStarEqual, SymSlashEqual, SymPercEqual:
-			// if err = checkPrevSymbol(lastSym, SymIdentifier, tk); err == nil {
 			currentTerm, err = tree.addToken(tk)
-			// }
+			firstToken = true
 		case SymFuncDef:
 			var funcDefTerm *term
 			if funcDefTerm, err = parser.parseFuncDef(scanner); err == nil {
@@ -426,24 +489,25 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 			}
 		case SymDollarRound:
 			var iterDefTerm *term
-			if iterDefTerm, err = parser.parseIterDef(scanner, allowVarRef); err == nil {
+			if iterDefTerm, err = parser.parseIterDef(scanner, ctx); err == nil {
 				err = tree.addTerm(iterDefTerm)
 				currentTerm = iterDefTerm
 			}
 		case SymIdentifier:
-			if tk.source[0] == '@' && !allowVarRef {
+			if tk.source[0] == '@' && !hasFlag(ctx, allowVarRef) {
 				err = tk.Errorf("variable references are not allowed in top level expressions: %q", tk.source)
 			} else {
 				currentTerm, err = tree.addToken(tk)
 			}
 		case SymQuestion:
-			if selectorTerm, err = parser.parseSelector(scanner, tree, allowVarRef); err == nil {
+			if selectorTerm, err = parser.parseSelector(scanner, tree, ctx); err == nil {
 				currentTerm = selectorTerm
+				addFlags(ctx, selectorContext)
 			}
 		case SymColon, SymDoubleColon:
 			var caseTerm *term
 			if selectorTerm != nil {
-				if caseTerm, err = parser.parseSelectorCase(scanner, allowVarRef, tk.Sym == SymDoubleColon); err == nil {
+				if caseTerm, err = parser.parseSelectorCase(scanner, ctx, tk.Sym == SymDoubleColon); err == nil {
 					addSelectorCase(selectorTerm, caseTerm)
 					currentTerm = caseTerm
 					if tk.Sym == SymDoubleColon {
@@ -451,80 +515,38 @@ func (parser *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarR
 					}
 				}
 			} else {
+				// if hasFlag(ctx, allowIndex) {
+				// 	tk.Sym = SymRange
+				// }
 				currentTerm, err = tree.addToken(tk)
 			}
-			if tk.IsSymbol(SymColon) {
+			if tk.IsOneOfA(SymColon, SymRange) {
 				// 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.addToken(tk)
 		}
 
 		if currentTerm != nil && currentTerm.tk.Sym != SymSelector && currentTerm.parent != nil && currentTerm.parent.tk.Sym != SymSelector {
 			selectorTerm = nil
-
+			remFlags(ctx, selectorContext)
 		}
 		// lastSym = tk.Sym
 	}
 
 	if err == nil {
-		err = tk.Error()
+		if !tk.IsOneOf(termSymbols) {
-	}
+			var symDesc string
-	return
+			if tk.IsSymbol(SymError) {
-}
+				symDesc = tk.ErrorText()
-
+			} else {
-// func checkPrevSymbol(lastSym, wantedSym Symbol, tk *Token) (err error) {
+				symDesc = SymToString(tk.Sym)
-// 	if lastSym != wantedSym {
-// 		err = fmt.Errorf(`assign operator (%q) must be preceded by a variable`, tk.source)
-// 	}
-// 	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
-					}
-				}
 			}
+			err = tk.ErrorExpectedGotStringWithPrefix("expected one of", SymListToString(termSymbols, true), symDesc)
+		} else {
+			err = tk.Error()
 		}
-	} else {
-		err = tk.Errorf("left operand of %q must be a variable or a variable expression", tk)
 	}
 	return
 }

scanner.go

@@ -40,9 +40,9 @@ func DefaultTranslations() map[Symbol]Symbol {
 		SymKwAnd:           SymAnd,
 		SymDoubleVertBar:   SymOr,
 		SymKwOr:            SymOr,
-		SymTilde:           SymNot,
+		// SymTilde:           SymNot,
-		SymKwNot:           SymNot,
+		SymKwNot:       SymNot,
-		SymLessGreater:     SymNotEqual,
+		SymLessGreater: SymNotEqual,
 	}
 }
 
@@ -149,6 +149,8 @@ func (scanner *scanner) fetchNextToken() (tk *Token) {
 			if next, _ := scanner.peek(); next == '*' {
 				scanner.readChar()
 				tk = scanner.fetchBlockComment()
+			} else if next, _ = scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymSlashEqual, ch, next)
 			} else if next == '/' {
 				scanner.readChar()
 				tk = scanner.fetchOnLineComment()
@@ -458,7 +460,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
+		_ = scanner.sync(err) // TODO: Check this function
 		txt := sb.String()
 		if sym == SymFloat {
 			value, err = strconv.ParseFloat(txt, 64)
@@ -590,7 +592,7 @@ func (scanner *scanner) fetchString(termCh byte) (tk *Token) {
 	}
 	if err != nil {
 		if err == io.EOF {
-			tk = scanner.makeErrorToken(errors.New("missing string termination \""))
+			tk = scanner.makeErrorToken(errors.New(string(termCh)))
 		} else {
 			tk = scanner.makeErrorToken(err)
 		}

symbol-map.go

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

symbol.go

@@ -69,6 +69,8 @@ const (
 	SymDoubleDot                         //  58: '..'
 	SymTripleDot                         //  59: '...'
 	SymStarEqual                         //  60: '*='
+	SymSlashEqual                        //  61: '/='
+	SymPercEqual                         //  62: '%='
 	SymChangeSign
 	SymUnchangeSign
 	SymIdentifier
@@ -88,6 +90,7 @@ const (
 	SymList
 	SymDict
 	SymIndex
+	SymRange // [index : index]
 	SymExpression
 	SymSelector     // <selector> ::= <expr> "?" <selector-case> {":" <selector-case>} ["::" <default-selector-case>]
 	SymSelectorCase // <selector-case> ::= [<list>] "{" <multi-expr> "}"

t_builtin-base_test.go

@@ -30,9 +30,9 @@ func TestFuncBase(t *testing.T) {
 		/*  16 */ {`isString("3" + 1)`, true, nil},
 		/*  17 */ {`isList(["3",  1])`, true, nil},
 		/*  18 */ {`isDict({"a":"3",  "b":1})`, true, nil},
-		/*  19 */ {`isFract(1|3)`, true, nil},
+		/*  19 */ {`isFract(1:3)`, true, nil},
-		/*  20 */ {`isFract(3|1)`, false, nil},
+		/*  20 */ {`isFract(3:1)`, false, nil},
-		/*  21 */ {`isRational(3|1)`, true, nil},
+		/*  21 */ {`isRational(3:1)`, true, nil},
 		/*  22 */ {`fract("2.2(3)")`, newFraction(67, 30), nil},
 		/*  23 */ {`fract("1.21(3)")`, newFraction(91, 75), nil},
 		/*  24 */ {`fract(1.21(3))`, newFraction(91, 75), nil},
@@ -41,26 +41,27 @@ func TestFuncBase(t *testing.T) {
 		/*  27 */ {`dec(2.0)`, float64(2), nil},
 		/*  28 */ {`dec("2.0")`, float64(2), nil},
 		/*  29 */ {`dec(true)`, float64(1), nil},
-		/*  30 */ {`dec(true")`, nil, `[1:11] missing string termination "`},
+		/*  30 */ {`dec(true")`, nil, "[1:11] expected one of `,`, `)`, got `\"`"},
 		/*  31 */ {`dec()`, nil, `dec(): too few params -- expected 1, got 0`},
 		/*  32 */ {`dec(1,2,3)`, nil, `dec(): too many params -- expected 1, got 3`},
 		/*  33 */ {`isBool(false)`, true, nil},
-		/*  34 */ {`fract(1|2)`, newFraction(1, 2), nil},
+		/*  34 */ {`fract(1:2)`, newFraction(1, 2), nil},
 		/*  35 */ {`fract(12,2)`, newFraction(6, 1), nil},
 		/*  36 */ {`bool(2)`, true, nil},
-		/*  37 */ {`bool(1|2)`, true, nil},
+		/*  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`},
 		/*  42 */ {`dec(false)`, float64(0), nil},
-		/*  43 */ {`dec(1|2)`, float64(0.5), nil},
+		/*  43 */ {`dec(1:2)`, float64(0.5), nil},
 		/*  44 */ {`dec([1])`, nil, `dec(): can't convert list to float`},
+		/*  45 */ {`eval("a=3"); a`, int64(3), nil},
 		// /*  45 */ {`string([1])`, nil, `string(): can't convert list to string`},
 	}
 
 	t.Setenv("EXPR_PATH", ".")
 
-	//runTestSuiteSpec(t, section, inputs, 10)
+	// runTestSuiteSpec(t, section, inputs, 45)
 	runTestSuite(t, section, inputs)
 }

t_builtin-string_test.go

@@ -15,7 +15,7 @@ func TestFuncString(t *testing.T) {
 		/*   1 */ {`builtin "string"; strJoin("-", "one", "two", "three")`, "one-two-three", nil},
 		/*   2 */ {`builtin "string"; strJoin("-", ["one", "two", "three"])`, "one-two-three", nil},
 		/*   3 */ {`builtin "string"; ls= ["one", "two", "three"]; strJoin("-", ls)`, "one-two-three", nil},
-		/*   4 */ {`builtin "string"; ls= ["one", "two", "three"]; strJoin(1, ls)`, nil, `strJoin(): the "separator" parameter must be a string, got a integer (1)`},
+		/*   4 */ {`builtin "string"; ls= ["one", "two", "three"]; strJoin(1, ls)`, nil, `strJoin(): the "separator" parameter must be a string, got an integer (1)`},
 		/*   5 */ {`builtin "string"; ls= ["one", 2, "three"]; strJoin("-", ls)`, nil, `strJoin(): expected string, got integer (2)`},
 		/*   6 */ {`builtin "string"; "<"+strTrim("  bye bye  ")+">"`, "<bye bye>", nil},
 		/*   7 */ {`builtin "string"; strSub("0123456789", 1,2)`, "12", nil},

t_expr_test.go

@@ -17,18 +17,19 @@ 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 */ {`a=3; a+=1`, int64(4), nil},
+		/*   6 */ {`a=3; a+=1; a`, int64(4), nil},
-		/*   7 */ {`a=3; a-=1`, int64(2), nil},
+		/*   7 */ {`a=3; a-=1; a`, int64(2), nil},
-		/*   8 */ {`a=3; a*=2`, int64(6), nil},
+		/*   8 */ {`a=3; a*=2; a`, 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`},
+		/*  11 */ {`a=3; a/=2`, int64(1), nil},
-		/*  12 */ {`*=2`, nil, `[1:2] left operand of "*=" must be a variable or a variable expression`},
+		/*  12 */ {`*=2`, nil, `[1:2] infix operator "*=" requires two non-nil operands, got 1`},
 		/*  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 */ {`
+		/*  17 */ {`true ? {"a"} :: {"b"}`, "a", nil},
+		/*  18 */ {`
 		ds={
 			"init":func(@end){@current=0 but true},
 			//"current":func(){current},
@@ -43,6 +44,6 @@ func TestExpr(t *testing.T) {
 	}
 	// t.Setenv("EXPR_PATH", ".")
 
-	// runTestSuiteSpec(t, section, inputs, 17)
+	// runTestSuiteSpec(t, section, inputs, 6, 7, 8, 9)
 	runTestSuite(t, section, inputs)
 }

t_fractions_test.go

@@ -11,35 +11,39 @@ import (
 func TestFractionsParser(t *testing.T) {
 	section := "Fraction"
 	inputs := []inputType{
-		/*   1 */ {`1|2`, newFraction(1, 2), nil},
+		/*   1 */ {`1:2`, newFraction(1, 2), nil},
-		/*   2 */ {`1|2 + 1`, newFraction(3, 2), nil},
+		/*   2 */ {`1:2 + 1`, newFraction(3, 2), nil},
-		/*   3 */ {`1|2 - 1`, newFraction(-1, 2), nil},
+		/*   3 */ {`1:2 - 1`, newFraction(-1, 2), nil},
-		/*   4 */ {`1|2 * 1`, newFraction(1, 2), nil},
+		/*   4 */ {`1:2 * 1`, newFraction(1, 2), nil},
-		/*   5 */ {`1|2 * 2|3`, newFraction(2, 6), nil},
+		/*   5 */ {`1:2 * 2:3`, newFraction(2, 6), nil},
-		/*   6 */ {`1|2 / 2|3`, newFraction(3, 4), nil},
+		/*   6 */ {`1:2 / 2:3`, newFraction(3, 4), nil},
-		/*   7 */ {`1|"5"`, nil, `denominator must be integer, got string (5)`},
+		/*   7 */ {`1:"5"`, nil, `denominator must be integer, got string (5)`},
-		/*   8 */ {`"1"|5`, nil, `numerator must be integer, got string (1)`},
+		/*   8 */ {`"1":5`, nil, `numerator must be integer, got string (1)`},
-		/*   9 */ {`1|+5`, nil, `[1:3] infix operator "|" requires two non-nil operands, got 1`},
+		/*   9 */ {`1:+5`, newFraction(1, 5), nil},
-		/*  10 */ {`1|(-2)`, newFraction(-1, 2), nil},
+		/*  10 */ {`1:(-2)`, newFraction(-1, 2), nil},
-		/*  11 */ {`builtin "math.arith"; add(1|2, 2|3)`, newFraction(7, 6), nil},
+		/*  11 */ {`builtin "math.arith"; add(1:2, 2:3)`, newFraction(7, 6), nil},
-		/*  12 */ {`builtin "math.arith"; add(1|2, 1.0, 2)`, float64(3.5), nil},
+		/*  12 */ {`builtin "math.arith"; add(1:2, 1.0, 2)`, float64(3.5), nil},
-		/*  13 */ {`builtin "math.arith"; mul(1|2, 2|3)`, newFraction(2, 6), nil},
+		/*  13 */ {`builtin "math.arith"; mul(1:2, 2:3)`, newFraction(2, 6), nil},
-		/*  14 */ {`builtin "math.arith"; mul(1|2, 1.0, 2)`, float64(1.0), nil},
+		/*  14 */ {`builtin "math.arith"; mul(1:2, 1.0, 2)`, float64(1.0), nil},
-		/*  15 */ {`1|0`, nil, `division by zero`},
+		/*  15 */ {`1:0`, nil, `division by zero`},
 		/*  16 */ {`fract(-0.5)`, newFraction(-1, 2), nil},
 		/*  17 */ {`fract("")`, (*FractionType)(nil), `bad syntax`},
 		/*  18 */ {`fract("-1")`, newFraction(-1, 1), nil},
 		/*  19 */ {`fract("+1")`, newFraction(1, 1), nil},
 		/*  20 */ {`fract("1a")`, (*FractionType)(nil), `strconv.ParseInt: parsing "1a": invalid syntax`},
 		/*  21 */ {`fract(1,0)`, nil, `fract(): division by zero`},
-		/*  22 */ {`string(1|2)`, "1|2", nil},
+		/*  22 */ {`string(1:2)`, "1:2", nil},
+		/*  23 */ {`1+1:2+0.5`, float64(2), nil},
+		/*  24 */ {`1:(2-2)`, nil, `division by zero`},
+		/*  25 */ {`[0,1][1-1]:1`, newFraction(0, 1), nil},
 	}
+	// runTestSuiteSpec(t, section, inputs, 25)
 	runTestSuite(t, section, inputs)
 }
 
 func TestFractionToStringSimple(t *testing.T) {
 	source := newFraction(1, 2)
-	want := "1|2"
+	want := "1:2"
 	got := source.ToString(0)
 	if got != want {
 		t.Errorf(`(1,2) -> result = %v [%T], want = %v [%T]`, got, got, want, want)
@@ -55,10 +59,9 @@ func TestFractionToStringMultiline(t *testing.T) {
 	}
 }
 
-// TODO Check this test: the output string ends with a space
+func TestToStringMultilineTty(t *testing.T) {
-func _TestToStringMultilineTty(t *testing.T) {
 	source := newFraction(-1, 2)
-	want := "\x1b[4m-1\x1b[0m\n2"
+	want := "\x1b[4m-1\x1b[0m\n 2"
 	got := source.ToString(MultiLine | TTY)
 	if got != want {
 		t.Errorf(`(1,2) -> result = %#v [%T], want = %#v [%T]`, got, got, want, want)

t_funcs_test.go

@@ -35,6 +35,7 @@ func TestFuncs(t *testing.T) {
 		/*  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`},
+		/*  25 */ {`f=func(x,x){x}`, nil, `[1:11] parameter "x" at position 2 already defined at position 1`},
 		//		/*  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_index_test.go

@@ -16,11 +16,13 @@ func TestCollections(t *testing.T) {
 		/*   3 */ {`"abcdef"[1:]`, "bcdef", nil},
 		/*   4 */ {`"abcdef"[:]`, "abcdef", nil},
 		// /*   5 */ {`[0,1,2,3,4][:]`, ListType{int64(0), int64(1), int64(2), int64(3), int64(4)}, nil},
-		/*   5 */ {`"abcdef"[1:2:3]`, nil, `[1:14] left operand '(1, 2)' [pair] and right operand '3' [integer] are not compatible with operator ":"`},
+		/*   5 */ {`"abcdef"[1:2:3]`, nil, `[1:14] invalid range specification`},
+		/*   6 */ {`"abcdef"[((1>0)?{1}:{0}):3]`, "bc", nil},
+		/*   7 */ {`"abcdef"[[0,1][0]:1]`, "a", nil},
 	}
 
 	t.Setenv("EXPR_PATH", ".")
 
-	// parserTestSpec(t, section, inputs, 5)
+	// runTestSuiteSpec(t, section, inputs, 5)
 	runTestSuite(t, section, inputs)
 }

t_iterator_test.go

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

t_list_test.go

@@ -39,9 +39,9 @@ func TestListParser(t *testing.T) {
 		/*  25 */ {`["a","b","c","d"][1,1]`, nil, `[1:19] one index only is allowed`},
 		/*  26 */ {`[0,1,2,3,4][:]`, newListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil},
 		/*  27 */ {`["a", "b", "c"] << ;`, nil, `[1:18] infix operator "<<" requires two non-nil operands, got 1`},
-		/*  28 */ {`2 << 3;`, nil, `[1:4] left operand '2' [integer] and right operand '3' [integer] are not compatible with operator "<<"`},
+		/*  28 */ {`2 << 3;`, int64(16), nil},
 		/*  29 */ {`but >> ["a", "b", "c"]`, nil, `[1:6] infix operator ">>" requires two non-nil operands, got 0`},
-		/*  30 */ {`2 >> 3;`, nil, `[1:4] left operand '2' [integer] and right operand '3' [integer] are not compatible with operator ">>"`},
+		/*  30 */ {`2 >> 3;`, int64(0), nil},
 		/*  31 */ {`a=[1,2]; a<<3`, newListA(int64(1), int64(2), int64(3)), nil},
 		/*  33 */ {`a=[1,2]; 5>>a`, newListA(int64(5), int64(1), int64(2)), nil},
 		/*  34 */ {`L=[1,2]; L[0]=9; L`, newListA(int64(9), int64(2)), nil},

t_parser_test.go

@@ -77,7 +77,7 @@ func TestGeneralParser(t *testing.T) {
 		/*  63 */ {`"1.5" == `, nil, `[1:8] infix operator "==" requires two non-nil operands, got 1`},
 		/*  64 */ {`"1.5" != `, nil, `[1:8] infix operator "!=" requires two non-nil operands, got 1`},
 		/*  65 */ {"+1.5", float64(1.5), nil},
-		/*  66 */ {"+", nil, `[1:2] prefix operator "+" requires one not nil operand`},
+		/*  66 */ {"+", nil, `[1:2] prefix operator "+" requires one non-nil operand`},
 		/*  67 */ {"4 / 0", nil, `division by zero`},
 		/*  68 */ {"4.0 / 0", nil, `division by zero`},
 		/*  69 */ {"4.0 / \n2", float64(2.0), nil},
@@ -94,10 +94,10 @@ func TestGeneralParser(t *testing.T) {
 		/*  80 */ {`5 % 2.0`, nil, `[1:4] left operand '5' [integer] and right operand '2' [float] are not compatible with operator "%"`},
 		/*  81 */ {`"a" < "b" AND NOT (2 < 1)`, true, nil},
 		/*  82 */ {`"a" < "b" AND NOT (2 == 1)`, true, nil},
-		/*  83 */ {`"a" < "b" AND ~ 2 == 1`, true, nil},
+		/*  83 */ {`"a" < "b" AND NOT 2 == 1`, true, nil},
-		/*  84 */ {`~ 2 > 1`, false, nil},
+		/*  84 */ {`NOT 2 > 1`, false, nil},
-		/*  85 */ {`~ true && true`, false, nil},
+		/*  85 */ {`nOT true && true`, false, nil},
-		/*  86 */ {`~ false || true`, true, nil},
+		/*  86 */ {`NOT false || true`, true, nil},
 		/*  87 */ {`false but true`, true, nil},
 		/*  88 */ {`2+3 but 5*2`, int64(10), nil},
 		/*  89 */ {`x=2`, int64(2), nil},
@@ -132,15 +132,13 @@ func TestGeneralParser(t *testing.T) {
 		/* 118 */ {`{"key":}`, nil, "[1:9] expected `dictionary-value`, got `}`"},
 		/* 119 */ {`{}`, &DictType{}, nil},
 		/* 120 */ {`v=10; v++; v`, int64(11), nil},
-		/* 121 */ {`1+1|2+0.5`, float64(2), nil},
+		/* 121 */ {`1.2()`, newFraction(6, 5), nil},
-		/* 122 */ {`1.2()`, newFraction(6, 5), nil},
+		/* 122 */ {`x="abc"; x ?! #x`, int64(3), nil},
-		/* 123 */ {`1|(2-2)`, nil, `division by zero`},
+		/* 123 */ {`x ?! #x`, nil, `[1:7] prefix/postfix operator "#" do not support operand '<nil>' [nil]`},
-		/* 124 */ {`x="abc"; x ?! #x`, int64(3), nil},
+		/* 124 */ {`x ?! (x+1)`, nil, nil},
-		/* 125 */ {`x ?! #x`, nil, `[1:7] prefix/postfix operator "#" do not support operand '<nil>' [nil]`},
+		/* 125 */ {`"abx" ?! (x+1)`, nil, `[1:6] left operand of "?!" must be a variable`},
-		/* 126 */ {`x ?! (x+1)`, nil, nil},
+		/* 126 */ {`"abx" ?? "pqr"`, nil, `[1:6] left operand of "??" must be a variable`},
-		/* 127 */ {`"abx" ?! (x+1)`, nil, `[1:6] left operand of "?!" must be a variable`},
+		/* 127 */ {`"abx" ?= "pqr"`, nil, `[1:6] left operand of "?=" must be a variable`},
-		/* 128 */ {`"abx" ?? "pqr"`, nil, `[1:6] left operand of "??" must be a variable`},
-		/* 129 */ {`"abx" ?= "pqr"`, nil, `[1:6] left operand of "?=" must be a variable`},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")

t_plugin_test.go

@@ -8,18 +8,18 @@ import (
 	"testing"
 )
 
-func _TestImportPlugin(t *testing.T) {
+// func TestImportPlugin(t *testing.T) {
-	t.Setenv("PLUGINS", "${HOME}/go/src/git.portale-stac.it/go")
+// 	t.Setenv("PLUGINS", "${HOME}/go/src/git.portale-stac.it/go")
-	t.Setenv("EXPR_PLUGIN_PATH","${PLUGINS}/expr-json-plugin:${PLUGINS}/expr-csv-plugin")
+// 	t.Setenv("EXPR_PLUGIN_PATH","${PLUGINS}/expr-json-plugin:${PLUGINS}/expr-csv-plugin")
 
-	gotCount, gotErr := importPluginFromSearchPath("json")
+// 	gotCount, gotErr := importPluginFromSearchPath("json")
-	if gotCount != 1 {
+// 	if gotCount != 1 {
-		t.Errorf("Import count: got=%d, want=1", gotCount)
+// 		t.Errorf("Import count: got=%d, want=1", gotCount)
-	}
+// 	}
-	if gotErr != nil {
+// 	if gotErr != nil {
-		t.Errorf("importPlugin() failed: %v", gotErr)
+// 		t.Errorf("importPlugin() failed: %v", gotErr)
-	}
+// 	}
-}
+// }
 
 func TestPluginExists(t *testing.T) {
 	name := "json"

t_relational_test.go

@@ -21,9 +21,9 @@ func TestRelational(t *testing.T) {
 		/*   8 */ {`true != false`, true, nil},
 		/*   9 */ {`1.0 != 3.0-2`, false, nil},
 		/*  10 */ {`[1,2] != [2,1]`, true, nil},
-		/*  11 */ {`1|2 == 1|3`, false, nil},
+		/*  11 */ {`1:2 == 1:3`, false, nil},
-		/*  12 */ {`1|2 != 1|3`, true, nil},
+		/*  12 */ {`1:2 != 1:3`, true, nil},
-		/*  13 */ {`1|2 == 4|8`, true, nil},
+		/*  13 */ {`1:2 == 4:8`, true, nil},
 		/*  14 */ {`1 < 8`, true, nil},
 		/*  15 */ {`1 <= 8`, true, nil},
 		/*  16 */ {`"a" < "b"`, true, nil},
@@ -32,10 +32,10 @@ func TestRelational(t *testing.T) {
 		/*  19 */ {`1.0 <= 8`, true, nil},
 		/*  20 */ {`1.0 <= 1.0`, true, nil},
 		/*  21 */ {`1.0 == 1`, true, nil},
-		/*  22 */ {`1|2 < 1|3`, false, nil},
+		/*  22 */ {`1:2 < 1:3`, false, nil},
-		/*  23 */ {`1|2 <= 1|3`, false, nil},
+		/*  23 */ {`1:2 <= 1:3`, false, nil},
-		/*  24 */ {`1|2 > 1|3`, true, nil},
+		/*  24 */ {`1:2 > 1:3`, true, nil},
-		/*  25 */ {`1|2 >= 1|3`, true, nil},
+		/*  25 */ {`1:2 >= 1:3`, true, nil},
 		/*  26 */ {`[1,2,3] > [2]`, true, nil},
 		/*  27 */ {`[1,2,3] > [9]`, false, nil},
 		/*  28 */ {`[1,2,3] >= [6]`, false, nil},

term.go

@@ -19,6 +19,7 @@ const (
 	priAnd
 	priNot
 	priRelational
+	priBinary
 	priSum
 	priProduct
 	priFraction
@@ -62,8 +63,8 @@ func (s *term) Clone() (d *term) {
 		}
 	}
 	d = &term{
-		tk: *s.tk.Clone(),
+		tk:       *s.tk.Clone(),
-		parent: s.parent,
+		parent:   s.parent,
 		children: children,
 		position: s.position,
 		priority: s.priority,
@@ -211,11 +212,11 @@ func (term *term) checkOperands() (err error) {
 		}
 	case posPrefix:
 		if term.children == nil || len(term.children) != 1 || term.children[0] == nil {
-			err = term.tk.Errorf("prefix operator %q requires one not nil operand", term.tk.String())
+			err = term.tk.Errorf("prefix operator %q requires one non-nil operand", term.tk.String())
 		}
 	case posPostfix:
 		if term.children == nil || len(term.children) != 1 || term.anyChildrenNil() {
-			err = term.tk.Errorf("postfix operator %q requires one not nil operand", term.tk.String())
+			err = term.tk.Errorf("postfix operator %q requires one non-nil operand", term.tk.String())
 		}
 	case posMultifix:
 		if term.children == nil || len(term.children) < 3 || term.anyChildrenNil() {

token.go

@@ -93,6 +93,15 @@ func (tk *Token) Error() (err error) {
 	return
 }
 
+func (tk *Token) ErrorText() (err string) {
+	if tk.Sym == SymError {
+		if msg, ok := tk.Value.(error); ok {
+			err = msg.Error()
+		}
+	}
+	return
+}
+
 func (tk *Token) Errors(msg string) (err error) {
 	err = fmt.Errorf("[%d:%d] %v", tk.row, tk.col, msg)
 	return
@@ -104,6 +113,10 @@ func (tk *Token) ErrorExpectedGot(symbol string) (err error) {
 }
 
 func (tk *Token) ErrorExpectedGotString(symbol, got string) (err error) {
-	err = fmt.Errorf("[%d:%d] expected `%s`, got `%s`", tk.row, tk.col, symbol, got)
+	return tk.ErrorExpectedGotStringWithPrefix("expected", symbol, got)
+}
+
+func (tk *Token) ErrorExpectedGotStringWithPrefix(prefix, symbol, got string) (err error) {
+	err = fmt.Errorf("[%d:%d] %s %s, got `%s`", tk.row, tk.col, prefix, symbol, got)
 	return
 }