Command-Line Options¶

-l / --load-file¶

Load definitions from the given file.

$cat name-of-file-to-load.egi x := 1$ egison -l name-of-file-to-load.egi
> x
1


-t / --test¶

Evaluate expressions in the given file.

$cat name-of-file-to-test.egi x := 1 x + 2 "This is the third line"$ egison -t name-of-file-to-test.egi
3
"This is the third line"


-e / --eval¶

Output the evaluation result of the given Egison expression.

$egison -e 'matchAll [1,2,3] as list something with$x ++ _ -> x'
[[], [1], [1, 2], [1, 2, 3]]


-c / --command¶

Execute the given expression, which should evaluate to an IO function.

$egison -c 'print (show 1)' 1  Display results in TSV¶ -T / --tsv¶ Output the evaluation result in the TSV form. When the evaluation result is a colleciton, each of its elements is printed in a single line. $ egison -T -e 'take 10 primes'
2
3
5
7
11
13
17
19
23
29


When the evaluation result is a collection of collections or a collection of tuples, the elements of the inner collections are separated by a tab.

$egison -T -e '[[1, 2, 3], [4, 5]]' 1 2 3 4 5$ egison -T -e '[(1, 2, 3), (4, 5, 6)]'
1       2       3
4       5       6


The following 3 options ( -s, -m and -f) allow you to work on the input in TSV format. Each line of the input is interpreted as a tuple.

-s / --substitute¶

Regard the input as a collection and apply the given function to it.

$seq 10 20 | egison -s '\matchAll as list integer with _ ++$x :: _ ++ #(x + 5) :: _ -> x'
10
11
12
13
14
15


-m / --map¶

Read the input line by line, apply the given function and print out the result. egison -m 'f' is equivalent to egison -s '\x -> map f x'.

2
3
5
7


-F / --field¶

You can specify how the TSV should be interepreted with this option.

For example, if you give -F 2c to the interpreter, all the elements from the 2nd row is packed up in a collection.

$seq 10 15 | egison -T -m '\x -> x :: pF x' 10 2 5 11 11 12 2 2 3 13 13 14 2 7 15 3 5$ seq 10 15 | egison -T -m '\x -> x :: pF x' | egison -F 2c -m '\x -> x'
(10, [2, 5])
(11, [11])
(12, [2, 2, 3])
(13, [13])
(14, [2, 7])
(15, [3, 5])


If you give -F 2,4c, elements in 2nd, 3rd and 4th column is packed in a collection.

$seq 10 20 | egison -T -m '\x -> x :: pF x' | egison -F 2,4c -m '\x -> x' (10, [2, 5]) (11, [11]) (12, [2, 2, 3]) (13, [13]) (14, [2, 7]) (15, [3, 5]) (16, [2, 2, 2], 2) (17, [17]) (18, [2, 3, 3]) (19, [19]) (20, [2, 2, 5])  If you replace the c with s, the elements are respectively interpreted as strings (i.e. surrounded with ""). For instance, if you give -F 2,2s, the elements in the 2nd column is stringified. $ seq 10 15 | egison -T -m '\x -> x :: pF x' | egison -F 2,2s -m '\x -> x'
(10, "2", 5)
(11, "11")
(12, "2", 2, 3)
(13, "13")
(14, "2", 7)
(15, "3", 5)


Likewise, giving -F 2,4s will stringify all the elements in the 2nd, 3rd and 4th columns.

-M / --math¶

Output the evaluation result in the specified format. The format can be chosen from latex, asciimath, mathematica and maxima.

$egison -M latex > x / y #latex|\frac{x}{y}|#  -S / --sexpr-syntax¶ Use the old S-expression syntax in REPL. $ egison -S
> (+ 1 2)
3


Note

When parsing programs in files, Egison switches the parser by the file extension. If the source file has extension .egi, it is interpreted in the new syntax, and if the source file has extension .segi, it is interpreted in the old (S-expression) syntax.

Warning

Since we are no longer taking care of the backward compatibility with the old syntax (before version 4.0.0), we recommend using the new syntax if possible.

As for Egison programs written in the old syntax, we have a tool to translate them in the new syntax. Please see Migration Guide for the New Syntax for details.