Doc: more details on the syntax of the numbers

ast.go

@@ -60,7 +60,7 @@ func (self *ast) addToken(tk *Token) (err error) {
 }
 
 func (self *ast) addToken2(tk *Token) (t *term, err error) {
-	if t = newTerm(tk, nil); t != nil {
+	if t = newTerm(tk); t != nil {
 		err = self.addTerm(t)
 	} else {
 		err = tk.Errorf("unexpected token %q", tk.String())

common-errors.go

@@ -8,6 +8,20 @@ import (
 	"fmt"
 )
 
+func errTooFewParams(minArgs, maxArgs, argCount int) (err error) {
+	if maxArgs < 0 {
+		err = fmt.Errorf("too few params -- expected %d or more, got %d", minArgs, argCount)
+	} else {
+		err = fmt.Errorf("too few params -- expected %d, got %d", minArgs, argCount)
+	}
+	return
+}
+
+func errTooMuchParams(maxArgs, argCount int) (err error) {
+	err = fmt.Errorf("too much params -- expected %d, got %d", maxArgs, argCount)
+	return
+}
+
 // --- General errors
 
 func errCantConvert(funcName string, value any, kind string) error {
@@ -18,11 +32,15 @@ func errExpectedGot(funcName string, kind string, value any) error {
 	return fmt.Errorf("%s() expected %s, got %T (%v)", funcName, kind, value, value)
 }
 
+func errDivisionByZero(funcName string) error {
+	return fmt.Errorf("%s() division by zero", funcName)
+}
+
 // --- Parameter errors
 
-func errOneParam(funcName string) error {
-	return fmt.Errorf("%s() requires exactly one param", funcName)
-}
+// func errOneParam(funcName string) error {
+// 	return fmt.Errorf("%s() requires exactly one param", funcName)
+// }
 
 func errMissingRequiredParameter(funcName, paramName string) error {
 	return fmt.Errorf("%s() missing required parameter %q", funcName, paramName)

dict_test.go

@@ -23,22 +23,10 @@ func TestDictParser(t *testing.T) {
 	inputs := []inputType{
 		/*  1 */ {`{}`, map[any]any{}, nil},
 		/*  2 */ {`{123}`, nil, errors.New(`[1:6] expected ":", got "}"`)},
-		/*  3 */ {`{1:"one",2:"two",3:"three"}`, map[int64]any{int64(1):"one", int64(2):"two", int64(3):"three"}, nil},
+		/*  3 */ {`{1:"one",2:"two",3:"three"}`, map[int64]any{int64(1): "one", int64(2): "two", int64(3): "three"}, nil},
 		/*  4 */ {`{1:"one",2:"two",3:"three"}.2`, "three", nil},
-		// /*  3 */ {`[1,2,"hello"]`, []any{int64(1), int64(2), "hello"}, nil},
-		// /*  4 */ {`[1+2, not true, "hello"]`, []any{int64(3), false, "hello"}, nil},
-		// /*  5 */ {`[1,2]+[3]`, []any{int64(1), int64(2), int64(3)}, nil},
-		// /*  6 */ {`[1,4,3,2]-[3]`, []any{int64(1), int64(4), int64(2)}, nil},
-		// /*  7 */ {`add([1,4,3,2])`, int64(10), nil},
-		// /*  8 */ {`add([1,[2,2],3,2])`, int64(10), nil},
-		// /*  9 */ {`mul([1,4,3.0,2])`, float64(24.0), nil},
-		// /* 10 */ {`add([1,"hello"])`, nil, errors.New(`add(): param nr 2 (2 in 1) has wrong type string, number expected`)},
-		// /* 11 */ {`[a=1,b=2,c=3] but a+b+c`, int64(6), nil},
-		// /* 12 */ {`[1,2,3] << 2+2`, []any{int64(1), int64(2), int64(3), int64(4)}, nil},
-		// /* 13 */ {`2-1 >> [2,3]`, []any{int64(1), int64(2), int64(3)}, nil},
-		// /* 14 */ {`[1,2,3].1`, int64(2), nil},
-		// /* 15 */ {`ls=[1,2,3] but ls.1`, int64(2), nil},
-		// /* 16 */ {`ls=[1,2,3] but ls.(-1)`, int64(3), nil},
+		/*  5 */ {`#{1:"one",2:"two",3:"three"}`, int64(3), nil},
+		/*  6 */ {`{1:"one"} + {2:"two"}`, map[any]any{1: "one", 2: "two"}, nil},
 	}
 
 	succeeded := 0

doc/Expr.adoc

@@ -22,7 +22,7 @@ Expressions calculator
 
 toc::[]
 
-#TODO: Work in progress (last update on 2024/05/10, 06:52 a.m.)#
+#TODO: Work in progress (last update on 2024/05/15, 10:00 p.m.)#
 
 == Expr
 _Expr_ is a GO package capable of analysing, interpreting and calculating expressions.
@@ -113,37 +113,84 @@ Here are some examples of execution.
 _Expr_ supports numerical, string, relational, boolean expressions, and mixed-type lists.
 
 === Numbers
-Numbers can be integers (GO int64) or float (GO float64). In mixed operations involving integers and floats, integers are automatically promoted to floats.
+_Expr_ supports three type of numbers:
+
+. [blue]#Integers#
+. [blue]#Floats#
+. [blue]#Factions# internally are stored as _pairs of_ Golang _int64_ values.
+
+In mixed operations involving integers, fractions and floats, automatic type promotion to the largest type take place.
+
+==== Integers
+__Expr__'s integers are a subset of the integer set. Internally they are stored as Golang _int64_ values.
+
+.Integer literal syntax
+====
+*_integer_* = [_sign_] _digit-seq_ +
+_sign_ = "**+**" | "**-**" +
+_digit-seq_ = _dec-seq_ | _bin-seq_ | _oct-seq_ | _hex-seq_ +
+_dec-seq_ = {__dec-digit__} +
+_dec-digit_ = "**0**"|"**1**"|...|"**9**" +
+_bin-seq_ = "**0b**"{__bin-digit__} +
+_bin-digit_ = "**0**"|"**1**" +
+_oct-seq_ = "**0o**"{__oct-digit__} +
+_oct-digit_ = "**0**"|"**1**"|...|"**7**" +
+_hex-seq_ = "**0x**"{__hex-digit__} +
+_hex-digit_ = "**0**"|"**1**"|...|"**9**"|"**a**"|...|"**z**"|"**A**"|...|"**Z**"
+====
+
+Value range: *-9223372036854775808* to *9223372036854775807*
 
 .Arithmetic operators
 [cols="^1,^2,6,4"]
 |===
 | Symbol    | Operation     | Description               | Examples
-
-| [blue]`+` / [blue]`-` | _change sign_ | Change the sign of values | [blue]`-1` _[-1]_ +
-[blue]`-(+2)` _[-2]_
-
-| [blue]`+` | _sum_ | Add two values | [blue]`-1 + 2` _[1]_ +
-[blue]`4 + 0.5` _[4.5]_
-
-| [blue]`-` | _subtraction_ | Subtract the right value from the left one | [blue]`3 - 1` _[2]_ +
-[blue]`4 - 0.5` _[3.5]_
-
-| [blue]`*` | _product_ | Multiply two values | `-1 * 2` _[-2]_ +
-[blue]`4 * 0.5` _[2.0]_
-
-| [blue]`/` | _Division_ | Divide the left value by the right one | [blue]`-1 / 2` _[0]_ +
-[blue]`1.0 / 2` _[0.5]_
-
-| [blue]`./` | _Float division_ | Force float division | [blue]`-1 ./ 2` _[-0.5]_
-
-| [blue]`%` | _Modulo_ | Remainder of the integer division | [blue]`5 % 2` _[1]_
-
+| [blue]`+` | _sum_         | Add two values            | [blue]`-1 + 2` -> 1
+| [blue]`-` | _subtraction_ | Subtract the right value from the left one | [blue]`3 - 1` -> 2
+| [blue]`*` | _product_     | Multiply two values       | [blue]`-1 * 2` -> -2
+| [blue]`/` | _Division_    | Divide the left value by the right one^(*)^ | [blue]`-10 / 2` -> 5
+| [blue]`%` | _Modulo_      | Remainder of the integer division | [blue]`5 % 2` -> 1
 |=== 
 
-=== Fractions
+^(*)^ See also the _float division_ [blue]`./` below.
+
+
+==== Floats
+__Expr__'s floats are a subset of the rational number set. Note that they can't hold the exact value of an unlimited number; floats can only approximate them. Internally floats are stored as Golang's _float64_ values.
+
+
+.Float literal syntax
+====
+*_float_* = [_sign_] _dec-seq_ "**.**" [_dec-seq_] [("**e**"|"**E**") [_sign_] _dec-seq_] +
+_sign_ = "**+**" | "**-**" +
+_dec-seq_ = _see-integer-literal-syntax_
+====
+
+
+.Arithmetic operators
+[cols="^1,^2,6,4"]
+|===
+| Symbol    | Operation     | Description               | Examples
+| [blue]`+` | _sum_         | Add two values            | [blue]`4 + 0.5` -> 4.5
+| [blue]`-` | _subtraction_ | Subtract the right value from the left one | [blue]`4 - 0.5` -> 3.5
+| [blue]`*` | _product_     | Multiply two values       | [blue]`4 * 0.5` -> 2.0
+| [blue]`/` | _Division_    | Divide the left value by the right one | [blue]`1.0 / 2` -> 0.5
+| [blue]`./`| _Float division_ | Force float division   | [blue]`-1 ./ 2` -> -0.5
+|===
+
+==== Fractions
 _Expr_ also supports fractions. Fraction literals are made with two integers separated by a vertical bar `|`.
 
+.Fraction literal syntax
+====
+*_fraction_* = [__sign__] (_num-den-spec_ | _float-spec_) +
+_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_ +
+====
+
 .Examples
 // [source,go]
 // ----
@@ -194,6 +241,25 @@ Some arithmetic operators can also be used with strings.
 | [blue]`*` | _repeat_ | Make _n_ copy of a string  | [blue]`"one" * 2` _["oneone"]_
 |===
 
+The items of strings can be accessed using the dot `.` operator.
+
+.Item access syntax
+[source,bnf]
+----
+<item> ::= <string-expr>"."<index-expr>
+----
+
+.String examples
+`>>>` [blue]`s="abc"`  [gray]_assign the string to variable s_ +
+[green]`abc` +
+`>>>` [blue]`s.1`      [gray]_char at position 1 (starting from 0)_ +
+[green]`b` +
+`>>>` [blue]`s.(-1)`   [gray]_char at position -1, the rightmost one_ +
+[green]`c` +
+`>>>` [blue]`\#s`       [gray]_number of chars_ +
+[gren]`3` +
+`>>>` [blue]`#"abc"`   [gray]_number of chars_ +
+[green]`3` +
 
 === Boolean
 Boolean data type has two values only: _true_ and _false_. Relational and Boolean expressions produce Boolean values.
@@ -278,29 +344,27 @@ The items of array can be accessed using the dot `.` operator.
 ----
 
 .Items of list
-[source,go]
-----
-`>>>` [blue]`[1,2,3].1`
-[green]`2`
-`>>>` [blue]`list=[1,2,3]; list.1`
-[green]`2`
-`>>>` [blue]`["one","two","three"].1`
-[green]`two`
-`>>>` [blue]`list=["one","two","three"]; list.(2-1)`
-[green]`two`
-`>>>` [blue]`list.(-1)`
-[green]`three`
-`>>>` [blue]`list.(-1)`
-[green]`three`
-`>>>` [blue]`list.(10)`
-----
+`>>>` [blue]`[1,2,3].1` +
+[green]`2` +
+`>>>` [blue]`list=[1,2,3]; list.1` +
+[green]`2` +
+`>>>` [blue]`["one","two","three"].1` +
+[green]`two` +
+`>>>` [blue]`list=["one","two","three"]; list.(2-1)` +
+[green]`two` +
+`>>>` [blue]`list.(-1)` +
+[green]`three` +
+`>>>` [blue]`list.(10)` +
+[red]`Eval Error: [1:9] index 10 out of bounds` +
+`>>>` [blue]`#list` +
+[green]`3`
 
 
 
 == 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.
 
-.List examples
+.Dictionary examples
 [source,go]
 ----
 {1:"one", 2:"two"}
@@ -311,7 +375,7 @@ The _dictionary_ data-type is set of pairs _key/value_. It is also known as _map
 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 _ExprContext_ interface.
+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_.
 
 .Examples
 [source,go]
@@ -365,23 +429,30 @@ The _selector operator_ is very similar to the _switch/case/default_ statement a
 <multi-expression> ::= <expression> {";" <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 find 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 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.
 
 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.
 
-
 .Examples
 [source,go]
 ----
-1 ? {"a"} : {"b"}                           // returns "b"
-10 ? {"a"} : {"b"} :: {"c"}                 // returns "c"
-10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}      // returns "b"
-10 ? {"a"} :[true, 2+8] {"b"} ::[10] {"c"}  // error:  "... case list in default clause"
-10 ? {"a"} :[10] {x="b" but x} :: {"c"}     // returns "b"
-10 ? {"a"} :[10] {x="b"; x} :: {"c"}        // returns "b"
-10 ? {"a"} : {"b"}                          // error:  "... no case catches the value (10) of the selection expression
+`>>>` [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`
+
 ----
 
 == Priorities of operators

doc/Expr.html

@@ -541,11 +541,16 @@ pre.rouge .ss {
 </li>
 <li><a href="#_data_types">2. Data types</a>
 <ul class="sectlevel2">
-<li><a href="#_numbers">2.1. Numbers</a></li>
-<li><a href="#_fractions">2.2. Fractions</a></li>
-<li><a href="#_strings">2.3. Strings</a></li>
-<li><a href="#_boolean">2.4. Boolean</a></li>
-<li><a href="#_lists">2.5. Lists</a></li>
+<li><a href="#_numbers">2.1. Numbers</a>
+<ul class="sectlevel3">
+<li><a href="#_integers">2.1.1. Integers</a></li>
+<li><a href="#_floats">2.1.2. Floats</a></li>
+<li><a href="#_fractions">2.1.3. Fractions</a></li>
+</ul>
+</li>
+<li><a href="#_strings">2.2. Strings</a></li>
+<li><a href="#_boolean">2.3. Boolean</a></li>
+<li><a href="#_lists">2.4. Lists</a></li>
 </ul>
 </li>
 <li><a href="#_dictionaries">3. Dictionaries</a></li>
@@ -579,7 +584,7 @@ pre.rouge .ss {
 <div class="sectionbody">
 <!-- toc disabled -->
 <div class="paragraph">
-<p><mark>TODO: Work in progress (last update on 2024/05/10, 06:52 a.m.)</mark></p>
+<p><mark>TODO: Work in progress (last update on 2024/05/15, 10:00 p.m.)</mark></p>
 </div>
 </div>
 </div>
@@ -721,7 +726,49 @@ pre.rouge .ss {
 <div class="sect2">
 <h3 id="_numbers"><a class="anchor" href="#_numbers"></a><a class="link" href="#_numbers">2.1. Numbers</a></h3>
 <div class="paragraph">
-<p>Numbers can be integers (GO int64) or float (GO float64). In mixed operations involving integers and floats, integers are automatically promoted to floats.</p>
+<p><em>Expr</em> supports three type of numbers:</p>
+</div>
+<div class="olist arabic">
+<ol class="arabic">
+<li>
+<p><span class="blue">Integers</span></p>
+</li>
+<li>
+<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>
+</li>
+</ol>
+</div>
+<div class="paragraph">
+<p>In mixed operations involving integers, fractions and floats, automatic type promotion to the largest type take place.</p>
+</div>
+<div class="sect3">
+<h4 id="_integers"><a class="anchor" href="#_integers"></a><a class="link" href="#_integers">2.1.1. Integers</a></h4>
+<div class="paragraph">
+<p><em>Expr</em>'s integers are a subset of the integer set. Internally they are stored as Golang <em>int64</em> values.</p>
+</div>
+<div class="exampleblock">
+<div class="title">Example 1. Integer literal syntax</div>
+<div class="content">
+<div class="paragraph">
+<p><strong><em>integer</em></strong> = [<em>sign</em>] <em>digit-seq</em><br>
+<em>sign</em> = "<strong>+</strong>" | "<strong>-</strong>"<br>
+<em>digit-seq</em> = <em>dec-seq</em> | <em>bin-seq</em> | <em>oct-seq</em> | <em>hex-seq</em><br>
+<em>dec-seq</em> = {<em>dec-digit</em>}<br>
+<em>dec-digit</em> = "<strong>0</strong>"|"<strong>1</strong>"|&#8230;&#8203;|"<strong>9</strong>"<br>
+<em>bin-seq</em> = "<strong>0b</strong>"{<em>bin-digit</em>}<br>
+<em>bin-digit</em> = "<strong>0</strong>"|"<strong>1</strong>"<br>
+<em>oct-seq</em> = "<strong>0o</strong>"{<em>oct-digit</em>}<br>
+<em>oct-digit</em> = "<strong>0</strong>"|"<strong>1</strong>"|&#8230;&#8203;|"<strong>7</strong>"<br>
+<em>hex-seq</em> = "<strong>0x</strong>"{<em>hex-digit</em>}<br>
+<em>hex-digit</em> = "<strong>0</strong>"|"<strong>1</strong>"|&#8230;&#8203;|"<strong>9</strong>"|"<strong>a</strong>"|&#8230;&#8203;|"<strong>z</strong>"|"<strong>A</strong>"|&#8230;&#8203;|"<strong>Z</strong>"</p>
+</div>
+</div>
+</div>
+<div class="paragraph">
+<p>Value range: <strong>-9223372036854775808</strong> to <strong>9223372036854775807</strong></p>
 </div>
 <table class="tableblock frame-all grid-all stretch">
 <caption class="title">Table 1. Arithmetic operators</caption>
@@ -731,70 +778,130 @@ pre.rouge .ss {
 <col style="width: 46.1538%;">
 <col style="width: 30.7693%;">
 </colgroup>
-<thead>
-<tr>
-<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> / <code class="blue">-</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>change sign</em></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">Change the sign of values</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1</code> <em>[-1]</em><br>
-<code class="blue">-(+2)</code> <em>[-2]</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock">Symbol</p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock">Operation</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Description</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Examples</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>sum</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Add two values</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 + 2</code> <em>[1]</em><br>
-<code class="blue">4 + 0.5</code> <em>[4.5]</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 + 2</code> &#8594; 1</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">-</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>subtraction</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Subtract the right value from the left one</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">3 - 1</code> <em>[2]</em><br>
-<code class="blue">4 - 0.5</code> <em>[3.5]</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">3 - 1</code> &#8594; 2</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">*</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>product</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Multiply two values</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>-1 * 2</code> <em>[-2]</em><br>
-<code class="blue">4 * 0.5</code> <em>[2.0]</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 * 2</code> &#8594; -2</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">/</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Division</em></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">Divide the left value by the right one</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 / 2</code> <em>[0]</em><br>
-<code class="blue">1.0 / 2</code> <em>[0.5]</em></p></td>
-</tr>
-<tr>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">./</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Float division</em></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock">Force float division</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 ./ 2</code> <em>[-0.5]</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Divide the left value by the right one<sup>(*)</sup></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-10 / 2</code> &#8594; 5</p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">%</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Modulo</em></p></td>
 <td class="tableblock halign-left valign-top"><p class="tableblock">Remainder of the integer division</p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">5 % 2</code> <em>[1]</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">5 % 2</code> &#8594; 1</p></td>
+</tr>
+</tbody>
+</table>
+<div class="paragraph">
+<p><sup>(*)</sup> See also the <em>float division</em> <code class="blue">./</code> below.</p>
+</div>
+</div>
+<div class="sect3">
+<h4 id="_floats"><a class="anchor" href="#_floats"></a><a class="link" href="#_floats">2.1.2. Floats</a></h4>
+<div class="paragraph">
+<p><em>Expr</em>'s floats are a subset of the rational number set. Note that they can&#8217;t hold the exact value of an unlimited number; floats can only approximate them. Internally floats are stored as Golang&#8217;s <em>float64</em> values.</p>
+</div>
+<div class="exampleblock">
+<div class="title">Example 2. Float literal syntax</div>
+<div class="content">
+<div class="paragraph">
+<p><strong><em>float</em></strong> = [<em>sign</em>] <em>dec-seq</em> "<strong>.</strong>" [<em>dec-seq</em>] [("<strong>e</strong>"|"<strong>E</strong>") [<em>sign</em>] <em>dec-seq</em>]<br>
+<em>sign</em> = "<strong>+</strong>" | "<strong>-</strong>"<br>
+<em>dec-seq</em> = <em>see-integer-literal-syntax</em></p>
+</div>
+</div>
+</div>
+<table class="tableblock frame-all grid-all stretch">
+<caption class="title">Table 2. Arithmetic operators</caption>
+<colgroup>
+<col style="width: 7.6923%;">
+<col style="width: 15.3846%;">
+<col style="width: 46.1538%;">
+<col style="width: 30.7693%;">
+</colgroup>
+<tbody>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock">Symbol</p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock">Operation</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Description</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Examples</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>sum</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Add two values</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">4 + 0.5</code> &#8594; 4.5</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">-</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>subtraction</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Subtract the right value from the left one</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">4 - 0.5</code> &#8594; 3.5</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">*</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>product</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Multiply two values</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">4 * 0.5</code> &#8594; 2.0</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">/</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Division</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Divide the left value by the right one</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">1.0 / 2</code> &#8594; 0.5</p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">./</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Float division</em></p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock">Force float division</p></td>
+<td class="tableblock halign-left valign-top"><p class="tableblock"><code class="blue">-1 ./ 2</code> &#8594; -0.5</p></td>
 </tr>
 </tbody>
 </table>
 </div>
-<div class="sect2">
-<h3 id="_fractions"><a class="anchor" href="#_fractions"></a><a class="link" href="#_fractions">2.2. Fractions</a></h3>
+<div class="sect3">
+<h4 id="_fractions"><a class="anchor" href="#_fractions"></a><a class="link" href="#_fractions">2.1.3. Fractions</a></h4>
 <div class="paragraph">
 <p><em>Expr</em> also supports fractions. Fraction literals are made with two integers separated by a vertical bar <code>|</code>.</p>
 </div>
+<div class="exampleblock">
+<div class="title">Example 3. Fraction literal syntax</div>
+<div class="content">
+<div class="paragraph">
+<p><strong><em>fraction</em></strong> = [<em>sign</em>] (<em>num-den-spec</em> | <em>float-spec</em>)<br>
+<em>sign</em> = "<strong>+</strong>" | "<strong>-</strong>"<br>
+<em>num-den-spec</em> = <em>digit-seq</em> "<strong>|</strong>" <em>digit-seq</em><br>
+<em>float-spec</em> = <em>dec-seq</em> "<strong>.</strong>" [<em>dec-seq</em>] "<strong>(</strong>" <em>dec-seq</em> "<strong>)</strong>"<br>
+<em>dec-seq</em> = <em>see-integer-literal-syntax</em><br>
+<em>digit-seq</em> = <em>see-integer-literal-syntax</em><br></p>
+</div>
+</div>
+</div>
 <div class="paragraph">
 <div class="title">Examples</div>
 <p><code>&gt;&gt;&gt;</code> <code class="blue">1 | 2</code><br>
@@ -828,8 +935,9 @@ pre.rouge .ss {
 <code class="green">1.5</code><br></p>
 </div>
 </div>
+</div>
 <div class="sect2">
-<h3 id="_strings"><a class="anchor" href="#_strings"></a><a class="link" href="#_strings">2.3. Strings</a></h3>
+<h3 id="_strings"><a class="anchor" href="#_strings"></a><a class="link" href="#_strings">2.2. Strings</a></h3>
 <div class="paragraph">
 <p>Strings are character sequences enclosed between two double quote <code class="blue">"</code>. Example: <code class="blue">"I&#8217;m a string"</code>.</p>
 </div>
@@ -837,7 +945,7 @@ pre.rouge .ss {
 <p>Some arithmetic operators can also be used with strings.</p>
 </div>
 <table class="tableblock frame-all grid-all stretch">
-<caption class="title">Table 2. String operators</caption>
+<caption class="title">Table 3. String operators</caption>
 <colgroup>
 <col style="width: 7.6923%;">
 <col style="width: 15.3846%;">
@@ -868,14 +976,36 @@ pre.rouge .ss {
 </tr>
 </tbody>
 </table>
+<div class="paragraph">
+<p>The items of strings can be accessed using the dot <code>.</code> operator.</p>
+</div>
+<div class="listingblock">
+<div class="title">Item access syntax</div>
+<div class="content">
+<pre class="rouge highlight"><code data-lang="bnf">&lt;item&gt; ::= &lt;string-expr&gt;"."&lt;index-expr&gt;</code></pre>
+</div>
+</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>
+<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 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 class="green">c</code><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>
+</div>
 </div>
 <div class="sect2">
-<h3 id="_boolean"><a class="anchor" href="#_boolean"></a><a class="link" href="#_boolean">2.4. Boolean</a></h3>
+<h3 id="_boolean"><a class="anchor" href="#_boolean"></a><a class="link" href="#_boolean">2.3. Boolean</a></h3>
 <div class="paragraph">
 <p>Boolean data type has two values only: <em>true</em> and <em>false</em>. Relational and Boolean expressions produce Boolean values.</p>
 </div>
 <table class="tableblock frame-all grid-all stretch">
-<caption class="title">Table 3. Relational operators</caption>
+<caption class="title">Table 4. Relational operators</caption>
 <colgroup>
 <col style="width: 7.6923%;">
 <col style="width: 15.3846%;">
@@ -936,7 +1066,7 @@ pre.rouge .ss {
 </tbody>
 </table>
 <table class="tableblock frame-all grid-all stretch">
-<caption class="title">Table 4. Boolean operators</caption>
+<caption class="title">Table 5. Boolean operators</caption>
 <colgroup>
 <col style="width: 15.3846%;">
 <col style="width: 15.3846%;">
@@ -1005,7 +1135,7 @@ pre.rouge .ss {
 </div>
 </div>
 <div class="sect2">
-<h3 id="_lists"><a class="anchor" href="#_lists"></a><a class="link" href="#_lists">2.5. Lists</a></h3>
+<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>
 </div>
@@ -1020,7 +1150,7 @@ pre.rouge .ss {
 </div>
 </div>
 <table class="tableblock frame-all grid-all stretch">
-<caption class="title">Table 5. List operators</caption>
+<caption class="title">Table 6. List operators</caption>
 <colgroup>
 <col style="width: 15.3846%;">
 <col style="width: 15.3846%;">
@@ -1059,23 +1189,22 @@ pre.rouge .ss {
 <pre class="rouge highlight"><code data-lang="bnf">&lt;item&gt; ::= &lt;list-expr&gt;"."&lt;index-expr&gt;</code></pre>
 </div>
 </div>
-<div class="listingblock">
+<div class="paragraph">
 <div class="title">Items of list</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,2,3].1`</span>
-<span class="p">[</span><span class="n">green</span><span class="p">]</span><span class="s">`2`</span>
-<span class="s">`&gt;&gt;&gt;`</span> <span class="p">[</span><span class="n">blue</span><span class="p">]</span><span class="s">`list=[1,2,3]; list.1`</span>
-<span class="p">[</span><span class="n">green</span><span class="p">]</span><span class="s">`2`</span>
-<span class="s">`&gt;&gt;&gt;`</span> <span class="p">[</span><span class="n">blue</span><span class="p">]</span><span class="s">`["one","two","three"].1`</span>
-<span class="p">[</span><span class="n">green</span><span class="p">]</span><span class="s">`two`</span>
-<span class="s">`&gt;&gt;&gt;`</span> <span class="p">[</span><span class="n">blue</span><span class="p">]</span><span class="s">`list=["one","two","three"]; list.(2-1)`</span>
-<span class="p">[</span><span class="n">green</span><span class="p">]</span><span class="s">`two`</span>
-<span class="s">`&gt;&gt;&gt;`</span> <span class="p">[</span><span class="n">blue</span><span class="p">]</span><span class="s">`list.(-1)`</span>
-<span class="p">[</span><span class="n">green</span><span class="p">]</span><span class="s">`three`</span>
-<span class="s">`&gt;&gt;&gt;`</span> <span class="p">[</span><span class="n">blue</span><span class="p">]</span><span class="s">`list.(-1)`</span>
-<span class="p">[</span><span class="n">green</span><span class="p">]</span><span class="s">`three`</span>
-<span class="s">`&gt;&gt;&gt;`</span> <span class="p">[</span><span class="n">blue</span><span class="p">]</span><span class="s">`list.(10)`</span></code></pre>
-</div>
+<p><code>&gt;&gt;&gt;</code> <code class="blue">[1,2,3].1</code><br>
+<code class="green">2</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">list=[1,2,3]; list.1</code><br>
+<code class="green">2</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">["one","two","three"].1</code><br>
+<code class="green">two</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">list=["one","two","three"]; list.(2-1)</code><br>
+<code class="green">two</code><br>
+<code>&gt;&gt;&gt;</code> <code class="blue">list.(-1)</code><br>
+<code class="green">three</code><br>
+<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>
 </div>
 </div>
 </div>
@@ -1087,7 +1216,7 @@ pre.rouge .ss {
 <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>
 </div>
 <div class="listingblock">
-<div class="title">List examples</div>
+<div class="title">Dictionary examples</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>
@@ -1112,7 +1241,7 @@ Support for dictionaries is still ongoing.
 <h2 id="_variables"><a class="anchor" href="#_variables"></a><a class="link" href="#_variables">4. 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 <em>ExprContext</em> interface.</p>
+<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>
 </div>
 <div class="listingblock">
 <div class="title">Examples</div>
@@ -1202,7 +1331,7 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 </div>
 </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 find 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 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>
 </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>
@@ -1213,13 +1342,21 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 <div class="listingblock">
 <div class="title">Examples</div>
 <div class="content">
-<pre class="rouge highlight"><code data-lang="go"><span class="m">1</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="c">// returns "b"</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="o">::</span> <span class="p">{</span><span class="s">"c"</span><span class="p">}</span>                 <span class="c">// returns "c"</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="c">// returns "b"</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="c">// error:  "... case list in default clause"</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="c">// returns "b"</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="c">// returns "b"</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="c">// error:  "... no case catches the value (10) of the selection expression</span></code></pre>
+<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>
 </div>
 </div>
 </div>
@@ -1232,7 +1369,7 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 <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 6. Operators priorities</caption>
+<caption class="title">Table 7. Operators priorities</caption>
 <colgroup>
 <col style="width: 12.5%;">
 <col style="width: 12.5%;">
@@ -1490,7 +1627,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-10 06:38:03 +0200
+Last updated 2024-05-15 22:00:00 +0200
 </div>
 </div>
 </body>

func-base.go

@@ -10,11 +10,7 @@ import (
 )
 
 func isNilFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	if len(args) == 1 {
 	result = args[0] == nil
-	} else {
-		err = errOneParam(name)
-	}
 	return
 }
 
@@ -43,6 +39,11 @@ func isFractionFunc(ctx ExprContext, name string, args []any) (result any, err e
 	return
 }
 
+func isRationalFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+	result = IsRational(args[0])
+	return
+}
+
 func isListFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	result = IsList(args[0])
 	return
@@ -53,9 +54,7 @@ func isDictionaryFunc(ctx ExprContext, name string, args []any) (result any, err
 	return
 }
 
-
 func intFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	if len(args) == 1 {
 	switch v := args[0].(type) {
 	case int64:
 		result = v
@@ -75,8 +74,77 @@ func intFunc(ctx ExprContext, name string, args []any) (result any, err error) {
 	default:
 		err = errCantConvert(name, v, "int")
 	}
+	return
+}
+
+func decFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+	switch v := args[0].(type) {
+	case int64:
+		result = float64(v)
+	case float64:
+		result = v
+	case bool:
+		if v {
+			result = float64(1)
 		} else {
-		err = errOneParam(name)
+			result = float64(0)
+		}
+	case string:
+		var f float64
+		if f, err = strconv.ParseFloat(v, 64); err == nil {
+			result = f
+		}
+	case *fraction:
+		result = v.toFloat()
+	default:
+		err = errCantConvert(name, v, "float")
+	}
+	return
+}
+
+func fractFunc(ctx ExprContext, name string, args []any) (result any, err error) {
+	switch v := args[0].(type) {
+	case int64:
+		var den int64 = 1
+		if len(args) > 1 {
+			var ok bool
+			if den, ok = args[1].(int64); !ok {
+				err = errExpectedGot(name, "integer", args[1])
+			} else if den == 0 {
+				err = errDivisionByZero(name)
+			}
+		}
+		if err == nil {
+			result = newFraction(v, den)
+		}
+	case float64:
+		result, err = float64ToFraction(v)
+		// var n, d int64
+		// if n, d, err = float64ToFraction(v); err == nil {
+		//	result = newFraction(n, d)
+		// }
+	case bool:
+		if v {
+			result = newFraction(1, 1)
+		} else {
+			result = newFraction(0, 1)
+		}
+	case string:
+		result, err = makeGeneratingFraction(v)
+		// var f float64
+		// // TODO temporary implementation
+		// if f, err = strconv.ParseFloat(v, 64); err == nil {
+		// 	var n, d int64
+		// 	if n, d, err = float64ToFraction(f); err == nil {
+		// 		result = newFraction(n, d)
+		// 	}
+		// } else {
+		// 	errors.New("convertion from string to float is ongoing")
+		// }
+	case *fraction:
+		result = v
+	default:
+		err = errCantConvert(name, v, "float")
 	}
 	return
 }
@@ -93,10 +161,13 @@ func ImportBuiltinsFuncs(ctx ExprContext) {
 	ctx.RegisterFunc("isString", &simpleFunctor{f: isStringFunc}, 1, 1)
 	ctx.RegisterFunc("isFraction", &simpleFunctor{f: isFractionFunc}, 1, 1)
 	ctx.RegisterFunc("isFract", &simpleFunctor{f: isFractionFunc}, 1, 1)
+	ctx.RegisterFunc("isRational", &simpleFunctor{f: isRationalFunc}, 1, 1)
 	ctx.RegisterFunc("isList", &simpleFunctor{f: isListFunc}, 1, 1)
 	ctx.RegisterFunc("isDictionary", &simpleFunctor{f: isDictionaryFunc}, 1, 1)
 	ctx.RegisterFunc("isDict", &simpleFunctor{f: isDictionaryFunc}, 1, 1)
 	ctx.RegisterFunc("int", &simpleFunctor{f: intFunc}, 1, 1)
+	ctx.RegisterFunc("dec", &simpleFunctor{f: decFunc}, 1, 1)
+	ctx.RegisterFunc("fract", &simpleFunctor{f: fractFunc}, 1, 2)
 }
 
 func init() {

func-string.go

@@ -33,9 +33,9 @@ func doJoinStr(funcName string, sep string, it Iterator) (result any, err error)
 }
 
 func joinStrFunc(ctx ExprContext, name string, args []any) (result any, err error) {
-	if len(args) < 1 {
-		return nil, errMissingRequiredParameter(name, paramSeparator)
-	}
+//	if len(args) < 1 {
+//		return nil, errMissingRequiredParameter(name, paramSeparator)
+//	}
 	if sep, ok := args[0].(string); ok {
 		if len(args) == 1 {
 			result = ""
@@ -62,9 +62,9 @@ func subStrFunc(ctx ExprContext, name string, args []any) (result any, err error
 	var source string
 	var ok bool
 
-	if len(args) < 1 {
-		return nil, errMissingRequiredParameter(name, paramSource)
-	}
+//	if len(args) < 1 {
+//		return nil, errMissingRequiredParameter(name, paramSource)
+//	}
 	if source, ok = args[0].(string); !ok {
 		return nil, errWrongParamType(name, paramSource, typeString, args[0])
 	}
@@ -93,9 +93,9 @@ func trimStrFunc(ctx ExprContext, name string, args []any) (result any, err erro
 	var source string
 	var ok bool
 
-	if len(args) < 1 {
-		return nil, errMissingRequiredParameter(name, paramSource)
-	}
+//	if len(args) < 1 {
+//		return nil, errMissingRequiredParameter(name, paramSource)
+//	}
 	if source, ok = args[0].(string); !ok {
 		return nil, errWrongParamType(name, paramSource, typeString, args[0])
 	}
@@ -108,9 +108,9 @@ func startsWithStrFunc(ctx ExprContext, name string, args []any) (result any, er
 	var ok bool
 
 	result = false
-	if len(args) < 1 {
-		return result, errMissingRequiredParameter(name, paramSource)
-	}
+//	if len(args) < 1 {
+//		return result, errMissingRequiredParameter(name, paramSource)
+//	}
 	if source, ok = args[0].(string); !ok {
 		return result, errWrongParamType(name, paramSource, typeString, args[0])
 	}
@@ -133,9 +133,9 @@ func endsWithStrFunc(ctx ExprContext, name string, args []any) (result any, err
 	var ok bool
 
 	result = false
-	if len(args) < 1 {
-		return result, errMissingRequiredParameter(name, paramSource)
-	}
+//	if len(args) < 1 {
+//		return result, errMissingRequiredParameter(name, paramSource)
+//	}
 	if source, ok = args[0].(string); !ok {
 		return result, errWrongParamType(name, paramSource, typeString, args[0])
 	}
@@ -159,9 +159,9 @@ func splitStrFunc(ctx ExprContext, name string, args []any) (result any, err err
 	var parts []string
 	var ok bool
 
-	if len(args) < 1 {
-		return result, errMissingRequiredParameter(name, paramSource)
-	}
+//	if len(args) < 1 {
+//		return result, errMissingRequiredParameter(name, paramSource)
+//	}
 	if source, ok = args[0].(string); !ok {
 		return result, errWrongParamType(name, paramSource, typeString, args[0])
 	}

funcs_test.go

@@ -57,16 +57,33 @@ func TestFuncs(t *testing.T) {
 		/*  44 */ {`builtin "string"; splitStr("one-two-three", "-", )`, newListA("one", "two", "three"), nil},
 		/*  45 */ {`isInt(2+1)`, true, nil},
 		/*  46 */ {`isInt(3.1)`, false, nil},
-		/*  46 */ {`isFloat(3.1)`, true, nil},
-		/*  47 */ {`isString("3.1")`, true, nil},
-		/*  48 */ {`isString("3" + 1)`, true, nil},
-		/*  49 */ {`isList(["3",  1])`, true, nil},
-		/*  50 */ {`isDict({"a":"3",  "b":1})`, true, nil},
-		/*  51 */ {`isFract(3|1)`, true, nil},
+		/*  47 */ {`isFloat(3.1)`, true, nil},
+		/*  48 */ {`isString("3.1")`, true, nil},
+		/*  49 */ {`isString("3" + 1)`, true, nil},
+		/*  50 */ {`isList(["3",  1])`, true, nil},
+		/*  51 */ {`isDict({"a":"3",  "b":1})`, true, nil},
+		/*  52 */ {`isFract(1|3)`, true, nil},
+		/*  53 */ {`isFract(3|1)`, false, nil},
+		/*  54 */ {`isRational(3|1)`, true, nil},
+		/*  55 */ {`builtin "math.arith"; add(1,2)`, int64(3), nil},
+		/*  56 */ {`fract("2.2(3)")`, newFraction(67, 30), nil},
+		/*  57 */ {`fract("1.21(3)")`, newFraction(91, 75), nil},
+		/*  58 */ {`fract(1.21(3))`, newFraction(91, 75), nil},
+		/*  59 */ {`fract(1.21)`, newFraction(121, 100), nil},
+		/*  60 */ {`dec(2)`, float64(2), nil},
+		/*  61 */ {`dec(2.0)`, float64(2), nil},
+		/*  62 */ {`dec("2.0")`, float64(2), nil},
+		/*  63 */ {`dec(true)`, float64(1), nil},
+		/*  64 */ {`dec(true")`, nil, errors.New("[1:11] missing string termination \"")},
+		/*  65 */ {`builtin "string"; joinStr("-", [1, "two", "three"])`, nil, errors.New(`joinStr() expected string, got int64 (1)`)},
+		/*  65 */ {`dec()`, nil, errors.New(`too few params -- expected 1, got 0`)},
+		/*  66 */ {`dec(1,2,3)`, nil, errors.New(`too much params -- expected 1, got 3`)},
+		/*  67 */ {`builtin "string"; joinStr()`, nil, errors.New(`too few params -- expected 1 or more, got 0`)},
+		// /*  64 */ {`string(true)`, "true", nil},
 	}
 
 	t.Setenv("EXPR_PATH", ".")
 
-	// parserTest(t, "Func", inputs[25:26])
+	//parserTest(t, "Func", inputs[54:55])
 	parserTest(t, "Func", inputs)
 }

global-context.go

@@ -0,0 +1,54 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// global-context.go
+package expr
+
+import "path/filepath"
+
+var globalCtx *SimpleFuncStore
+
+func ImportInContext(name string) (exists bool) {
+	var mod *module
+	if mod, exists = moduleRegister[name]; exists {
+		mod.importFunc(globalCtx)
+		mod.imported = true
+	}
+	return
+}
+
+func ImportInContextByGlobPattern(pattern string) (count int, err error) {
+	var matched bool
+	for name, mod := range moduleRegister {
+		if matched, err = filepath.Match(pattern, name); err == nil {
+			if matched {
+				count++
+				mod.importFunc(globalCtx)
+				mod.imported = true
+			}
+		} else {
+			break
+		}
+	}
+	return
+}
+
+func GetVar(ctx ExprContext, name string) (value any, exists bool) {
+	if value, exists = ctx.GetVar(name); !exists {
+		value, exists = globalCtx.GetVar(name)
+	}
+	return
+}
+
+func GetFuncInfo(ctx ExprContext, name string) (item ExprFunc, exists bool, ownerCtx ExprContext) {
+	if item, exists = ctx.GetFuncInfo(name); exists {
+		ownerCtx = ctx
+	} else if item, exists = globalCtx.GetFuncInfo(name); exists {
+		ownerCtx = globalCtx
+	}
+	return
+}
+
+func init() {
+	globalCtx = NewSimpleFuncStore()
+}

list_test.go

@@ -39,6 +39,7 @@ func TestListParser(t *testing.T) {
 		/*  17 */ {`list=["one","two","three"]; list.10`, nil, errors.New(`[1:36] index 10 out of bounds`)},
 		/*  18 */ {`["a", "b", "c"]`, newListA("a", "b", "c"), nil},
 		/*  19 */ {`["a", "b", "c"]`, newList([]any{"a", "b", "c"}), nil},
+		/*  20 */ {`#["a", "b", "c"]`, int64(3), nil},
 
 		// /*  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},

module-register.go

@@ -6,7 +6,6 @@ package expr
 
 import (
 	"fmt"
-	"path/filepath"
 )
 
 type module struct {
@@ -31,30 +30,30 @@ func registerImport(name string, importFunc func(ExprContext), description strin
 	moduleRegister[name] = newModule(importFunc, description)
 }
 
-func ImportInContext(ctx ExprContext, name string) (exists bool) {
-	var mod *module
-	if mod, exists = moduleRegister[name]; exists {
-		mod.importFunc(ctx)
-		mod.imported = true
-	}
-	return
-}
+// func ImportInContext(ctx ExprContext, name string) (exists bool) {
+// 	var mod *module
+// 	if mod, exists = moduleRegister[name]; exists {
+// 		mod.importFunc(ctx)
+// 		mod.imported = true
+// 	}
+// 	return
+// }
 
-func ImportInContextByGlobPattern(ctx ExprContext, pattern string) (count int, err error) {
-	var matched bool
-	for name, mod := range moduleRegister {
-		if matched, err = filepath.Match(pattern, name); err == nil {
-			if matched {
-				count++
-				mod.importFunc(ctx)
-				mod.imported = true
-			}
-		} else {
-			break
-		}
-	}
-	return
-}
+// func ImportInContextByGlobPattern(ctx ExprContext, pattern string) (count int, err error) {
+// 	var matched bool
+// 	for name, mod := range moduleRegister {
+// 		if matched, err = filepath.Match(pattern, name); err == nil {
+// 			if matched {
+// 				count++
+// 				mod.importFunc(ctx)
+// 				mod.imported = true
+// 			}
+// 		} else {
+// 			break
+// 		}
+// 	}
+// 	return
+// }
 
 func IterateModules(op func(name, description string, imported bool) bool) {
 	if op != nil {

operand-const.go

@@ -1,32 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operand-const.go
-package expr
-
-// -------- const term
-func newConstTerm(tk *Token) *term {
-	return &term{
-		tk:       *tk,
-		parent:   nil,
-		children: nil,
-		position: posLeaf,
-		priority: priValue,
-		evalFunc: evalConst,
-	}
-}
-
-// -------- eval func
-func evalConst(ctx ExprContext, self *term) (v any, err error) {
-	v = self.tk.Value
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymString, newConstTerm)
-	registerTermConstructor(SymInteger, newConstTerm)
-	registerTermConstructor(SymFloat, newConstTerm)
-	registerTermConstructor(SymBool, newConstTerm)
-	registerTermConstructor(SymKwNil, newConstTerm)
-}

operand-func.go

@@ -23,16 +23,15 @@ func newFuncCallTerm(tk *Token, args []*term) *term {
 
 // -------- eval func call
 func checkFunctionCall(ctx ExprContext, name string, params []any) (err error) {
-	if info, exists := ctx.GetFuncInfo(name); exists {
+	if info, exists, owner := GetFuncInfo(ctx, name); exists {
 		if info.MinArgs() > len(params) {
-			if info.MaxArgs() < 0 {
-				err = fmt.Errorf("too few params -- expected %d or more, got %d", info.MinArgs(), len(params))
-			} else {
-				err = fmt.Errorf("too few params -- expected %d, got %d", info.MinArgs(), len(params))
+			err = errTooFewParams(info.MinArgs(), info.MaxArgs(), len(params))
 		}
+		if err == nil && info.MaxArgs() >= 0 && info.MaxArgs() < len(params) {
+			err = errTooMuchParams(info.MaxArgs(), len(params))
 		}
-		if info.MaxArgs() >= 0 && info.MaxArgs() < len(params) {
-			err = fmt.Errorf("too much params -- expected %d, got %d", info.MaxArgs(), len(params))
+		if err == nil && owner != ctx {
+			ctx.RegisterFunc(name, info.Functor(), info.MinArgs(), info.MaxArgs())
 		}
 	} else {
 		err = fmt.Errorf("unknown function %s()", name)

operand-literal.go

@@ -0,0 +1,33 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operand-literal.go
+package expr
+
+// -------- literal term
+func newLiteralTerm(tk *Token) *term {
+	return &term{
+		tk:       *tk,
+		parent:   nil,
+		children: nil,
+		position: posLeaf,
+		priority: priValue,
+		evalFunc: evalLiteral,
+	}
+}
+
+// -------- eval func
+func evalLiteral(ctx ExprContext, self *term) (v any, err error) {
+	v = self.tk.Value
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymString, newLiteralTerm)
+	registerTermConstructor(SymInteger, newLiteralTerm)
+	registerTermConstructor(SymFloat, newLiteralTerm)
+	registerTermConstructor(SymFraction, newLiteralTerm)
+	registerTermConstructor(SymBool, newLiteralTerm)
+	registerTermConstructor(SymKwNil, newLiteralTerm)
+}

operand-var.go

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

operator-builtin.go

@@ -28,13 +28,13 @@ func evalBuiltin(ctx ExprContext, self *term) (v any, err error) {
 	count := 0
 	if IsString(childValue) {
 		module, _ := childValue.(string)
-		count, err = ImportInContextByGlobPattern(ctx, module)
+		count, err = ImportInContextByGlobPattern(module)
 	} else {
 		var moduleSpec any
 		it := NewAnyIterator(childValue)
 		for moduleSpec, err = it.Next(); err == nil; moduleSpec, err = it.Next() {
 			if module, ok := moduleSpec.(string); ok {
-				if ImportInContext(ctx, module) {
+				if ImportInContext(module) {
 					count++
 				} else {
 					err = self.Errorf("unknown module %q", module)

operator-fraction.go

@@ -7,6 +7,7 @@ package expr
 import (
 	"errors"
 	"fmt"
+	"math"
 	"strconv"
 	"strings"
 )
@@ -24,6 +25,137 @@ func newFraction(num, den int64) *fraction {
 	return &fraction{num, den}
 }
 
+func float64ToFraction(f float64) (fract *fraction, err error) {
+	var sign string
+	intPart, decPart := math.Modf(f)
+	if decPart < 0.0 {
+		sign = "-"
+		intPart = -intPart
+		decPart = -decPart
+	}
+	dec := fmt.Sprintf("%.12f", decPart)
+	s := fmt.Sprintf("%s%.f%s", sign, intPart, dec[1:])
+	// fmt.Printf("S: '%s'\n",s)
+	return makeGeneratingFraction(s)
+}
+
+// Based on https://cs.opensource.google/go/go/+/refs/tags/go1.22.3:src/math/big/rat.go;l=39
+/*
+func _float64ToFraction(f float64) (num, den int64, err error) {
+	const expMask = 1<<11 - 1
+	bits := math.Float64bits(f)
+	mantissa := bits & (1<<52 - 1)
+	exp := int((bits >> 52) & expMask)
+	switch exp {
+	case expMask: // non-finite
+		err = errors.New("infite")
+		return
+	case 0: // denormal
+		exp -= 1022
+	default: // normal
+		mantissa |= 1 << 52
+		exp -= 1023
+	}
+
+	shift := 52 - exp
+
+	// Optimization (?): partially pre-normalise.
+	for mantissa&1 == 0 && shift > 0 {
+		mantissa >>= 1
+		shift--
+	}
+
+	if f < 0 {
+		num = -int64(mantissa)
+	} else {
+		num = int64(mantissa)
+	}
+	den = int64(1)
+
+	if shift > 0 {
+		den = den << shift
+	} else {
+		num = num << (-shift)
+	}
+	return
+}
+*/
+
+func makeGeneratingFraction(s string) (f *fraction, err error) {
+	var num, den int64
+	var sign int64 = 1
+	var parts []string
+	if len(s) == 0 {
+		goto exit
+	}
+	if s[0] == '-' {
+		sign = int64(-1)
+		s = s[1:]
+	} else if s[0] == '+' {
+		s = s[1:]
+	}
+	if strings.HasSuffix(s, "()") {
+		s = s[0 : len(s)-2]
+	}
+	parts = strings.SplitN(s, ".", 2)
+	if num, err = strconv.ParseInt(parts[0], 10, 64); err != nil {
+		return
+	}
+	if len(parts) == 1 {
+		f = newFraction(sign*num, 1)
+	} else if len(parts) == 2 {
+		subParts := strings.SplitN(parts[1], "(", 2)
+		if len(subParts) == 1 {
+			den = 1
+			dec := parts[1]
+			lsd := len(dec)
+			for i := lsd - 1; i >= 0 && dec[i] == '0'; i-- {
+				lsd--
+			}
+			for _, c := range dec[0:lsd] {
+				if c < '0' || c > '9' {
+					return nil, errExpectedGot("fract", "digit", c)
+				}
+				num = num*10 + int64(c-'0')
+				den = den * 10
+			}
+			f = newFraction(sign*num, den)
+		} else if len(subParts) == 2 {
+			sub := num
+			mul := int64(1)
+			for _, c := range subParts[0] {
+				if c < '0' || c > '9' {
+					return nil, errExpectedGot("fract", "digit", c)
+				}
+				num = num*10 + int64(c-'0')
+				sub = sub*10 + int64(c-'0')
+				mul *= 10
+			}
+			if len(subParts) == 2 {
+				if s[len(s)-1] != ')' {
+					goto exit
+				}
+				p := subParts[1][0 : len(subParts[1])-1]
+				for _, c := range p {
+					if c < '0' || c > '9' {
+						return nil, errExpectedGot("fract", "digit", c)
+					}
+					num = num*10 + int64(c-'0')
+					den = den*10 + 9
+				}
+				den *= mul
+			}
+			num -= sub
+			f = newFraction(sign*num, den)
+		}
+	}
+exit:
+	if f == nil {
+		err = errors.New("bad syntax")
+	}
+	return
+}
+
 func (f *fraction) toFloat() float64 {
 	return float64(f.num) / float64(f.den)
 }
@@ -146,12 +278,12 @@ func lcm(a, b int64) (l int64) {
 
 func sumFract(f1, f2 *fraction) (sum *fraction) {
 	m := lcm(f1.den, f2.den)
-	sum = newFraction(f1.num*(m/f1.den) + f2.num*(m/f2.den), m)
+	sum = newFraction(f1.num*(m/f1.den)+f2.num*(m/f2.den), m)
 	return
 }
 
 func mulFract(f1, f2 *fraction) (prod *fraction) {
-	prod = newFraction(f1.num * f2.num, f1.den * f2.den)
+	prod = newFraction(f1.num*f2.num, f1.den*f2.den)
 	return
 }
 

operator-length.go

@@ -24,11 +24,14 @@ func evalLength(ctx ExprContext, self *term) (v any, err error) {
 	}
 
 	if IsList(childValue) {
-		list, _ := childValue.([]any)
-		v = int64(len(list))
+		ls, _ := childValue.(*ListType)
+		v = int64(len(*ls))
 	} else if IsString(childValue) {
 		s, _ := childValue.(string)
 		v = int64(len(s))
+	} else if IsDict(childValue) {
+		m, _ := childValue.(map[any]any)
+		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)

operator-sum.go

@@ -61,6 +61,14 @@ func evalPlus(ctx ExprContext, self *term) (v any, err error) {
 		} 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
+		}
+		v = c
 	} else {
 		err = self.errIncompatibleTypes(leftValue, rightValue)
 	}

parser.go

@@ -119,7 +119,7 @@ func (self *parser) parseFuncDef(scanner *scanner) (tree *term, err error) {
 	for lastSym != SymClosedRound && lastSym != SymEos {
 		tk = scanner.Next()
 		if tk.IsSymbol(SymIdentifier) {
-			param := newTerm(tk, nil)
+			param := newTerm(tk)
 			args = append(args, param)
 			tk = scanner.Next()
 		} else if itemExpected {

parser_test.go

@@ -158,6 +158,8 @@ func TestGeneralParser(t *testing.T) {
 		/* 137 */ {`builtin "os.file"`, int64(1), nil},
 		/* 138 */ {`v=10; v++; v`, int64(11), nil},
 		/* 139 */ {`1+1|2+0.5`, float64(2), nil},
+		/* 140 */ {`1.2()`, newFraction(6, 5), nil},
+		/* 141 */ {`1|(2-2)`, nil, errors.New(`division by zero`)},
 	}
 
 	// t.Setenv("EXPR_PATH", ".")

scanner.go

@@ -385,7 +385,8 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
 				}
 			}
 		}
-		if err == nil && (ch == 'e' || ch == 'E') {
+		if err == nil {
+			if ch == 'e' || ch == 'E' {
 				sym = SymFloat
 				sb.WriteByte(ch)
 				if ch, err = self.readChar(); err == nil {
@@ -398,7 +399,23 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
 							sb.WriteByte(ch)
 						}
 					} else {
-					err = errors.New("expected integer exponent")
+						err = fmt.Errorf("[%d:%d] expected integer exponent, got %c", self.row, self.column, ch)
+					}
+				}
+			} else if ch == '(' {
+				sym = SymFraction
+				sb.WriteByte(ch)
+				ch, err = self.readChar()
+				for ; err == nil && (ch >= '0' && ch <= '9'); ch, err = self.readChar() {
+					sb.WriteByte(ch)
+				}
+				if err == nil {
+					if ch != ')' {
+						err = fmt.Errorf("[%d:%d] expected ')', got '%c'", self.row, self.column, ch)
+					} else {
+						sb.WriteByte(ch)
+						_, err = self.readChar()
+					}
 				}
 			}
 		}
@@ -412,6 +429,8 @@ func (self *scanner) parseNumber(firstCh byte) (tk *Token) {
 		txt := sb.String()
 		if sym == SymFloat {
 			value, err = strconv.ParseFloat(txt, 64)
+		} else if sym == SymFraction {
+			value, err = makeGeneratingFraction(txt)
 		} else {
 			value, err = strconv.ParseInt(txt, numBase, 64)
 		}

scanner_test.go

@@ -7,6 +7,7 @@ package expr
 import (
 	"errors"
 	"fmt"
+	"reflect"
 	"strings"
 	"testing"
 )
@@ -55,15 +56,18 @@ func TestScanner(t *testing.T) {
 		/* 33 */ {`(`, SymOpenRound, nil, nil},
 		/* 34 */ {`)`, SymClosedRound, nil, nil},
 		/* 35 */ {`1E+2`, SymFloat, float64(100), nil},
-		/* 36 */ {`1E+x`, SymError, errors.New("expected integer exponent"), nil},
+		/* 36 */ {`1E+x`, SymError, errors.New("[1:5] expected integer exponent, got x"), nil},
 		/* 37 */ {`$`, SymDollar, nil, nil},
 		/* 38 */ {`\`, SymError, errors.New("incomplete escape sequence"), nil},
 		/* 39 */ {`"string"`, SymString, "string", nil},
-		/* 39 */ {`identifier`, SymIdentifier, "identifier", nil},
+		/* 40 */ {`identifier`, SymIdentifier, "identifier", nil},
+		/* 41 */ {`1.2(3)`, SymFraction, newFraction(37, 30), nil},
 	}
 
 	for i, input := range inputs {
-
+		// if i != 40 {
+		// 	continue
+		// }
 		if input.wantErr == nil {
 			t.Log(fmt.Sprintf("[+]Test nr %2d -- %q", i+1, input.source))
 		} else {
@@ -75,7 +79,8 @@ func TestScanner(t *testing.T) {
 
 		if tk := scanner.Next(); tk == nil {
 			t.Errorf("%d: %q -> got = (nil), want %v (value %v [%T])", i+1, input.source, input.wantSym, input.wantValue, input.wantValue)
-		} else if tk.Sym != input.wantSym || tk.Value != input.wantValue {
+			// } else if tk.Sym != input.wantSym || tk.Value != input.wantValue {
+		} else if tk.Sym != input.wantSym || !reflect.DeepEqual(tk.Value, input.wantValue) {
 			if tk.Sym == SymError && input.wantSym == tk.Sym {
 				if tkErr, tkOk := tk.Value.(error); tkOk {
 					if inputErr, inputOk := input.wantValue.(error); inputOk {
@@ -86,7 +91,7 @@ func TestScanner(t *testing.T) {
 					}
 				}
 			} else {
-				t.Errorf("%d: %q -> got = %v (value=%v [%T), want %v (value=%v [%T)", i+1,
+				t.Errorf("%d: %q -> got = %v (value=%v [%T]), want %v (value=%v [%T])", i+1,
 					input.source, tk.Sym, tk.Value, tk.Value, input.wantSym, input.wantValue, input.wantValue)
 			}
 		}

symbol.go

@@ -73,6 +73,7 @@ const (
 	SymBool
 	SymInteger
 	SymFloat
+	SymFraction
 	SymString
 	SymIterator
 	SymOr

term-constuctor-registry.go

@@ -17,11 +17,10 @@ func registerTermConstructor(sym Symbol, constructor termContructor) {
 	constructorRegistry[sym] = constructor
 }
 
-func newTerm(tk *Token, parent *term) (inst *term) {
+func newTerm(tk *Token) (inst *term) {
 	if constructorRegistry != nil {
 		if construct, exists := constructorRegistry[tk.Sym]; exists {
 			inst = construct(tk)
-			inst.setParent(parent)
 		}
 	}
 	return

utils.go

@@ -44,6 +44,13 @@ func IsFract(v any) (ok bool) {
 	return ok
 }
 
+func IsRational(v any) (ok bool) {
+	if _, ok = v.(*fraction); !ok {
+		_, ok = v.(int64)
+	}
+	return ok
+}
+
 func IsNumber(v any) (ok bool) {
 	return IsFloat(v) || IsInteger(v)
 }