Expr

TODO

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 provides 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 take place.

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 can also be used with strings.

The items of strings can be accessed using the dot . operator.

>>> s="abc" assign the string to variable s
abc
>>> s.1 char at position 1 (starting from 0)
b
>>> s.(-1) char at position -1, the rightmost one
c
>>> #s number of chars
3
>>> #"abc" number of chars
3

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

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"]]

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

>>> [1,2,3].1
2
>>> list=[1,2,3]; list.1
2
>>> ["one","two","three"].1
two
>>> list=["one","two","three"]; list.(2-1)
two
>>> list.(-1)
three
>>> list.(10)
Eval Error: [1:9] index 10 out of bounds
>>> #list
3

The dictionary, or dict, 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.

>>> {1:"one", 2:"two"}
>>> {"one":1, "two": 2}
>>> {"sum":1+2+3, "prod":1*2*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 expressione 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 automatica 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. Examples: 5 but 2 returns 2, x=2*3 but x-1 returns 5.

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

The assignment operator = is used to define variables in the evaluation context or to change their value (see ExprContext). The value on the left side of = must be an identifier. The value on the right side can be any expression and it becomes the result of the assignment operation.

>>> a=15+1 16

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

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 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'
[green]>>>` 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 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.

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

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

>>> var ?? (1+2)’ [green]`3
>>> var
Eval Error: undefined variable or function "var"
>>> var ?= (1+2)
3
>>> var
3

TODO: function calls operations

TODO: function definitions operations

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