Doc: updated last change date and time

doc/Expr.adoc

@@ -22,7 +22,7 @@ Expressions calculator
 
 toc::[]
 
-#TODO: Work in progress (last update on 2024/05/17, 7:30 a.m.)#
+#TODO: Work in progress (last update on 2024/05/17, 15:47 p.m.)#
 
 == Expr
 _Expr_ is a GO package capable of analysing, interpreting and calculating expressions.
@@ -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
@@ -241,7 +241,7 @@ Fractions can be used together with integers and floats in expressions.
 `>>>` [blue]`4 - 1|2` +
 [green]`7|2` +
 `>>>` [blue]`1.0 + 1|2` +
-[green]`1.5` +
+[green]`1.5`
 
 
 
@@ -289,7 +289,8 @@ _item_ = _string-expr_ "**.**" _integer-expr_
 `>>>` [blue]`\#s`       [gray]_number of chars_ +
 [gren]`3` +
 `>>>` [blue]`#"abc"`   [gray]_number of chars_ +
-[green]`3` +
+[green]`3`
+
 
 === Booleans
 Boolean data type has two values only: [blue]_true_ and [blue]_false_. Relational and boolean expressions result in boolean values.
@@ -475,50 +476,65 @@ The assignment operator [blue]`=` is used to define variables in the evaluation
 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.

doc/Expr.html

@@ -561,6 +561,7 @@ pre.rouge .ss {
 <li><a href="#_but_operator">4.2. <code class="blue">but</code> operator</a></li>
 <li><a href="#_assignment_operator">4.3. Assignment operator <code class="blue">=</code></a></li>
 <li><a href="#_selector_operator">4.4. Selector operator <code class="blue">? : ::</code></a></li>
+<li><a href="#_variable_default_value_and">4.5. Variable default value <code class="blue">??</code> and <code class="blue">?=</code></a></li>
 </ul>
 </li>
 <li><a href="#_priorities_of_operators">5. Priorities of operators</a></li>
@@ -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/17, 7:30 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>
@@ -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>
@@ -953,7 +954,7 @@ pre.rouge .ss {
 <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>
@@ -1031,7 +1032,7 @@ pre.rouge .ss {
 <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 class="green">3</code></p>
 </div>
 </div>
 <div class="sect2">
@@ -1404,11 +1405,10 @@ Technically <code class="blue">;</code> is not treated as a real operator. It ac
 <p>The assignment operator <code class="blue">=</code> is used to define variables 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="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">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">a=15+1</code>
+<code class="green">16</code></p>
 </div>
 </div>
 <div class="sect2">
@@ -1416,46 +1416,89 @@ The value on the left side of <code class="blue">=</code> must be an identifier.
 <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>
@@ -1724,7 +1767,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-17 07:30:14 +0200
+Last updated 2024-05-17 15:47:29 +0200
 </div>
 </div>
 </body>