Evaluating Expressions

When called with --eval 'expr' or -e 'expr', it executes the Egison expression. A expression should be enclosed with single quotes (').

$ egison -e '(take 10 primes)'
{2 3 5 7 11 13 17 19 23 29}

Output in TSV Format

When called with --tsv or -T, it outputs in TSV format. Each element of the output collection is printed in a line.

$ egison -T -e '(take 10 primes)'
2
3
5
7
11
13
17
19
23
29

When the inner elements are collections, the elements of these collections are splitted by tab.

$ egison -T -e '(map p-f (between 100 110))'
2	2	5	5
101
2	3	17
103
2	2	2	13
3	5	7
2	53
107
2	2	3	3	3
109
2	5	11

When the inner elements are tuples, the elements of these tuples are also splitted by tab.

$ egison -T -e '(zip nats primes)' | head -n 10
1	2
2	3
3	5
4	7
5	11
6	13
7	17
8	19
9	23
10	29

Handling Input in TSV Format

When called with --map、--filter、--substitute, it parses input as TSV and treat them as a collection of tuples.
We explain these options in this section.

Applying a same operation to every line (--map option)

When called with --map 'expr' or -m 'expr', it applies the function specified by 'expr' to every line.

$ seq 100 110 | egison -T -m '(lambda [$x] [x (p-f x)])'
100	2	2	5	5
101	101
102	2	3	17
103	103
104	2	2	2	13
105	3	5	7
106	2	53
107	107
108	2	2	3	3	3
109	109
110	2	5	11

Extracting lines that satisfy the predicate (--filter option)

When called with --filter 'expr' or -f 'expr', it extracts lines that satisfy the predicate specified by 'expr'.

$ seq 1 20 | egison -f 'prime?'
2
3
5
7
11
13
17
19

Handling input as an infinite stream (--substitute option)

When called with --substitute 'expr' or -s 'expr', it treats whole input as an infinite stream and apply it to the function specified by 'expr'.
We enumerate twin primes to demonstrate this feature in the next section.

Enumerating twin primes on a shell

We can enumerate twin primes in command line using Egison commands.

$ seq 1 100 | egison -f 'prime?' | egison -T -s '(match-all-lambda (list integer) [<join _ <cons $p <cons ,(+ p 2) _>>> [p (+ p 2)]])'
3	5
5	7
11	13
17	19
29	31
41	43
59	61
71	73

We can enumerate twin primes in one Egison expression as follow.

$ egison -T -e '(match-all primes (list integer) [<join _ <cons $p <cons ,(+ p 2) _>>> [p (+ p 2)]])' | head -n 8
3	5
5	7
11	13
17	19
29	31
41	43
59	61
71	73

Advanced Options

We can specify how to parse each element in TSV by using --field or -F options.

When called with -F 2c as the following example, it treats the second element and after as one collection.

This option is designed referring the -k option of the sort command.
For example, when called with -F 2,4c, it encloses the second, third, and fourth elements with { and } and treats them as a collection.

$ seq 10 20 | egison -T -m '(lambda [$x] [x (p-f x)])' | egison -F 2c -m 'id'
[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}]

We can use s not only c. When called with -F 1,1s, the first element is enclosed with "" and we can parse it as a string.

Additionally, when called with -F 1,3s, the first, second, and third elements are enclosed with "".

$ seq 10 20 | egison -T -m '(lambda [$x] [x (p-f x)])' | egison -F 1,1s -F 2c -m 'id'
["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}]

What to do next...

Back to Home