• Effekt Logo Effekt Library
    • effekt
      • 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
      • 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
      • Control
        • break
        • continue
      • loop
      • loop
      • each
      • each
      • repeat
      • repeat
      • locally
      • literal
        • literal
      • splice
        • splice
    • effekt
      • Jump to source: libraries/common/effekt.effekt
      Example usage: examples/stdlib/effekt
      • 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 / {}
      • 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)
      • 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 / {}