@effekt-lang/effekt 0.54.0 → 0.56.0

package/libraries/chez/common/effekt_primitives.ss

@@ -70,7 +70,7 @@
   (cond
     ; Same object reference (fast path)
     [(eq? obj1 obj2) #t]
-    
+
     ; If both are records, compare them structurally
     [(and (record? obj1) (record? obj2))
      (let* ([rtd1 (record-rtd obj1)]
@@ -87,7 +87,7 @@
                  (if (not (equal_impl field1 field2))
                      (set! result #f)))))
            #f))]
-    
+
     ; For lists, compare elements recursively
     [(and (list? obj1) (list? obj2))
      (and (= (length obj1) (length obj2))
@@ -95,7 +95,7 @@
             (or (null? l1)
                 (and (equal_impl (car l1) (car l2))
                      (loop (cdr l1) (cdr l2))))))]
-    
+
     ; For all other types, use Scheme's built-in equal?
     [else (equal? obj1 obj2)]))
 
@@ -134,4 +134,10 @@
   (raise
     (condition
       (make-error)
-      (make-message-condition (string-append pos " not implemented yet" )))))
+      (make-message-condition (string-append pos " not implemented yet" )))))
+
+(define (unreachable)
+  (raise
+    (condition
+      (make-error)
+      (make-message-condition ("should not be reachable!")))))

package/libraries/common/dictionary.effekt

@@ -0,0 +1,133 @@
+module dictionary
+
+import array
+import bytearray
+import stream
+
+
+/// A trie-based dictionary for efficient key-value storage with bytearray keys.
+/// Supports String and ByteArray keys with fast lookup and insertion.
+type Dictionary[A] {
+  Empty()
+  Leaf(value: A)
+  Branch(children: Array[Dictionary[A]])
+  Node(value: A, children: Array[Dictionary[A]])
+}
+
+/// Insert a value with a String key.
+def insert[A](trie: Dictionary[A], key: String, value: A): Dictionary[A] =
+  insert(trie, key.fromString, value)
+
+/// Insert a key-value pair into the dictionary with a ByteArray key.
+def insert[A](trie: Dictionary[A], key: ByteArray, value: A): Dictionary[A] = {
+  def go(trie: Dictionary[A], i: Int): Dictionary[A] =
+    if (i < key.size) {
+      trie match {
+        case Empty() =>
+          val child = go(Empty(), i + 1)
+          val children = array(256, Empty())
+          children.unsafeSet(key.unsafeGet(i).toInt, child)
+          Branch(children)
+        case Leaf(existing) =>
+          val child = go(Empty(), i + 1)
+          val children = array(256, Empty())
+          children.unsafeSet(key.unsafeGet(i).toInt, child)
+          Node(existing, children)
+        case Branch(children) =>
+          val child = go(children.unsafeGet(key.unsafeGet(i).toInt), i + 1)
+          children.unsafeSet(key.unsafeGet(i).toInt, child)
+          Branch(children)
+        case Node(existing, children) =>
+          val child = go(children.unsafeGet(key.unsafeGet(i).toInt), i + 1)
+          children.unsafeSet(key.unsafeGet(i).toInt, child)
+          Node(existing, children)
+      }
+    } else {
+      trie match {
+        case Empty() => Leaf(value)
+        case Leaf(_) => Leaf(value)
+        case Node(_, children) => Node(value, children)
+        case Branch(children) => Node(value, children)
+      }
+    }
+  go(trie, 0)
+}
+
+/// Look up a value in the dictionary by string key.
+def lookup[A](trie: Dictionary[A], key: String): Option[A] =
+  lookup(trie, key.fromString)
+
+/// Look up a value in the dictionary by bytearray key.
+def lookup[A](trie: Dictionary[A], key: ByteArray): Option[A] = {
+  def go(trie: Dictionary[A], i: Int): Option[A] =
+    if (i < key.size) {
+      trie match {
+        case Empty() => None()
+        case Leaf(_) => None()
+        case Branch(children) => go(children.unsafeGet(key.unsafeGet(i).toInt), i + 1)
+        case Node(_, children) => go(children.unsafeGet(key.unsafeGet(i).toInt), i + 1)
+      }
+    } else {
+      trie match {
+        case Empty() => None()
+        case Leaf(value) => Some(value)
+        case Branch(_) => None()
+        case Node(value, _) => Some(value)
+      }
+    }
+  go(trie, 0)
+}
+
+/// A record pairing a key with a value for use in streams.
+record Tagged[A](key: ByteArray, value: A)
+
+/// Collect key-value pairs from a stream of Tagged elements into a Dictionary.
+def collect[A] { stream: () => Unit / emit[Tagged[A]] }: Dictionary[A] = {
+  var trie = Empty()
+  for[Tagged[A]] { stream() } { case Tagged(bytes, value) =>
+    trie = trie.insert(bytes, value)
+  }
+  return trie
+}
+
+/// Emit all values stored in the dictionary as a push stream.
+def each[A](trie: Dictionary[A]): Unit / emit[A] =
+  trie match {
+    case Empty() => ()
+    case Leaf(value) => do emit(value)
+    case Branch(children) =>
+      each(0, children.size) { i =>
+        each(children.unsafeGet(i))
+      }
+    case Node(value, children) =>
+      do emit(value)
+      each(0, children.size) { i =>
+        each(children.unsafeGet(i))
+      }
+  }
+
+/// Emit all key-value pairs stored in the dictionary as a push stream of Tagged elements.
+def eachTagged[A](trie: Dictionary[A]): Unit / emit[Tagged[A]] = {
+  def fromBytesReverse(bytes: List[Byte], n: Int): ByteArray = {
+    val key = bytearray::allocate(n)
+    foreachIndex(bytes) { (i, b) => key.unsafeSet(n - 1 - i, b) }
+    key
+  }
+  def go(trie: Dictionary[A], key: List[Byte], n: Int): Unit =
+    trie match {
+      case Empty() => ()
+      case Leaf(value) => do emit(Tagged(fromBytesReverse(key, n), value))
+      case Branch(children) =>
+        each(0, children.size) { i =>
+          go(children.unsafeGet(i), Cons(i.toByte, key), n + 1)
+        }
+      case Node(value, children) =>
+        do emit(Tagged(fromBytesReverse(key, n), value))
+        each(0, children.size) { i =>
+          go(children.unsafeGet(i), Cons(i.toByte, key), n + 1)
+        }
+    }
+  go(trie, Nil(), 0)
+}
+
+

package/libraries/common/json.effekt

@@ -25,12 +25,12 @@ def handleJsonBuilder[R]{b: JsonBuilder}{ body: => R / JsonBuilder }: R = try bo
   def bool(v) = resume(b.bool(v))
   def number(n) = resume(b.number(n))
   def string(s) = resume(b.string(s))
-  def list() = resume { {c} => b.list{c} }
-  def dict() = resume { {c} => b.dict{c} }
+  def list[T]() = resume { {c} => b.list{c} }
+  def dict[T]() = resume { {c} => b.dict{c} }
 }
 /// Make explicitly bound JsonObjectBuilder instance implicit
 def handleJsonObjectBuilder[R]{b: JsonObjectBuilder}{ body: => R / JsonObjectBuilder }: R = try body() with JsonObjectBuilder {
-  def field(k) = resume { {c} => b.field(k){c} }
+  def field[T](k) = resume { {c} => b.field(k){c} }
 }
 
 // --------------------------------------------------------------------------------
@@ -49,8 +49,8 @@ def encodeJsonList[R]{ body: => R / JsonBuilder }: R / emit[String] = {
       def bool(v) = { c(); resume(do bool(v)) }
       def number(n) = { c(); resume(do number(n)) }
       def string(s) = { c(); resume(do string(s)) }
-      def list() = resume { { b } => c(); do list{b} }
-      def dict() = resume { { b } => c(); do dict{b} }
+      def list[T]() = resume { { b } => c(); do list{b} }
+      def dict[T]() = resume { { b } => c(); do dict{b} }
     }
   }
   do emit("]")
@@ -66,7 +66,7 @@ def encodeJsonObject[R]{ body: => R / JsonObjectBuilder }: R / emit[String] = {
   }
   val r = encodeJson {
     try body() with JsonObjectBuilder {
-      def field(k) = resume { {b} => c(k); b() }
+      def field[T](k) = resume { {b} => c(k); b() }
     }
   }
   do emit("}")
@@ -80,8 +80,8 @@ def encodeJson[R]{ body: => R / JsonBuilder }: R / emit[String] = {
       def bool(v) = { resume(do emit( if(v){ "true" } else { "false" } )) }
       def number(n) = { resume(do emit(show(n))) }
       def string(s) = { resume(do emit(escape(s))) }
-      def list() = resume { {b} => encodeJsonList { b() } }
-      def dict() = resume { {b} => encodeJsonObject { b() } }
+      def list[T]() = resume { {b} => encodeJsonList { b() } }
+      def dict[T]() = resume { {b} => encodeJsonObject { b() } }
   }
 }
 
@@ -209,7 +209,7 @@ def decodeJsonList(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} =
 // --------------------------------------------------------------------------------
 /// Ignore the generated calls to JsonObjectBuilder
 def ignoreDict[R](){ body: => R / JsonObjectBuilder }: R = try body() with JsonObjectBuilder {
-  def field(k) = resume { {v} => ignore{v} }
+  def field[T](k) = resume { {v} => ignore{v} }
 }
 
 /// Ignore the generated calls to JsonBuilder
@@ -218,8 +218,8 @@ def ignore[R](){ body: => R / JsonBuilder }: R = try body() with JsonBuilder {
   def bool(b) = resume(())
   def null() = resume(())
   def string(s) = resume(())
-  def list() = resume { {e} => ignore{e} }
-  def dict() = resume { {e} => ignoreDict{e} }
+  def list[T]() = resume { {e} => ignore{e} }
+  def dict[T]() = resume { {e} => ignoreDict{e} }
 }
 
 // --------------------------------------------------------------------------------
@@ -264,12 +264,12 @@ def build[R](){ body: => R / JsonBuilder }: (R, JsonValue) = {
     def bool(b) = { r = Bool(b); resume(()) }
     def null() = { r = Null(); resume(()) }
     def string(s) = { r = String(s); resume(()) }
-    def list() = resume { {els} =>
+    def list[T]() = resume { {els} =>
       val x = buildList {els}
       r = List(x.second)
       x.first
     }
-    def dict() = resume { {fs} =>
+    def dict[T]() = resume { {fs} =>
       val x = buildDict {fs}
       r = Dict(x.second)
       x.first
@@ -283,12 +283,12 @@ def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = list::ret
     def bool(b) = { do emit(Bool(b)); resume(()) }
     def null() = { do emit(Null()); resume(()) }
     def string(s) = { do emit(String(s)); resume(()) }
-    def list() = resume { {els} =>
+    def list[T]() = resume { {els} =>
       val x = buildList {els}
       do emit(List(x.second))
       x.first
     }
-    def dict() = resume { {fs} =>
+    def dict[T]() = resume { {fs} =>
       val x = buildDict {fs}
       do emit(Dict(x.second))
       x.first
@@ -297,7 +297,7 @@ def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = list::ret
 }
 def buildDict[R](){ body: => R / JsonObjectBuilder }: (R, List[(String, JsonValue)]) = list::returning::collect[(String, JsonValue), R] {
   try body() with JsonObjectBuilder {
-    def field(k) = resume { {v} =>
+    def field[T](k) = resume { {v} =>
       val x = build{v}
       do emit((k, x.second))
       x.first
@@ -325,7 +325,7 @@ namespace test {
       with scanner[Char]
 
       def k = new JsonObjectBuilder {
-        def field(k){v} = { println(k); ignore{v} }
+        def field[T](k){v} = { println(k); ignore{v} }
       }
       def jsonBuilder[R] {e: => R / JsonBuilder}: R = {
         def d = new JsonBuilder {
@@ -333,8 +333,8 @@ namespace test {
           def bool(b) = ()
           def null() = println("NULL")
           def string(s) = ()
-          def list(){e} = jsonBuilder{e}
-          def dict(){e} = handleJsonObjectBuilder{k}{e}
+          def list[T](){e} = jsonBuilder{e}
+          def dict[T](){e} = handleJsonObjectBuilder{k}{e}
         }
         handleJsonBuilder{d}{e}
       }

package/libraries/common/list.effekt

@@ -944,6 +944,22 @@ def each[A](list: List[A]): Unit / emit[A] =
       each(tail)
   }
 
+/// Push iterator that emits all the tails (suffixes) of the given `list`.
+///
+/// Examples:
+/// ```effekt
+/// > list::collect[List[Int]] { [1, 2, 3].tails }
+/// [[1, 2, 3], [2, 3], [3], []]
+///
+/// > list::collect[List[Int]] { [].tails }
+/// [[]]
+/// ```
+def tails[A](list: List[A]): Unit / emit[List[A]] =
+  list match {
+    case Nil()            => do emit(Nil())
+    case Cons(head, tail) => do emit(list); tails(tail)
+  }
+
 def feed[T, R](list: List[T]) { reader: () => R / read[T] }: R = {
   var l = list
   try {

package/libraries/common/option.effekt

@@ -37,7 +37,7 @@ def foreach[A](self: Option[A]) { f: A => Unit }: Unit = self match {
 }
 
 def value[A](self: Option[A]): A / Exception[MissingValue] = self match {
-  case None() => do raise(MissingValue(), "Trying to get the value of an empty option")
+  case None() => do raise(MissingValue(), "Trying to get the value of an empty option") match {}
   case Some(v) => v
 }
 

package/libraries/common/process.effekt

@@ -1,4 +1,5 @@
 module process
+import array
 
 extern def exit(errorCode: Int) at io: Nothing =
   js   "(function() { process.exit(${errorCode}) })()"
@@ -7,3 +8,101 @@ extern def exit(errorCode: Int) at io: Nothing =
     ret %Pos zeroinitializer
   """
   chez "(exit ${errorCode})"
+
+// Subprocesses
+// ------------
+
+extern jsNode """
+const { spawn } = require('node:child_process');
+"""
+extern llvm """
+  declare %Pos @c_spawn_options_default()
+  declare %Pos @c_spawn_options_on_stdout(%Pos, %Pos)
+  declare %Pos @c_spawn_options_on_stderr(%Pos, %Pos)
+  declare %Pos @c_spawn_options_pipe_stdin(%Pos, %Pos)
+  declare %Pos @c_write_stream(%Pos, %Pos)
+  declare %Pos @c_close_stream(%Pos)
+  declare %Pos @c_spawn(%Pos, %Pos, %Pos)
+"""
+
+extern type SpawnOptions
+extern def default() at {}: SpawnOptions =
+  jsNode """{ stdio: [0,1,2], onSpawn: (p) => {} }"""
+  llvm """
+    %opts = call %Pos @c_spawn_options_default()
+    ret %Pos %opts
+  """
+extern def onStdout(opts: SpawnOptions, callback: String => Unit at {io, global}) at {}: SpawnOptions =
+  jsNode """(function() {
+    let old = ${opts};
+    old.stdio[1] = 'pipe';
+    let oldSpawn = old.onSpawn;
+    old.onSpawn = function(p) {
+      oldSpawn(p);
+      p.stdout.on('data', (chunk) => {
+        $effekt.runToplevel((ks, k) => (${callback})(chunk, ks, k));
+      });
+    };
+    return old; })()"""
+  llvm """
+    %opts = call %Pos @c_spawn_options_on_stdout(%Pos ${opts}, %Pos ${callback})
+    ret %Pos %opts
+  """
+extern def onStderr(opts: SpawnOptions, callback: String => Unit at {io, global}) at {}: SpawnOptions =
+  jsNode """(function() {
+    let old = ${opts};
+    old.stdio[2] = 'pipe';
+    let oldSpawn = old.onSpawn;
+    old.onSpawn = function(p) {
+      oldSpawn(p);
+      p.stderr.on('data', (chunk) => {
+        $effekt.runToplevel((ks, k) => (${callback})(chunk, ks, k));
+      });
+    };
+    return old; })()"""
+  llvm """
+    %opts = call %Pos @c_spawn_options_on_stderr(%Pos ${opts}, %Pos ${callback})
+    ret %Pos %opts
+  """
+extern type WritableStream
+extern def withStdin(opts: SpawnOptions, callback: WritableStream => Unit at {io, global}) at {}: SpawnOptions =
+  jsNode """(function () {
+    let old = ${opts};
+    old.stdio[0] = 'pipe'
+    let oldSpawn = old.onSpawn;
+    old.onSpawn = function(p) {
+      oldSpawn(p);
+      p.on('spawn', () => {
+        $effekt.runToplevel((ks, k) => (${callback})(p.stdin, ks, k));
+      });
+    };
+    return old;
+  })()"""
+  llvm """
+    %opts = call %Pos @c_spawn_options_pipe_stdin(%Pos ${opts}, %Pos ${callback})
+    ret %Pos %opts
+  """
+extern def write(to: WritableStream, s: String) at io: Unit =
+  jsNode """${to}.write(${s})"""
+  llvm """
+    call void @c_write_stream(%Pos ${to}, %Pos ${s})
+    ret %Pos zeroinitializer
+  """
+extern def close(to: WritableStream) at io: Unit =
+  jsNode """${to}.end()"""
+  llvm """
+    call void @c_close_stream(%Pos ${to})
+    ret %Pos zeroinitializer
+  """
+
+extern def spawn(cmd: String, args: Array[String], options: SpawnOptions) at async: Int  =
+  jsNode """$effekt.capture(k => {
+    let p = spawn(${cmd}, ${args}, ${options});
+    ${options}.onSpawn(p);
+    p.on('close', (exitcode, sig) => { k(exitcode) });
+    return p;
+    })"""
+  llvm """
+    call void @c_spawn(%Pos ${cmd}, %Pos ${args}, %Pos ${options}, %Stack %stack)
+    ret void
+  """

package/libraries/common/random.effekt

@@ -170,7 +170,7 @@ def main() = {
       val b = randomInt(0, 9)
       val c = randomInt(0, 9)
       println(a.show ++ " " ++ b.show ++ " " ++ c.show)
-      println(a*100 + b*10 + c)
+      println(a * 100 + b * 10 + c)
     }
   }
 

package/libraries/common/stream.effekt

@@ -2,6 +2,7 @@ module stream
 
 import effekt
 import option
+import exception
 
 // Effects
 // -------
@@ -128,6 +129,26 @@ def iterate[A](initial: A) { step: A => A }: Unit / emit[A] = {
   }
 }
 
+/// Re-emit from the `stream` as long as the `predicate` holds.
+/// Once the predicate fails, the stream ends.
+///
+/// Examples:
+/// ```effekt
+/// > list::collect[Int] { takeWhile[Int] { x => x < 3 } { [1, 2, 3, 4, 1].each } }
+/// [1, 2]
+///
+/// > list::collect[Int] { takeWhile[Int] { x => x < 10 } { [1, 2, 3].each } }
+/// [1, 2, 3]
+///
+/// > list::collect[Int] { takeWhile[Int] { x => x < 0 } { [1, 2, 3].each } }
+/// []
+/// ```
+def takeWhile[A] { predicate: A => Bool } { stream: () => Unit / emit[A] }: Unit / emit[A] =
+  try { stream() } with emit[A] {
+    case value and predicate(value) => do emit(value); resume(())
+    case _                          => () // end the stream
+  }
+
 
 def sum { stream: () => Unit / emit[Int] }: Int =
   returning::sum[Unit]{stream}.second
@@ -135,6 +156,71 @@ def sum { stream: () => Unit / emit[Int] }: Int =
 def product { stream: () => Unit / emit[Int] }: Int =
   returning::product[Unit]{stream}.second
 
+/// Returns true if all elements in the stream satisfy the given predicate,
+/// false otherwise. Short-circuits as soon as a non-matching element is found.
+///
+/// Examples:
+/// ```effekt
+/// > all[Int] { x => x > 0 } { [1, 2, 3].each }
+/// true
+///
+/// > all[Int] { x => x < 3 } { [1, 2, 3, 4].each }
+/// false
+///
+/// > all[Bool] { x => x } { [false, true, true].each }
+/// false
+///
+/// > all[Int] { x => x >= 0 } { () } // empty stream
+/// true
+/// ```
+def all[A] { cond: A => Bool } { stream: => Unit / emit[A] }: Bool =
+  try { stream(); true } with emit[A] {
+    case value and not(cond(value)) => false
+    case _                          => resume(())
+  }
+
+/// Returns true if any element in the stream satisfies the given predicate,
+/// false otherwise. Short-circuits as soon as a matching element is found.
+///
+/// Examples:
+/// ```effekt
+/// > any[Int] { x => x > 0 } { [-2, -1, 0, 1, 2].each }
+/// true
+///
+/// > any[Int] { x => x > 10 } { [1, 2, 3, 4].each }
+/// false
+///
+/// > any[Bool] { x => x } { [false, true, false].each }
+/// true
+///
+/// > any[Int] { x => x == 0 } { () } // empty stream
+/// false
+/// ```
+def any[A] { cond: A => Bool } { stream: => Unit / emit[A] }: Bool =
+  try { stream(); false } with emit[A] {
+    case value and cond(value) => true
+    case _                     => resume(())
+  }
+
+/// Count the number of emitted values that satisfy the given predicate.
+///
+/// Examples:
+/// ```
+/// > countIf[Int] { x => x > 0 } { [2, -1, 0, 1, -2].each }
+/// 2
+///
+/// > countIf[Bool] { x => x } { [false, false, true, false].each }
+/// 1
+/// ```
+def countIf[A] { shouldCount: A => Bool } { stream: () => Unit / emit[A] }: Int = {
+  var count = 0
+  for {stream} {
+    case x and shouldCount(x) => count = count + 1
+    case _                    => ()
+  }
+  count
+}
+
 def source[A] { stream: () => Unit / emit[A] } { reader: () => Unit / read[A] }: Unit =
   returning::source[A, Unit]{stream}{reader}
 
@@ -177,9 +263,9 @@ namespace internal {
 
 /// Use cons to handle prod, but also emit to the outside.
 /// The outside controls iteration, i.e., if cons aborts, the rest of prod will still be emitted.
-/// 
+///
 /// Starts by executing cons. Will stop cons during execution if the outside stops consuming.
-/// 
+///
 /// Example, printing all values consumed by the outside:
 ///
 ///     with teeing{ {s} => for{s}{ e => println(e) } }
@@ -215,9 +301,9 @@ def teeing[A]{ cons: { => Unit / emit[A] } => Unit }{ prod: => Unit / emit[A] }:
 }
 
 /// Binds a `teeing`-like function in the body, stopping the inner producer once all consumers in tees are done consuming.
-/// 
+///
 /// Example of use, equivalent to `tee[A]{cns1}{cns2}{prd}`:
-/// 
+///
 ///     manyTee[A] { {tee} =>
 ///       with tee{cns1}
 ///       with tee{cns2}
@@ -253,6 +339,25 @@ def tee[A]{ cons1: { => Unit / emit[A] } => Unit }{ cons2: { => Unit / emit[A] }
   }
 }
 
+/// Return exactly the very first element of the given stream
+/// or raise MissingValue if no elements are emitted.
+///
+/// Examples:
+/// ```effekt
+/// > first[Int] { [1, 2, 3].each }
+/// 1
+/// > first[Bool] { do emit(true) }
+/// true
+/// > first[String] { () } // empty stream
+/// <Exception MissingValue: code in first did not emit any values>
+/// ```
+def first[A] { body: => Unit / emit[A] }: A / Exception[MissingValue] =
+  try {
+    body()
+    val r: A = do raise[MissingValue](MissingValue(), "code in first did not emit any values")
+    r
+  } with emit[A] { a => a }
+
 namespace returning {
 
 /// Canonical handler of push streams that performs `action` for every

package/libraries/common/union_find.effekt

@@ -15,9 +15,9 @@ namespace internal {
   def parent(u: UnionFind, s: Int): Int / Exception[MissingValue] = {
     with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ s.show) }
     val c = u.rawElements.get(s)
-    if (c < 0) { 
-      do raise(MissingValue(), "Root node " ++ s.show ++ " has no parent.") 
-    } else { 
+    if (c < 0) {
+      do raise(MissingValue(), "Root node " ++ s.show ++ " has no parent.")
+    } else {
       c
     }
   }
@@ -31,11 +31,11 @@ namespace internal {
     }
   }
   def setParent(u: UnionFind, child: Int, parent: Int) = {
-    with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ child.show) }
+    with default[OutOfBounds, Unit] { do raise(MissingValue(), "No node " ++ child.show) }
     u.rawElements.set(child, parent)
   }
   def setRank(u: UnionFind, root: Int, rank: Int) = {
-    with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ root.show) }
+    with default[OutOfBounds, Unit] { do raise(MissingValue(), "No node " ++ root.show) }
     u.rawElements.set(root, -1 * rank - 1)
   }
 }
@@ -66,7 +66,7 @@ def find(u: UnionFind, s: Int): Int / Exception[MissingValue] = {
   }
   val root = goFind(s)
 
-  def goCompress(s: Int): Unit = { 
+  def goCompress(s: Int): Unit = {
     if (not(u.internal::isRoot(s))) {
       val p = u.internal::parent(s)
       u.internal::setParent(s, root)
@@ -82,7 +82,7 @@ def find(u: UnionFind, s: Int): Int / Exception[MissingValue] = {
 ///
 /// O(1)
 def unionRoots(u: UnionFind, x: Int, y: Int): Int / Exception[MissingValue] = {
-  if(not(u.internal::isRoot(x) && u.internal::isRoot(y))) { 
+  if(not(u.internal::isRoot(x) && u.internal::isRoot(y))) {
     panic("unionRoots should only be called on representatives")
   }
 

package/libraries/js/effekt_builtins.js

@@ -56,6 +56,6 @@ $effekt.println = function println$impl(str) {
 
 $effekt.unit = { __unit: true }
 
-$effekt.emptyMatch = function() { throw "empty match" }
+$effekt.unreachable = function() { throw "should not be reachable!" }
 
 $effekt.hole = function(pos) { throw pos + " not implemented yet" }

package/libraries/llvm/forward-declare-c.ll

@@ -7,8 +7,8 @@ declare void @c_io_println(%Pos)
 declare %Pos @c_io_readln()
 declare %Double @c_io_random()
 
-declare void @hole(i8*)
-declare void @duplicated_prompt()
+declare void @hole(i8*) cold
+declare void @duplicated_prompt() cold
 
 declare %Pos @c_ref_fresh(%Pos)
 declare %Pos @c_ref_get(%Pos)