The Egison Programming Language

Primitive Functions
Numbers	`+` `-` `*` `/` `numerator` `denominator` `modulo` `quotient` `remainder` `neg` `abs` `eq?` `lt?` `lte?` `gt?` `gte?`
Float numbers	`round` `floor` `ceiling` `truncate` `sqrt` `exp` `log` `sin` `cos` `tan` `asin` `acos` `atan` `sinh` `cosh` `tanh` `asinh` `acosh` `atanh` `itof` `rtof`
Strings	`pack` `unpack` `uncons-string` `length-string` `append-string` `split-string` `regex` `regex-cg` `read` `show`
Collections	`empty?` `uncons` `unsnoc`
Predicates	`bool?` `integer?` `rational?` `char?` `string?` `tuple?` `collection?` `hash?`

Primitive Functions with Side Effects
I/O	`open-input-file` `open-output-file` `close-input-port` `close-output-port` `read-char` `read-line` `write-char` `write-string` `write` `eof?` `flush` `read-char-from-port` `read-line-from-port` `write-char-to-port` `write-string-to-port` `write-to-port` `eof-port?` `flush-port`
Other	`return` `rand`

Primitive Functions

We give the list of primitive functions, here. It consists of numeric functions, boolean functions, string functions, and I/O functions. We don't describe precise behaviour of them, but give simply examples.

+: (+ 13 21);=>34 (+ 3.14159 2.71828);=>5.85987
-: (- 13 21);=>-8 (- 3.14159 2.71828);=>0.42330999999999985
*: (* 13 21);=>273 (* 3.14159 2.71828);=>8.539721265199999
/: (/ 13 21);=>13/21 (/ 3.14159 2.71828);=>1.1557271509925393
numerator: (numerator (/ 13 21));=>13
denominator: (denominator (/ 13 21));=>21
modulo: (modulo -21 13);=>5
quotient: (quotient -21 13);=>-1
remainder: (remainder -21 13);=>-8
neg: (neg -89);=>89
abs: (abs -89);=>89
eq?: (eq? 2 -5);=>#f (eq? 3.14159 2.71828);=>#f
lt?: (lt? 2 2);=>#f (lt? 2 -5);#f (lt? 3.14159 2.71828);=>#f
lte?: (lte? 2 2);=>#t (lte? 2 -5);=>#f (lte? 3.14159 2.71828);=>#f
gt?: (gt? 2 2);=>#f (gt? 2 -5);=>#t (gt? 3.14159 2.71828);=>#t
gte?: (gte? 2 2);=>#t (gte? 2 -5);=>#t (gte? 3.14159 2.71828);=>#t
round: (round 3.14159);=>3 (round -2.71828);=>-3
floor: (floor 3.14159);=>3 (floor -2.71828);=>-3
ceiling: (ceiling 3.14159);=>4 (ceiling -2.71828);=>-2
truncate: (truncate 3.14159);=>3 (truncate -2.71828);=>-2
sqrt: (sqrt 2.71828)
exp: (exp 2.71828)
log: (log 2.71828)
sin: (sin 2.71828)
cos: (cos 2.71828)
tan: (tan 2.71828)
asin: (asin 0.41078)
acos: (acos 0.41078)
atan: (atan 0.41078)
sinh: (sinh 2.71828)
cosh: (cosh 2.71828)
tanh: (tanh 2.71828)
asinh: (asinh 3.14159)
acosh: (acosh 3.14159)
atanh: (atanh 3.14159)
itof: (itof 3);=>3.0
rtof: (rtof (/ 3 2));=>1.5
pack: (pack {c#E c#g c#i c#s c#o c#n});=>"Egison"
unpack: (unpack "Egison");=>{c#E c#g c#i c#s c#o c#n}
uncons-string: (uncons-string "Egison");=>[c#E "gison"]
length-string: (length-string "Egison");=>6
append-string: (append-string "Egi" "son");=>"Egison"
split-string: (split-string "," "2,3,5,7,11,13");=>{"2" "3" "5" "7" "11" "13"}
regex: (regex "cde" "abcdefg");=>{["ab" "cde" "fg"]} (regex "[0-9]+" "abc123defg");=>{["abc" "123" "defg"]}
regex-cg: (regex-cg "([0-9]+),([0-9]+)" "abc,123,45,defg");=>{["abc," {"123" "45"} ",defg"]}
read: (read "3");=>3 (read "3.14159");=>3.14159 (read "{1 2}");=>{1 2} (read "\"Hello world!\"");=>"Hello world!"
show: (show 3);=>"3" (show 3.14159);=>"3.14159" (show {1 2});=>"{1 2}" (show "Hello world!");=>""Hello world!""
empty?: (empty? {});=>#t
uncons: (uncons {1 2 3});=>[1 {2 3}]
unsnoc: (unsnoc {1 2 3});=>[{1 2} 3]
bool?: (bool? #t);=>#t
integer?: (integer? 1);=>#t
rational?: (rational? (/ 1 2));=>#t
char?: (char? c#1);=>#t
string?: (string? "hello");=>#t
collection?: (collection? {});=>#t
hash?: (hash? {|[1 1] [2 12]|});=>#t

Primitive Functions with a Side Effect

open-input-file: [$inport (open-input-file "./input.txt")]
open-output-file: [$outport (open-output-file "./output.txt")]
close-input-port: [(close-input-port inport)]
close-output-port: [(close-output-port outport)]
read-char: [$c (read-char)]
read-line: [$line (read-line)]
write-char: [(write-char c#c)]
write-string: [(write-string "string")]
write: [(write [|{[ 1 c#b "TH" ] [| #t |]} {} |])]
eof?: [(eof?)]
flush: [(flush)]
read-char-from-port: [$c (read-char-from-port inport)]
read-line-from-port: [$line (read-line-from-port inport)]
write-char-to-port: [(write-char-to-port c#c outport)]
write-string-to-port: [(write-string-to-port "String" outport)]
write-to-port: [(write-to-port [|{[ 1 c#b "TH" ] [| #t |]} {} |] outport)]
eof-port?: [(eof-port? inport)]
flush-port: [(flush-port outport)]
return: [$r (return [])]
rand: [$r (rand 1 6)]

What to do next...

Top of Manual Back to Home