@effekt-lang/effekt 0.77.0 → 0.79.0

package/libraries/common/array.effekt

@@ -63,9 +63,10 @@ extern def unsafeAllocate[T](size: Int) at global: Array[T] =
 
 /// Fills a given array in-place.
 def fill[T](arr: Array[T], filler: T): Unit = {
-  arr.foreachIndex { (idx, _) =>
-    arr.set(idx, filler)
-  }
+  val n = arr.size
+  def go(i: Int): Unit =
+    if (i < n) { arr.set(i, filler); go(i + 1) }
+  go(0)
 }
 
 /// Creates a new Array of size `size` filled with the value `init`
@@ -107,7 +108,7 @@ define void @assertInbounds(i64 %index, %Pos %arr) alwaysinline {
   %in_bounds = icmp ult i64 %index, %size
   br i1 %in_bounds, label %ok, label %out
 out:
-  call void @exit(i64 1)
+  call void @exit(i32 1)
   unreachable
 ok:
   ret void

package/libraries/common/bytearray.effekt

@@ -61,7 +61,7 @@ define void @assertInboundsByteArray(i64 %index, %Pos %arr) alwaysinline {
   %in_bounds = icmp ult i64 %index, %size
   br i1 %in_bounds, label %ok, label %out
 out:
-  call void @exit(i64 1)
+  call void @exit(i32 1)
   unreachable
 ok:
   ret void
@@ -113,17 +113,35 @@ def build(size: Int) { index: Int => Byte }: ByteArray = {
   arr
 }
 
+/// Copies `length`-many bytes from `from` to `to`
+/// starting at `start` (in `from`) and `offset` (in `to`).
+/// The ranges may overlap, even within the same bytearray: the source bytes are
+/// read before any are written. Panics if out of bounds.
+///
+/// O(N)
+def copy(from: ByteArray, start: Int, to: ByteArray, offset: Int, length: Int): Unit =
+  if (length < 0 || start < 0 || offset < 0
+      || start + length > from.size || offset + length > to.size) {
+    <{ "bytearray::copy: range out of bounds" }>
+  } else {
+    unsafeCopy(from, start, to, offset, length)
+  }
+
+/// `copy` without its bounds check.
+/// Corrupts memory if misused; prefer `copy`.
+extern def unsafeCopy(from: ByteArray, start: Int, to: ByteArray, offset: Int, length: Int) at global: Unit =
+  js "bytearray$copy(${from}, ${start}, ${to}, ${offset}, ${length})"
+  chez "(bytevector-copy! ${from} ${start} ${to} ${offset} ${length})"
+  llvm """
+    %z = call %Pos @c_bytearray_copy(%Pos ${from}, %Int ${start}, %Pos ${to}, %Int ${offset}, %Int ${length})
+    ret %Pos %z
+  """
+
 def resize(source: ByteArray, size: Int): ByteArray = {
   val target = allocate(size)
-  val n = min(source.size, target.size)
-  def go(i: Int): ByteArray =
-    if (i < n) {
-      target.set(i, source.get(i))
-      go(i + 1)
-    } else {
-      target
-    }
-  go(0)
+  // safe: `min` establishes the bound for both ranges ~> no check is needed
+  unsafeCopy(source, 0, target, 0, min(source.size, size))
+  target
 }
 
 /// Sorts a given bytearray `arr` in-place using a counting sort,
@@ -190,6 +208,21 @@ extern def toString(arr: ByteArray) at {}: String =
   chez "(utf8->string ${arr})"
 
 extern js """
+  function bytearray$copy(src, srcOff, dst, dstOff, n) {
+    // for small `n`, it's faster to copy manually to avoid allocating `subarray`
+    if (n < 40) {
+      if (srcOff < dstOff) {
+        for (let i = n - 1; i >= 0; --i) dst[dstOff + i] = src[srcOff + i];
+      } else {
+        for (let i = 0; i < n; ++i) dst[dstOff + i] = src[srcOff + i];
+      }
+    } else {
+      // safe: `set` clones the source region first when both share a buffer
+      dst.set(src.subarray(srcOff, srcOff + n), dstOff);
+    }
+    return $effekt.unit;
+  }
+
   function bytearray$set(bytes, index, value) {
     bytes[index] = value;
     return $effekt.unit;
@@ -242,22 +275,8 @@ extern def compareByteArrayImpl(b1: ByteArray, b2: ByteArray) at {}: Int =
   """
   chez "(bytearray$compare ${b1} ${b2})"
 
-def compareByteArray(b1: ByteArray, b2: ByteArray): Ordering = {
-  val ret = compareByteArrayImpl(b1, b2)
-  if (ret == 0) {
-    Equal()
-  } else if (ret < 0) {
-    Less()
-  } else { // ret > 0
-    Greater()
-  }
-}
-
-def compareStringBytes(left: String, right: String): Ordering = {
-  val l = left.fromString
-  val r = right.fromString
-  compareByteArray(l, r)
-}
+def compareByteArray(b1: ByteArray, b2: ByteArray): Ordering =
+  compareByteArrayImpl(b1, b2).fromInt
 
 
 // Streaming

package/libraries/common/char.effekt

@@ -144,6 +144,10 @@ extern def infixGte(x: Char, y: Char) at {}: Bool =
     ret %Pos %adt_boolean
   """
 
+def compareChar(x: Char, y: Char): Ordering =
+  if (x == y) Equal()
+  else if (x < y) Less()
+  else Greater()
 
 /**
  * Determines the number of bytes needed by a codepoint
@@ -155,18 +159,21 @@ def utf8ByteCount(codepoint: Char): Int = codepoint match {
   case c and c >= '\u0080'  and c <= '\u07FF'   => 2
   case c and c >= '\u0800'  and c <= '\uFFFF'   => 3
   case c and c >= '\u10000' and c <= '\u10FFFF' => 4
-  case c => panic("Not a valid code point")
+  case c => <{ "Not a valid code point" }>
 }
 
 def utf16UnitCount(codepoint: Char): Int = codepoint match {
   case c and c >= '\u0000'  and c <= '\uFFFF'   => 1
-  case c and c >= '\u10000' and c <= '\u10FFFF' => 4
-  case c => panic("Not a valid code point")
+  case c and c >= '\u10000' and c <= '\u10FFFF' => 2
+  case c => <{ "Not a valid code point" }>
 }
 
+/// How many index units `c` occupies in the unit that `length` and `unsafeCharAt`
+/// use on this backend. Adding it to a code-point boundary gives the next character.
 extern def charWidth(c: Char) at {}: Int =
-  // JavaScript strings are UTF-16 where every unicode character after 0xffff takes two units
-  js "(${c} > 0xffff) ? 2 : 1"
+  js { utf16UnitCount(c) }
+  chez { 1 }
+  llvm { utf8ByteCount(c) }
 
 
 def decodeChar(): Char / {next[Byte], stop} = {

package/libraries/common/dictionary.effekt

@@ -6,14 +6,40 @@ import bytearray
 import stream
 
 /// Internal trie node type.
+///
+/// Nodes with at most four children are `Branch1` ... `Branch4`, holding their
+/// children behind `Ref`s so that descending along an existing path can
+/// update in place without rebuilding the spine. A fifth child promotes the
+/// node to the dense representation (`Branch256` / `Node256`), a full 256-slot
+/// array indexed by the byte, whose cells are mutable themselves.
+///
+/// Invariant: in the sparse representations, `byte1 < byte2 < byte3 < byte4`
+/// (bytes are unsigned), so iteration is in key order in every representation.
+///
+/// `Leaf`, `Node1` ... `Node4` and `Node256` carry a value at this
+/// position; `Branch1` ... `Branch4` and `Branch256` do not.
+///
+/// No `Trie` value is ever shared between two live positions: insertion
+/// mutates through `Ref`s and array cells, so aliasing a subtree would be
+/// unsound.
 type Trie[A] {
   Empty()
   Leaf(value: A)
-  Branch(children: Array[Trie[A]])
-  Node(value: A, children: Array[Trie[A]])
+  Branch1(byte: Byte, child: Ref[Trie[A]])
+  Node1(value: A, byte: Byte, child: Ref[Trie[A]])
+  Branch2(byte1: Byte, child1: Ref[Trie[A]], byte2: Byte, child2: Ref[Trie[A]])
+  Node2(value: A, byte1: Byte, child1: Ref[Trie[A]], byte2: Byte, child2: Ref[Trie[A]])
+  Branch3(byte1: Byte, child1: Ref[Trie[A]], byte2: Byte, child2: Ref[Trie[A]], byte3: Byte, child3: Ref[Trie[A]])
+  Node3(value: A, byte1: Byte, child1: Ref[Trie[A]], byte2: Byte, child2: Ref[Trie[A]], byte3: Byte, child3: Ref[Trie[A]])
+  Branch4(byte1: Byte, child1: Ref[Trie[A]], byte2: Byte, child2: Ref[Trie[A]], byte3: Byte, child3: Ref[Trie[A]], byte4: Byte, child4: Ref[Trie[A]])
+  Node4(value: A, byte1: Byte, child1: Ref[Trie[A]], byte2: Byte, child2: Ref[Trie[A]], byte3: Byte, child3: Ref[Trie[A]], byte4: Byte, child4: Ref[Trie[A]])
+  Branch256(children: Array[Trie[A]])
+  Node256(value: A, children: Array[Trie[A]])
 }
 
 /// A mutable trie-based dictionary for efficient key-value storage with bytearray keys.
+///
+/// Mutating the dictionary while iterating it (`each`, `eachTagged`) is undefined.
 type Dictionary[A] = Ref[Trie[A]]
 
 /// A record pairing a key with a value for use in streams.
@@ -27,34 +53,104 @@ def insert[A](dictionary: Dictionary[A], key: String, value: A): Unit =
 
 /// Insert a key-value pair into the dictionary with a ByteArray key.
 def insert[A](dictionary: Dictionary[A], key: ByteArray, value: A): Unit = {
+  val n = key.size
+
+  // The rest of the key from position `i` on, as a chain of `Branch1`s
+  // ending in a `Leaf`.
+  def chain(i: Int): Trie[A] =
+    if (i < n) Branch1(key.get(i), ref(chain(i + 1)))
+    else Leaf(value)
+
+  // The four children of a `Branch4`, plus the rest of the key at `b`,
+  // as a full 256-slot array.
+  def densified(byte1: Byte, child1: Ref[Trie[A]], byte2: Byte, child2: Ref[Trie[A]], byte3: Byte, child3: Ref[Trie[A]], byte4: Byte, child4: Ref[Trie[A]], b: Byte, i: Int): Array[Trie[A]] = {
+    val children = array[Trie[A]](256, Empty())
+    children.set(byte1.toInt, child1.get)
+    children.set(byte2.toInt, child2.get)
+    children.set(byte3.toInt, child3.get)
+    children.set(byte4.toInt, child4.get)
+    children.set(b.toInt, chain(i + 1))
+    children
+  }
+
   def go(trie: Trie[A], i: Int): Trie[A] =
-    if (i < key.size) {
+    if (i < n) {
+      val b = key.get(i)
       trie match {
-        case Empty() =>
-          val child = go(Empty(), i + 1)
-          val children = array(256, Empty())
-          children.set(key.get(i).toInt, child)
-          Branch(children)
-        case Leaf(existing) =>
-          val child = go(Empty(), i + 1)
-          val children = array(256, Empty())
-          children.set(key.get(i).toInt, child)
-          Node(existing, children)
-        case Branch(children) =>
-          val child = go(children.get(key.get(i).toInt), i + 1)
-          children.set(key.get(i).toInt, child)
-          Branch(children)
-        case Node(existing, children) =>
-          val child = go(children.get(key.get(i).toInt), i + 1)
-          children.set(key.get(i).toInt, child)
-          Node(existing, children)
+        case Empty() => chain(i)
+        case Leaf(existing) => Node1(existing, b, ref(chain(i + 1)))
+
+        case Branch1(byte1, child1) =>
+          if (b == byte1) { child1.set(go(child1.get, i + 1)); trie }
+          else if (b.toInt < byte1.toInt) Branch2(b, ref(chain(i + 1)), byte1, child1)
+          else Branch2(byte1, child1, b, ref(chain(i + 1)))
+        case Node1(existing, byte1, child1) =>
+          if (b == byte1) { child1.set(go(child1.get, i + 1)); trie }
+          else if (b.toInt < byte1.toInt) Node2(existing, b, ref(chain(i + 1)), byte1, child1)
+          else Node2(existing, byte1, child1, b, ref(chain(i + 1)))
+
+        case Branch2(byte1, child1, byte2, child2) =>
+          if (b == byte1) { child1.set(go(child1.get, i + 1)); trie }
+          else if (b == byte2) { child2.set(go(child2.get, i + 1)); trie }
+          else if (b.toInt < byte1.toInt) Branch3(b, ref(chain(i + 1)), byte1, child1, byte2, child2)
+          else if (b.toInt < byte2.toInt) Branch3(byte1, child1, b, ref(chain(i + 1)), byte2, child2)
+          else Branch3(byte1, child1, byte2, child2, b, ref(chain(i + 1)))
+        case Node2(existing, byte1, child1, byte2, child2) =>
+          if (b == byte1) { child1.set(go(child1.get, i + 1)); trie }
+          else if (b == byte2) { child2.set(go(child2.get, i + 1)); trie }
+          else if (b.toInt < byte1.toInt) Node3(existing, b, ref(chain(i + 1)), byte1, child1, byte2, child2)
+          else if (b.toInt < byte2.toInt) Node3(existing, byte1, child1, b, ref(chain(i + 1)), byte2, child2)
+          else Node3(existing, byte1, child1, byte2, child2, b, ref(chain(i + 1)))
+
+        case Branch3(byte1, child1, byte2, child2, byte3, child3) =>
+          if (b == byte1) { child1.set(go(child1.get, i + 1)); trie }
+          else if (b == byte2) { child2.set(go(child2.get, i + 1)); trie }
+          else if (b == byte3) { child3.set(go(child3.get, i + 1)); trie }
+          else if (b.toInt < byte1.toInt) Branch4(b, ref(chain(i + 1)), byte1, child1, byte2, child2, byte3, child3)
+          else if (b.toInt < byte2.toInt) Branch4(byte1, child1, b, ref(chain(i + 1)), byte2, child2, byte3, child3)
+          else if (b.toInt < byte3.toInt) Branch4(byte1, child1, byte2, child2, b, ref(chain(i + 1)), byte3, child3)
+          else Branch4(byte1, child1, byte2, child2, byte3, child3, b, ref(chain(i + 1)))
+        case Node3(existing, byte1, child1, byte2, child2, byte3, child3) =>
+          if (b == byte1) { child1.set(go(child1.get, i + 1)); trie }
+          else if (b == byte2) { child2.set(go(child2.get, i + 1)); trie }
+          else if (b == byte3) { child3.set(go(child3.get, i + 1)); trie }
+          else if (b.toInt < byte1.toInt) Node4(existing, b, ref(chain(i + 1)), byte1, child1, byte2, child2, byte3, child3)
+          else if (b.toInt < byte2.toInt) Node4(existing, byte1, child1, b, ref(chain(i + 1)), byte2, child2, byte3, child3)
+          else if (b.toInt < byte3.toInt) Node4(existing, byte1, child1, byte2, child2, b, ref(chain(i + 1)), byte3, child3)
+          else Node4(existing, byte1, child1, byte2, child2, byte3, child3, b, ref(chain(i + 1)))
+
+        case Branch4(byte1, child1, byte2, child2, byte3, child3, byte4, child4) =>
+          if (b == byte1) { child1.set(go(child1.get, i + 1)); trie }
+          else if (b == byte2) { child2.set(go(child2.get, i + 1)); trie }
+          else if (b == byte3) { child3.set(go(child3.get, i + 1)); trie }
+          else if (b == byte4) { child4.set(go(child4.get, i + 1)); trie }
+          else Branch256(densified(byte1, child1, byte2, child2, byte3, child3, byte4, child4, b, i))
+        case Node4(existing, byte1, child1, byte2, child2, byte3, child3, byte4, child4) =>
+          if (b == byte1) { child1.set(go(child1.get, i + 1)); trie }
+          else if (b == byte2) { child2.set(go(child2.get, i + 1)); trie }
+          else if (b == byte3) { child3.set(go(child3.get, i + 1)); trie }
+          else if (b == byte4) { child4.set(go(child4.get, i + 1)); trie }
+          else Node256(existing, densified(byte1, child1, byte2, child2, byte3, child3, byte4, child4, b, i))
+
+        case Branch256(children) =>
+          children.set(b.toInt, go(children.get(b.toInt), i + 1)); trie
+        case Node256(_, children) =>
+          children.set(b.toInt, go(children.get(b.toInt), i + 1)); trie
       }
     } else {
       trie match {
         case Empty() => Leaf(value)
         case Leaf(_) => Leaf(value)
-        case Node(_, children) => Node(value, children)
-        case Branch(children) => Node(value, children)
+        case Branch1(byte1, child1) => Node1(value, byte1, child1)
+        case Node1(_, byte1, child1) => Node1(value, byte1, child1)
+        case Branch2(byte1, child1, byte2, child2) => Node2(value, byte1, child1, byte2, child2)
+        case Node2(_, byte1, child1, byte2, child2) => Node2(value, byte1, child1, byte2, child2)
+        case Branch3(byte1, child1, byte2, child2, byte3, child3) => Node3(value, byte1, child1, byte2, child2, byte3, child3)
+        case Node3(_, byte1, child1, byte2, child2, byte3, child3) => Node3(value, byte1, child1, byte2, child2, byte3, child3)
+        case Branch4(byte1, child1, byte2, child2, byte3, child3, byte4, child4) => Node4(value, byte1, child1, byte2, child2, byte3, child3, byte4, child4)
+        case Node4(_, byte1, child1, byte2, child2, byte3, child3, byte4, child4) => Node4(value, byte1, child1, byte2, child2, byte3, child3, byte4, child4)
+        case Branch256(children) => Node256(value, children)
+        case Node256(_, children) => Node256(value, children)
       }
     }
   dictionary.set(go(dictionary.get, 0))
@@ -68,18 +164,56 @@ def lookup[A](dictionary: Dictionary[A], key: String): Option[A] =
 def lookup[A](dictionary: Dictionary[A], key: ByteArray): Option[A] = {
   def go(trie: Trie[A], i: Int): Option[A] =
     if (i < key.size) {
+      val b = key.get(i)
       trie match {
         case Empty() => None()
         case Leaf(_) => None()
-        case Branch(children) => go(children.get(key.get(i).toInt), i + 1)
-        case Node(_, children) => go(children.get(key.get(i).toInt), i + 1)
+        case Branch1(byte1, child1) =>
+          if (b == byte1) go(child1.get, i + 1) else None()
+        case Node1(_, byte1, child1) =>
+          if (b == byte1) go(child1.get, i + 1) else None()
+        case Branch2(byte1, child1, byte2, child2) =>
+          if (b == byte1) go(child1.get, i + 1)
+          else if (b == byte2) go(child2.get, i + 1)
+          else None()
+        case Node2(_, byte1, child1, byte2, child2) =>
+          if (b == byte1) go(child1.get, i + 1)
+          else if (b == byte2) go(child2.get, i + 1)
+          else None()
+        case Branch3(byte1, child1, byte2, child2, byte3, child3) =>
+          if (b == byte1) go(child1.get, i + 1)
+          else if (b == byte2) go(child2.get, i + 1)
+          else if (b == byte3) go(child3.get, i + 1)
+          else None()
+        case Node3(_, byte1, child1, byte2, child2, byte3, child3) =>
+          if (b == byte1) go(child1.get, i + 1)
+          else if (b == byte2) go(child2.get, i + 1)
+          else if (b == byte3) go(child3.get, i + 1)
+          else None()
+        case Branch4(byte1, child1, byte2, child2, byte3, child3, byte4, child4) =>
+          if (b == byte1) go(child1.get, i + 1)
+          else if (b == byte2) go(child2.get, i + 1)
+          else if (b == byte3) go(child3.get, i + 1)
+          else if (b == byte4) go(child4.get, i + 1)
+          else None()
+        case Node4(_, byte1, child1, byte2, child2, byte3, child3, byte4, child4) =>
+          if (b == byte1) go(child1.get, i + 1)
+          else if (b == byte2) go(child2.get, i + 1)
+          else if (b == byte3) go(child3.get, i + 1)
+          else if (b == byte4) go(child4.get, i + 1)
+          else None()
+        case Branch256(children) => go(children.get(b.toInt), i + 1)
+        case Node256(_, children) => go(children.get(b.toInt), i + 1)
       }
     } else {
       trie match {
-        case Empty() => None()
         case Leaf(value) => Some(value)
-        case Branch(_) => None()
-        case Node(value, _) => Some(value)
+        case Node1(value, _, _) => Some(value)
+        case Node2(value, _, _, _, _) => Some(value)
+        case Node3(value, _, _, _, _, _, _) => Some(value)
+        case Node4(value, _, _, _, _, _, _, _, _) => Some(value)
+        case Node256(value, _) => Some(value)
+        case _ => None()
       }
     }
   go(dictionary.get, 0)
@@ -87,48 +221,104 @@ def lookup[A](dictionary: Dictionary[A], key: ByteArray): Option[A] = {
 
 /// Collect key-value pairs from a stream of Tagged elements into a fresh Dictionary.
 def collect[A] { stream: () => Unit / emit[Tagged[A]] }: Dictionary[A] = {
-  val dictionary = ref(Empty())
+  val dictionary = empty[A]()
   for[Tagged[A]] { stream() } { case Tagged(bytes, value) =>
     dictionary.insert(bytes, value)
   }
-  return dictionary
+  dictionary
 }
 
-/// Emit all values stored in the dictionary as a push stream.
+/// Emit all values stored in the dictionary as a push stream,
+/// in lexicographic key order (a key before its extensions).
 def each[A](dictionary: Dictionary[A]): Unit / emit[A] = {
   def go(trie: Trie[A]): Unit / emit[A] =
     trie match {
       case Empty() => ()
       case Leaf(value) => do emit(value)
-      case Branch(children) =>
-        each(0, children.size) { i => go(children.get(i)) }
-      case Node(value, children) =>
+      case Branch1(_, child1) => go(child1.get)
+      case Node1(value, _, child1) =>
+        do emit(value); go(child1.get)
+      case Branch2(_, child1, _, child2) =>
+        go(child1.get); go(child2.get)
+      case Node2(value, _, child1, _, child2) =>
+        do emit(value); go(child1.get); go(child2.get)
+      case Branch3(_, child1, _, child2, _, child3) =>
+        go(child1.get); go(child2.get); go(child3.get)
+      case Node3(value, _, child1, _, child2, _, child3) =>
+        do emit(value); go(child1.get); go(child2.get); go(child3.get)
+      case Branch4(_, child1, _, child2, _, child3, _, child4) =>
+        go(child1.get); go(child2.get); go(child3.get); go(child4.get)
+      case Node4(value, _, child1, _, child2, _, child3, _, child4) =>
+        do emit(value); go(child1.get); go(child2.get); go(child3.get); go(child4.get)
+      case Branch256(children) =>
+        each(0, 256) { i => go(children.get(i)) }
+      case Node256(value, children) =>
         do emit(value)
-        each(0, children.size) { i => go(children.get(i)) }
+        each(0, 256) { i => go(children.get(i)) }
     }
   go(dictionary.get)
 }
 
-/// Emit all key-value pairs stored in the dictionary as a push stream of Tagged elements.
+/// Emit all key-value pairs stored in the dictionary as a push stream of
+/// Tagged elements, in lexicographic key order (a key before its extensions).
 def eachTagged[A](dictionary: Dictionary[A]): Unit / emit[Tagged[A]] = {
-  def fromBytesReverse(bytes: List[Byte], n: Int): ByteArray = {
-    val key = bytearray::allocate(n)
-    foreachIndex(bytes) { (i, b) => key.set(n - 1 - i, b) }
-    key
+  var buffer = bytearray::allocate(32)
+  // `depth` grows by exactly one per level, so `depth <= buffer.size` always
+  // holds and a single doubling suffices.
+  def push(depth: Int, b: Byte): Unit = {
+    if (depth >= buffer.size) {
+      buffer = buffer.resize(buffer.size * 2)
+    }
+    buffer.set(depth, b)
   }
-  def go(trie: Trie[A], key: List[Byte], n: Int): Unit =
+  def emitAt(depth: Int, value: A): Unit = {
+    val key = bytearray::allocate(depth)
+    // safe: `key` has exactly `depth` bytes, and `depth` is within `buffer`'s capacity.
+    bytearray::unsafeCopy(buffer, 0, key, 0, depth)
+    do emit(Tagged(key, value))
+  }
+  def go(trie: Trie[A], depth: 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.get(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.get(i), Cons(i.toByte, key), n + 1)
-        }
+      case Leaf(value) => emitAt(depth, value)
+      case Branch1(byte1, child1) =>
+        push(depth, byte1); go(child1.get, depth + 1)
+      case Node1(value, byte1, child1) =>
+        emitAt(depth, value)
+        push(depth, byte1); go(child1.get, depth + 1)
+      case Branch2(byte1, child1, byte2, child2) =>
+        push(depth, byte1); go(child1.get, depth + 1)
+        push(depth, byte2); go(child2.get, depth + 1)
+      case Node2(value, byte1, child1, byte2, child2) =>
+        emitAt(depth, value)
+        push(depth, byte1); go(child1.get, depth + 1)
+        push(depth, byte2); go(child2.get, depth + 1)
+      case Branch3(byte1, child1, byte2, child2, byte3, child3) =>
+        push(depth, byte1); go(child1.get, depth + 1)
+        push(depth, byte2); go(child2.get, depth + 1)
+        push(depth, byte3); go(child3.get, depth + 1)
+      case Node3(value, byte1, child1, byte2, child2, byte3, child3) =>
+        emitAt(depth, value)
+        push(depth, byte1); go(child1.get, depth + 1)
+        push(depth, byte2); go(child2.get, depth + 1)
+        push(depth, byte3); go(child3.get, depth + 1)
+      case Branch4(byte1, child1, byte2, child2, byte3, child3, byte4, child4) =>
+        push(depth, byte1); go(child1.get, depth + 1)
+        push(depth, byte2); go(child2.get, depth + 1)
+        push(depth, byte3); go(child3.get, depth + 1)
+        push(depth, byte4); go(child4.get, depth + 1)
+      case Node4(value, byte1, child1, byte2, child2, byte3, child3, byte4, child4) =>
+        emitAt(depth, value)
+        push(depth, byte1); go(child1.get, depth + 1)
+        push(depth, byte2); go(child2.get, depth + 1)
+        push(depth, byte3); go(child3.get, depth + 1)
+        push(depth, byte4); go(child4.get, depth + 1)
+      case Branch256(children) =>
+        each(0, 256) { i => push(depth, i.toByte); go(children.get(i), depth + 1) }
+      case Node256(value, children) =>
+        emitAt(depth, value)
+        each(0, 256) { i => push(depth, i.toByte); go(children.get(i), depth + 1) }
     }
-  go(dictionary.get, Nil(), 0)
-}
+  go(dictionary.get, 0)
+}
+

package/libraries/common/effekt.effekt

@@ -72,7 +72,7 @@ extern def readln() at async: String =
   jsNode "$effekt.capture(callback => $effekt.readln(callback))"
   llvm """
     %result = call %Pos @c_io_readln()
-    tail call void @resume_Pos(%Stack %stack, %Pos %result)
+    notail call void @resume_Pos(%Stack %stack, %Pos %result)
     ret void
   """
 
@@ -191,20 +191,25 @@ extern def random() at io: Double =
 // extern io def freshGlobal[T](t: T): Ref[T] at global = js "$effekt.fresh(${t})"
 
 
-// Equality
+// Comparison
 // ========
 
 /// 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.
+/// - `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.
 type Ordering {
   Less();
   Equal();
   Greater()
 }
 
+def ordering::fromInt(n: Int): Ordering =
+  if (n == 0) Equal()
+  else if (n < 0) Less()
+  else Greater()
+
 def compareInt(n: Int, m: Int) =
   if (n == m) Equal()
   else if (n < m) Less()
@@ -215,16 +220,8 @@ extern def genericCompareImpl[R](x: R, y: R) at {}: Int =
 
 /// Compares two values of the same type, returning an `Ordering`.
 /// Only available on the JavaScript backend.
-def genericCompare[R](x: R, y: R): Ordering = {
-  val ret = genericCompareImpl(x, y)
-  if (ret == 0) {
-    Equal()
-  } else if (ret < 0) {
-    Less()
-  } else { // ret > 0
-    Greater()
-  }
-}
+def genericCompare[R](x: R, y: R): Ordering =
+  genericCompareImpl(x, y).fromInt
 
 def println(o: Ordering): Unit = println(o.show)
 

package/libraries/common/io/filesystem.effekt

@@ -245,49 +245,49 @@ namespace internal {
   extern def openForReading(path: String) at async: Int =
     jsNode "$effekt.capture(callback => open(${path}, 'r', callback))"
     llvm """
-      call void @c_fs_open_reading(%Pos ${path}, %Stack %stack)
+      notail call void @c_fs_open_reading(%Pos ${path}, %Stack %stack)
       ret void
     """
 
   extern def openForWriting(path: String) at async: Int =
     jsNode "$effekt.capture(callback => open(${path}, 'w', callback))"
     llvm """
-      call void @c_fs_open_writing(%Pos ${path}, %Stack %stack)
+      notail call void @c_fs_open_writing(%Pos ${path}, %Stack %stack)
       ret void
     """
 
   extern def openForAppending(path: String) at async: Int =
     jsNode "$effekt.capture(callback => open(${path}, 'a', callback))"
     llvm """
-      call void @c_fs_open_appending(%Pos ${path}, %Stack %stack)
+      notail call void @c_fs_open_appending(%Pos ${path}, %Stack %stack)
       ret void
     """
 
   extern def read(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int) at async: Int =
     jsNode "$effekt.capture(callback => read(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
-      call void @c_fs_read(%Int ${file}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Int ${position}, %Stack %stack)
+      notail call void @c_fs_read(%Int ${file}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Int ${position}, %Stack %stack)
       ret void
     """
 
   extern def write(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int) at async: Int =
     jsNode "$effekt.capture(callback => write(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
-      call void @c_fs_write(%Int ${file}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Int ${position}, %Stack %stack)
+      notail call void @c_fs_write(%Int ${file}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Int ${position}, %Stack %stack)
       ret void
     """
 
   extern def close(file: Int) at async: Int =
     jsNode "$effekt.capture(callback => close(${file}, callback))"
     llvm """
-      call void @c_fs_close(%Int ${file}, %Stack %stack)
+      notail call void @c_fs_close(%Int ${file}, %Stack %stack)
       ret void
     """
 
   extern def mkdir(path: String) at async: Int =
     jsNode "$effekt.capture(callback => mkdir(${path}, callback))"
     llvm """
-      call void @c_fs_mkdir(%Pos ${path}, %Stack %stack)
+      notail call void @c_fs_mkdir(%Pos ${path}, %Stack %stack)
       ret void
     """