Expr

Expressions are texts containing sequences of operations represented by a syntax very similar to that of most programming languages. Expr package provides these macro functions:

Before we begin to describe the syntax of Expr, it is worth introducing dev-expr because it will be used to show many examples of expressions.

dev-expr is a simple program that can be used to evaluate expressions interactively. As its name suggests, it was created for testing purpose. In fact, in additon to the automatic verification test suite based on the Go test framework, dev-expr provided an important aid for quickly testing of new features during their development.

dev-expr can work as a REPL, Read-Execute-Print-Loop, or it can process expression acquired from files or standard input.

The program can be downloaded from dev-expr.

Here are some examples of execution.

Expr supports three type of numbers:

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

Strings are character sequences enclosed between two double quote ".

>>> "I’m a string"
I’m a string

>>> "123abc?!"
123abc?!

>>> "123\nabc"
123
abc

>>> "123\tabc"
123    abc

Some arithmetic operators also apply to strings.

The charanters in a string can be accessed using the square [] operator.

>>> s="abcd" // assign the string to variable s
"abcd"

>>> s[1] // char at position 1 (starting from 0)
"b"

>>> s[-1] // char at position -1, the rightmost one
"d"

>>> #s // number of chars
4

>>> #"abc" // number of chars
3

>>> s[1:3] // chars from position 1 to position 3 excluded
"bc"

Boolean data type has two values only: true and false. Relational and boolean expressions result in boolean values.

^(*) See also the in operator in the list and dictionary sections.

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

>>> [1,2,3] // List of integers
[1, 2, 3]

>>> ["one", "two", "three"] // List of strings
["one", "two", "three"]

>>> ["one", 2, false, 4.1] // List of mixed-types
["one", 2, false, 4.1]

>>> ["one"+1, 2.0*(9-2)] // List of expressions
["one1", 14]

>>> [ [1,"one"], [2,"two"]] // List of lists
[[1, "one"], [2, "two"]]

Array’s items can be accessed using the index [] operator.

>>> [1,2,3][1]
2

>>> index=2; ["a", "b", "c", "d"][index]
c

>>> ["a", "b", "c", "d"][2:]
["c", "d"]

>>> list=[1,2,3]; list[1]
2

>>> ["one","two","three"][1]
two

>>> list=["one","two","three"]; list[2-1]
two

>>> list[1]="six"; list
["one", "six", "three"]

>>> list[-1]
three

>>> list[10]
Eval Error: [1:9] index 10 out of bounds

>>> #list
3

>>> "first" >> list
["first", "one", "six", "three"]

>>> list << "last"
["first", "one", "six", "three", "last"]

>>> "six" in list
true

>>> "ten" in list
false

>>> [1,2,3] + ["one", "two", "three"]
[1, 2, 3, "one", "two", "three"]

>>> [1,2,3,4] - [2,4]
[1, 3]

The dictionary, or dict, data-type represents sets of pairs key/value. It is also known as map or associative array.

Dictionary literals are sequences of pairs separated by comma , enclosed between brace brackets.

>>> {1:"one", 2:"two"}
{1: "one", 2: "two"}

>>> {"one":1, "two": 2}
{"one": 1, "two": 2}

>>> {"sum":1+2+3, "prod":1*2*3}
{"sum": 6, "prod": 6}

>>> {"one":1, "two":2}["two"]
2

>>> d={"one":1, "two":2}; d["six"]=6; d
{"two": 2, "one": 1, "six": 6}

>>> #d
3

The semicolon operator ; is an infixed pseudo-operator. It evaluates the left expression first and then the right expression. The value of the latter is the final result.

An expression that contains ; is called a multi-expression and each component expression is called a sub-expression.

>>> a=1; b=2; c=3; a+b+c
6

The value of each sub-expression is stored in the automatic variable last.

>>> 2+3; b=last+10; last
15

but is an infixed operator. Its operands can be expressions of any type. It evaluates the left expression first, then the right expression. The value of the right expression is the final result.

>>> 5 but 2
2

>>> x=2*3 but x-1
5.

but behavior is very similar to ;. The only difference is that ; is not a true operator and can’t be used inside parenthesis ( and ).

The assignment operator = is used to define variables or to change their value in the evaluation context (see ExprContext).

The value on the left side of = must be a variable identifier or an expression that evalutes to a variable. The value on the right side can be any expression and it becomes the result of the assignment operation.

>>> a=15+1
16

>>> L=[1,2,3]; L[1]=5; L
[1, 5, 3]

The selector operator is very similar to the switch/case/default statement available in many programming languages.

In other words, the selector operator evaluates the 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, 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 : 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.

>>> 1 ? {"a"} : {"b"}
b

>>> 10 ? {"a"} : {"b"} :: {"c"}
c

>>> 10 ? {"a"} :[true, 2+8] {"b"} :: {"c"}
b

>>> 10 ? {"a"} :[true, 2+8] {"b"} :: [10] {"c"}
Parse Error: [1:34] case list in default clause

>>> 10 ? {"a"} :[10] {x="b" but x} :: {"c"}
b

>>> 10 ? {"a"} :[10] {x="b"; x} :: {"c"}
b

>>> 10 ? {"a"} : {"b"}
Eval Error: [1:3] no case catches the value (10) of the selection expression

The left operand of first two operators, ?? and ?=, must be a variable. The right operator can be any expression. They return the value of the variable if this is defined; otherwise they return the value of the right expression.

The ?? operator do not change the status of the left variable.

The ?= assigns the calculated value of the right expression to the left variable.

The third one, ?!, is the alternate operator. If the variable on the left size is not defined, it returns nil. Otherwise it returns the result of the expressione on the right side.

>>> var ?? (1+2)
3

>>> var
Eval Error: undefined variable or function "var"

>>> var ?= (1+2)
3

>>> var
3

>>> x ?! 5
nil

>>> x=1; x ?! 5
5

>>> y ?! (c=5); c
Eval Error: undefined variable or function "c"

A function is identified and referenced by its name. It can have zero or more parameter. Expr functions also support optional parameters and passing paramters by name.

>>> // A simple function: it takes two parameters and returns their "sum"^(*)
>>> sum = func(a, b){ a + b }
sum(a, b):any{}

^(*) Since the plus, *+*, operator is defined for multiple data-types, the sum() function can be used for any pair of that types.

>>> // A more complex example: recursive calculation of the n-th value of Fibonacci’s sequence
>>> fib = func(n){ n ? [0] {0}: [1] {1} :: {fib(n-1)+fib(n-2)} }
fib(n):any{}

>>> // Same function fib() but entered by splitting it over mulple text lines
>>> fib = func(n){ \
...   n ? \
...     [0] {0} : \
...     [1] {1} :: \
...     { \
...       fib(n-1) + fib(n-2) \
...     } \
... }
fib(n):any{}

>>> // Required and optional parameters
>>> measure = func(value, unit="meter"){ value + " " + unit + (value > 1) ? [true] {"s"} :: {""}}
measure(value, unit="meter"):any{}

Description of how to define Golan functions and how to bind them to Expr are topics treated in another document that I’ll write, one day, maybe.

To call a function, either Expr or Golang type, it is necessary to specify its name and, at least, its required parameters.

>>> // sum of two integers
>>> sum(-6, 2)
-4
>>> // same as above but passing the parameters by name
>>> sum(a=-6, b=2)
-4
>>> // again, but swapping parameter positions (see the diff() examples below)
>>> sum(b=2, a=-6)
-4
>>> // sum of a fraction and an integer
>>> sum(3|2, 2)
7|2
>>> // sum of two strings
>>> sum("bye", "-bye")
"bye-bye"
>>> // sum of two lists
>>> sum(["one", 1], ["two", 2])
["one", 1, "two", 2]

>>> // diff(a,b) calculates a-b
>>> diff = func(a,b){a-b}
diff(a, b):any{}
>>> // simple invocation
>>> diff(10,8)
2
>>> // swapped parameters passed by name
>>> diff(b=8,a=10)
2

>>> // Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, …​
>>> fib(6)
8
>>> fib(9)
34

>>> // simple call
>>> measure(10,"litre")
"10 litres"
>>> // accept the default unit
>>> measure(8)
"8 meters"
>>> // without the required parameter 'value'
>>> measure(unit="degrees"))
Eval Error: measure(): missing params — value

>>> factory = func(n=2){ func(x){x*n} }
factory(n=2):any{}
>>> double = factory()
double(x):any{}
>>> triple = factory(3)
triple(x):any{}
>>> double(5)
10
>>> triple(5)
15

Functions compute values in a local context (scope) that do not make effects on the calling context. This is the normal behavior. Using the clone modifier @ it is possibile to export local definition to the calling context. The clone modifier must be used as prefix to variable names and it is part of the name. E.g. @x is not the same as x; they are two different and un related variables.

Clone variables are normal local variables. The only diffence will appear when the defining function terminate, just before the destruction of its local context. At that point, all local clone variables are cloned in the calling context with the same names but the @ symbol.

>>> f = func() { @x = 3; x = 5 } // f() declares two different local variables: @x and x
f():any{}
>>> f() // The multi-expression (two) in f() is calculated and the last result is returned
5
>>> x // The x variable was not defined in the main context before the f() invocation. It appears in the main context by cloning the @x variable, local to f() after its termnation.
3

import(<source-file>) loads the multi-expression contained in the specified source and returns its value.