@effekt-lang/effekt 0.77.0 → 0.79.0

package/libraries/common/io/network.effekt

@@ -147,28 +147,28 @@ namespace internal {
   extern def connect(host: String, port: Int) at async: Int =
     jsNode "$effekt.capture(k => tcp$connect(${host}, ${port}, k))"
     llvm """
-      call void @c_tcp_connect(%Pos ${host}, %Int ${port}, %Stack %stack)
+      notail call void @c_tcp_connect(%Pos ${host}, %Int ${port}, %Stack %stack)
       ret void
     """
 
   extern def read(handle: Int, buffer: ByteArray, offset: Int, size: Int) at async: Int =
     jsNode "$effekt.capture(k => tcp$read(${handle}, ${buffer}, ${offset}, ${size}, k))"
     llvm """
-      call void @c_tcp_read(%Int ${handle}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Stack %stack)
+      notail call void @c_tcp_read(%Int ${handle}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Stack %stack)
       ret void
     """
 
   extern def write(handle: Int, buffer: ByteArray, offset: Int, size: Int) at async: Int =
     jsNode "$effekt.capture(k => tcp$write(${handle}, ${buffer}, ${offset}, ${size}, k))"
     llvm """
-      call void @c_tcp_write(%Int ${handle}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Stack %stack)
+      notail call void @c_tcp_write(%Int ${handle}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Stack %stack)
       ret void
     """
 
   extern def close(handle: Int) at async: Unit =
     jsNode "$effekt.capture(k => tcp$close(${handle}, k))"
     llvm """
-      call void @c_tcp_close(%Int ${handle}, %Stack %stack)
+      notail call void @c_tcp_close(%Int ${handle}, %Stack %stack)
       ret void
     """
 
@@ -182,14 +182,14 @@ namespace internal {
   extern def listen(listener: Int, handler: Connection => Unit at {io, async, global}) at async: Int =
     jsNode "$effekt.capture(k => tcp$listen(${listener}, ${handler}, k))"
     llvm """
-      call void @c_tcp_listen(%Int ${listener}, %Pos ${handler}, %Stack %stack)
+      notail call void @c_tcp_listen(%Int ${listener}, %Pos ${handler}, %Stack %stack)
       ret void
     """
 
   extern def shutdown(handle: Int) at async: Unit =
     jsNode "$effekt.capture(k => tcp$shutdown(${handle}, k))"
     llvm """
-      call void @c_tcp_shutdown(%Int ${handle}, %Stack %stack)
+      notail call void @c_tcp_shutdown(%Int ${handle}, %Stack %stack)
       ret void
     """
 

package/libraries/common/io/signal.effekt

@@ -74,18 +74,18 @@ extern def fire[A, B](signal: Signal[A, B], value: A) at async: B =
     store i64 2, ptr %statePtr
     store %Stack %stack, ptr %stackPtr
     store %Pos ${value}, ptr %valuePtr
-    call void @erasePositive(%Pos ${signal})
+    notail call void @erasePositive(%Pos ${signal})
     ret void
   fire:
     %otherStack = load %Stack, ptr %stackPtr
     %otherValue = load %Pos, ptr %valuePtr
     store i64 3, ptr %statePtr
-    call void @erasePositive(%Pos ${signal})
-    call void @resume_Pos(%Stack %otherStack, %Pos ${value})
-    call void @resume_Pos(%Stack %stack, %Pos %otherValue)
+    notail call void @erasePositive(%Pos ${signal})
+    notail call void @resume_Pos(%Stack %otherStack, %Pos ${value})
+    notail call void @resume_Pos(%Stack %stack, %Pos %otherValue)
     ret void
   panic:
-    call void @exit(i64 1)
+    notail call void @exit(i32 1)
     ret void
   """
 
@@ -102,18 +102,18 @@ extern def wait[A, B](signal: Signal[A, B], value: B) at async: A =
     store i64 1, ptr %statePtr
     store %Stack %stack, ptr %stackPtr
     store %Pos ${value}, ptr %valuePtr
-    call void @erasePositive(%Pos ${signal})
+    notail call void @erasePositive(%Pos ${signal})
     ret void
   wait:
     %otherStack = load %Stack, ptr %stackPtr
     %otherValue = load %Pos, ptr %valuePtr
     store i64 3, ptr %statePtr
-    call void @erasePositive(%Pos ${signal})
-    call void @resume_Pos(%Stack %otherStack, %Pos ${value})
-    call void @resume_Pos(%Stack %stack, %Pos %otherValue)
+    notail call void @erasePositive(%Pos ${signal})
+    notail call void @resume_Pos(%Stack %otherStack, %Pos ${value})
+    notail call void @resume_Pos(%Stack %stack, %Pos %otherValue)
     ret void
   panic:
-    call void @exit(i64 1)
+    notail call void @exit(i32 1)
     ret void
   """
 

package/libraries/common/io/time.effekt

@@ -7,6 +7,6 @@ extern llvm """
 extern def sleep(millis: Int) at async: Unit =
   js "$effekt.capture(k => setTimeout(() => k($effekt.unit), ${millis}))"
   llvm """
-    call void @c_timer_start(%Int ${millis}, %Stack %stack)
+    notail call void @c_timer_start(%Int ${millis}, %Stack %stack)
     ret void
   """

package/libraries/common/io.effekt

@@ -11,22 +11,22 @@ extern llvm """
 extern def spawn[T](task: () => T at {io, async, global}) at async: Unit =
   js "$effekt.capture(k => { setTimeout(() => k($effekt.unit), 0); return $effekt.run(${task}) })"
   llvm """
-    call void @c_yield(%Stack %stack)
-    call void @run(%Pos ${task})
+    notail call void @c_yield(%Stack %stack)
+    notail call void @run(%Pos ${task})
     ret void
   """
 
 extern def yield() at async: Unit =
   js "$effekt.capture(k => setTimeout(() => k($effekt.unit), 0))"
   llvm """
-    call void @c_yield(%Stack %stack)
+    notail call void @c_yield(%Stack %stack)
     ret void
   """
 
 extern def abort() at async: Nothing =
   js "$effekt.capture(k => undefined)"
   llvm """
-    call void @eraseStack(%Stack %stack)
+    notail call void @eraseStack(%Stack %stack)
     ret void
   """
 

package/libraries/common/list.effekt

@@ -820,6 +820,28 @@ def partition[A](l: List[A]) { pred: A => Bool }: (List[A], List[A]) = {
   (lefts.reverse, rights.reverse)
 }
 
+/// List functions that we discourage to use, but should still be available
+namespace slow {
+  /// Find the first element in a list which satisfies a given predicate.
+  /// If there is no such element, returns None.
+  /// 
+  /// Examples:
+  /// ```
+  /// > [].slow::find{ x => x.mod(2) == 0 }
+  /// None()
+  /// > [1, 3, 6].slow::find{ x => x.mod(2) == 0 }
+  /// Some(6)
+  /// > [2, 4, 6].slow::find{ x => x.mod(2) == 0 }
+  /// Some(2)
+  /// ```
+  /// 
+  /// O(N)
+  def find[A](list: List[A]){ pred: A => Bool }: Option[A] = list match {
+    case Cons(x, xs) => if (pred(x)) Some(x) else find(xs){pred}
+    case Nil() => None()
+  }
+}
+
 /// Utilities for sorting, see 'sortBy' for more details.
 namespace sort {
   /// Splits the given list into monotonic segments (so a list of lists).

package/libraries/common/map.effekt

@@ -80,19 +80,13 @@ def get[K, V](m: Map[K, V], k: K): Option[V] = internal::get(m.tree, m.compare,
 ///
 /// O(log N)
 def getOrElse[K, V](m: Map[K, V], k: K) { default: => V }: V =
-  internal::get(m.tree, m.compare, k) match {
-    case None() => default()
-    case Some(v) => v
-  }
+  internal::getOrElse(m.tree, m.compare, k) {default}
 
 /// Check if map `m` contains a key `k`.
 ///
 /// O(log N)
 def contains[K, V](m: Map[K, V], k: K): Bool =
-  internal::get(m.tree, m.compare, k) match {
-    case None() => false
-    case Some(_) => true
-  }
+  internal::contains(m.tree, m.compare, k)
 
 /// Get minimum in the map `m`.
 ///
@@ -354,15 +348,10 @@ def collect[K, V](?compare: (K, K) => Ordering at {}) { stream: () => Unit / emi
 namespace returning {
   /// Collects `(key, value)` pairs from a push stream producer `stream` into a new `map`,
   /// using the provided `compare` function, returning the result of the producer as well as the collected map.
-  def collect[K, V, R](?compare: (K, K) => Ordering at {}) { stream: () => R / emit[(K, V)] }: (R, Map[K, V]) =
-    var map = map::empty[K, V](compare)
-    val r = try {
-      stream()
-    } with emit[(K, V)] { case (k, v) =>
-      map = map.put(k, v)
-      resume(())
-    }
-    (r, map)
+  def collect[K, V, R](?compare: (K, K) => Ordering at {}) { stream: () => R / emit[(K, V)] }: (R, Map[K, V]) = {
+    val (r, tree) = internal::collect[K, V, R](compare) {stream}
+    (r, Map(tree, compare))
+  }
 }
 
 // Internal tree representation
@@ -417,6 +406,33 @@ namespace internal {
       case Bin(size, _, _, _, _) => size
     }
 
+  /// Look up `k` in the tree `m`, handing the value it is bound to to `found`,
+  /// or running `missing` if there is none.
+  ///
+  /// O(log N)
+  def getWith[K, V, R](m: Tree[K, V], compare: (K, K) => Ordering at {}, k: K) { found: V => R } { missing: => R }: R =
+    m match {
+      case Tip() => missing()
+      case Bin(_, k2, v, l, r) =>
+        compare(k, k2) match {
+          case Less() => getWith(l, compare, k) {found} {missing}
+          case Greater() => getWith(r, compare, k) {found} {missing}
+          case Equal() => found(v)
+        }
+    }
+
+  /// Whether the tree `m` binds the key `k`.
+  ///
+  /// O(log N)
+  def contains[K, V](m: Tree[K, V], compare: (K, K) => Ordering at {}, k: K): Bool =
+    getWith(m, compare, k) { _v => true } { false }
+
+  /// The value bound to `k` in the tree `m`, or `default` if there is none.
+  ///
+  /// O(log N)
+  def getOrElse[K, V](m: Tree[K, V], compare: (K, K) => Ordering at {}, k: K) { default: => V }: V =
+    getWith(m, compare, k) { v => v } {default}
+
   /// Insert a new key `k` and value `v` into the tree `m`.
   /// If the key `k` is already present in `m`, its associated value is replaced with `v`.
   ///
@@ -451,15 +467,7 @@ namespace internal {
   ///
   /// O(log N)
   def get[K, V](m: Tree[K, V], compare: (K, K) => Ordering at {}, k: K): Option[V] =
-    m match {
-      case Tip() => None()
-      case Bin(size, k2, v, l, r) =>
-        compare(k, k2) match {
-          case Less() => get(l, compare, k)
-          case Greater() => get(r, compare, k)
-          case Equal() => Some(v)
-        }
-    }
+    getWith(m, compare, k) { v => Some(v) } { None() }
 
   /// Get minimum in the tree `m`.
   ///
@@ -600,98 +608,184 @@ namespace internal {
     go(m)
   }
 
+  /// A balanced subtree waiting to be joined, and the key separating it from the pairs collected after it.
+  ///
+  /// A list of these is the *right* spine of the tree being built.
+  /// Their sizes strictly increase towards the back, so the list is the digits of a binary counter.
+  record Waiting[K, V](size: Int, key: K, value: V, tree: Tree[K, V])
+
+  /// Collect `(key, value)` pairs from a push stream producer `stream` into a tree,
+  /// returning the result of the producer as well.
+  /// Consider using `map::fromList` if you know the full list.
+  ///
+  /// O(N) if the stream is sorted by key (in _either_ direction),
+  /// O(N log N) otherwise
+  def collect[K, V, R](compare: (K, K) => Ordering at {}) { stream: () => R / emit[(K, V)] }: (R, Tree[K, V]) = {
+    // Note that `fromList` is always better since it knows the whole list of pairs in advance,
+    // whereas we have to be streaming here. Otherwise the functions are very similar...
+
+    // The lowest digit of the binary counter is a lone pair, kept as the leaf it will one day become. :)
+    var lowest: Tree[K, V] = Tip()
+    var spine: List[Waiting[K, V]] = Nil()
+    var tree = Tip()
+    // which way the current run is going; is `Equal` once a monotone run is over
+    var direction: Ordering = Less()
+
+    // How the currently collected pair compares with the one collected last.
+    def compareLast(k: K): Ordering =
+      lowest match {
+        case Bin(_, previous, _, _, _) => compare(previous, k)
+        case Tip() => spine match {
+          case Nil() => Less()
+          case Cons(Waiting(_, previous, _, _), _) => compare(previous, k)
+        }
+      }
+
+    // Give the pair collected last a new value, overwriting the existing one.
+    def rebind(v: V): Unit =
+      lowest match {
+        case Bin(_, k, _, _, _) =>
+          lowest = singleton(k, v)
+        case Tip() => spine match {
+          case Nil() => ()
+          case Cons(Waiting(size, k, _, tree), more) =>
+            spine = Cons(Waiting(size, k, v, tree), more)
+        }
+      }
+
+    // Increment the binary counter: carry while the next subtree has the same size.
+    def extend(k: K, v: V): Unit = {
+      def carry(size: Int, subtree: Tree[K, V], rest: List[Waiting[K, V]]): List[Waiting[K, V]] =
+        rest match {
+          case Nil() => [Waiting(size, k, v, subtree)]
+          case Cons(Waiting(s, k2, v2, t), more) =>
+            if (s == size) {
+              val merged = if (direction is Greater()) bin(k2, v2, subtree, t) else bin(k2, v2, t, subtree)
+              carry(2 * size + 1, merged, more)
+            } else {
+              Cons(Waiting(size, k, v, subtree), rest)
+            }
+        }
+
+      lowest match {
+        case Tip() => lowest = singleton(k, v)
+        case Bin(_, _, _, _, _) =>
+          val leaf = lowest
+          lowest = Tip()
+          spine = carry(1, leaf, spine)
+      }
+    }
+
+    def joinSpineWith(spine: List[Waiting[K, V]], whole: Tree[K, V]): Tree[K, V] =
+      spine match {
+        case Nil() => whole
+        case Cons(Waiting(_, k, v, subtree), more) =>
+          val joined = if (direction is Greater()) link(k, v, whole, subtree) else link(k, v, subtree, whole)
+          more.joinSpineWith(joined)
+      }
+
+    val result = try {
+      stream()
+    } with emit[(K, V)] { case (k, v) =>
+      // as long as the keys all keep going the same way, we can build a tree in O(N) time
+      direction match {
+        // the run is over, so we have to insert each new pair without a shortcut
+        case Equal() => tree = tree.put(compare, k, v)
+        case _ =>
+          (compareLast(k), direction) match {
+            case (Equal(), _) => rebind(v)
+            case (Less(), Less()) => extend(k, v)
+            case (Greater(), Greater()) => extend(k, v)
+            case (ordering, _) =>
+              // the new key goes against the run:
+              if (spine is Nil()) {
+                // - if it's the first pair, we just set the direction
+                direction = ordering
+                extend(k, v)
+              } else {
+                // - if it's not the first pair, we have to join up the run and use the slow path
+                tree = spine.joinSpineWith(lowest).put(compare, k, v)
+                direction = Equal()
+              }
+          }
+      }
+
+      resume(())
+    }
+
+    (result, if (direction is Equal()) tree else spine.joinSpineWith(lowest))
+  }
+
   /// Create a tree from a list of (key, value) pairs.
   /// If the list contains more than one value for the same key,
   /// only the last value is used in the tree.
   ///
-  /// O(N) if the list is sorted by key,
+  /// O(N) if the list is sorted by key (in _either_ direction),
   /// O(N log N) otherwise
-  def fromList[K, V](pairs: List[(K, V)], compare: (K, K) => Ordering at {}): Tree[K, V] = {
+  def fromList[K, V](pairs: List[(K, V)], compare: (K, K) => Ordering at {}): Tree[K, V] =
     pairs match {
       case Nil() => Tip()
       case Cons((k, v), Nil()) => singleton(k, v)
-      case Cons((k, v), rest) =>
-        // TODO: this function should really, **really** get inlined!
-        def notOrdered(k: K, pairs: List[(K, V)]) = {
-          pairs match {
-            case Nil() => false
-            case Cons((k2, _), _) =>  // k >= k2
-              compare(k, k2) match {
-                case Less() => false
-                case Greater() => true
-                case Equal() => true
+      case Cons(_, _) =>
+        // the first pair not yet taken, and whether the run repeated a key
+        var rest = pairs
+        var repeated = false
+        // which way the current run is going; is `Equal` once a monotone run is over
+        var direction: Ordering = Equal()
+
+        // How many distinct keys the non-decreasing run at the front of `ps` holds.
+        def runLength(ps: List[(K, V)], count: Int): Int =
+          ps match {
+            case Nil() => count
+            case Cons((k, _), tail) => tail match { // note: tail is effectivelly an @-pattern!
+              case Nil() => count + 1
+              case Cons((next, _), _) => (compare(k, next), direction) match {
+                case (Less()   , Less()   ) => runLength(tail, count + 1)
+                case (Greater(), Greater()) => runLength(tail, count + 1)
+                case (Equal(), _) => repeated = true; runLength(tail, count)
+
+                // the first comparison that is not `Equal` settles which way we go
+                case (ordering, Equal()) => direction = ordering; runLength(tail, count + 1)
+                case _ => count + 1
               }
+            }
           }
-        }
 
-        // Naive insertion, used for the worst-case scenario when the list is not sorted by key
-        def insertMany(m: Tree[K, V], pairs: List[(K, V)]) = {
-          var treeSoFar = m
-          pairs.foreach { case (k, v) =>
-            treeSoFar = treeSoFar.put(compare, k, v)
+        // Advance `rest` past any repeats of `k`, giving back the last binding of it.
+        def lastBinding(k: K, v: V): V =
+          if (rest is Cons((next, value), tail) and compare(k, next) is Equal()) {
+            rest = tail
+            lastBinding(k, value)
+          } else {
+            v
           }
-          treeSoFar
-        }
 
-        // Returns a triple `(tree, xs, ys)`
-        //
-        // Invariant: At least one of `xs`, `ys` is empty.
-        // Moreover, if `ys` is nonempty, its keys are **not** ordered!
-        // Otherwise, all of the seen keys have been ordered so far.
-        //
-        // TODO: Possibly use a better type to encode the invariant?
-        def create(level: Int, pairs: List[(K, V)]): (Tree[K, V], List[(K, V)], List[(K, V)]) = {
-          pairs match {
-            case Nil() => (Tip(), [], [])
-            case Cons((k, v), rest) =>
-              if (level == 1) {
-                val one = singleton(k, v)
-                if (notOrdered(k, rest)) {
-                  (one, [], rest)
-                } else {
-                  (one, rest, [])
-                }
-              } else {
-                val res = create(level.bitwiseShr(1), pairs)
-                res match {
-                  case (_, Nil(), _) => res
-                  case (l, Cons((k2, v2), Nil()), zs) => (l.putMax(k2, v2), [], zs)
-                  case (l, Cons((k2, v2), rest2), _) =>
-                    // @-pattern
-                    val xs = Cons((k2, v2), rest2)
-
-                    if (notOrdered(k2, rest2)) { (l, [], xs) }
-                    else {
-                      val (r, zs, ws) = create(level.bitwiseShr(1), rest2);
-                      (link(k2, v2, l, r), zs, ws)
-                    }
-                }
-              }
+        // Shape `count` distinct keys from `rest` into a balanced tree, leaving `rest` on the first pair not taken.
+        // The order is established already, so knowing the size lays the tree out from the root down, one node per key.
+        def fromSorted(count: Int): Tree[K, V] =
+          if (count <= 0) Tip() else {
+            val half = (count - 1) / 2
+            val front = half.fromSorted
+            rest match {
+              case Nil() => <{ "fromList: fewer pairs than counted" }>
+              case Cons((k, v), tail) =>
+                rest = tail
+                val value = if (repeated) lastBinding(k, v) else v
+                val back = (count - 1 - half).fromSorted
+                if (direction is Greater()) bin(k, value, back, front) else bin(k, value, front, back)
+            }
           }
-        }
 
-        def go(level: Int, m: Tree[K, V], pairs: List[(K, V)]): Tree[K, V] = {
-          pairs match {
+        // Whatever is left, once the run has stopped, goes through `put`.
+        def insertMany(m: Tree[K, V], ps: List[(K, V)]): Tree[K, V] =
+          ps match {
             case Nil() => m
-            case Cons((k, v), Nil()) => m.putMax(k, v)
-            case Cons((k, v), rest) =>
-              if (notOrdered(k, rest)) { insertMany(m, pairs) }
-              else {
-                val l = m; // m is the left subtree here
-                val cr = create(level, rest)
-                cr match {
-                  case (r, xs, Nil()) => go(level.bitwiseShl(1), link(k, v, l, r), xs)
-                  case (r, Nil(), ys) => insertMany(link(k, v, l, r), ys)
-                  case _ => <{ "create: go: cannot happen, invariant broken!" }>
-                }
-              }
+            case Cons((k, v), tail) => m.put(compare, k, v).insertMany(tail)
           }
-        }
 
-        if (notOrdered(k, rest)) { insertMany(singleton(k, v), rest) }
-        else { go(1, singleton(k, v), rest) }
+        val sorted = runLength(pairs, 0).fromSorted
+        sorted.insertMany(rest)
     }
-  }
 
   /// Remove a key `k` from a tree `m`.
   /// If `k` is not in `m`, `m` is returned.
@@ -1053,4 +1147,4 @@ namespace internal {
 
     "[" ++ res ++ "]"
   }
-}
+}

package/libraries/common/process.effekt

@@ -4,7 +4,8 @@ import array
 extern def exit(errorCode: Int) at io: Nothing =
   js   "(function() { process.exit(${errorCode}) })()"
   llvm """
-    call void @exit(i64 ${errorCode})
+    %exitCode = trunc i64 ${errorCode} to i32
+    call void @exit(i32 %exitCode)
     ret %Pos zeroinitializer
   """
   chez "(exit ${errorCode})"
@@ -107,6 +108,6 @@ extern def spawn(cmd: String, args: Array[String], options: SpawnOptions) at asy
     return p;
     })"""
   llvm """
-    call void @c_spawn(%Pos ${cmd}, %Pos ${args}, %Pos ${options}, %Stack %stack)
+    notail call void @c_spawn(%Pos ${cmd}, %Pos ${args}, %Pos ${options}, %Stack %stack)
     ret void
   """

package/libraries/common/random.effekt

@@ -114,11 +114,24 @@ def randomInt32s(): Unit / {emit[Int], random} =
 
 /// `max` is _inclusive_!
 def randomInt(min: Int, max: Int): Int / random = {
+  // How many bytes it takes to represent `range` distinct values.
+  // Each bound is a power of two, so it's exact even as a JS 'number'.
+  def bytesFor(range: Int): Int =
+    if (range <= 1) 0
+    else if (range <= 256) 1
+    else if (range <= 65536) 2
+    else if (range <= 16777216) 3
+    else if (range <= 4294967296) 4
+    else if (range <= 1099511627776) 5
+    else if (range <= 281474976710656) 6
+    else if (range <= 72057594037927936) 7
+    else 8
+
   if (min > max) {
     randomInt(max, min)
   } else {
     val range = max - min + 1
-    val bytesNeeded = (log(range.toDouble) / log(256.0)).ceil
+    val bytesNeeded = bytesFor(range)
 
     var result = 0
     repeat(bytesNeeded) {

package/libraries/common/set.effekt

@@ -79,22 +79,19 @@ def toMap[K, V](keys: Set[K]) { valueOf: K => V }: Map[K, V] = {
 
 /// Create a set from a given list and a pure, first-class comparison function.
 ///
-/// O(N log N)
 /// O(N) if the list is sorted
-def fromList[A](list: List[A], ?compare: (A, A) => Ordering at {}): Set[A] = {
-  val tree: internal::Tree[A, Unit] = internal::fromList(list.map { k => (k, ()) }, compare)
-  Set(tree, compare)
-}
+/// O(N log N)
+def fromList[A](list: List[A], ?compare: (A, A) => Ordering at {}): Set[A] =
+  set::collect(compare) { list.each }
 
 /// Create a set from a given list with a generic comparison function.
 /// Works only on the JavaScript backends!
 ///
-/// O(N log N)
 /// O(N) if the list is sorted
+/// O(N log N)
 def fromListGeneric[A](list: List[A]): Set[A] = {
   val compare: (A, A) => Ordering at {} = box { (left, right) => genericCompare(left, right) }
-  val tree: internal::Tree[A, Unit] = internal::fromList(list.map { k => (k, ()) }, compare)
-  Set(tree, compare)
+  set::collect(compare) { list.each }
 }
 
 /// Traverse all elements in order, running the function `action` on each element.
@@ -150,10 +147,7 @@ def any[A](s: Set[A]) { predicate: A => Bool }: Bool = {
 ///
 /// O(log N)
 def contains[A](s: Set[A], a: A): Bool =
-  internal::get(s.tree, s.compare, a) match {
-    case None() => false
-    case Some(v) => true
-  }
+  internal::contains(s.tree, s.compare, a)
 
 
 /// Check if set `s1` is a subset of set `s2`.
@@ -260,13 +254,9 @@ namespace returning {
   /// Collects elements emitted by a push stream producer `stream` into a new set
   /// using provided `compare` function, returning the result of the producer as well as the collected set.
   def collect[A, R](?compare: (A, A) => Ordering at {}) { stream: () => R / emit[A] }: (R, Set[A]) = {
-    var set = set::empty(compare)
-    val r = try {
-      stream()
-    } with emit[A] { (v) =>
-      set = set.insert(v)
-      resume(())
+    val (r, tree) = internal::collect[A, Unit, R](compare) {
+      stream::returning::for[A, R] {stream} { (v: A) => do emit((v, ())) }
     }
-    (r, set)
+    (r, Set(tree, compare))
   }
 }

package/libraries/common/string.effekt

@@ -210,6 +210,28 @@ namespace internal {
       do emit(c.utf8ByteCount)
     }
   }
+
+  def compareCodePoints(left: String, right: String): Ordering = {
+    val ln = left.length
+    val rn = right.length
+    def go(i: Int, j: Int): Ordering =
+      if (i >= ln) { if (j >= rn) Equal() else Less() }
+      else if (j >= rn) Greater()
+      else {
+        val a = unsafeCharAt(left, i)
+        val b = unsafeCharAt(right, j)
+        compareChar(a, b) match {
+          case Equal() =>
+            // equal code points have equal widths, so take the step only once
+            val w = a.charWidth
+            go(i + w, j + w)
+          case Less() => Less()
+          case Greater() => Greater()
+        }
+      }
+
+    go(0, 0)
+  }
 }
 
 /// Returns the number of bytes that the given `str` would take up in a UTF-8 encoding.
@@ -235,6 +257,12 @@ extern def utf8ByteLength(str: String) at {io, global}: Int =
 // extern def unsafeIndexOf(str: String, sub: String) at {}: Int =
 //   js "${str}.indexOf(${sub})"
 
+/// Compares two strings lexicographically by code point.
+/// Identical on every backend.
+extern def compareStringBytes(left: String, right: String) at {}: Ordering =
+  llvm { compareByteArray(fromString(left), fromString(right)) }
+  default { internal::compareCodePoints(left, right) }
+
 def charAt(str: String, index: Int): Char / Exception[OutOfBounds] =
   if (index < 0 || index >= length(str))
     do raise(OutOfBounds(), "Index out of bounds: " ++ show(index) ++ " in string: '" ++ str ++ "'")