@effekt-lang/effekt 0.3.0 → 0.4.0

package/README.md

@@ -11,26 +11,14 @@ aims to be significantly more lightweight in its concepts.
 Also, Effekt comes with no warranty and there are (probably) many bugs -- If this does not discourage you, feel free to
 play with it and give us your feedback :)
 
-## Installation
-
-You need to have Java (>= 11) and Node (>= 12) and npm installed.
-
-The recommended way of installing Effekt is by running:
+## Examples
 
-```
-npm install -g https://github.com/effekt-lang/effekt/releases/latest/download/effekt.tgz
-```
+If you are looking for examples of the Effekt language, we invite you to look at the [casestudies](https://github.com/effekt-lang/effekt/tree/master/examples/casestudies) and the [language tour](https://effekt-lang.org/tour).
 
-Alternatively, you can download the `effekt.tgz` file from [another release](https://github.com/effekt-lang/effekt/releases) and then run
-
-```
-npm install -g effekt.tgz
-```
+## Installation
 
-This will make the `effekt` command globally available. You can start the Effekt REPL by entering:
+Please navigate to the [getting-started guide](https://effekt-lang.org/docs/getting-started#installing-effekt) on our [website](https://effekt-lang.org) for detailed instructions of how to install Effekt.
 
-```
-> effekt
-```
+## Contributing
 
-You can find more information about the Effekt language and how to use it on the website (<https://effekt-lang.org>).
+Thanks for considering to contribute to the Effekt compiler! For setting up your local environment, please check out our [contributing guide](https://effekt-lang.org/contributing.html) on the [website](https://effekt-lang.org).

package/libraries/common/args.effekt

@@ -3,7 +3,6 @@ module args
 extern io def commandLineArgs(): List[String] =
   js { js::commandLineArgs() }
   chez { chez::commandLineArgs() }
-  ml { ml::commandLineArgs() }
   llvm { llvm::commandLineArgs() }
 
 namespace js {
@@ -46,32 +45,6 @@ namespace chez {
   def commandLineArgs(): List[String] = nativeArgs().toList
 }
 
-namespace ml {
-
-  // MLList[String]
-  // we inline these from mllist to not have a dependency
-  extern type Args
-
-  extern io def nativeArgs(): Args =
-    ml "CommandLine.arguments ()"
-
-  extern pure def isEmpty(args: Args): Bool =
-    ml "null ${args}"
-
-  extern io def first(a: Args): String =
-    ml "hd ${a}"
-
-  extern io def rest(a: Args): Args =
-    ml "tl ${a}"
-
-
-  def commandLineArgs(): List[String] = {
-    def toList(args: Args): List[String] =
-      if (args.isEmpty) Nil() else Cons(args.first, args.rest.toList)
-    nativeArgs().toList
-  }
-}
-
 namespace llvm {
   extern io def argCount(): Int =
     llvm """

package/libraries/common/array.effekt

@@ -24,15 +24,13 @@ extern global def allocate[T](size: Int): Array[T] =
 /**
  * Creates a new Array of size `size` filled with the value `init`
  */
-extern global def array[T](size: Int, init: T): Array[T] =
-  ml "Array.array (${size}, ${init})"
-  default {
-    val arr = allocate[T](size);
-    each(0, size) { i =>
-      unsafeSet(arr, i, init)
-    };
-    arr
-  }
+def array[T](size: Int, init: T): Array[T] = {
+  val arr = allocate[T](size);
+  each(0, size) { i =>
+    unsafeSet(arr, i, init)
+  };
+  arr
+}
 
 /**
  * Converts a List `list` to an Array
@@ -53,7 +51,6 @@ def fromList[T](list: List[T]): Array[T] = {
 extern pure def size[T](arr: Array[T]): Int =
   js "${arr}.length"
   chez "(vector-length ${arr})"
-  ml "Array.length ${arr}"
   llvm """
     %z = call %Int @c_array_size(%Pos ${arr})
     ret %Int %z
@@ -68,17 +65,16 @@ extern pure def size[T](arr: Array[T]): Int =
 extern global def unsafeGet[T](arr: Array[T], index: Int): T =
   js "${arr}[${index}]"
   chez "(vector-ref ${arr} ${index})"
-  ml "Array.sub (${arr}, ${index})"
   llvm """
     %z = call %Pos @c_array_get(%Pos ${arr}, %Int ${index})
     ret %Pos %z
   """
 
 extern js """
-function array$set(arr, index, value) {
-  arr[index] = value;
-  return $effekt.unit
-}
+  function array$set(arr, index, value) {
+    arr[index] = value;
+    return $effekt.unit
+  }
 """
 
  /**
@@ -90,7 +86,6 @@ function array$set(arr, index, value) {
 extern global def unsafeSet[T](arr: Array[T], index: Int, value: T): Unit =
   js "array$set(${arr}, ${index}, ${value})"
   chez "(begin (vector-set! ${arr} ${index} ${value}) #f)"
-  ml "Array.update (${arr}, ${index}, ${value})"
   llvm """
     %z = call %Pos @c_array_set(%Pos ${arr}, %Int ${index}, %Pos ${value})
     ret %Pos %z

package/libraries/common/bench.effekt

@@ -1,17 +1,17 @@
 module bench
 
+type Nanos = Int
+
 /**
  * The current time (since UNIX Epoch) in nanoseconds.
  *
  * The actual precision varies across the different backends.
  * - js: Milliseconds
  * - chez: Microseconds
- * - ml: Microseconds
  */
-extern io def timestamp(): Int =
+extern io def timestamp(): Nanos =
   js "Date.now() * 1000000"
   chez "(timestamp)"
-  ml "IntInf.toInt (Time.toNanoseconds (Time.now ()))"
   llvm """
     %time_ptr = alloca { i64, i64 }
     call i32 @clock_gettime(i32 0, ptr %time_ptr)
@@ -27,24 +27,35 @@ extern llvm """
   declare i32 @clock_gettime(i32, ptr)
 """
 
+// This should not be needed when using NodeJS 16.x or newer.
+extern jsNode """
+  const { performance } = require('node:perf_hooks');
+"""
+
 /**
  * High-precision timestamp in nanoseconds that should be for measurements.
  *
  * This timestamp should only be used for **relative** measurements,
  * as gives no guarantees on the absolute time (unlike a UNIX timestamp).
  */
-extern io def relativeTimestamp(): Int =
+extern io def relativeTimestamp(): Nanos =
   js "Math.round(performance.now() * 1000000)"
   default { timestamp() }
 
+type Duration = Int
+
+namespace Duration {
+  def diff(fromNanos: Nanos, toNanos: Nanos): Duration = toNanos - fromNanos
+}
+
 /**
  * Runs the block and returns the time in nanoseconds
  */
-def timed { block: => Unit }: Int = {
+def timed { block: => Unit }: Duration = {
   val before = relativeTimestamp()
   block()
   val after = relativeTimestamp()
-  after - before
+  Duration::diff(before, after)
 }
 
 def measure(warmup: Int, iterations: Int) { block: => Unit }: Unit = {
@@ -58,3 +69,18 @@ def measure(warmup: Int, iterations: Int) { block: => Unit }: Unit = {
   run(warmup, false)
   run(iterations, true)
 }
+
+/**
+ * Takes a duration in nanoseconds and formats it in milliseconds with precision of two decimal digits.
+ */
+def formatMs(nanos: Nanos): String = {
+  val micros = nanos / 1000000
+  val sub = (nanos.mod(1000000).toDouble / 10000.0).round
+
+  if (sub == 100) {
+    // overflow because of rounding
+    (micros + 1).show ++ ".0ms"
+  } else {
+    micros.show ++ "." ++ sub.show ++ "ms"
+  }
+}

package/libraries/common/effekt.effekt

@@ -30,10 +30,6 @@ namespace chez {
   extern include chezMonadic "../chez/monadic/effekt.ss"
 }
 
-namespace ml {
-  extern include ml "../ml/effekt.sml"
-}
-
 namespace llvm {
   extern include llvm "../llvm/rts.ll"
   extern include llvm "../llvm/forward-declare-c.ll"
@@ -49,10 +45,6 @@ extern def println(value: String): Unit =
     call void @c_io_println_String(%Pos ${value})
     ret %Pos zeroinitializer ; Unit
   """
-  ml { print(value); print("\n") }
-
-extern io def print(value: String): Unit =
-  ml "print ${value}"
 
 def println(value: Int): Unit = println(value.show)
 def println(value: Unit): Unit = println(value.show)
@@ -63,7 +55,6 @@ def println(value: Byte): Unit = println(value.show)
 extern pure def show(value: Int): String =
   js "'' + ${value}"
   chez "(show-number ${value})"
-  ml "show'int ${value}"
   llvm """
     %z = call %Pos @c_buffer_show_Int(%Int ${value})
     ret %Pos %z
@@ -74,7 +65,6 @@ def show(value: Unit): String = "()"
 extern pure def show(value: Double): String =
   js "'' + ${value}"
   chez "(show-number ${value})"
-  ml "show'real ${value}"
   llvm """
     %z = call %Pos @c_buffer_show_Double(%Double ${value})
     ret %Pos %z
@@ -89,7 +79,6 @@ def show(value: Bool): String =
 extern pure def show(value: Char): String =
   js "String.fromCodePoint(${value})"
   chez "(string (integer->char ${value}))"
-  ml "str (chr ${value})"
   llvm """
     %z = call %Pos @c_buffer_show_Char(%Int ${value})
     ret %Pos %z
@@ -115,7 +104,6 @@ extern io def inspect[R](value: R): Unit =
 extern pure def infixConcat(s1: String, s2: String): String =
   js "((${s1}) + (${s2}))"
   chez "(string-append ${s1} ${s2})"
-  ml "${s1} ^ ${s2}"
   llvm """
     %spz = call %Pos @c_buffer_concatenate(%Pos ${s1}, %Pos ${s2})
     ret %Pos %spz
@@ -124,7 +112,6 @@ extern pure def infixConcat(s1: String, s2: String): String =
 extern pure def length(str: String): Int =
   js "${str}.length"
   chez "(string-length ${str})"
-  ml "String.size ${str}"
   llvm """
     %x = call %Int @c_buffer_length(%Pos ${str})
     call void @erasePositive(%Pos ${str})
@@ -134,7 +121,6 @@ extern pure def length(str: String): Int =
 extern pure def unsafeSubstring(str: String, from: Int, to: Int): String =
   js "${str}.substring(${from}, ${to})"
   chez "(substring ${str} ${from} ${to})" // potentially raises: "Exception in substring: ..."
-  ml "String.extract (${str}, ${from}, SOME (${to} - ${from}))"
   llvm """
     %x = call %Pos @c_buffer_substring(%Pos ${str}, i64 ${from}, i64 ${to})
     ret %Pos %x
@@ -147,7 +133,6 @@ extern pure def unsafeSubstring(str: String, from: Int, to: Int): String =
 extern io def random(): Double =
   js "Math.random()"
   chez "(random 1.0)"
-  ml "mlRandomReal ()"
 
 // References and state
 // ====================
@@ -203,7 +188,6 @@ def println(o: Ordering): Unit = println(o.show)
 extern pure def equals[R](x: R, y: R): Bool =
   js "$effekt.equals(${x}, ${y})"
   chez "(equal? ${x} ${y})"
-  ml "${x} = ${y}"
 
 def differsFrom[R](x: R, y: R): Bool =
   not(equals(x, y))
@@ -212,12 +196,10 @@ def differsFrom[R](x: R, y: R): Bool =
 extern pure def infixEq(x: Unit, y: Unit): Bool =
   js "true"
   chez "#t"
-  ml "true"
 
 extern pure def infixEq(x: Int, y: Int): Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"
-  ml "${x} = ${y}"
   llvm """
     %z = icmp eq %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -228,7 +210,6 @@ extern pure def infixEq(x: Int, y: Int): Bool =
 extern pure def infixNeq(x: Int, y: Int): Bool =
   js "${x} !== ${y}"
   chez "(not (equal? ${x} ${y}))"
-  ml "${x} <> ${y}"
   llvm """
     %z = icmp ne %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -239,7 +220,6 @@ extern pure def infixNeq(x: Int, y: Int): Bool =
 extern pure def infixEq(x: Char, y: Char): Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"
-  ml "${x} = ${y}"
   llvm """
     %z = icmp eq %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -250,7 +230,6 @@ extern pure def infixEq(x: Char, y: Char): Bool =
 extern pure def infixNeq(x: Char, y: Char): Bool =
   js "${x} !== ${y}"
   chez "(not (equal? ${x} ${y}))"
-  ml "${x} <> ${y}"
   llvm """
     %z = icmp ne %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -261,7 +240,6 @@ extern pure def infixNeq(x: Char, y: Char): Bool =
 extern pure def infixEq(x: String, y: String): Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"
-  ml "${x} = ${y}"
   llvm """
     %res = call %Pos @c_buffer_eq(%Pos ${x}, %Pos ${y})
     ret %Pos %res
@@ -272,7 +250,6 @@ def infixNeq(x: String, y: String): Bool = not(x == y)
 extern pure def infixEq(x: Bool, y: Bool): Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"
-  ml "${x} = ${y}"
   llvm """
     %slim_x = extractvalue %Pos ${x}, 0
     %slim_y = extractvalue %Pos ${y}, 0
@@ -285,7 +262,6 @@ extern pure def infixEq(x: Bool, y: Bool): Bool =
 extern pure def infixNeq(x: Bool, y: Bool): Bool =
   js "${x} !== ${y}"
   chez "(not (equal? ${x} ${y}))"
-  ml "${x} <> ${y}"
   llvm """
     %slim_x = extractvalue %Pos ${x}, 0
     %slim_y = extractvalue %Pos ${y}, 0
@@ -301,87 +277,69 @@ extern pure def infixNeq(x: Bool, y: Bool): Bool =
 extern pure def infixAdd(x: Int, y: Int): Int =
   js "(${x} + ${y})"
   chez "(+ ${x} ${y})"
-  ml "(${x}: int) + ${y}"
   llvm "%z = add  %Int ${x}, ${y} ret %Int %z"
 
 extern pure def infixMul(x: Int, y: Int): Int =
   js "(${x} * ${y})"
   chez "(* ${x} ${y})"
-  ml "(${x}: int) * ${y}"
   llvm "%z = mul  %Int ${x}, ${y} ret %Int %z"
 
 extern pure def infixDiv(x: Int, y: Int): Int =
   js "Math.floor(${x} / ${y})"
   chez "(floor (/ ${x} ${y}))"
-  ml "(${x}: int) div ${y}"
   llvm "%z = sdiv %Int ${x}, ${y} ret %Int %z"
 
 extern pure def infixSub(x: Int, y: Int): Int =
   js "(${x} - ${y})"
   chez "(- ${x} ${y})"
-  ml "(${x}: int) - ${y}"
   llvm "%z = sub  %Int ${x}, ${y} ret %Int %z"
 
 extern pure def mod(x: Int, y: Int): Int =
   js "(${x} % ${y})"
   chez "(modulo ${x} ${y})"
-  ml "(${x}: int) mod ${y}"
   llvm "%z = srem %Int ${x}, ${y} ret %Int %z"
 
 extern pure def infixAdd(x: Double, y: Double): Double =
   js "(${x} + ${y})"
   chez "(+ ${x} ${y})"
-  ml "(${x}: real) + ${y}"
   llvm "%z = fadd %Double ${x}, ${y} ret %Double %z"
 
 extern pure def infixMul(x: Double, y: Double): Double =
   js "(${x} * ${y})"
   chez "(* ${x} ${y})"
-  ml "(${x}: real) * ${y}"
   llvm "%z = fmul %Double ${x}, ${y} ret %Double %z"
 
 extern pure def infixSub(x: Double, y: Double): Double =
   js "(${x} - ${y})"
   chez "(- ${x} ${y})"
-  ml "(${x}: real) - ${y}"
   llvm "%z = fsub %Double ${x}, ${y} ret %Double %z"
 
 extern pure def infixDiv(x: Double, y: Double): Double =
   js "(${x} / ${y})"
   chez "(/ ${x} ${y})"
-  ml "(${x}: real) / ${y}"
   llvm "%z = fdiv %Double ${x}, ${y} ret %Double %z"
 
 extern pure def cos(x: Double): Double =
   js "Math.cos(${x})"
   chez "(cos ${x})"
-  ml "Math.cos ${x}"
 
 extern pure def sin(x: Double): Double =
   js "Math.sin(${x})"
   chez "(sin ${x})"
-  ml "Math.sin ${x}"
 
 extern pure def atan(x: Double): Double =
   js "Math.atan(${x})"
   chez "(atan ${x})"
-  ml "Math.atan ${x}"
 
 extern pure def tan(x: Double): Double =
   js "Math.tan(${x})"
   chez "(tan ${x})"
-  ml "Math.tan ${x}"
 
 extern pure def sqrt(x: Double): Double =
   js "Math.sqrt(${x})"
   chez "(sqrt ${x})"
-  ml "Math.sqrt ${x}"
   llvm "%z = call %Double @llvm.sqrt.f64(double ${x}) ret %Double %z"
 
-extern llvm """
-declare double @llvm.sqrt.f64(double %x)
-"""
-
 def square(x: Double): Double = x * x
 
 def neg(n: Double): Double =
@@ -396,52 +354,73 @@ def abs(n: Double): Double =
 extern pure def log(x: Double): Double =
   js "Math.log(${x})"
   chez "(log ${x})"
-  ml "Math.ln ${x}"
 
 extern pure def log1p(x: Double): Double =
   js "Math.log1p(${x})"
   chez "(log (+ ${x} 1))"
-  ml "Math.ln (${x} + 1.0)"
 
 extern pure def exp(x: Double): Double =
   js "Math.exp(${x})"
   chez "(exp ${x})"
-  ml "Math.exp ${x}"
+
+def pow(base: Double, exponent: Int): Double = {
+  def loop(base: Double, exponent: Int, acc: Double): Double = {
+    if (exponent == 0) acc
+    else if (exponent.mod(2) == 0) loop(base * base, exponent / 2, acc)  // even exponent
+    else loop(base, exponent - 1, acc * base)  // odd exponent
+  }
+  loop(base, exponent, 1.0)
+}
+
+extern pure def pow(base: Double, exponent: Double): Double =
+  js "Math.pow(${base}, ${exponent})"
+  chez "(expt ${base} ${exponent})"
 
 // since we do not have "extern val", yet
 extern pure def _pi(): Double =
   js "Math.PI"
   chez "(* 4 (atan 1))"
-  ml "Math.pi"
 
 val PI: Double = _pi()
 
 extern pure def toInt(d: Double): Int =
   js "Math.trunc(${d})"
   chez "(flonum->fixnum ${d})"
-  ml "Real.trunc ${d}"
   llvm "%z = fptosi double ${d} to %Int ret %Int %z"
 
 extern pure def toDouble(d: Int): Double =
   js "${d}"
   chez "${d}"
-  ml "Real.fromInt ${d}"
   llvm "%z = sitofp i64 ${d} to double ret double %z"
 
 extern pure def round(d: Double): Int =
   js "Math.round(${d})"
   chez "(round ${d})"
-  ml "Real.round ${d}"
+  llvm """
+    %i = call %Double @llvm.round.f64(double ${d})
+    %z = fptosi double %i to %Int ret %Int %z
+  """
+
+def round(d: Double, digits: Int): Double = {
+  val factor = pow(10.0, digits)
+  round(d * factor).toDouble / factor
+}
 
 extern pure def floor(d: Double): Int =
   js "Math.floor(${d})"
   chez "(flonum->fixnum (floor ${d}))"
-  ml "Real.floor ${d}"
+  llvm """
+    %i = call %Double @llvm.floor.f64(double ${d})
+    %z = fptosi double %i to %Int ret %Int %z
+  """
 
 extern pure def ceil(d: Double): Int =
   js "Math.ceil(${d})"
   chez "(flonum->fixnum (ceiling ${d}))"
-  ml "Real.ceil ${d}"
+  llvm """
+    %i = call %Double @llvm.ceil.f64(double ${d})
+    %z = fptosi double %i to %Int ret %Int %z
+  """
 
 def min(n: Int, m: Int): Int =
   if (n < m) n else m
@@ -459,7 +438,6 @@ def abs(n: Int): Int =
 extern pure def infixLt(x: Int, y: Int): Bool =
   js "(${x} < ${y})"
   chez "(< ${x} ${y})"
-  ml "(${x}: int) < ${y}"
   llvm """
     %z = icmp slt %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -470,7 +448,6 @@ extern pure def infixLt(x: Int, y: Int): Bool =
 extern pure def infixLte(x: Int, y: Int): Bool =
   js "(${x} <= ${y})"
   chez "(<= ${x} ${y})"
-  ml "(${x}: int) <= ${y}"
   llvm """
     %z = icmp sle %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -481,7 +458,6 @@ extern pure def infixLte(x: Int, y: Int): Bool =
 extern pure def infixGt(x: Int, y: Int): Bool =
   js "(${x} > ${y})"
   chez "(> ${x} ${y})"
-  ml "(${x}: int) > ${y}"
   llvm """
     %z = icmp sgt %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -492,7 +468,6 @@ extern pure def infixGt(x: Int, y: Int): Bool =
 extern pure def infixGte(x: Int, y: Int): Bool =
   js "(${x} >= ${y})"
   chez "(>= ${x} ${y})"
-  ml "(${x}: int) >= ${y}"
   llvm """
     %z = icmp sge %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -503,17 +478,14 @@ extern pure def infixGte(x: Int, y: Int): Bool =
 extern pure def infixEq(x: Double, y: Double): Bool =
   js "${x} === ${y}"
   chez "(= ${x} ${y})"
-  ml "(${x}: real) = ${y}"
 
 extern pure def infixNeq(x: Double, y: Double): Bool =
   js "${x} !== ${y}"
   chez "(not (= ${x} ${y}))"
-  ml "(${x}: real) <> ${y}"
 
 extern pure def infixLt(x: Double, y: Double): Bool =
   js "(${x} < ${y})"
   chez "(< ${x} ${y})"
-  ml "(${x}: real) < ${y}"
   llvm """
     %z = fcmp olt %Double ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -524,12 +496,10 @@ extern pure def infixLt(x: Double, y: Double): Bool =
 extern pure def infixLte(x: Double, y: Double): Bool =
   js "(${x} <= ${y})"
   chez "(<= ${x} ${y})"
-  ml "(${x}: real) <= ${y}"
 
 extern pure def infixGt(x: Double, y: Double): Bool =
   js "(${x} > ${y})"
   chez "(> ${x} ${y})"
-  ml "(${x}: real) > ${y}"
   llvm """
     %z = fcmp ogt %Double ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -540,28 +510,23 @@ extern pure def infixGt(x: Double, y: Double): Bool =
 extern pure def infixGte(x: Double, y: Double): Bool =
   js "(${x} >= ${y})"
   chez "(>= ${x} ${y})"
-  ml "(${x}: real) >= ${y}"
 
 // TODO do we really need those? if yes, move to string.effekt
 extern pure def infixLt(x: String, y: String): Bool =
   js "(${x} < ${y})"
   chez "(< ${x} ${y})"
-  ml "(${x}: string) < ${y}"
 
 extern pure def infixLte(x: String, y: String): Bool =
   js "(${x} <= ${y})"
   chez "(<= ${x} ${y})"
-  ml "(${x}: string) <= ${y}"
 
 extern pure def infixGt(x: String, y: String): Bool =
   js "(${x} > ${y})"
   chez "(> ${x} ${y})"
-  ml "(${x}: string) > ${y}"
 
 extern pure def infixGte(x: String, y: String): Bool =
   js "(${x} >= ${y})"
   chez "(>= ${x} ${y})"
-  ml "(${x}: string) >= ${y}"
 
 
 // Boolean operations
@@ -569,7 +534,6 @@ extern pure def infixGte(x: String, y: String): Bool =
 extern pure def not(b: Bool): Bool =
   js "!${b}"
   chez "(not ${b})"
-  ml "not ${b}"
   llvm """
     %p = extractvalue %Pos ${b}, 0
     %q = xor i64 1, %p
@@ -620,7 +584,6 @@ extern pure def toInt(n: Byte): Int =
 //
 //   js:   undefined || null
 //   chez: #f
-//   ml:  NONE (of option 'a)
 //   llvm: null?
 
 /**
@@ -629,7 +592,6 @@ extern pure def toInt(n: Byte): Int =
 extern pure def undefined[A](): A =
   js "undefined"
   chez "#f"
-  ml "NONE"
 
 /**
  * Is an FFI value undefined?
@@ -637,7 +599,6 @@ extern pure def undefined[A](): A =
 extern pure def isUndefined[A](value: A): Bool =
   js "(${value} === undefined || ${value} === null)"
   chez "(eq? ${value} #f)"
-  ml "Option.isSome ${value}"
 
 
 // Tuples

package/libraries/common/exception.effekt

@@ -53,7 +53,6 @@ def wrongFormat(msg: String): Nothing / Exception[WrongFormat] =
 extern io def panic[R](msg: String): R =
   js "(function() { throw ${msg} })()"
   chez "(raise ${msg})"
-  ml "raise Fail ${msg}"
   llvm """
     call void @c_io_println_String(%Pos ${msg})
     call void @exit(i32 1)