@effekt-lang/effekt 0.76.0 → 0.78.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`

package/libraries/common/bytearray.effekt

@@ -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/effekt.effekt

@@ -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/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

@@ -8,7 +8,7 @@ record Map[K, V](tree: internal::Tree[K, V], compare: (K, K) => Ordering at {})
 /// Create a new empty map using a pure, first-class comparison function.
 ///
 /// O(1)
-def empty[K, V](compare: (K, K) => Ordering at {}): Map[K, V] =
+def empty[K, V](?compare: (K, K) => Ordering at {}): Map[K, V] =
   Map(internal::empty(), compare)
 
 /// Create a new empty map using a generic comparison function.
@@ -34,7 +34,7 @@ def nonEmpty[K, V](m: Map[K, V]): Bool = internal::nonEmpty(m.tree)
 /// Create a new map containing the mapping from `k` to `v` and a pure, first-class comparison function.
 ///
 /// O(1)
-def singleton[K, V](k: K, v: V, compare: (K, K) => Ordering at {}): Map[K, V] =
+def singleton[K, V](k: K, v: V, ?compare: (K, K) => Ordering at {}): Map[K, V] =
   Map(internal::singleton(k, v), compare)
 
 /// Create a new map containing the mapping from `k` to `v` using a generic comparison function.
@@ -91,7 +91,7 @@ def getOrElse[K, V](m: Map[K, V], k: K) { default: => V }: V =
 def contains[K, V](m: Map[K, V], k: K): Bool =
   internal::get(m.tree, m.compare, k) match {
     case None() => false
-    case Some(v) => true
+    case Some(_) => true
   }
 
 /// Get minimum in the map `m`.
@@ -156,15 +156,26 @@ def filter[K, V](m: Map[K, V]) { shouldKeep: V => Bool }: Map[K, V] =
 def foreach[K, V](m: Map[K, V]) { action: (K, V) => Unit }: Unit =
   internal::foreach(m.tree) {action}
 
+/// Traverse all keys and their associated values in map `m` in *reverse*order,
+/// running the function `action` on a key and its associated value.
+///
+/// Law: `m.foreachReversed { action } === m.toList.reverse.foreach { action }`
+///
+/// O(N)
+///
+/// TODO: Support {Control} for early exits.
+def foreachReversed[K, V](m: Map[K, V]) { action: (K, V) => Unit }: Unit =
+  internal::foreachReversed(m.tree) {action}
+
 /// Convert a map `m` into a list of (key, value) pairs.
 ///
 /// O(N)
 def toList[K, V](m: Map[K, V]): List[(K, V)] = {
   var acc = Nil()
-  m.foreach { (k, v) =>
+  m.foreachReversed { (k, v) =>
     acc = Cons((k, v), acc)
   }
-  acc.reverse
+  acc
 }
 
 /// Get a list of keys of the map `m`.
@@ -172,10 +183,10 @@ def toList[K, V](m: Map[K, V]): List[(K, V)] = {
 /// O(N)
 def keys[K, V](m: Map[K, V]): List[K] = {
   var acc = Nil()
-  m.foreach { (k, _v) =>
+  m.foreachReversed { (k, _v) =>
     acc = Cons(k, acc)
   }
-  acc.reverse
+  acc
 }
 
 /// Get a list of values of the map `m`.
@@ -183,10 +194,10 @@ def keys[K, V](m: Map[K, V]): List[K] = {
 /// O(N)
 def values[K, V](m: Map[K, V]): List[V] = {
   var acc = Nil()
-  m.foreach { (_k, v) =>
+  m.foreachReversed { (_k, v) =>
     acc = Cons(v, acc)
   }
-  acc.reverse
+  acc
 }
 
 /// Create a map from a list of (key, value) pairs and a pure, first-class comparison function.
@@ -195,7 +206,7 @@ def values[K, V](m: Map[K, V]): List[V] = {
 ///
 /// O(N) if the list is sorted by key,
 /// O(N log N) otherwise
-def fromList[K, V](pairs: List[(K, V)], compare: (K, K) => Ordering at {}): Map[K, V] =
+def fromList[K, V](pairs: List[(K, V)], ?compare: (K, K) => Ordering at {}): Map[K, V] =
   Map(internal::fromList(pairs, compare), compare)
 
 /// Create a map from a list of (key, value) pairs and a generic comparison function.
@@ -253,7 +264,7 @@ def getIndex[K, V](m: Map[K, V], n: Int): Option[(K, V)] =
 /// Uses an explicit pure, first-class comparison function.
 ///
 /// O(???)
-def difference[K, V](m1: Map[K, V], m2: Map[K, V], compare: (K, K) => Ordering at {}) = {
+def difference[K, V](m1: Map[K, V], m2: Map[K, V], ?compare: (K, K) => Ordering at {}) = {
   val newTree = internal::difference(m1.tree, m2.tree, compare)
   Map(newTree, compare)
 }
@@ -273,7 +284,7 @@ def difference[K, V](m1: Map[K, V], m2: Map[K, V]) = {
 /// Uses an explicit pure, first-class comparison function.
 ///
 /// O(???)
-def union[K, V](m1: Map[K, V], m2: Map[K, V], compare: (K, K) => Ordering at {}) { combine: (K, V, V) => V }: Map[K, V] = {
+def union[K, V](m1: Map[K, V], m2: Map[K, V], ?compare: (K, K) => Ordering at {}) { combine: (K, V, V) => V }: Map[K, V] = {
   val newTree = internal::union(m1.tree, m2.tree, compare) {combine}
   Map(newTree, compare)
 }
@@ -283,7 +294,7 @@ def union[K, V](m1: Map[K, V], m2: Map[K, V], compare: (K, K) => Ordering at {})
 /// Uses an explicit pure, first-class comparison function.
 ///
 /// O(???)
-def union[K, V](m1: Map[K, V], m2: Map[K, V], compare: (K, K) => Ordering at {}) { combine: (V, V) => V }: Map[K, V] =
+def union[K, V](m1: Map[K, V], m2: Map[K, V], ?compare: (K, K) => Ordering at {}) { combine: (V, V) => V }: Map[K, V] =
   union(m1, m2, compare) { (k, v1, v2) => combine(v1, v2) }
 
 /// Construct a new map which contains the elements of both `m1` and `m2`.
@@ -297,7 +308,7 @@ def union[K, V](m1: Map[K, V], m2: Map[K, V]): Map[K, V] =
 /// Construct a new map which combines all elements that are in both `m1` and `m2` using the `combine` function.
 ///
 /// O(???)
-def intersection[K, A, B, C](m1: Map[K, A], m2: Map[K, B], compare: (K, K) => Ordering at {}) { combine: (K, A, B) => C }: Map[K, C] = {
+def intersection[K, A, B, C](m1: Map[K, A], m2: Map[K, B], ?compare: (K, K) => Ordering at {}) { combine: (K, A, B) => C }: Map[K, C] = {
   val newTree = internal::intersection(m1.tree, m2.tree, compare) {combine}
   Map(newTree, compare)
 }
@@ -305,7 +316,7 @@ def intersection[K, A, B, C](m1: Map[K, A], m2: Map[K, B], compare: (K, K) => Or
 /// Construct a new map which combines all elements that are in both `m1` and `m2` using the `combine` function.
 ///
 /// O(???)
-def intersection[K, A, B, C](m1: Map[K, A], m2: Map[K, B], compare: (K, K) => Ordering at {}) { combine: (A, B) => C }: Map[K, C] =
+def intersection[K, A, B, C](m1: Map[K, A], m2: Map[K, B], ?compare: (K, K) => Ordering at {}) { combine: (A, B) => C }: Map[K, C] =
   m1.intersection[K, A, B, C](m2, compare) { (k, v1, v2) => combine(v1, v2) }
 
 /// Construct a new map which combines all elements that are in both `m1` and `m2`.
@@ -315,6 +326,47 @@ def intersection[K, A, B, C](m1: Map[K, A], m2: Map[K, B], compare: (K, K) => Or
 def intersection[K, A, B](m1: Map[K, A], m2: Map[K, B]): Map[K, A] =
   m1.intersection[K, A, B, A](m2, m1.compare) { (k, v1, v2) => v1 }
 
+
+
+// Streaming
+// ---------
+
+/// Turns a `map` into a producer of a push stream
+/// of `(key, value)` pairs by emitting each contained *in order*.
+def each[K, V](map: Map[K, V]): Unit / emit[(K, V)] =
+  map.foreach { (k, v) => do emit((k, v)) }
+
+/// Turns a `map` into a producer of a push stream
+/// of its keys by emitting each contained *in order*.
+def eachKey[K, V](map: Map[K, V]): Unit / emit[K] =
+  map.foreach { (k, _v) => do emit(k) }
+
+/// Turns a `map` into a producer of a push stream
+/// of its values by emitting each contained.
+def eachValue[K, V](map: Map[K, V]): Unit / emit[V] =
+  map.foreach { (_k, v) => do emit(v) }
+
+/// Collects `(key, value)` pairs from a push stream producer `stream` into a new `map`
+/// using the provided `compare` function, discarding the result of the producer.
+def collect[K, V](?compare: (K, K) => Ordering at {}) { stream: () => Unit / emit[(K, V)] }: Map[K, V] =
+  returning::collect[K, V, Unit](compare){stream}.second
+
+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)
+}
+
+// Internal tree representation
+
 /// Please don't directly use:
 /// - the `Tree` type
 /// - its internal constructors `Bin` & `Tip`,
@@ -527,6 +579,27 @@ namespace internal {
     go(m)
   }
 
+  /// Traverse all keys and their associated values in tree `m` in *reverse* order,
+  /// running the function `action` on a key and its associated value.
+  ///
+  /// Law: `m.foreachReversed { action } === m.toList.reverse.foreach { action }`
+  ///
+  /// O(N)
+  ///
+  /// TODO: Support {Control} for early exits.
+  def foreachReversed[K, V](m: Tree[K, V]) { action: (K, V) => Unit }: Unit = {
+    def go(m: Tree[K, V]): Unit = {
+      m match {
+        case Tip() => ()
+        case Bin(_, k, v, l, r) =>
+          go(r)
+          action(k, v)
+          go(l)
+      }
+    }
+    go(m)
+  }
+
   /// 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.
@@ -572,11 +645,11 @@ namespace internal {
             case Nil() => (Tip(), [], [])
             case Cons((k, v), rest) =>
               if (level == 1) {
-                val singleton = Bin(1, k, v, Tip(), Tip())
+                val one = singleton(k, v)
                 if (notOrdered(k, rest)) {
-                  (singleton, [], rest)
+                  (one, [], rest)
                 } else {
-                  (singleton, rest, [])
+                  (one, rest, [])
                 }
               } else {
                 val res = create(level.bitwiseShr(1), pairs)
@@ -584,7 +657,8 @@ namespace internal {
                   case (_, Nil(), _) => res
                   case (l, Cons((k2, v2), Nil()), zs) => (l.putMax(k2, v2), [], zs)
                   case (l, Cons((k2, v2), rest2), _) =>
-                    val xs = Cons((k2, v2), rest2) // @-pattern
+                    // @-pattern
+                    val xs = Cons((k2, v2), rest2)
 
                     if (notOrdered(k2, rest2)) { (l, [], xs) }
                     else {
@@ -608,7 +682,7 @@ namespace internal {
                 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 _ => panic("create: go: cannot happen, invariant broken!")
+                  case _ => <{ "create: go: cannot happen, invariant broken!" }>
                 }
               }
           }
@@ -763,9 +837,8 @@ namespace internal {
   val ratio = 2
   val delta = 3
 
-  def bin[K, V](k: K, v: V, l: Tree[K, V], r: Tree[K, V]): Tree[K, V] = {
+  def bin[K, V](k: K, v: V, l: Tree[K, V], r: Tree[K, V]): Tree[K, V] =
     Bin(l.size() + r.size() + 1, k, v, l, r)
-  }
 
   def balance[K, V](k: K, v: V, l: Tree[K, V], r: Tree[K, V]): Tree[K, V] = {
     /*
@@ -778,10 +851,8 @@ namespace internal {
           t2    t3            t1    t2
     */
     def singleL[A, B](k1: A, v1: B, t1: Tree[A, B], m: Tree[A, B]): Tree[A, B] = {
-      m match {
-        case Bin(_, k2, v2, t2, t3) => bin(k2, v2, bin(k1, v1, t1, t2), t3)
-        case _ => panic("impossible: singleL: Tip")
-      }
+      val Bin(_, k2, v2, t2, t3) = m else <{ "impossible: singleL: Tip" }>
+      bin(k2, v2, bin(k1, v1, t1, t2), t3)
     }
 
     /*
@@ -794,10 +865,8 @@ namespace internal {
       t1    t2            t1      t2    t3
     */
     def singleR[A, B](k1: A, v1: B, m: Tree[A, B], t3: Tree[A, B]): Tree[A, B] = {
-      m match {
-        case Bin(_, k2, v2, t1, t2) => bin(k2, v2, t1, bin(k1, v1, t2, t3))
-        case _ => panic("impossible: singleR: Tip")
-      }
+      val Bin(_, k2, v2, t1, t2) = m else <{ "impossible: singleR: Tip" }>
+      bin(k2, v2, t1, bin(k1, v1, t2, t3))
     }
 
     /*
@@ -812,11 +881,8 @@ namespace internal {
           t2    t3
     */
     def doubleL[A, B](k1: A, v1: B, t1: Tree[A, B], m: Tree[A, B]): Tree[A, B] = {
-      m match {
-        case Bin(_, k2, v2, Bin(_, k3, v3, t2, t3), t4) =>
-          bin(k3, v3, bin(k1, v1, t1, t2), bin(k2, v2, t3, t4))
-        case _ => panic("impossible: doubleL: Tip")
-      }
+      val Bin(_, k2, v2, Bin(_, k3, v3, t2, t3), t4) = m else <{ "impossible: doubleL: Tip" }>
+      bin(k3, v3, bin(k1, v1, t1, t2), bin(k2, v2, t3, t4))
     }
 
     /*
@@ -831,12 +897,8 @@ namespace internal {
                 t2    t3
     */
     def doubleR[A, B](k1: A, v1: B, m: Tree[A, B], t4: Tree[A, B]): Tree[A, B] = {
-      m match {
-        case Bin(_, k2, v2, t1, Bin(_, k3, v3, t2, t3)) =>
-          bin(k3, v3, bin(k2, v2, t1, t2), bin(k1, v1, t3, t4))
-        case _ =>
-          panic("impossible: doubleR: Tip")
-      }
+      val Bin(_, k2, v2, t1, Bin(_, k3, v3, t2, t3)) = m else <{ "impossible: doubleR: Tip" }>
+      bin(k3, v3, bin(k2, v2, t1, t2), bin(k1, v1, t3, t4))
     }
 
     def rotateL[A, B](k: A, v: B, l: Tree[A, B], r: Tree[A, B]): Tree[A, B] = {
@@ -859,7 +921,7 @@ namespace internal {
     if ((sizeL + sizeR) <= 1) { Bin(sizeCombined, k, v, l, r) }
     else if (sizeR > (delta * sizeL)) { rotateL(k, v, l, r) }
     else if (sizeL > (delta * sizeR)) { rotateR(k, v, l, r) }
-    else { Bin(sizeCombined, k, v, l, r)}
+    else { Bin(sizeCombined, k, v, l, r) }
   }
 
   record MaxView[K, V](k: K, v: V, m: Tree[K, V])
@@ -963,13 +1025,13 @@ namespace internal {
   // Section: prettyprinting for trees:
 
   /// Works only on the backends that support `genericShow` (JavaScript)!
-  def prettyTree[K, V](m: Tree[K, V]): String = {
+  def prettyTree[K, V](m: Tree[K, V]) { ?key::show: K => String } { ?value::show: V => String }: String = {
     // Helper function to recursively build the string representation of the tree
     def go(t: Tree[K, V], prefix: String, isTail: Bool): String = {
       t match {
         case Tip() => ""
         case Bin(_, k, v, l, r) =>
-          val pair = k.show ++ " → " ++ v.show
+          val pair = key::show(k) ++ " → " ++ value::show(v)
           val currentLine = prefix ++ (if (isTail) "└── " else "├── ") ++ pair ++ "\n"
 
           val newPrefix = prefix ++ (if (isTail) "    " else "│   ")
@@ -984,47 +1046,11 @@ namespace internal {
     go(m, "", true)
   }
 
-  def prettyPairs[K, V](list: List[(K, V)]) { showLeft: K => String } { showRight: V => String }: String = {
+  def prettyPairs[K, V](list: List[(K, V)]) { ?key::show: K => String } { ?value::show: V => String }: String = {
     val res: String =
-      list.map { case (k, v) => showLeft(k) ++ " → " ++ showRight(v) }
+      list.map { case (k, v) => key::show(k) ++ " → " ++ value::show(v) }
           .join(", ")
 
     "[" ++ res ++ "]"
   }
-}
-
-
-// Streaming
-// ---------
-
-/// Turns a `map` into a producer of a push stream
-/// of `(key, value)` pairs by emitting each contained *in order*.
-def each[K, V](map: Map[K, V]): Unit / emit[(K, V)] =
-  map.foreach { (k, v) => do emit((k, v)) }
-
-/// Turns a `map` into a producer of a push stream
-/// of its keys by emitting each contained *in order*.
-def eachKey[K, V](map: Map[K, V]): Unit / emit[K] =
-  map.foreach { (k, _v) => do emit(k) }
-
-/// Turns a `map` into a producer of a push stream
-/// of its values by emitting each contained.
-def eachValue[K, V](map: Map[K, V]): Unit / emit[V] =
-  map.foreach { (_k, v) => do emit(v) }
-
-/// Collects `(key, value)` pairs from a push stream producer `stream` into a new `map`
-/// using the provided `compare` function, discarding the result of the producer.
-def collect[K, V](compare: (K, K) => Ordering at {}) { stream: () => Unit / emit[(K, V)] }: Map[K, V] =
-  returning::collect[K, V, Unit](compare){stream}.second
-
-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]) =
-    try {
-      (stream(), empty(compare))
-    } with emit[(K, V)] { case (k, v) =>
-      val (r, map) = resume(());
-      (r, map.put(k, v))
-    }
-}
+}