Doc: more details on some operators

Added virtual symbol SymVariable translated from general real SymIdentifier symbol
parser_test.go: incompatible type error corrected
2024-05-20 06:59:49 +02:00 · 2024-05-20 06:05:24 +02:00 · 2024-05-20 05:32:28 +02:00 · 2024-05-20 05:31:20 +02:00 · 2024-05-20 05:30:26 +02:00 · 2024-05-20 05:27:44 +02:00
32 changed files with 1089 additions and 334 deletions
@@ -119,7 +119,7 @@ func (self *ast) eval(ctx ExprContext, preset bool) (result any, err error) {
 		if self.forest != nil {
 			for _, root := range self.forest {
 				if result, err = root.compute(ctx); err == nil {
-					ctx.setVar(ControlLastResult, result)
+					ctx.UnsafeSetVar(ControlLastResult, result)
 				} else {
 					//err = fmt.Errorf("error in expression nr %d: %v", i+1, err)
 					break
@@ -128,7 +128,7 @@ func (self *ast) eval(ctx ExprContext, preset bool) (result any, err error) {
 		}
 		if err == nil {
 			result, err = self.root.compute(ctx)
-			ctx.setVar(ControlLastResult, result)
+			ctx.UnsafeSetVar(ControlLastResult, result)
 		}
 		// } else {
 		// 	err = errors.New("empty expression")
@@ -15,7 +15,7 @@ func exportVar(ctx ExprContext, name string, value any) {
 	if name[0] == '@' {
 		name = name[1:]
 	}
-	ctx.setVar(name, value)
+	ctx.UnsafeSetVar(name, value)
 }

 func exportFunc(ctx ExprContext, name string, info ExprFunc) {
@@ -33,7 +33,7 @@ type ExprContext interface {
 	Clone() ExprContext
 	GetVar(varName string) (value any, exists bool)
 	SetVar(varName string, value any)
-	setVar(varName string, value any)
+	UnsafeSetVar(varName string, value any)
 	EnumVars(func(name string) (accept bool)) (varNames []string)
 	EnumFuncs(func(name string) (accept bool)) (funcNames []string)
 	GetFuncInfo(name string) (item ExprFunc, exists bool)
@@ -27,6 +27,7 @@ func TestDictParser(t *testing.T) {
 		/*  4 */ {`{1:"one",2:"two",3:"three"}.2`, "three", nil},
 		/*  5 */ {`#{1:"one",2:"two",3:"three"}`, int64(3), nil},
 		/*  6 */ {`{1:"one"} + {2:"two"}`, map[any]any{1: "one", 2: "two"}, nil},
+		/*  7 */ {`2 in {1:"one", 2:"two"}`, true, nil},
 	}

 	succeeded := 0
@@ -101,3 +102,49 @@ func TestDictParser(t *testing.T) {
 	}
 	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
 }
+
+func TestDictToStringMultiLine(t *testing.T) {
+	var good bool
+	section := "dict-ToString-ML"
+	want := `{
+	"first": 1
+}`
+	args := map[any]*term{
+		"first": newLiteralTerm(NewValueToken(0, 0, SymInteger, "1", 1)),
+	}
+	dict := newDict(args)
+	got := dict.ToString(MultiLine)
+	// fmt.Printf("got=%q\n", got)
+
+	if good = got == want; !good {
+		t.Errorf("ToString(MultiLine): got = %q, want %q", got, want)
+	}
+
+	if good {
+		t.Logf("%s -- succeeded", section)
+	} else {
+		t.Logf("%s -- failed", section)
+	}
+}
+
+func TestDictToString(t *testing.T) {
+	var good bool
+	section := "dict-ToString-SL"
+	want := `{"first": 1}`
+	args := map[any]*term{
+		"first": newLiteralTerm(NewValueToken(0, 0, SymInteger, "1", 1)),
+	}
+	dict := newDict(args)
+	got := dict.ToString(0)
+	// fmt.Printf("got=%q\n", got)
+
+	if good = got == want; !good {
+		t.Errorf("ToString(0): got = %q, want %q", got, want)
+	}
+
+	if good {
+		t.Logf("%s -- succeeded", section)
+	} else {
+		t.Logf("%s -- failed", section)
+	}
+}
@@ -22,7 +22,7 @@ Expressions calculator

 toc::[]

-#TODO: Work in progress (last update on 2024/05/16, 7:08 a.m.)#
+#TODO: Work in progress (last update on 2024/05/20, 06:58 a.m.)#

 == Expr
 _Expr_ is a GO package capable of analysing, interpreting and calculating expressions.
@@ -44,7 +44,7 @@ Here are some examples of execution.
 .Run `dev-expr` in REPL mode and ask for help
 [source,shell]
 ----
-# Assume the expr source directory. Type 'exit' or Ctrl+D to quit the program.
+# Type 'exit' or Ctrl+D to quit the program.

 [user]$ ./dev-expr
 expr -- Expressions calculator v1.7.1(build 2),2024/05/16 (celestino.amoroso@portale-stac.it)
@@ -122,7 +122,7 @@ _Expr_ supports three type of numbers:

 . [blue]#Integers#
 . [blue]#Floats#
-. [blue]#Factions# internally are stored as _pairs of_ Golang _int64_ values.
+. [blue]#Factions#

 In mixed operations involving integers, fractions and floats, automatic type promotion to the largest type take place.

@@ -183,7 +183,7 @@ _dec-seq_ = _see-integer-literal-syntax_
 `>>>` [blue]`4.5E-3` +
 [green]`0.0045` +
 `>>>` [blue]`4.5E10` +
-[green]`4.5e+10` +
+[green]`4.5e+10`


 .Arithmetic operators
@@ -207,7 +207,7 @@ _sign_ = "**+**" | "**-**" +
 _num-den-spec_ = _digit-seq_ "**|**" _digit-seq_ +
 _float-spec_ = _dec-seq_ "**.**" [_dec-seq_] "**(**" _dec-seq_ "**)**" +
 _dec-seq_ = _see-integer-literal-syntax_ +
-_digit-seq_ = _see-integer-literal-syntax_ +
+_digit-seq_ = _see-integer-literal-syntax_
 ====

 .Examples
@@ -235,12 +235,13 @@ _digit-seq_ = _see-integer-literal-syntax_ +

 Fractions can be used together with integers and floats in expressions.

+.Examples
 `>>>` [blue]`1|2 + 5` +
 [green]`11|2` +
 `>>>` [blue]`4 - 1|2` +
 [green]`7|2` +
 `>>>` [blue]`1.0 + 1|2` +
-[green]`1.5` +
+[green]`1.5`



@@ -265,10 +266,10 @@ Some arithmetic operators can also be used with strings.
 |===
 | Symbol    | Operation     | Description               | Examples

-| [blue]`+` | _concatenation_ | Join two strings or two _stringable_ values | [blue]`"one" + "two"` _["onetwo"]_ +
-[blue]`"one" + 2` _["one2"]_
+| [blue]`+` | _concatenation_ | Join two strings or two _stringable_ values | [blue]`"one" + "two"` -> _"onetwo"_ +
+[blue]`"one" + 2` -> _"one2"_

-| [blue]`*` | _repeat_ | Make _n_ copy of a string  | [blue]`"one" * 2` _["oneone"]_
+| [blue]`*` | _repeat_ | Make _n_ copy of a string  | [blue]`"one" * 2` -> _"oneone"_
 |===

 The items of strings can be accessed using the dot `.` operator.
@@ -279,18 +280,19 @@ _item_ = _string-expr_ "**.**" _integer-expr_
 ====

 .String examples
-`>>>` [blue]`s="abc"`  [gray]_assign the string to variable s_ +
+`>>>` [blue]`s="abc"`  [gray]_// assign the string to variable s_ +
 [green]`abc` +
-`>>>` [blue]`s.1`      [gray]_char at position 1 (starting from 0)_ +
+`>>>` [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]`c` +
-`>>>` [blue]`\#s`       [gray]_number of chars_ +
+`>>>` [blue]`\#s`       [gray]_// number of chars_ +
 [gren]`3` +
-`>>>` [blue]`#"abc"`   [gray]_number of chars_ +
-[green]`3` +
+`>>>` [blue]`#"abc"`   [gray]_// number of chars_ +
+[green]`3`

-=== Boolean
+
+=== Booleans
 Boolean data type has two values only: [blue]_true_ and [blue]_false_. Relational and boolean expressions result in boolean values.

 .Relational operators
@@ -341,35 +343,47 @@ Currently, boolean operations are evaluated using _short cut evaluation_. This m
 ====

 === Lists
-_Expr_ supports list of mixed-type values, also specified by normal expressions.
+_Expr_ supports list of mixed-type values, also specified by normal expressions. Internally, _Expr_'s lists are Go arrays.

-.List examples
-[source,go]
----
-[1, 2, 3]                   // List of integers
-["one", "two", "three"]     // List of strings
-["one", 2, false, 4.1]      // List of mixed-types
-["one"+1, 2.0*(9-2)]        // List of expressions
-[ [1,"one"], [2,"two"]]     // List of lists
----
+.List literal syntax
+====
+*_list_* = _empty-list_ | _non-empty-list_ +
+_empty-list_ = "**[]**" +
+_non-empty-list_ = "**[**" _any-value_ {"**,**" _any-value} "**]**" +
+====
+
+.Examples
+`>>>` [blue]`[1,2,3]`                     [gray]_// List of integers_ +
+[green]`[1, 2, 3]` +
+`>>>` [blue]`["one", "two", "three"]`     [gray]_// List of strings_ +
+[green]`["one", "two", "three"]` +
+`>>>` [blue]`["one", 2, false, 4.1]`      [gray]_// List of mixed-types_ +
+[green]`["one", 2, false, 4.1]` +
+`>>>` [blue]`["one"+1, 2.0*(9-2)]`        [gray]_// List of expressions_ +
+[green]`["one1", 14]` +
+`>>>` [blue]`[ [1,"one"], [2,"two"]]`     [gray]_// List of lists_ +
+[green]`[[1, "one"], [2, "two"]]`

 .List operators
 [cols="^2,^2,5,4"]
 |===
 | Symbol    | Operation     | Description               | Examples

-| [blue]`+` | _Join_ | Joins two lists | [blue]`[1,2] + [3]` _[ [1,2,3] ]_
-
-| [blue]`-` | _Difference_ | Left list without elements in the right list  | [blue]`[1,2,3] - [2]` _[ [1,3] ]_
+| [blue]`+` | _Join_ | Joins two lists | [blue]`[1,2] + [3]` -> _[1,2,3]_
+| [blue]`-` | _Difference_ | Left list without elements in the right list  | [blue]`[1,2,3] - [2]` -> _[1,3]_
+| [blue]`>>` | _Front insertion_ | Insert an item in front | [blue]`0 >> [1,2]` -> _[0,1,2]_
+| [blue]`<<` | _Back insertion_ | Insert an item at end | [blue]`[1,2] << 3` -> _[1,2,3]_
+| [blue]`.` | _List item_ | Item at given position | [blue]`[1,2.3].1` -> _2_
+| [blue]`in` | _Item in list_ | True if item is in list | [blue]`2 in [1,2,3]` -> _true_ +
+[blue]`6 in [1,2,3]` -> _false_
 |===

 The items of array can be accessed using the dot `.` operator.

 .Item access syntax
-[source,bnf]
----
-<item> ::= <list-expr>"."<index-expr>
----
+====
+_item_ = _list-expr_ "**.**" _integer-expr_
+====

 .Items of list
 `>>>` [blue]`[1,2,3].1` +
@@ -385,113 +399,183 @@ The items of array can be accessed using the dot `.` operator.
 `>>>` [blue]`list.(10)` +
 [red]`Eval Error: [1:9] index 10 out of bounds` +
 `>>>` [blue]`#list` +
-[green]`3`
+[green]`3` +
+`>>>` [blue]`index=2; ["a", "b", "c", "d"].index` +
+[green]`c`



-== Dictionaries
-The _dictionary_ data-type is set of pairs _key/value_. It is also known as _map_ or _associative array_. Dictionary literals are sequences of pairs separated by comma `,`; sequences are enclosed between brace brackets.
+=== Dictionaries
+The _dictionary_, or _dict_, data-type is set of pairs _key/value_. It is also known as _map_ or _associative array_.

-.Dictionary examples
-[source,go]
----
-{1:"one", 2:"two"}
-{"one":1, "two": 2}
-{"sum":1+2+3, "prod":1*2*3}
----
+Dictionary literals are sequences of pairs separated by comma [blue]`,` enclosed between brace brackets.

-WARNING: Support for dictionaries is still ongoing.
-
-== Variables
-A variable is an identifier with an assigned value. Variables are stored in the object that implements the Go _ExprContext_ interface, e.g. _SimpleVarStore_ or _SimpleFuncStore_.
+.Dict literal syntax
+====
+*_dict_* = _empty-dict_ | _non-empty-dict_ +
+_empty-dict_ = "**{}**" +
+_non-empty-dict_ = "**{**" _key-scalar_ "**:**" _any-value_ {"**,**" _key-scalar_ "**:**" _any-value} "**}**" +
+====

 .Examples
-[source,go]
----
-a=1
-x = 5.2 * (9-3)
-x = 1; y = 2*x
----
+`>>>` [blue]`{1:"one", 2:"two"}` +
+[green]`{1: "one", 2: "two"}` +
+`>>>` [blue]`{"one":1, "two": 2}` +
+[green]`{"one": 1, "two": 2}` +
+`>>>` [blue]`{"sum":1+2+3, "prod":1*2*3}` +
+[green]`{"sum": 6, "prod": 6}`
+
+
+.Dict operators
+[cols="^2,^2,4,5"]
+|===
+| Symbol    | Operation     | Description               | Examples
+
+| [blue]`+` | _Join_ | Joins two dicts | [blue]`{1:"one"}+{6:"six"}` -> _{1: "one", 6: "six"}_
+| [blue]`.` | _Dict item value_ | Item value of given key | [blue]`{"one":1, "two":2}."two"` -> _2_
+| [blue]`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_
+|===
+
+
+== Variables
+_Expr_, like most programming languages, supports variables. A variable is an identifier with an assigned value. Variables are stored in _contexts_.
+
+.Variable literal syntax
+====
+*_variable_* = _identifier_ "*=*" _any-value_ +
+_identifier_ = _alpha_ {(_alpha_)|_dec-digit_|"*_*"} +
+__alpha__ = "*a*"|"*b*"|..."*z*"|"*A*"|"*B*"|..."*Z*"
+====
+
+NOTE: The assign operator [blue]`=` returns the value assigned to the variable.
+
+.Examples
+`>>>` [blue]`a=1` +
+[green]`1` +
+`>>>` [blue]`a_b=1+2` +
+[green]`1+2` +
+`>>>` [blue]`a_b` +
+[green]`3` +
+`>>>` [blue]`x = 5.2 * (9-3)`  [gray]_// The assigned value has the approximation error typical of the float data-type_ +
+[green]`31.200000000000003` +
+`>>>` [blue]`x = 1; y = 2*x` +
+[green]`2` +
+`>>>` [blue]`_a=2` +
+[red]`Parse Error: [1:2] unexpected token "_"` +
+`>>>` [blue]`1=2` +
+[red]`Parse Error: assign operator ("=") must be preceded by a variable`
+

 == Other operations

 === [blue]`;` operator
-The semicolon operator [blue]`;` is an infixed pseudo-operator. It evaluates the left expression first and then the right expression. The latter is the final result.
+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.
+
+An expression that contains [blue]`;` is called a _multi-expression_ and each component expressione is called a _sub-expression_.

 IMPORTANT: Technically [blue]`;` is not treated as a real operator. It acts as a separator in lists of expressions.

 TIP: [blue]`;` can be used to set some variables before the final calculation.

 .Example
-[source,go]
----
-a=1; b=2; c=3; a+b+c    // returns 6
----
+`>>>` [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_.
+
+.Example
+`>>>` [blue]`2+3; b=last+10; last` +
+[green]`15`
+

 === [blue]`but` operator
-[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` returns 2, [blue]`x=2*3 but x-1` returns 5.
+[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.

-[blue]`but` is very similar to [blue]`;`. The only difference is that [blue]`;` can't be used inside parenthesis [blue]`(` and [blue]`)`.
+.Examples
+[blue]`5 but 2` +
+[green]`2` +
+[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]`)`.

 === Assignment operator [blue]`=`
-The assignment operator [blue]`=` is used to define variables in the evaluation context or to change their value (see _ExprContext_).
+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.

 .Example
-[source,go]
----
-a=15+1    // returns 16
----
+`>>>` [blue]`a=15+1`
+[green]`16`
+

 === Selector operator [blue]`? : ::`
 The _selector operator_ is very similar to the _switch/case/default_ statement available in many programming languages.

-.Syntax
-[source,bnf]
----
-<selector-operator> ::= <select-expression> "?" <selector-case> { ":" <selector-case> } ["::" <default-multi-expression>]
-<selector-case> ::= [<match-list>] <case-value>
-<match-list> ::= "["<item>{","<items>}"]"
-<item> ::= <expression
-<case-multi-expression> ::= "{" <multi-expression> "}"
-<multi-expression> ::= <expression> {";" <expression>}
----
+.Selector literal Syntax
+_selector-operator_ = _select-expression_ "*?*" _selector-case_ { "*:*" _selector-case_ } ["*::*" _default-multi-expression_] +
+_selector-case_ = [_match-list_] _case-value_ +
+_match-list_ = "*[*" _item_ {"*,*" _items_} "*]*" +
+_item_ = _expression_ +
+_case-multi-expression_ = "*{*" _multi-expression_ "*}*" +
+_multi-expression_ = _expression_ { "*;*" _expression_ } +
+_default-multi-expression_ = _multi-expression_

-In other words, the selector operator evaluates the expression (`<select-expression>`) on the left-hand side of the `?` symbol; it then compares the result obtained with the values listed in the `<match-list>`'s. 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.
+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.

-The match lists are optional. In that case, the position, from left to right, of the `<selector-case>` is used as match-list. Of course, that only works if the select-expression results in an integer.
+The match lists are optional. In that case, the position, from left to right, of the _selector-case_ is used as _match-list_. Of course, that only works if the _select-expression_ results in an integer.

-The `:` symbol (colon) is the separator of the selector-cases. Note that if the value of the select-expression does not match any match-list, an error will be issued. Therefore, it is strongly recommended to provide a default (multi-)expression introduced by the `::` symbol (double-colon). Also note that the default expression has no match-list.
+The [blue]`:` symbol (colon) is the separator of the selector-cases. Note that if the value of the _select-expression_ does not match any _match-list_, an error will be issued. Therefore, it is strongly recommended to provide a default (multi-)expression introduced by the [blue]`::` symbol (double-colon). Also note that the default expression has no _match-list_.

 .Examples
-[source,go]
----
-`>>>` [blue]`1 ? {"a"} : {"b"}`
-[green]`b`
-`>>>` [blue]`10 ? {"a"} : {"b"} :: {"c"}`
-[green]`c'
-[green]`>>>` [blue]`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}`
-[green]`b`
-`>>>` [blue]`10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}`
-[red]`Parse Error: [1:34] case list in default clause`
-[green]`>>>` [blue]`10 ? {"a"} :[10] {x="b" but x} :: {"c"}`
-[green]`b`
-`>>>` [blue]`10 ? {"a"} :[10] {x="b"; x} :: {"c"}`
-[green]`b`
-`>>>` [blue]`10 ? {"a"} : {"b"}`
+`>>>` [blue]`1 ? {"a"} : {"b"}` +
+[green]`b` +
+`>>>` [blue]`10 ? {"a"} : {"b"} :: {"c"}` +
+[green]`c' +
+[green]`>>>` [blue]`10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}` +
+[green]`b` +
+`>>>` [blue]`10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}` +
+[red]`Parse Error: [1:34] case list in default clause` +
+[green]`>>>` [blue]`10 ? {"a"} :[10] {x="b" but x} :: {"c"}` +
+[green]`b` +
+`>>>` [blue]`10 ? {"a"} :[10] {x="b"; x} :: {"c"}` +
+[green]`b` +
+`>>>` [blue]`10 ? {"a"} : {"b"}` +
 [red]`Eval Error: [1:3] no case catches the value (10) of the selection expression`

----
+
+=== Variable default value [blue]`??` and [blue]`?=`
+The left operand of these two operators must be a variable. The right operator can be any expression. They return the value of the variable if this is define; otherwise they return the value of the right expression.
+
+IMPORTANT: If the left variable is defined, the right expression is not evuated at all.
+
+The [blue]`??` do not change the status of the left variable.
+
+The [blue]`?=` assigns the calculated value of the right expression to the left variable.
+
+.Examples
+`>>>` [blue]`var ?? (1+2)`'
+[green]`3` +
+`>>>` [blue]`var` +
+[red]`Eval Error: undefined variable or function "var"` +
+`>>>` [blue]`var ?= (1+2)` +
+[green]`3` +
+`>>>` [blue]`var` +
+[green]`3`
+
+NOTE: These operators have a high priority, in particular higher than the operator [blue]`=`.

 == Priorities of operators
 The table below shows all supported operators by decreasing priorities.

 .Operators priorities
-[cols="^2,^2,^2,^5,^5"]
+[cols="^2,^2,^2,^5,^6"]
 |===
 | Priority | Operators     | Position | Operation | Operands and results

-.1+|*ITEM*| [blue]`.` | _Infix_ | _Item_| _collection_ `"."` _key_ -> _any_
+.2+|*ITEM*| [blue]`.` | _Infix_ | _List item_| _list_ `"."` _integer_ -> _any_
+| [blue]`.` | _Infix_ | _Dict item_ | _dict_ `""` _any_ -> _any_
 .2+|*INC*| [blue]`++` | _Postfix_ | _Post increment_| _integer-variable_ `"++"` -> _integer_
 | [blue]`++` | _Postfix_ | _Next item_ | _iterator_ `"++"` -> _any_
 .1+|*FACT*| [blue]`!` | _Postfix_ | _Factorial_| _integer_ `"!"` -> _integer_
@@ -503,24 +587,29 @@ The table below shows all supported operators by decreasing priorities.
 | [blue]`/` | _Infix_ | _Division_ | _number_ `"/"` _number_ -> _number_
 | [blue]`./` | _Infix_ | _Float-division_ | __number__ `"./"` _number_ -> _float_
 | [blue]`%` | _Infix_ | _Integer-remainder_ | _integer_ `"%"` _integer_ -> _integer_
-.5+|*SUM*| [blue]`+` | _Infix_ | _Sum_ | _number_ `"+"` _number_ -> _number_
+.6+|*SUM*| [blue]`+` | _Infix_ | _Sum_ | _number_ `"+"` _number_ -> _number_
 | [blue]`+` | _Infix_ |  _String-concat_ | (_string_\|_number_) `"+"` (_string_\|_number_) -> _string_
 | [blue]`+` | _Infix_ |  _List-join_ | _list_ `"+"` _list_ -> _list_
+| [blue]`+` | _Infix_ |  _Dict-join_ | _dict_ `"+"` _dict_ -> _dict_
 | [blue]`-` | _Infix_ | _Subtraction_ | _number_ `"-"` _number_ -> _number_
 | [blue]`-` | _Infix_ | _List-difference_ | _list_ `"-"` _list_ -> _list_
-.6+|*RELATION*| [blue]`<` | _Infix_ | _less_ | _comparable_ `"<"` _comparable_ -> _boolean_
+.8+|*RELATION*| [blue]`<` | _Infix_ | _less_ | _comparable_ `"<"` _comparable_ -> _boolean_
 | [blue]`\<=` | _Infix_ |  _less-equal_ | _comparable_ `"\<="` _comparable_ -> _boolean_
 | [blue]`>` | _Infix_ |  _greater_ | _comparable_ `">"` _comparable_ -> _boolean_
 | [blue]`>=` | _Infix_ |  _greater-equal_ | _comparable_ `">="` _comparable_ -> _boolean_
 | [blue]`==` | _Infix_ |  _equal_ | _comparable_ `"=="` _comparable_ -> _boolean_
 | [blue]`!=` | _Infix_ |  _not-equal_ | _comparable_ `"!="` _comparable_ -> _boolean_
+| [blue]`in` | _Infix_ |  _member-of-list_ | _any_ `"in"` _list_ -> _boolean_
+| [blue]`in` | _Infix_ |  _key-of-dict_ | _any_ `"in"` _dict_ -> _boolean_
 .1+|*NOT*| [blue]`not` | _Prefix_ | _not_ | `"not"` _boolean_ -> _boolean_
 .2+|*AND*| [blue]`and` | _Infix_ | _and_ | _boolean_ `"and"` _boolean_ -> _boolean_
 | [blue]`&&` | _Infix_ | _and_ | _boolean_ `"&&"` _boolean_ -> _boolean_
 .2+|*OR*| [blue]`or` | _Infix_ | _or_ | _boolean_ `"or"` _boolean_ -> _boolean_
 | [blue]`\|\|` | _Infix_ | _or_ | _boolean_ `"\|\|"` _boolean_ -> _boolean_
-.1+|*ASSIGN*| [blue]`=` | _Infix_ | _assignment_ | _identifier_ "=" _any_ -> _any_
-.1+|*BUT*| [blue]`but` | _Infix_ | _but_ | _any_ "but" _any_ -> _any_
+.3+|*ASSIGN*| [blue]`=` | _Infix_ | _assignment_ | _identifier_ "=" _any_ -> _any_
+| [blue]`>>` | _Infix_ | _front-insert_ | _any_ ">>" _list_ -> _list_
+| [blue]`<<` | _Infix_ | _back-insert_ | _list_ "<<" _any_ -> _list_
+ .1+|*BUT*| [blue]`but` | _Infix_ | _but_ | _any_ "but" _any_ -> _any_
 |===

 == Functions
@@ -549,31 +549,32 @@ pre.rouge .ss {
 </ul>
 </li>
 <li><a href="#_strings">2.2. Strings</a></li>
-<li><a href="#_boolean">2.3. Boolean</a></li>
+<li><a href="#_booleans">2.3. Booleans</a></li>
 <li><a href="#_lists">2.4. Lists</a></li>
+<li><a href="#_dictionaries">2.5. Dictionaries</a></li>
 </ul>
 </li>
-<li><a href="#_dictionaries">3. Dictionaries</a></li>
-<li><a href="#_variables">4. Variables</a></li>
-<li><a href="#_other_operations">5. Other operations</a>
+<li><a href="#_variables">3. Variables</a></li>
+<li><a href="#_other_operations">4. Other operations</a>
 <ul class="sectlevel2">
-<li><a href="#_operator">5.1. <code class="blue">;</code> operator</a></li>
-<li><a href="#_but_operator">5.2. <code class="blue">but</code> operator</a></li>
-<li><a href="#_assignment_operator">5.3. Assignment operator <code class="blue">=</code></a></li>
-<li><a href="#_selector_operator">5.4. Selector operator <code class="blue">? : ::</code></a></li>
+<li><a href="#_operator">4.1. <code class="blue">;</code> operator</a></li>
+<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>
 </ul>
 </li>
-<li><a href="#_priorities_of_operators">6. Priorities of operators</a></li>
-<li><a href="#_functions">7. Functions</a>
+<li><a href="#_priorities_of_operators">5. Priorities of operators</a></li>
+<li><a href="#_functions">6. Functions</a>
 <ul class="sectlevel2">
-<li><a href="#_function_calls">7.1. Function calls</a></li>
-<li><a href="#_function_definitions">7.2. Function definitions</a></li>
+<li><a href="#_function_calls">6.1. Function calls</a></li>
+<li><a href="#_function_definitions">6.2. Function definitions</a></li>
 </ul>
 </li>
-<li><a href="#_builtins">8. Builtins</a>
+<li><a href="#_builtins">7. Builtins</a>
 <ul class="sectlevel2">
-<li><a href="#_builtin_functions">8.1. Builtin functions</a></li>
-<li><a href="#_import">8.2. <em class="blue">import()</em></a></li>
+<li><a href="#_builtin_functions">7.1. Builtin functions</a></li>
+<li><a href="#_import">7.2. <em class="blue">import()</em></a></li>
 </ul>
 </li>
 </ul>
@@ -584,7 +585,7 @@ pre.rouge .ss {
 <div class="sectionbody">
 <!-- toc disabled -->
 <div class="paragraph">
-<p><mark>TODO: Work in progress (last update on 2024/05/16, 7:08 a.m.)</mark></p>
+<p><mark>TODO: Work in progress (last update on 2024/05/17, 15:47 p.m.)</mark></p>
 </div>
 </div>
 </div>
@@ -622,7 +623,7 @@ pre.rouge .ss {
 <div class="listingblock">
 <div class="title">Run <code>dev-expr</code> in REPL mode and ask for help</div>
 <div class="content">
-<pre class="rouge highlight"><code data-lang="shell"><span class="c"># Assume the expr source directory. Type 'exit' or Ctrl+D to quit the program.</span>
+<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
 <span class="nb">expr</span> <span class="nt">--</span> Expressions calculator v1.7.1<span class="o">(</span>build 2<span class="o">)</span>,2024/05/16 <span class="o">(</span>celestino.amoroso@portale-stac.it<span class="o">)</span>
@@ -742,7 +743,7 @@ pre.rouge .ss {
 <p><span class="blue">Floats</span></p>
 </li>
 <li>
-<p><span class="blue">Factions</span> internally are stored as <em>pairs of</em> Golang <em>int64</em> values.</p>
+<p><span class="blue">Factions</span></p>
 </li>
 </ol>
 </div>
@@ -854,7 +855,7 @@ pre.rouge .ss {
 <code>&gt;&gt;&gt;</code> <code class="blue">4.5E-3</code><br>
 <code class="green">0.0045</code><br>
 <code>&gt;&gt;&gt;</code> <code class="blue">4.5E10</code><br>
-<code class="green">4.5e+10</code><br></p>
+<code class="green">4.5e+10</code></p>
 </div>
 <table class="tableblock frame-all grid-all stretch">
 <caption class="title">Table 2. Arithmetic operators</caption>
@@ -918,7 +919,7 @@ pre.rouge .ss {
 <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>
 <em>dec-seq</em> = <em>see-integer-literal-syntax</em><br>
-<em>digit-seq</em> = <em>see-integer-literal-syntax</em><br></p>
+<em>digit-seq</em> = <em>see-integer-literal-syntax</em></p>
 </div>
 </div>
 </div>
@@ -947,12 +948,13 @@ pre.rouge .ss {
 <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>
 <code class="green">11|2</code><br>
 <code>&gt;&gt;&gt;</code> <code class="blue">4 - 1|2</code><br>
 <code class="green">7|2</code><br>
 <code>&gt;&gt;&gt;</code> <code class="blue">1.0 + 1|2</code><br>
-<code class="green">1.5</code><br></p>
+<code class="green">1.5</code></p>
 </div>
 </div>
 </div>
@@ -997,14 +999,14 @@ pre.rouge .ss {
 <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>concatenation</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Join two strings or two <em>stringable</em> values</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">"one" + "two"</code> <em>["onetwo"]</em><br>
-<code class="blue">"one" + 2</code> <em>["one2"]</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">"one" + "two"</code> &#8594; <em>"onetwo"</em><br>
+<code class="blue">"one" + 2</code> &#8594; <em>"one2"</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>repeat</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Make <em>n</em> copy of a string</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">"one" * 2</code> <em>["oneone"]</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">"one" * 2</code> &#8594; <em>"oneone"</em></p></td>
 </tr>
 </tbody>
 </table>
@@ -1021,20 +1023,20 @@ pre.rouge .ss {
 </div>
 <div class="paragraph">
 <div class="title">String examples</div>
-<p><code>&gt;&gt;&gt;</code> <code class="blue">s="abc"</code>  <em class="gray">assign the string to variable s</em><br>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">s="abc"</code>  <em class="gray">// assign the string to variable s</em><br>
 <code class="green">abc</code><br>
-<code>&gt;&gt;&gt;</code> <code class="blue">s.1</code>      <em class="gray">char at position 1 (starting from 0)</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">s.1</code>      <em class="gray">// char at position 1 (starting from 0)</em><br>
 <code class="green">b</code><br>
-<code>&gt;&gt;&gt;</code> <code class="blue">s.(-1)</code>   <em class="gray">char at position -1, the rightmost one</em><br>
+<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">c</code><br>
-<code>&gt;&gt;&gt;</code> <code class="blue">#s</code>       <em class="gray">number of chars</em><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">#s</code>       <em class="gray">// number of chars</em><br>
 <code class="gren">3</code><br>
-<code>&gt;&gt;&gt;</code> <code class="blue">#"abc"</code>   <em class="gray">number of chars</em><br>
-<code class="green">3</code><br></p>
+<code>&gt;&gt;&gt;</code> <code class="blue">#"abc"</code>   <em class="gray">// number of chars</em><br>
+<code class="green">3</code></p>
 </div>
 </div>
 <div class="sect2">
-<h3 id="_boolean"><a class="anchor" href="#_boolean"></a><a class="link" href="#_boolean">2.3. Boolean</a></h3>
+<h3 id="_booleans"><a class="anchor" href="#_booleans"></a><a class="link" href="#_booleans">2.3. Booleans</a></h3>
 <div class="paragraph">
 <p>Boolean data type has two values only: <em class="blue">true</em> and <em class="blue">false</em>. Relational and boolean expressions result in boolean values.</p>
 </div>
@@ -1171,18 +1173,31 @@ pre.rouge .ss {
 <div class="sect2">
 <h3 id="_lists"><a class="anchor" href="#_lists"></a><a class="link" href="#_lists">2.4. Lists</a></h3>
 <div class="paragraph">
-<p><em>Expr</em> supports list of mixed-type values, also specified by normal expressions.</p>
+<p><em>Expr</em> supports list of mixed-type values, also specified by normal expressions. Internally, <em>Expr</em>'s lists are Go arrays.</p>
 </div>
-<div class="listingblock">
-<div class="title">List examples</div>
+<div class="exampleblock">
+<div class="title">Example 5. List literal syntax</div>
 <div class="content">
-<pre class="rouge highlight"><code data-lang="go"><span class="p">[</span><span class="m">1</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="m">3</span><span class="p">]</span>                   <span class="c">// List of integers</span>
-<span class="p">[</span><span class="s">"one"</span><span class="p">,</span> <span class="s">"two"</span><span class="p">,</span> <span class="s">"three"</span><span class="p">]</span>     <span class="c">// List of strings</span>
-<span class="p">[</span><span class="s">"one"</span><span class="p">,</span> <span class="m">2</span><span class="p">,</span> <span class="no">false</span><span class="p">,</span> <span class="m">4.1</span><span class="p">]</span>      <span class="c">// List of mixed-types</span>
-<span class="p">[</span><span class="s">"one"</span><span class="o">+</span><span class="m">1</span><span class="p">,</span> <span class="m">2.0</span><span class="o">*</span><span class="p">(</span><span class="m">9</span><span class="o">-</span><span class="m">2</span><span class="p">)]</span>        <span class="c">// List of expressions</span>
-<span class="p">[</span> <span class="p">[</span><span class="m">1</span><span class="p">,</span><span class="s">"one"</span><span class="p">],</span> <span class="p">[</span><span class="m">2</span><span class="p">,</span><span class="s">"two"</span><span class="p">]]</span>     <span class="c">// List of lists</span></code></pre>
+<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>
 </div>
 </div>
+</div>
+<div class="paragraph">
+<div class="title">Examples</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">[1,2,3]</code>                     <em class="gray">// List of integers</em><br>
+<code class="green">[1, 2, 3]</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">["one", "two", "three"]</code>     <em class="gray">// List of strings</em><br>
+<code class="green">["one", "two", "three"]</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">["one", 2, false, 4.1]</code>      <em class="gray">// List of mixed-types</em><br>
+<code class="green">["one", 2, false, 4.1]</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">["one"+1, 2.0*(9-2)]</code>        <em class="gray">// List of expressions</em><br>
+<code class="green">["one1", 14]</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">[ [1,"one"], [2,"two"]]</code>     <em class="gray">// List of lists</em><br>
+<code class="green">[[1, "one"], [2, "two"]]</code></p>
+</div>
 <table class="tableblock frame-all grid-all stretch">
 <caption class="title">Table 6. List operators</caption>
 <colgroup>
@@ -1204,23 +1219,50 @@ pre.rouge .ss {
 <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>Join</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Joins two lists</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">[1,2] + [3]</code> <em>[ [1,2,3] ]</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">[1,2] + [3]</code> &#8594; <em>[1,2,3]</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>Difference</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Left list without elements in the right list</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">[1,2,3] - [2]</code> <em>[ [1,3] ]</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">[1,2,3] - [2]</code> &#8594; <em>[1,3]</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&gt;&gt;</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Front insertion</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Insert an item in front</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">0 &gt;&gt; [1,2]</code> &#8594; <em>[0,1,2]</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&lt;&lt;</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Back insertion</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Insert an item at end</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">[1,2] &lt;&lt; 3</code> &#8594; <em>[1,2,3]</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>List item</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Item at given position</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">[1,2.3].1</code> &#8594; <em>2</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">in</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Item in list</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">True if item is in list</p></td>
+<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>
 </tbody>
 </table>
 <div class="paragraph">
 <p>The items of array can be accessed using the dot <code>.</code> operator.</p>
 </div>
-<div class="listingblock">
-<div class="title">Item access syntax</div>
+<div class="exampleblock">
+<div class="title">Example 6. Item access syntax</div>
 <div class="content">
-<pre class="rouge highlight"><code data-lang="bnf">&lt;item&gt; ::= &lt;list-expr&gt;"."&lt;index-expr&gt;</code></pre>
+<div class="paragraph">
+<p><em>item</em> = <em>list-expr</em> "<strong>.</strong>" <em>integer-expr</em></p>
+</div>
 </div>
 </div>
 <div class="paragraph">
@@ -1238,62 +1280,136 @@ pre.rouge .ss {
 <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><br>
 <code>&gt;&gt;&gt;</code> <code class="blue">#list</code><br>
-<code class="green">3</code></p>
+<code class="green">3</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">index=2; ["a", "b", "c", "d"].index</code><br>
+<code class="green">c</code></p>
 </div>
 </div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="_dictionaries"><a class="anchor" href="#_dictionaries"></a><a class="link" href="#_dictionaries">3. Dictionaries</a></h2>
-<div class="sectionbody">
+<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> data-type is set of pairs <em>key/value</em>. It is also known as <em>map</em> or <em>associative array</em>. Dictionary literals are sequences of pairs separated by comma <code>,</code>; sequences are enclosed between brace brackets.</p>
+<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>
 </div>
-<div class="listingblock">
-<div class="title">Dictionary examples</div>
+<div class="paragraph">
+<p>Dictionary literals are sequences of pairs separated by comma <code class="blue">,</code> enclosed between brace brackets.</p>
+</div>
+<div class="exampleblock">
+<div class="title">Example 7. Dict literal syntax</div>
 <div class="content">
-<pre class="rouge highlight"><code data-lang="go"><span class="p">{</span><span class="m">1</span><span class="o">:</span><span class="s">"one"</span><span class="p">,</span> <span class="m">2</span><span class="o">:</span><span class="s">"two"</span><span class="p">}</span>
-<span class="p">{</span><span class="s">"one"</span><span class="o">:</span><span class="m">1</span><span class="p">,</span> <span class="s">"two"</span><span class="o">:</span> <span class="m">2</span><span class="p">}</span>
-<span class="p">{</span><span class="s">"sum"</span><span class="o">:</span><span class="m">1</span><span class="o">+</span><span class="m">2</span><span class="o">+</span><span class="m">3</span><span class="p">,</span> <span class="s">"prod"</span><span class="o">:</span><span class="m">1</span><span class="o">*</span><span class="m">2</span><span class="o">*</span><span class="m">3</span><span class="p">}</span></code></pre>
+<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>
 </div>
 </div>
-<div class="admonitionblock warning">
-<table>
+</div>
+<div class="paragraph">
+<div class="title">Examples</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">{1:"one", 2:"two"}</code><br>
+<code class="green">{1: "one", 2: "two"}</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">{"one":1, "two": 2}</code><br>
+<code class="green">{"one": 1, "two": 2}</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">{"sum":1+2+3, "prod":1*2*3}</code><br>
+<code class="green">{"sum": 6, "prod": 6}</code></p>
+</div>
+<table class="tableblock frame-all grid-all stretch">
+<caption class="title">Table 7. Dict operators</caption>
+<colgroup>
+<col style="width: 15.3846%;">
+<col style="width: 15.3846%;">
+<col style="width: 30.7692%;">
+<col style="width: 38.4616%;">
+</colgroup>
+<thead>
 <tr>
-<td class="icon">
-<i class="fa icon-warning" title="Warning"></i>
-</td>
-<td class="content">
-Support for dictionaries is still ongoing.
-</td>
+<th class="tableblock halign-center valign-top">Symbol</th>
+<th class="tableblock halign-center valign-top">Operation</th>
+<th class="tableblock halign-left valign-top">Description</th>
+<th class="tableblock halign-left valign-top">Examples</th>
 </tr>
+</thead>
+<tbody>
+<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>Join</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Joins two dicts</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">{1:"one"}+{6:"six"}</code> &#8594; <em>{1: "one", 6: "six"}</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>Dict item value</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Item value of given key</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">{"one":1, "two":2}."two"</code> &#8594; <em>2</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">in</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Key in dict</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">True if key is in dict</p></td>
+<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>
+</tbody>
 </table>
 </div>
 </div>
 </div>
 <div class="sect1">
-<h2 id="_variables"><a class="anchor" href="#_variables"></a><a class="link" href="#_variables">4. Variables</a></h2>
+<h2 id="_variables"><a class="anchor" href="#_variables"></a><a class="link" href="#_variables">3. Variables</a></h2>
 <div class="sectionbody">
 <div class="paragraph">
-<p>A variable is an identifier with an assigned value. Variables are stored in the object that implements the Go <em>ExprContext</em> interface, e.g. <em>SimpleVarStore</em> or <em>SimpleFuncStore</em>.</p>
+<p><em>Expr</em>, like most programming languages, supports variables. A variable is an identifier with an assigned value. Variables are stored in <em>contexts</em>.</p>
 </div>
-<div class="listingblock">
-<div class="title">Examples</div>
+<div class="exampleblock">
+<div class="title">Example 8. Variable literal syntax</div>
 <div class="content">
-<pre class="rouge highlight"><code data-lang="go"><span class="n">a</span><span class="o">=</span><span class="m">1</span>
-<span class="n">x</span> <span class="o">=</span> <span class="m">5.2</span> <span class="o">*</span> <span class="p">(</span><span class="m">9</span><span class="o">-</span><span class="m">3</span><span class="p">)</span>
-<span class="n">x</span> <span class="o">=</span> <span class="m">1</span><span class="p">;</span> <span class="n">y</span> <span class="o">=</span> <span class="m">2</span><span class="o">*</span><span class="n">x</span></code></pre>
+<div class="paragraph">
+<p><strong><em>variable</em></strong> = <em>identifier</em> "<strong>=</strong>" <em>any-value</em><br>
+<em>identifier</em> = <em>alpha</em> {(<em>alpha</em>)|<em>dec-digit</em>|"<strong>_</strong>"}<br>
+<em>alpha</em> = "<strong>a</strong>"|"<strong>b</strong>"|&#8230;&#8203;"<strong>z</strong>"|"<strong>A</strong>"|"<strong>B</strong>"|&#8230;&#8203;"<strong>Z</strong>"</p>
 </div>
 </div>
 </div>
+<div class="admonitionblock note">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-note" title="Note"></i>
+</td>
+<td class="content">
+The assign operator <code class="blue">=</code> returns the value assigned to the variable.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<div class="title">Examples</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">a=1</code><br>
+<code class="green">1</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">a_b=1+2</code><br>
+<code class="green">1+2</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">a_b</code><br>
+<code class="green">3</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">x = 5.2 * (9-3)</code>  <em class="gray">// The assigned value has the approximation error typical of the float data-type</em><br>
+<code class="green">31.200000000000003</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">x = 1; y = 2*x</code><br>
+<code class="green">2</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue"><em>a=2</code><br>
+<code class="red">Parse Error: [1:2] unexpected token "</em>"</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">1=2</code><br>
+<code class="red">Parse Error: assign operator ("=") must be preceded by a variable</code></p>
+</div>
+</div>
 </div>
 <div class="sect1">
-<h2 id="_other_operations"><a class="anchor" href="#_other_operations"></a><a class="link" href="#_other_operations">5. Other operations</a></h2>
+<h2 id="_other_operations"><a class="anchor" href="#_other_operations"></a><a class="link" href="#_other_operations">4. Other operations</a></h2>
 <div class="sectionbody">
 <div class="sect2">
-<h3 id="_operator"><a class="anchor" href="#_operator"></a><a class="link" href="#_operator">5.1. <code class="blue">;</code> operator</a></h3>
+<h3 id="_operator"><a class="anchor" href="#_operator"></a><a class="link" href="#_operator">4.1. <code class="blue">;</code> operator</a></h3>
 <div class="paragraph">
-<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 latter is the final result.</p>
+<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="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>
 </div>
 <div class="admonitionblock important">
 <table>
@@ -1319,97 +1435,155 @@ Technically <code class="blue">;</code> is not treated as a real operator. It ac
 </tr>
 </table>
 </div>
-<div class="listingblock">
+<div class="paragraph">
 <div class="title">Example</div>
-<div class="content">
-<pre class="rouge highlight"><code data-lang="go"><span class="n">a</span><span class="o">=</span><span class="m">1</span><span class="p">;</span> <span class="n">b</span><span class="o">=</span><span class="m">2</span><span class="p">;</span> <span class="n">c</span><span class="o">=</span><span class="m">3</span><span class="p">;</span> <span class="n">a</span><span class="o">+</span><span class="n">b</span><span class="o">+</span><span class="n">c</span>    <span class="c">// returns 6</span></code></pre>
-</div>
-</div>
-</div>
-<div class="sect2">
-<h3 id="_but_operator"><a class="anchor" href="#_but_operator"></a><a class="link" href="#_but_operator">5.2. <code class="blue">but</code> operator</a></h3>
-<div class="paragraph">
-<p><code class="blue">but</code> 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: <code class="blue">5 but 2</code> returns 2, <code class="blue">x=2*3 but x-1</code> returns 5.</p>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">a=1; b=2; c=3; a+b+c</code><br>
+<code class="green">6</code></p>
 </div>
 <div class="paragraph">
-<p><code class="blue">but</code> is very similar to <code class="blue">;</code>. The only difference is that <code class="blue">;</code> can&#8217;t be used inside parenthesis <code class="blue">(</code> and <code class="blue">)</code>.</p>
+<p>The value of each sub-expression is stored in the automatica variable <em>last</em>.</p>
 </div>
-</div>
-<div class="sect2">
-<h3 id="_assignment_operator"><a class="anchor" href="#_assignment_operator"></a><a class="link" href="#_assignment_operator">5.3. Assignment operator <code class="blue">=</code></a></h3>
 <div class="paragraph">
-<p>The assignment operator <code class="blue">=</code> is used to define variables in the evaluation context or to change their value (see <em>ExprContext</em>).
-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>
-</div>
-<div class="listingblock">
 <div class="title">Example</div>
-<div class="content">
-<pre class="rouge highlight"><code data-lang="go"><span class="n">a</span><span class="o">=</span><span class="m">15</span><span class="o">+</span><span class="m">1</span>    <span class="c">// returns 16</span></code></pre>
-</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">2+3; b=last+10; last</code><br>
+<code class="green">15</code></p>
 </div>
 </div>
 <div class="sect2">
-<h3 id="_selector_operator"><a class="anchor" href="#_selector_operator"></a><a class="link" href="#_selector_operator">5.4. Selector operator <code class="blue">? : ::</code></a></h3>
+<h3 id="_but_operator"><a class="anchor" href="#_but_operator"></a><a class="link" href="#_but_operator">4.2. <code class="blue">but</code> operator</a></h3>
+<div class="paragraph">
+<p><code class="blue">but</code> 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.</p>
+</div>
+<div class="paragraph">
+<div class="title">Examples</div>
+<p><code class="blue">5 but 2</code><br>
+<code class="green">2</code><br>
+<code class="blue">x=2*3 but x-1</code><br>
+<code class="green">5</code>.</p>
+</div>
+<div class="paragraph">
+<p><code class="blue">but</code> behavior is very similar to <code class="blue">;</code>. The only difference is that <code class="blue">;</code> is not a true operator and can&#8217;t be used inside parenthesis <code class="blue">(</code> and <code class="blue">)</code>.</p>
+</div>
+</div>
+<div class="sect2">
+<h3 id="_assignment_operator"><a class="anchor" href="#_assignment_operator"></a><a class="link" href="#_assignment_operator">4.3. Assignment operator <code class="blue">=</code></a></h3>
+<div class="paragraph">
+<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>
+</div>
+<div class="paragraph">
+<div class="title">Example</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">a=15+1</code>
+<code class="green">16</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="listingblock">
-<div class="title">Syntax</div>
-<div class="content">
-<pre class="rouge highlight"><code data-lang="bnf">&lt;selector-operator&gt; ::= &lt;select-expression&gt; "?" &lt;selector-case&gt; { ":" &lt;selector-case&gt; } ["::" &lt;default-multi-expression&gt;]
-&lt;selector-case&gt; ::= [&lt;match-list&gt;] &lt;case-value&gt;
-&lt;match-list&gt; ::= "["&lt;item&gt;{","&lt;items&gt;}"]"
-&lt;item&gt; ::= &lt;expression
-&lt;case-multi-expression&gt; ::= "{" &lt;multi-expression&gt; "}"
-&lt;multi-expression&gt; ::= &lt;expression&gt; {";" &lt;expression&gt;}</code></pre>
-</div>
+<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>
+<em>item</em> = <em>expression</em><br>
+<em>case-multi-expression</em> = "<strong>{</strong>" <em>multi-expression</em> "<strong>}</strong>"<br>
+<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 class="paragraph">
-<p>In other words, the selector operator evaluates the expression (<code>&lt;select-expression&gt;</code>) on the left-hand side of the <code>?</code> symbol; it then compares the result obtained with the values listed in the <code>&lt;match-list&gt;&#8217;s. If the comparision finds a match with a value in a match-list, the associated  `&lt;case-multi-expression&gt;</code> is evaluted, and its result will be the final result of the selection operation.</p>
+<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>
 <div class="paragraph">
-<p>The match lists are optional. In that case, the position, from left to right, of the <code>&lt;selector-case&gt;</code> is used as match-list. Of course, that only works if the select-expression results in an integer.</p>
+<p>The match lists are optional. In that case, the position, from left to right, of the <em>selector-case</em> is used as <em>match-list</em>. Of course, that only works if the <em>select-expression</em> results in an integer.</p>
 </div>
 <div class="paragraph">
-<p>The <code>:</code> symbol (colon) is the separator of the selector-cases. Note that if the value of the select-expression does not match any match-list, an error will be issued. Therefore, it is strongly recommended to provide a default (multi-)expression introduced by the <code>::</code> symbol (double-colon). Also note that the default expression has no match-list.</p>
+<p>The <code class="blue">:</code> symbol (colon) is the separator of the selector-cases. Note that if the value of the <em>select-expression</em> does not match any <em>match-list</em>, an error will be issued. Therefore, it is strongly recommended to provide a default (multi-)expression introduced by the <code class="blue">::</code> symbol (double-colon). Also note that the default expression has no <em>match-list</em>.</p>
 </div>
-<div class="listingblock">
+<div class="paragraph">
 <div class="title">Examples</div>
-<div class="content">
-<pre class="rouge highlight"><code data-lang="go"><span class="s">`&gt;&gt;&gt;`</span> <span class="p">[</span><span class="n">blue</span><span class="p">]</span><span class="s">`1 ? {"a"} : {"b"}`</span>
-<span class="p">[</span><span class="n">green</span><span class="p">]</span><span class="s">`b`</span>
-<span class="s">`&gt;&gt;&gt;`</span> <span class="p">[</span><span class="n">blue</span><span class="p">]</span><span class="s">`10 ? {"a"} : {"b"} :: {"c"}`</span>
-<span class="p">[</span><span class="n">green</span><span class="p">]</span><span class="s">`c'
-[green]`</span><span class="o">&gt;&gt;&gt;</span><span class="s">` [blue]`</span><span class="m">10</span> <span class="err">?</span> <span class="p">{</span><span class="s">"a"</span><span class="p">}</span> <span class="o">:</span><span class="p">[</span><span class="no">true</span><span class="p">,</span> <span class="m">2</span><span class="o">+</span><span class="m">8</span><span class="p">]</span> <span class="p">{</span><span class="s">"b"</span><span class="p">}</span> <span class="o">::</span> <span class="p">{</span><span class="s">"c"</span><span class="p">}</span><span class="s">`
-[green]`</span><span class="n">b</span><span class="s">`
-`</span><span class="o">&gt;&gt;&gt;</span><span class="s">` [blue]`</span><span class="m">10</span> <span class="err">?</span> <span class="p">{</span><span class="s">"a"</span><span class="p">}</span> <span class="o">:</span><span class="p">[</span><span class="no">true</span><span class="p">,</span> <span class="m">2</span><span class="o">+</span><span class="m">8</span><span class="p">]</span> <span class="p">{</span><span class="s">"b"</span><span class="p">}</span> <span class="o">::</span><span class="p">[</span><span class="m">10</span><span class="p">]</span> <span class="p">{</span><span class="s">"c"</span><span class="p">}</span><span class="s">`
-[red]`</span><span class="n">Parse</span> <span class="n">Error</span><span class="o">:</span> <span class="p">[</span><span class="m">1</span><span class="o">:</span><span class="m">34</span><span class="p">]</span> <span class="k">case</span> <span class="n">list</span> <span class="n">in</span> <span class="k">default</span> <span class="n">clause</span><span class="s">`
-[green]`</span><span class="o">&gt;&gt;&gt;</span><span class="s">` [blue]`</span><span class="m">10</span> <span class="err">?</span> <span class="p">{</span><span class="s">"a"</span><span class="p">}</span> <span class="o">:</span><span class="p">[</span><span class="m">10</span><span class="p">]</span> <span class="p">{</span><span class="n">x</span><span class="o">=</span><span class="s">"b"</span> <span class="n">but</span> <span class="n">x</span><span class="p">}</span> <span class="o">::</span> <span class="p">{</span><span class="s">"c"</span><span class="p">}</span><span class="s">`
-[green]`</span><span class="n">b</span><span class="s">`
-`</span><span class="o">&gt;&gt;&gt;</span><span class="s">` [blue]`</span><span class="m">10</span> <span class="err">?</span> <span class="p">{</span><span class="s">"a"</span><span class="p">}</span> <span class="o">:</span><span class="p">[</span><span class="m">10</span><span class="p">]</span> <span class="p">{</span><span class="n">x</span><span class="o">=</span><span class="s">"b"</span><span class="p">;</span> <span class="n">x</span><span class="p">}</span> <span class="o">::</span> <span class="p">{</span><span class="s">"c"</span><span class="p">}</span><span class="s">`
-[green]`</span><span class="n">b</span><span class="s">`
-`</span><span class="o">&gt;&gt;&gt;</span><span class="s">` [blue]`</span><span class="m">10</span> <span class="err">?</span> <span class="p">{</span><span class="s">"a"</span><span class="p">}</span> <span class="o">:</span> <span class="p">{</span><span class="s">"b"</span><span class="p">}</span><span class="s">`
-[red]`</span><span class="n">Eval</span> <span class="n">Error</span><span class="o">:</span> <span class="p">[</span><span class="m">1</span><span class="o">:</span><span class="m">3</span><span class="p">]</span> <span class="n">no</span> <span class="k">case</span> <span class="n">catches</span> <span class="n">the</span> <span class="n">value</span> <span class="p">(</span><span class="m">10</span><span class="p">)</span> <span class="n">of</span> <span class="n">the</span> <span class="n">selection</span> <span class="n">expression</span><span class="s">`
-</span></code></pre>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">1 ? {"a"} : {"b"}</code><br>
+<code class="green">b</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">10 ? {"a"} : {"b"} :: {"c"}</code><br>
+<code class="green">c'<br>
+[green]</code>&gt;&gt;&gt;` <code class="blue">10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}</code><br>
+<code class="green">b</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}</code><br>
+<code class="red">Parse Error: [1:34] case list in default clause</code><br>
+<code class="green">&gt;&gt;&gt;</code> <code class="blue">10 ? {"a"} :[10] {x="b" but x} :: {"c"}</code><br>
+<code class="green">b</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">10 ? {"a"} :[10] {x="b"; x} :: {"c"}</code><br>
+<code class="green">b</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">10 ? {"a"} : {"b"}</code><br>
+<code class="red">Eval Error: [1:3] no case catches the value (10) of the selection expression</code></p>
 </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>
+<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 define; otherwise they return the value of the right expression.</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 defined, the right expression is not evuated at all.
+</td>
+</tr>
+</table>
+</div>
+<div class="paragraph">
+<p>The <code class="blue">??</code> do not change the status of the left variable.</p>
+</div>
+<div class="paragraph">
+<p>The <code class="blue">?=</code> assigns the calculated value of the right expression to the left variable.</p>
+</div>
+<div class="paragraph">
+<div class="title">Examples</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">var ?? (1+2)&#8217;
+[green]`3</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">var</code><br>
+<code class="red">Eval Error: undefined variable or function "var"</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">var ?= (1+2)</code><br>
+<code class="green">3</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">var</code><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">
+These operators have a high priority, in particular higher than the operator <code class="blue">=</code>.
+</td>
+</tr>
+</table>
+</div>
 </div>
 </div>
 </div>
 <div class="sect1">
-<h2 id="_priorities_of_operators"><a class="anchor" href="#_priorities_of_operators"></a><a class="link" href="#_priorities_of_operators">6. Priorities of operators</a></h2>
+<h2 id="_priorities_of_operators"><a class="anchor" href="#_priorities_of_operators"></a><a class="link" href="#_priorities_of_operators">5. Priorities of operators</a></h2>
 <div class="sectionbody">
 <div class="paragraph">
 <p>The table below shows all supported operators by decreasing priorities.</p>
 </div>
 <table class="tableblock frame-all grid-all stretch">
-<caption class="title">Table 7. Operators priorities</caption>
+<caption class="title">Table 8. Operators priorities</caption>
 <colgroup>
-<col style="width: 12.5%;">
-<col style="width: 12.5%;">
-<col style="width: 12.5%;">
-<col style="width: 31.25%;">
-<col style="width: 31.25%;">
+<col style="width: 11.7647%;">
+<col style="width: 11.7647%;">
+<col style="width: 11.7647%;">
+<col style="width: 29.4117%;">
+<col style="width: 35.2942%;">
 </colgroup>
 <thead>
 <tr>
@@ -1422,11 +1596,17 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 </thead>
 <tbody>
 <tr>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><strong>ITEM</strong></p></td>
+<td class="tableblock halign-center valign-top" rowspan="2"><p class="tableblock"><strong>ITEM</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>Item</em></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>collection</em> <code>"."</code> <em>key</em> &#8594; <em>any</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>List item</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>list</em> <code>"."</code> <em>integer</em> &#8594; <em>any</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>Dict item</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>dict</em> <code>""</code> <em>any</em> &#8594; <em>any</em></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top" rowspan="2"><p class="tableblock"><strong>INC</strong></p></td>
@@ -1499,7 +1679,7 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>integer</em> <code>"%"</code> <em>integer</em> &#8594; <em>integer</em></p></td>
 </tr>
 <tr>
-<td class="tableblock halign-center valign-top" rowspan="5"><p class="tableblock"><strong>SUM</strong></p></td>
+<td class="tableblock halign-center valign-top" rowspan="6"><p class="tableblock"><strong>SUM</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>Sum</em></p></td>
@@ -1518,6 +1698,12 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 <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"><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>Dict-join</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>dict</em> <code>"+"</code> <em>dict</em> &#8594; <em>dict</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>Subtraction</em></p></td>
@@ -1530,7 +1716,7 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 <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="6"><p class="tableblock"><strong>RELATION</strong></p></td>
+<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>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>less</em></p></td>
@@ -1567,6 +1753,18 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>comparable</em> <code>"!="</code> <em>comparable</em> &#8594; <em>boolean</em></p></td>
 </tr>
 <tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">in</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>member-of-list</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>any</em> <code>"in"</code> <em>list</em> &#8594; <em>boolean</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">in</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>key-of-dict</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>any</em> <code>"in"</code> <em>dict</em> &#8594; <em>boolean</em></p></td>
+</tr>
+<tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><strong>NOT</strong></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">not</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Prefix</em></p></td>
@@ -1600,13 +1798,25 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>boolean</em> <code>"||"</code> <em>boolean</em> &#8594; <em>boolean</em></p></td>
 </tr>
 <tr>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><strong>ASSIGN</strong></p></td>
+<td class="tableblock halign-center valign-top" rowspan="3"><p class="tableblock"><strong>ASSIGN</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>assignment</em></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>identifier</em> "=" <em>any</em> &#8594; <em>any</em></p></td>
 </tr>
 <tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&gt;&gt;</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>front-insert</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>any</em> "&gt;&gt;" <em>list</em> &#8594; <em>list</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&lt;&lt;</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>back-insert</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>list</em> "&lt;&lt;" <em>any</em> &#8594; <em>list</em></p></td>
+</tr>
+<tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><strong>BUT</strong></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">but</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
@@ -1618,7 +1828,7 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 </div>
 </div>
 <div class="sect1">
-<h2 id="_functions"><a class="anchor" href="#_functions"></a><a class="link" href="#_functions">7. Functions</a></h2>
+<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 in many programming languages.</p>
@@ -1627,13 +1837,13 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 <p>In <em>Expr</em> 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>
 <div class="sect2">
-<h3 id="_function_calls"><a class="anchor" href="#_function_calls"></a><a class="link" href="#_function_calls">7.1. Function calls</a></h3>
+<h3 id="_function_calls"><a class="anchor" href="#_function_calls"></a><a class="link" href="#_function_calls">6.1. Function calls</a></h3>
 <div class="paragraph">
 <p><mark>TODO: function calls operations</mark></p>
 </div>
 </div>
 <div class="sect2">
-<h3 id="_function_definitions"><a class="anchor" href="#_function_definitions"></a><a class="link" href="#_function_definitions">7.2. Function definitions</a></h3>
+<h3 id="_function_definitions"><a class="anchor" href="#_function_definitions"></a><a class="link" href="#_function_definitions">6.2. Function definitions</a></h3>
 <div class="paragraph">
 <p><mark>TODO: function definitions operations</mark></p>
 </div>
@@ -1641,17 +1851,17 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 </div>
 </div>
 <div class="sect1">
-<h2 id="_builtins"><a class="anchor" href="#_builtins"></a><a class="link" href="#_builtins">8. Builtins</a></h2>
+<h2 id="_builtins"><a class="anchor" href="#_builtins"></a><a class="link" href="#_builtins">7. Builtins</a></h2>
 <div class="sectionbody">
 <div class="paragraph">
 <p><mark>TODO: builtins</mark></p>
 </div>
 <div class="sect2">
-<h3 id="_builtin_functions"><a class="anchor" href="#_builtin_functions"></a><a class="link" href="#_builtin_functions">8.1. Builtin functions</a></h3>
+<h3 id="_builtin_functions"><a class="anchor" href="#_builtin_functions"></a><a class="link" href="#_builtin_functions">7.1. Builtin functions</a></h3>

 </div>
 <div class="sect2">
-<h3 id="_import"><a class="anchor" href="#_import"></a><a class="link" href="#_import">8.2. <em class="blue">import()</em></a></h3>
+<h3 id="_import"><a class="anchor" href="#_import"></a><a class="link" href="#_import">7.2. <em class="blue">import()</em></a></h3>
 <div class="paragraph">
 <p><em class="blue">import(<span class="grey">&lt;source-file&gt;</span>)</em> loads the multi-expression contained in the specified source and returns its value.</p>
 </div>
@@ -1661,7 +1871,7 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2024-05-16 07:10:03 +0200
+Last updated 2024-05-20 06:58:09 +0200
 </div>
 </div>
 </body>
@@ -22,7 +22,7 @@ func TestExpr(t *testing.T) {
 		/*   3 */ {`f=openFile("test-file.txt"); line=readFile(f); closeFile(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},
-		/*   10 */ {`
+		/*   6 */ {`
 		ds={
 			"init":func(end){@end=end; @current=0 but true},
 			"current":func(){current},
@@ -4,17 +4,62 @@
 // formatter.go
 package expr

+import "fmt"
+
 type FmtOpt uint16

 const (
 	TTY FmtOpt = 1 << iota
 	MultiLine
+	Truncate
 	Base2
 	Base8
 	Base10
 	Base16
 )

+const (
+	TruncateEllipsis = "(...)"
+	MinTruncateSize  = 10
+	TruncateSize     = MinTruncateSize + 15
+)
+
+func TruncateString(s string) (trunc string) {
+	finalPart := len(s) - (MinTruncateSize - len(TruncateEllipsis))
+	trunc = s[0:len(s)-MinTruncateSize] + TruncateEllipsis + s[finalPart:]
+	return
+}
+
 type Formatter interface {
 	ToString(options FmtOpt) string
 }
+
+func getFormatted(v any, opt FmtOpt) (text string) {
+	if v == nil {
+		text = "(nil)"
+	} else if s, ok := v.(string); ok {
+		text = s
+	} else if formatter, ok := v.(Formatter); ok {
+		text = formatter.ToString(opt)
+	} else {
+		text = fmt.Sprintf("%v", v)
+	}
+	return
+}
+
+type Typer interface {
+	TypeName() string
+}
+
+func getTypeName(v any) (name string) {
+	if typer, ok := v.(Typer); ok {
+		name = typer.TypeName()
+	} else if IsInteger(v) {
+		name = "integer"
+	} else if IsFloat(v) {
+		name = "float"
+	} else {
+		name = fmt.Sprintf("%T", v)
+	}
+	return
+}
@@ -40,6 +40,9 @@ func TestListParser(t *testing.T) {
 		/*  18 */ {`["a", "b", "c"]`, newListA("a", "b", "c"), nil},
 		/*  19 */ {`["a", "b", "c"]`, newList([]any{"a", "b", "c"}), nil},
 		/*  20 */ {`#["a", "b", "c"]`, int64(3), nil},
+		/*  21 */ {`"b" in ["a", "b", "c"]`, true, nil},
+		/*  22 */ {`a=[1,2]; (a)<<3`, []any{1, 2, 3}, nil},
+		/*  23 */ {`a=[1,2]; (a)<<3; 1`, []any{1, 2}, nil},

 		// /*  8 */ {`[int(x)|x=csv("test.csv",1,all(),1)]`, []any{int64(10), int64(40), int64(20)}, nil},
 		// /*  9 */ {`sum(@[int(x)|x=csv("test.csv",1,all(),1)])`, []any{int64(10), int64(40), int64(20)}, nil},
@@ -58,8 +61,8 @@ func TestListParser(t *testing.T) {
 		var gotErr error

 		ctx := NewSimpleFuncStore()
-		ctx.SetVar("var1", int64(123))
-		ctx.SetVar("var2", "abc")
+		// ctx.SetVar("var1", int64(123))
+		// ctx.SetVar("var2", "abc")
 		ImportMathFuncs(ctx)
 		parser := NewParser(ctx)

@@ -4,6 +4,125 @@
 // operand-dict.go
 package expr

+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type DictType map[any]any
+
+func newDict(dictAny map[any]*term) (dict *DictType) {
+	var d DictType
+	if dictAny != nil {
+		d = make(DictType, len(dictAny))
+		for i, item := range dictAny {
+			d[i] = item
+		}
+	} else {
+		d = make(DictType)
+	}
+	dict = &d
+	return
+}
+
+func (dict *DictType) toMultiLine(sb *strings.Builder, indent int) {
+	sb.WriteString(strings.Repeat("\t", indent))
+	sb.WriteString("{\n")
+
+	first := true
+	for name, value := range *dict {
+		if first {
+			first = false
+		} else {
+			sb.WriteByte(',')
+			sb.WriteByte('\n')
+		}
+
+		sb.WriteString(strings.Repeat("\t", indent+1))
+		if key, ok := name.(string); ok {
+			sb.WriteString(string('"') + key + string('"'))
+		} else {
+			sb.WriteString(fmt.Sprintf("%v", name))
+		}
+		sb.WriteString(": ")
+		if f, ok := value.(Formatter); ok {
+			sb.WriteString(f.ToString(MultiLine))
+		} else if _, ok = value.(Functor); ok {
+			sb.WriteString("func(){}")
+		} else {
+			sb.WriteString(fmt.Sprintf("%v", value))
+		}
+	}
+	sb.WriteString(strings.Repeat("\t", indent))
+	sb.WriteString("\n}")
+}
+
+func (dict *DictType) ToString(opt FmtOpt) string {
+	var sb strings.Builder
+	if opt&MultiLine != 0 {
+		dict.toMultiLine(&sb, 0)
+	} else {
+		sb.WriteByte('{')
+		first := true
+		for key, value := range *dict {
+			if first {
+				first = false
+			} else {
+				sb.WriteString(", ")
+			}
+			if s, ok := key.(string); ok {
+				sb.WriteString(string('"') + s + string('"'))
+			} else {
+				sb.WriteString(fmt.Sprintf("%v", key))
+			}
+			sb.WriteString(": ")
+			if formatter, ok := value.(Formatter); ok {
+				sb.WriteString(formatter.ToString(opt))
+			} else if t, ok := value.(*term); ok {
+				sb.WriteString(t.String())
+			} else {
+				sb.WriteString(fmt.Sprintf("%#v", value))
+			}
+		}
+		sb.WriteByte('}')
+	}
+	return sb.String()
+}
+
+func (dict *DictType) String() string {
+	return dict.ToString(0)
+}
+
+func (dict *DictType) TypeName() string {
+	return "dict"
+}
+
+func (dict *DictType) hasKey(target any) (ok bool) {
+	for key := range *dict {
+		if ok = reflect.DeepEqual(key, target); ok {
+			break
+		}
+	}
+	return
+}
+
+func (dict *DictType) clone() (c *DictType) {
+	c = newDict(nil)
+	for k, v := range *dict {
+		(*c)[k] = v
+	}
+	return
+}
+
+func (dict *DictType) merge(second *DictType) {
+	if second != nil {
+		for k, v := range *second {
+			(*dict)[k] = v
+		}
+	}
+}
+
 // -------- dict term
 func newDictTerm(args map[any]*term) *term {
 	return &term{
@@ -19,7 +138,7 @@ func newDictTerm(args map[any]*term) *term {
 // -------- dict func
 func evalDict(ctx ExprContext, self *term) (v any, err error) {
 	dict, _ := self.value().(map[any]*term)
-	items := make(map[any]any, len(dict))
+	items := make(DictType, len(dict))
 	for key, tree := range dict {
 		var param any
 		if param, err = tree.compute(ctx); err != nil {
@@ -28,7 +147,7 @@ func evalDict(ctx ExprContext, self *term) (v any, err error) {
 		items[key] = param
 	}
 	if err == nil {
-		v = items
+		v = &items
 	}
 	return
 }
@@ -7,7 +7,8 @@ package expr
 import "fmt"

 // -------- expr term
-func newExprTerm(tk *Token) *term {
+func newExprTerm(root *term) *term {
+	tk := NewValueToken(root.tk.row, root.tk.col, SymExpression, root.source(), root)
 	return &term{
 		tk:       *tk,
 		parent:   nil,
@@ -20,8 +21,8 @@ func newExprTerm(tk *Token) *term {

 // -------- eval expr
 func evalExpr(ctx ExprContext, self *term) (v any, err error) {
-	if expr, ok := self.value().(Expr); ok {
-		v, err = expr.eval(ctx, false)
+	if expr, ok := self.value().(*term); ok {
+		v, err = expr.compute(ctx)
 	} else {
 		err = fmt.Errorf("expression expected, got %T", self.value())
 	}
@@ -87,10 +87,10 @@ func (functor *funcDefFunctor) Invoke(ctx ExprContext, name string, args []any)
 			if functor, ok := arg.(Functor); ok {
 				ctx.RegisterFunc(p, functor, 0, -1)
 			} else {
-				ctx.setVar(p, arg)
+				ctx.UnsafeSetVar(p, arg)
 			}
 		} else {
-			ctx.setVar(p, nil)
+			ctx.UnsafeSetVar(p, nil)
 		}
 	}
 	result, err = functor.expr.eval(ctx, false)
@@ -66,12 +66,13 @@ func evalFirstChild(ctx ExprContext, self *term) (value any, err error) {
 }

 func getDataSourceDict(ctx ExprContext, self *term, firstChildValue any) (ds map[string]Functor, err error) {
-	if dictAny, ok := firstChildValue.(map[any]any); ok {
+	// if dictAny, ok := firstChildValue.(map[any]any); ok {
+	if dictAny, ok := firstChildValue.(*DictType); ok {
 		requiredFields := []string{currentName, nextName}
 		fieldsMask := 0b11
 		foundFields := 0
 		ds = make(map[string]Functor)
-		for keyAny, item := range dictAny {
+		for keyAny, item := range *dictAny {
 			if key, ok := keyAny.(string); ok {
 				if functor, ok := item.(*funcDefFunctor); ok {
 					ds[key] = functor
@@ -6,12 +6,28 @@ package expr

 import (
 	"fmt"
+	"reflect"
 	"strings"
 )

 type ListType []any

-func (ls *ListType) ToString(opt FmtOpt) string {
+func newListA(listAny ...any) (list *ListType) {
+	return newList(listAny)
+}
+
+func newList(listAny []any) (list *ListType) {
+	if listAny != nil {
+		ls := make(ListType, len(listAny))
+		for i, item := range listAny {
+			ls[i] = item
+		}
+		list = &ls
+	}
+	return
+}
+
+func (ls *ListType) ToString(opt FmtOpt) (s string) {
 	var sb strings.Builder
 	sb.WriteByte('[')
 	if len(*ls) > 0 {
@@ -39,29 +55,32 @@ func (ls *ListType) ToString(opt FmtOpt) string {
 		}
 	}
 	sb.WriteByte(']')
-	return sb.String()
+	s = sb.String()
+	if opt&Truncate != 0 && len(s) > TruncateSize {
+		s = TruncateString(s)
+	}
+	return
 }

 func (ls *ListType) String() string {
 	return ls.ToString(0)
 }

-func newListA(listAny ...any) (list *ListType) {
-	return newList(listAny)
+func (ls *ListType) TypeName() string {
+	return "list"
 }

-func newList(listAny []any) (list *ListType) {
-	if listAny != nil {
-		ls := make(ListType, len(listAny))
-		for i, item := range listAny {
-			ls[i] = item
+func (list *ListType) indexDeepCmp(target any) (index int) {
+	index = -1
+	for i, item := range *list {
+		if reflect.DeepEqual(item, target) {
+			index = i
+			break
 		}
-		list = &ls
 	}
 	return
 }

-
 // -------- list term
 func newListTermA(args ...*term) *term {
 	return newListTerm(args)
@@ -8,7 +8,7 @@ import "fmt"

 // -------- variable term
 func newVarTerm(tk *Token) *term {
-	return &term{
+	t := &term{
 		tk: *tk,
 		// class:    classVar,
 		// kind:     kindUnknown,
@@ -18,6 +18,8 @@ func newVarTerm(tk *Token) *term {
 		priority: priValue,
 		evalFunc: evalVar,
 	}
+	t.tk.Sym = SymVariable
+	return t
 }

 // -------- eval func
@@ -22,7 +22,7 @@ func evalAssign(ctx ExprContext, self *term) (v any, err error) {
 	}

 	leftTerm := self.children[0]
-	if leftTerm.tk.Sym != SymIdentifier {
+	if leftTerm.tk.Sym != SymVariable {
 		err = leftTerm.tk.Errorf("left operand of %q must be a variable", self.tk.source)
 		return
 	}
@@ -44,7 +44,7 @@ func evalAssign(ctx ExprContext, self *term) (v any, err error) {
 			}
 			ctx.RegisterFunc(leftTerm.source(), functor, minArgs, maxArgs)
 		} else {
-			ctx.setVar(leftTerm.source(), v)
+			ctx.UnsafeSetVar(leftTerm.source(), v)
 		}
 	}
 	return
@@ -8,9 +8,7 @@ package expr

 func newNullCoalesceTerm(tk *Token) (inst *term) {
 	return &term{
-		tk: *tk,
-		// class:    classOperator,
-		// kind:     kindUnknown,
+		tk:       *tk,
 		children: make([]*term, 0, 2),
 		position: posInfix,
 		priority: priCoalesce,
@@ -26,7 +24,7 @@ func evalNullCoalesce(ctx ExprContext, self *term) (v any, err error) {
 	}

 	leftTerm := self.children[0]
-	if leftTerm.tk.Sym != SymIdentifier {
+	if leftTerm.tk.Sym != SymVariable {
 		err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
 		return
 	}
@@ -34,11 +32,7 @@ func evalNullCoalesce(ctx ExprContext, self *term) (v any, err error) {
 	if leftValue, exists := ctx.GetVar(leftTerm.source()); exists {
 		v = leftValue
 	} else if rightValue, err = self.children[1].compute(ctx); err == nil {
-		// if _, ok := rightValue.(Functor); ok {
-		// 	err = errCoalesceNoFunc(self.children[1])
-		// } else {
 		v = rightValue
-		// }
 	}
 	return
 }
@@ -63,7 +57,7 @@ func evalAssignCoalesce(ctx ExprContext, self *term) (v any, err error) {
 	}

 	leftTerm := self.children[0]
-	if leftTerm.tk.Sym != SymIdentifier {
+	if leftTerm.tk.Sym != SymVariable {
 		err = leftTerm.Errorf("left operand of %q must be a variable", self.tk.source)
 		return
 	}
@@ -75,17 +69,12 @@ func evalAssignCoalesce(ctx ExprContext, self *term) (v any, err error) {
 			ctx.RegisterFunc(leftTerm.source(), functor, 0, -1)
 		} else {
 			v = rightValue
-			ctx.setVar(leftTerm.source(), rightValue)
+			ctx.UnsafeSetVar(leftTerm.source(), rightValue)
 		}
 	}
 	return
 }

-// utils
-// func errCoalesceNoFunc(t *term) error {
-// 	return t.Errorf("the right operand of a coalescing operation cannot be a function definition")
-// }
-
 // init
 func init() {
 	registerTermConstructor(SymDoubleQuestion, newNullCoalesceTerm)
@@ -59,28 +59,16 @@ func evalDot(ctx ExprContext, self *term) (v any, err error) {
 		if index, err = verifyIndex(ctx, indexTerm, len(unboxedValue)); err == nil {
 			v = string(unboxedValue[index])
 		}
-	case map[any]any:
+	case *DictType:
 		var ok bool
 		var indexValue any
 		if indexValue, err = indexTerm.compute(ctx); err == nil {
-			if v, ok = unboxedValue[indexValue]; !ok {
+			if v, ok = (*unboxedValue)[indexValue]; !ok {
 				err = fmt.Errorf("key %v does not belong to the dictionary", rightValue)
 			}
 		}
-	// case *dataCursor:
-	// 	if indexTerm.symbol() == SymIdentifier {
-	// 		opName := indexTerm.source()
-	// 		if opName == resetName {
-	// 			_, err = unboxedValue.Reset()
-	// 		} else if opName == cleanName {
-	// 			_, err = unboxedValue.Clean()
-	// 		} else {
-	// 			err = indexTerm.Errorf("iterators do not support command %q", opName)
-	// 		}
-	// 		v = err == nil
-	// 	}
 	case ExtIterator:
-		if indexTerm.symbol() == SymIdentifier {
+		if indexTerm.symbol() == SymVariable {
 			opName := indexTerm.source()
 			if unboxedValue.HasOperation(opName) {
 				v, err = unboxedValue.CallOperation(opName, []any{})
@@ -4,6 +4,8 @@
 // operand-fraction.go
 package expr

+//https://www.youmath.it/lezioni/algebra-elementare/lezioni-di-algebra-e-aritmetica-per-scuole-medie/553-dalle-frazioni-a-numeri-decimali.html
+
 import (
 	"errors"
 	"fmt"
@@ -202,6 +204,10 @@ func (f *fraction) ToString(opt FmtOpt) string {
 	return sb.String()
 }

+func (f *fraction) TypeName() string {
+	return "fraction"
+}
+
 // -------- fraction term
 func newFractionTerm(tk *Token) *term {
 	return &term{
@@ -0,0 +1,46 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-in.go
+package expr
+
+//-------- in term
+
+func newInTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priRelational,
+		evalFunc: evalIn,
+	}
+}
+
+// func hasKey(d map[any]any, target any) (ok bool) {
+// 	_, ok = d[target]
+// 	return
+// }
+
+func evalIn(ctx ExprContext, self *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+		return
+	}
+
+	if IsList(rightValue) {
+		list, _ := rightValue.(*ListType)
+		v = list.indexDeepCmp(leftValue) >= 0
+	} else if IsDict(rightValue) {
+		dict, _ := rightValue.(*DictType)
+		v = dict.hasKey(leftValue)
+	} else {
+		err = self.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymKwIn, newInTerm)
+}
@@ -37,6 +37,9 @@ func evalInsert(ctx ExprContext, self *term) (v any, err error) {
 		list, _ := rightValue.(*ListType)
 		newList := append(ListType{leftValue}, *list...)
 		v = &newList
+		if self.children[1].symbol() == SymVariable {
+			ctx.UnsafeSetVar(self.children[1].source(), v)
+		}
 	} else {
 		err = self.errIncompatibleTypes(leftValue, rightValue)
 	}
@@ -54,12 +57,33 @@ func evalAppend(ctx ExprContext, self *term) (v any, err error) {
 		list, _ := leftValue.(*ListType)
 		newList := append(*list, rightValue)
 		v = &newList
+		if self.children[0].symbol() == SymVariable {
+			ctx.UnsafeSetVar(self.children[0].source(), v)
+		}
 	} else {
 		err = self.errIncompatibleTypes(leftValue, rightValue)
 	}
 	return
 }

+// func evalAssignAppend(ctx ExprContext, self *term) (v any, err error) {
+// 	var leftValue, rightValue any
+
+// 	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
+// 		return
+// 	}
+
+// 	if IsList(leftValue) {
+// 		list, _ := leftValue.(*ListType)
+// 		newList := append(*list, rightValue)
+// 		v = &newList
+// 		if
+// 	} else {
+// 		err = self.errIncompatibleTypes(leftValue, rightValue)
+// 	}
+// 	return
+// }
+
 // init
 func init() {
 	registerTermConstructor(SymInsert, newInsertTerm)
@@ -30,8 +30,9 @@ func evalLength(ctx ExprContext, self *term) (v any, err error) {
 		s, _ := childValue.(string)
 		v = int64(len(s))
 	} else if IsDict(childValue) {
-		m, _ := childValue.(map[any]any)
-		v = int64(len(m))
+		// m, _ := childValue.(map[any]any)
+		m, _ := childValue.(*DictType)
+		v = int64(len(*m))
 	} else if it, ok := childValue.(Iterator); ok {
 		if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(countName) {
 			count, _ := extIt.CallOperation(countName, nil)
@@ -25,7 +25,7 @@ func evalPostInc(ctx ExprContext, self *term) (v any, err error) {

 	if it, ok := childValue.(Iterator); ok {
 		v, err = it.Next()
-	} else if IsInteger(childValue) && self.children[0].symbol() == SymIdentifier {
+	} else if IsInteger(childValue) && self.children[0].symbol() == SymVariable {
 		v = childValue
 		i, _ := childValue.(int64)
 		ctx.SetVar(self.children[0].source(), i+1)
@@ -38,15 +38,28 @@ func evalPlus(ctx ExprContext, self *term) (v any, err error) {
 			rightInt, _ := rightValue.(int64)
 			v = leftInt + rightInt
 		}
-	} else if IsList(leftValue) || IsList(rightValue) {
+		// } else if IsList(leftValue) || IsList(rightValue) {
+		// 	var leftList, rightList *ListType
+		// 	var ok bool
+		// 	if leftList, ok = leftValue.(*ListType); !ok {
+		// 		leftList = &ListType{leftValue}
+		// 	}
+		// 	if rightList, ok = rightValue.(*ListType); !ok {
+		// 		rightList = &ListType{rightValue}
+		// 	}
+		// 	sumList := make(ListType, 0, len(*leftList)+len(*rightList))
+		// 	for _, item := range *leftList {
+		// 		sumList = append(sumList, item)
+		// 	}
+		// 	for _, item := range *rightList {
+		// 		sumList = append(sumList, item)
+		// 	}
+		// 	v = &sumList
+	} else if IsList(leftValue) && IsList(rightValue) {
 		var leftList, rightList *ListType
-		var ok bool
-		if leftList, ok = leftValue.(*ListType); !ok {
-			leftList = &ListType{leftValue}
-		}
-		if rightList, ok = rightValue.(*ListType); !ok {
-			rightList = &ListType{rightValue}
-		}
+		leftList, _ = leftValue.(*ListType)
+		rightList, _ = rightValue.(*ListType)
+
 		sumList := make(ListType, 0, len(*leftList)+len(*rightList))
 		for _, item := range *leftList {
 			sumList = append(sumList, item)
@@ -55,19 +68,17 @@ func evalPlus(ctx ExprContext, self *term) (v any, err error) {
 			sumList = append(sumList, item)
 		}
 		v = &sumList
-	} else if isFraction(leftValue) || isFraction(rightValue) {
+	} else if (isFraction(leftValue) && IsNumber(rightValue)) || (isFraction(rightValue) && IsNumber(leftValue)) {
 		if IsFloat(leftValue) || IsFloat(rightValue) {
 			v = numAsFloat(leftValue) + numAsFloat(rightValue)
 		} else {
 			v, err = sumAnyFract(leftValue, rightValue)
 		}
 	} else if IsDict(leftValue) && IsDict(rightValue) {
-		leftDict, _ := leftValue.(map[any]any)
-		rightDict, _ := rightValue.(map[any]any)
-		c := CloneMap(leftDict)
-		for key, value := range rightDict {
-			c[key] = value
-		}
+		leftDict, _ := leftValue.(*DictType)
+		rightDict, _ := rightValue.(*DictType)
+		c := leftDict.clone()
+		c.merge(rightDict)
 		v = c
 	} else {
 		err = self.errIncompatibleTypes(leftValue, rightValue)
@@ -277,6 +277,7 @@ func (self *parser) parseDictionary(scanner *scanner, allowVarRef bool) (subtree
 			err = scanner.Previous().ErrorExpectedGot("}")
 		} else {
 			subtree = newDictTerm(args)
+			// subtree = newMapTerm(args)
 		}
 	}
 	return
@@ -389,7 +390,7 @@ func (self *parser) parseGeneral(scanner *scanner, allowForest bool, allowVarRef
 			var subTree *ast
 			if subTree, err = self.parseGeneral(scanner, false, allowVarRef, SymClosedRound); err == nil {
 				subTree.root.priority = priValue
-				err = tree.addTerm(subTree.root)
+				err = tree.addTerm(newExprTerm(subTree.root))
 				currentTerm = subTree.root
 			}
 		case SymFuncCall:
@@ -98,7 +98,7 @@ func TestGeneralParser(t *testing.T) {
 		/*  77 */ {`5 % 2`, int64(1), nil},
 		/*  78 */ {`5 % (-2)`, int64(1), nil},
 		/*  79 */ {`-5 % 2`, int64(-1), nil},
-		/*  80 */ {`5 % 2.0`, nil, errors.New(`[1:4] left operand '5' [int64] and right operand '2' [float64] are not compatible with operator "%"`)},
+		/*  80 */ {`5 % 2.0`, nil, errors.New(`[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},
@@ -137,7 +137,7 @@ func TestGeneralParser(t *testing.T) {
 		/* 116 */ {`null`, nil, errors.New(`undefined variable or function "null"`)},
 		/* 117 */ {`{"key"}`, nil, errors.New(`[1:8] expected ":", got "}"`)},
 		/* 118 */ {`{"key":}`, nil, errors.New(`[1:9] expected "dictionary-value", got "}"`)},
-		/* 119 */ {`{}`, map[any]any{}, nil},
+		/* 119 */ {`{}`, &DictType{}, nil},
 		/* 120 */ {`1|2`, newFraction(1, 2), nil},
 		/* 121 */ {`1|2 + 1`, newFraction(3, 2), nil},
 		/* 122 */ {`1|2 - 1`, newFraction(-1, 2), nil},
@@ -36,7 +36,7 @@ func (ctx *SimpleVarStore) GetVar(varName string) (v any, exists bool) {
 	return
 }

-func (ctx *SimpleVarStore) setVar(varName string, value any) {
+func (ctx *SimpleVarStore) UnsafeSetVar(varName string, value any) {
 	// fmt.Printf("[%p] setVar(%v, %v)\n", ctx, varName, value)
 	ctx.varStore[varName] = value
 }
@@ -98,8 +98,8 @@ func varsCtxToBuilder(sb *strings.Builder, ctx ExprContext, indent int) {
 			sb.WriteString(f.ToString(0))
 		} else if _, ok = value.(Functor); ok {
 			sb.WriteString("func(){}")
-		} else if _, ok = value.(map[any]any); ok {
-			sb.WriteString("dict{}")
+			// } else if _, ok = value.(map[any]any); ok {
+			// 	sb.WriteString("dict{}")
 		} else {
 			sb.WriteString(fmt.Sprintf("%v", value))
 		}
@@ -72,6 +72,7 @@ const (
 	SymIdentifier
 	SymBool
 	SymInteger
+	SymVariable
 	SymFloat
 	SymFraction
 	SymString
@@ -99,6 +100,7 @@ const (
 	SymKwBut
 	SymKwFunc
 	SymKwBuiltin
+	SymKwIn
 	SymKwInclude
 	SymKwNil
 )
@@ -112,6 +114,7 @@ func init() {
 		"BUILTIN": SymKwBuiltin,
 		"BUT":     SymKwBut,
 		"FUNC":    SymKwFunc,
+		"IN":      SymKwIn,
 		"INCLUDE": SymKwInclude,
 		"NOT":     SymKwNot,
 		"OR":      SymKwOr,
@@ -161,10 +161,14 @@ func (self *term) toInt(computedValue any, valueDescription string) (i int, err
 }

 func (self *term) errIncompatibleTypes(leftValue, rightValue any) error {
+	leftType := getTypeName(leftValue)
+	leftText := getFormatted(leftValue, Truncate)
+	rightType := getTypeName(rightValue)
+	rightText := getFormatted(rightValue, Truncate)
 	return self.tk.Errorf(
-		"left operand '%v' [%T] and right operand '%v' [%T] are not compatible with operator %q",
-		leftValue, leftValue,
-		rightValue, rightValue,
+		"left operand '%s' [%s] and right operand '%s' [%s] are not compatible with operator %q",
+		leftText, leftType,
+		rightText, rightType,
 		self.source())
 }

@@ -31,6 +31,7 @@ func TestGetRoom(t *testing.T) {
 		t.Errorf("err: got <%v>, want <nil>", gotErr)
 	}
 }
+
 func TestGetChildrenCount(t *testing.T) {
 	tk1 := NewValueToken(0, 0, SymInteger, "100", 100)

@@ -35,7 +35,7 @@ func IsList(v any) (ok bool) {
 }

 func IsDict(v any) (ok bool) {
-	_, ok = v.(map[any]any)
+	_, ok = v.(*DictType)
 	return ok
 }

@@ -147,6 +147,12 @@ func fromGenericAny(v any) (exprAny any, ok bool) {
 	if exprAny, ok = anyFloat(v); ok {
 		return
 	}
+	if exprAny, ok = v.(*DictType); ok {
+		return
+	}
+	if exprAny, ok = v.(*ListType); ok {
+		return
+	}
 	return
 }

@@ -0,0 +1,139 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// utils_test.go
+package expr
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestIsString(t *testing.T) {
+	count := 0
+	succeeded := 0
+	failed := 0
+
+	count++
+	if !IsBool(true) {
+		t.Errorf("%d: IsBool(true) -> result = false, want true", count)
+		failed++
+	} else {
+		succeeded++
+	}
+
+	count++
+	if !IsString("abc") {
+		t.Errorf("%d: IsString(\"abc\") -> result = false, want true", count)
+		failed++
+	} else {
+		succeeded++
+	}
+
+	count++
+	if !IsInteger(int64(123)) {
+		t.Errorf("%d: IsInteger(123) -> result = false, want true", count)
+		failed++
+	} else {
+		succeeded++
+	}
+
+	count++
+	if !IsFloat(1.23) {
+		t.Errorf("%d: IsFloat(1.23) -> result = false, want true", count)
+		failed++
+	} else {
+		succeeded++
+	}
+
+	count++
+	if !IsFloat(numAsFloat(123)) {
+		t.Errorf("%d: IsFloat(numAsFloat(123)) -> result = false, want true", count)
+		failed++
+	} else {
+		succeeded++
+	}
+
+	count++
+	b, ok := toBool(true)
+	if !(ok && b) {
+		t.Errorf("%d: toBool(true) b=%v, ok=%v -> result = false, want true", count, b, ok)
+		failed++
+	} else {
+		succeeded++
+	}
+
+	count++
+	b, ok = toBool("abc")
+	if !(ok && b) {
+		t.Errorf("%d: toBool(\"abc\") b=%v, ok=%v -> result = false, want true", count, b, ok)
+		failed++
+	} else {
+		succeeded++
+	}
+
+	t.Logf("test count: %d, succeeded count: %d, failed count: %d", count, succeeded, failed)
+}
+
+func TestToIntOk(t *testing.T) {
+	source := int64(64)
+	wantValue := int(64)
+	wantErr := error(nil)
+
+	gotValue, gotErr := toInt(source, "test")
+
+	if gotErr != nil || gotValue != wantValue {
+		t.Errorf("toInt(%v, \"test\") gotValue=%v, gotErr=%v -> wantValue=%v, wantErr=%v",
+			source, gotValue, gotErr, wantValue, wantErr)
+	}
+}
+
+func TestToIntErr(t *testing.T) {
+	source := uint64(64)
+	wantValue := 0
+	wantErr := errors.New(`test expected integer, got uint64 (64)`)
+
+	gotValue, gotErr := toInt(source, "test")
+
+	if gotErr.Error() != wantErr.Error() || gotValue != wantValue {
+		t.Errorf("toInt(%v, \"test\") gotValue=%v, gotErr=%v -> wantValue=%v, wantErr=%v",
+			source, gotValue, gotErr, wantValue, wantErr)
+	}
+}
+
+func TestAnyInteger(t *testing.T) {
+	type inputType struct {
+		source    any
+		wantValue int64
+		wantOk    bool
+	}
+	section := "utils.anyInteger"
+
+	inputs := []inputType{
+		/*  1 */ {int8(-8), int64(-8), true},
+		/*  2 */ {int16(-16), int64(-16), true},
+		/*  3 */ {int32(-32), int64(-32), true},
+		/*  4 */ {int64(-64), int64(-64), true},
+		/*  5 */ {uint8(8), int64(8), true},
+		/*  6 */ {uint16(16), int64(16), true},
+		/*  7 */ {uint32(32), int64(32), true},
+		/*  8 */ {uint64(64), int64(64), true},
+		/*  9 */ {int(-1), int64(-1), true},
+		/* 10 */ {true, 0, false},
+	}
+
+	succeeded := 0
+	failed := 0
+
+	for i, input := range inputs {
+		gotValue, gotOk := anyInteger(input.source)
+		if gotOk != input.wantOk || gotValue != input.wantValue {
+			t.Errorf("%d: anyInteger(%v) -> gotOk = %t, wantOk = %t; gotValue = %v, wantValue = %v",
+				i+1, input.source, gotOk, input.wantOk, gotValue, input.wantValue)
+			failed++
+		} else {
+			succeeded++
+		}
+	}
+	t.Logf("%s -- test count: %d, succeeded: %d, failed: %d", section, len(inputs), succeeded, failed)
+}
Author	SHA1	Message	Date
camoroso	f22b5a6f0b	Doc: more details on some operators	2024-05-20 06:59:49 +02:00
camoroso	7c8dbb0ac7	Added virtual symbol SymVariable translated from general real SymIdentifier symbol	2024-05-20 06:05:24 +02:00
camoroso	e5c5920db0	parser_test.go: incompatible type error corrected	2024-05-20 05:32:28 +02:00
camoroso	61efdb4eef	operator-fraction.go: Typer interface implementation	2024-05-20 05:31:20 +02:00
camoroso	82ec78719d	operand-list.go: ToString() now can handle the Truncate option	2024-05-20 05:30:26 +02:00
camoroso	554ff1a9dd	operator-sum.go: better type checking when adding fractions	2024-05-20 05:27:44 +02:00
camoroso	6bb891e09d	term.go: Error messagge about incompatible types now truncates long values	2024-05-20 05:26:33 +02:00
camoroso	1c4ffd7d64	formatter.go: Truncate function and number type names	2024-05-20 05:25:04 +02:00
camoroso	b92b19e1dd	New interface to Typer: the function TypeName() returns a more readable type name	2024-05-19 02:23:28 +02:00
camoroso	9967918418	operator-sum.go: adding item to a list is no more allowed. The sum operator '+' now ca only join two list.	2024-05-19 02:20:36 +02:00
camoroso	6c14c07d66	operand-iterator.go: adapted to the new DictType	2024-05-19 01:47:06 +02:00
camoroso	9ea170e53b	new operator 'in': it returns true if a item belongs to a list or if a key belongs to a dict	2024-05-19 01:44:50 +02:00
camoroso	a543360151	when the list value involved in an insert or append operations (directly) comes from a variable, that variable receives the result list	2024-05-19 01:42:15 +02:00
camoroso	24a25bbf94	adapted and enhanced the dict operations to make them compatible with the new DictType	2024-05-19 01:38:07 +02:00
camoroso	d6a1607041	The content of round bracket now returns an expressione term. This way the content is decoupled from external terms.	2024-05-19 01:34:07 +02:00
camoroso	4d43ab2c2f	context.go: setVar() renamed as UnsafeSetVar()	2024-05-19 01:27:44 +02:00
camoroso	9bd4a0ba23	utils.go:fromGenericAny() now supports also ListType and DictType	2024-05-19 01:21:06 +02:00
camoroso	2b184cf3f2	operand-map.go replaced by operand-dict.go	2024-05-19 01:20:04 +02:00
camoroso	263e419d9a	operand-map.go: to be removed	2024-05-18 08:54:18 +02:00
camoroso	c39970fa7e	new operator 'in' added. It check if an item is member of a list, or if a key is contained in a dictionary	2024-05-18 07:47:41 +02:00
camoroso	14bb9e942b	operator-fraction.go: added link to a tutorial about fractions	2024-05-18 07:07:17 +02:00
camoroso	9451958218	utils_test.go: new test file	2024-05-18 07:06:06 +02:00
camoroso	91fdc1926e	Doc: updated last change date and time	2024-05-17 15:48:17 +02:00
camoroso	9a3abdf1b6	Doc: more details on the syntax of the selector and variable default operators	2024-05-17 15:46:56 +02:00
camoroso	ac3e690f87	Doc: more details on the syntax of the dictionaries, variables and multi-expressions	2024-05-17 07:31:13 +02:00