Effekt Library

effekt

chez

llvm

println
readln
println
println
println
println
println
show
show
show
show
show
show
show
genericShow
inspect
infixConcat
length
unsafeSubstring
random
Ordering

Less
Equal
Greater

compareInt
genericCompareImpl
genericCompare
show
println
equals
differsFrom
infixEq
infixEq
infixNeq
infixEq
infixNeq
infixEq
infixNeq
infixEq
infixNeq
infixAdd
infixMul
infixDiv
infixSub
mod
infixAdd
infixMul
infixSub
infixDiv
cos
sin
atan
tan
sqrt
square
neg
min
max
abs
log
log1p
exp
pow
pow
_pi
PI
toInt
toDouble
round
round
floor
ceil
min
max
neg
abs
infixLt
infixLte
infixGt
infixGte
infixEq
infixNeq
infixLt
infixLte
infixGt
infixGte
infixLt
infixLte
infixGt
infixGte
not
infixOr
infixAnd
bitwiseShl
bitwiseShr
bitwiseAnd
bitwiseOr
bitwiseXor
toByte
toInt
undefined
isUndefined
Tuple2
Tuple3
Tuple4
Tuple5
Tuple6
OneOrBoth

This
That
Both

Control

break
continue

loop
loop
each
each
repeat
repeat
locally
literal

literal

splice

splice

effekt

libraries/common/effekt.effekt

examples/stdlib/effekt

chez

llvm

println (value: String): Unit / {}
readln : String / {}
println (value: Int): Unit / {}
println (value: Unit): Unit / {}
println (value: Double): Unit / {}
println (value: Bool): Unit / {}
println (value: Byte): Unit / {}
show (value: Int): String / {}
show (value: Unit): String / {}
show (value: Double): String / {}
show (value: String): String / {}
show (value: Bool): String / {}
show (value: Char): String / {}
show (value: Byte): String / {}
genericShow [R] (value: R): String / {}
inspect [R] (value: R): Unit / {}
infixConcat (s1: String, s2: String): String / {}
length (str: String): Int / {}
unsafeSubstring (str: String, from: Int, to: Int): String / {}
random : Double / {}
Ordering

Result of comparison between two objects according to some order:

- `Less()` means that the first object is *before* the first in the order,
- `Equal()` means that the two objects are the same in the order,
- and `Greater()` means that the second object is *before* the first in the order.

Less
Equal
Greater

compareInt (n: Int, m: Int)
genericCompareImpl [R] (x: R, y: R): Int / {}
genericCompare [R] (x: R, y: R): Ordering / {}

Compares two values of the same type, returning an `Ordering`.
Only available on the JavaScript backend.

show (o: Ordering): String / {}
println (o: Ordering): Unit / {}
equals [R] (x: R, y: R): Bool / {}

Structural equality: Not available in the LLVM backend

differsFrom [R] (x: R, y: R): Bool / {}
infixEq (x: Unit, y: Unit): Bool / {}
infixEq (x: Int, y: Int): Bool / {}
infixNeq (x: Int, y: Int): Bool / {}
infixEq (x: Char, y: Char): Bool / {}
infixNeq (x: Char, y: Char): Bool / {}
infixEq (x: String, y: String): Bool / {}
infixNeq (x: String, y: String): Bool / {}
infixEq (x: Bool, y: Bool): Bool / {}
infixNeq (x: Bool, y: Bool): Bool / {}
infixAdd (x: Int, y: Int): Int / {}
infixMul (x: Int, y: Int): Int / {}
infixDiv (x: Int, y: Int): Int / {}
infixSub (x: Int, y: Int): Int / {}
mod (x: Int, y: Int): Int / {}
infixAdd (x: Double, y: Double): Double / {}
infixMul (x: Double, y: Double): Double / {}
infixSub (x: Double, y: Double): Double / {}
infixDiv (x: Double, y: Double): Double / {}
cos (x: Double): Double / {}
sin (x: Double): Double / {}
atan (x: Double): Double / {}
tan (x: Double): Double / {}
sqrt (x: Double): Double / {}
square (x: Double): Double / {}
neg (n: Double): Double / {}
min (n: Double, m: Double): Double / {}
max (n: Double, m: Double): Double / {}
abs (n: Double): Double / {}
log (x: Double): Double / {}
log1p (x: Double): Double / {}
exp (x: Double): Double / {}
pow (base: Double, exponent: Int): Double / {}
pow (base: Double, exponent: Double): Double / {}
_pi : Double / {}
PI
toInt (d: Double): Int / {}
toDouble (d: Int): Double / {}
round (d: Double): Int / {}
round (d: Double, digits: Int): Double / {}
floor (d: Double): Int / {}
ceil (d: Double): Int / {}
min (n: Int, m: Int): Int / {}
max (n: Int, m: Int): Int / {}
neg (n: Int): Int / {}
abs (n: Int): Int / {}
infixLt (x: Int, y: Int): Bool / {}
infixLte (x: Int, y: Int): Bool / {}
infixGt (x: Int, y: Int): Bool / {}
infixGte (x: Int, y: Int): Bool / {}
infixEq (x: Double, y: Double): Bool / {}
infixNeq (x: Double, y: Double): Bool / {}
infixLt (x: Double, y: Double): Bool / {}
infixLte (x: Double, y: Double): Bool / {}
infixGt (x: Double, y: Double): Bool / {}
infixGte (x: Double, y: Double): Bool / {}
infixLt (x: String, y: String): Bool / {}
infixLte (x: String, y: String): Bool / {}
infixGt (x: String, y: String): Bool / {}
infixGte (x: String, y: String): Bool / {}
not (b: Bool): Bool / {}
infixOr { first: => Bool } { second: => Bool }: Bool / {}
infixAnd { first: => Bool } { second: => Bool }: Bool / {}
bitwiseShl (x: Int, y: Int): Int / {}

Arithmetic left shift

bitwiseShr (x: Int, y: Int): Int / {}

Arithmetic right shift

bitwiseAnd (x: Int, y: Int): Int / {}
bitwiseOr (x: Int, y: Int): Int / {}
bitwiseXor (x: Int, y: Int): Int / {}
toByte (n: Int): Byte / {}
toInt (n: Byte): Int / {}
undefined [A]: A / {}

The value used by the FFI to represent undefined values

isUndefined [A] (value: A): Bool / {}

Is an FFI value undefined?

Tuple2 [A, B] (first: A, second: B)
Tuple3 [A, B, C] (first: A, second: B, third: C)
Tuple4 [A, B, C, D] (first: A, second: B, third: C, fourth: D)
Tuple5 [A, B, C, D, E] (first: A, second: B, third: C, fourth: D, fifth: E)
Tuple6 [A, B, C, D, E, F] (first: A, second: B, third: C, fourth: D, fifth: E, sixth: F)
OneOrBoth [A, B]

This (a: A)
That (b: B)
Both (a: A, b: B)

Control

break : Unit / {}
continue : Unit / {}

loop { f: => Unit }: Unit / {}
loop { f: {Control} => Unit }: Unit / {}
each (start: Int, end: Int) { action: (Int) => Unit }

Calls provided action repeatedly. `start` is inclusive, `end` is not.

each (start: Int, end: Int) { action: (Int){Control} => Unit }

Calls provided action repeatedly with support for breaking. `start` is inclusive, `end` is not.

repeat (n: Int) { action: => Unit }
repeat (n: Int) { action: {Control} => Unit }
locally [R] { p: => R }: R / {}

Scopes a local computation

literal

literal (s: String): Unit / {}

splice [A]

splice (x: A): Unit / {}