@effekt-lang/effekt 0.78.0 → 0.80.0

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})"
@@ -47,7 +48,7 @@ extern def onStdout(opts: SpawnOptions, callback: String => Unit at {io, global}
     };
     return old; })()"""
   llvm """
-    %opts = call %Pos @c_spawn_options_on_stdout(%Pos ${opts}, %Pos ${callback})
+    %opts = call %Pos @c_spawn_options_on_stdout(%Pos ${opts}, %Neg ${callback})
     ret %Pos %opts
   """
 extern def onStderr(opts: SpawnOptions, callback: String => Unit at {io, global}) at {}: SpawnOptions =
@@ -63,7 +64,7 @@ extern def onStderr(opts: SpawnOptions, callback: String => Unit at {io, global}
     };
     return old; })()"""
   llvm """
-    %opts = call %Pos @c_spawn_options_on_stderr(%Pos ${opts}, %Pos ${callback})
+    %opts = call %Pos @c_spawn_options_on_stderr(%Pos ${opts}, %Neg ${callback})
     ret %Pos %opts
   """
 extern type WritableStream =
@@ -83,7 +84,7 @@ extern def withStdin(opts: SpawnOptions, callback: WritableStream => Unit at {io
     return old;
   })()"""
   llvm """
-    %opts = call %Pos @c_spawn_options_pipe_stdin(%Pos ${opts}, %Pos ${callback})
+    %opts = call %Pos @c_spawn_options_pipe_stdin(%Pos ${opts}, %Neg ${callback})
     ret %Pos %opts
   """
 extern def write(to: WritableStream, s: String) at io: Unit =
@@ -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/sourcepos.effekt

@@ -0,0 +1,75 @@
+module sourcepos
+import io/error
+import io/filesystem
+import stringbuffer
+import tty
+
+def toGccStyleString(sp: SourcePosition): String = {
+  s"${sp.file}:${sp.startLine.show()}:${sp.startColumn.show()}"
+}
+def toClangStyleString = toGccStyleString
+def toMsvcStyleString(sp: SourcePosition): String = {
+  s"${sp.file}(${sp.startLine.show()},${sp.startColumn.show()})"
+}
+def toPythonStyleString(sp: SourcePosition): String = {
+  s"File \"${sp.file}\", line ${sp.startLine.show()}"
+}
+
+def getSourceLine(file: String, line: Int): String / {Exception[IOError], stop} = {
+  with stringBuffer
+  with readFileUTF8(file)
+  var currentLine = 1
+  while (currentLine < line) {
+    val c = do next()
+    if (c == '\n' || c == '\r') {
+      currentLine += 1
+    }
+  }
+  var c = do next()
+  while (c != '\n' && c != '\r') {
+    do write(c.toString)
+    c = do next()
+  }
+}
+def getSourceText(sp: SourcePosition): String / {Exception[IOError], stop} = {
+  with stringBuffer
+  with readFileUTF8(sp.file)
+  var currentLine = 1
+  var currentColumn = 1
+  while (currentLine < sp.startLine || currentColumn < sp.startColumn) {
+    val c = do next()
+    if (c == '\n' || c == '\r') {
+      currentLine += 1
+      currentColumn = 0
+    }
+  }
+  var c = do next()
+  while (currentLine <= sp.endLine && currentColumn <= sp.endColumn) {
+    do write(c.toString)
+    if (c == '\n' || c == '\r') {
+      currentLine += 1
+      currentColumn = 0
+    }
+    c = do next()
+  }
+}
+
+def getMarkedSource(sp: SourcePosition): String / Formatted = {
+  try {
+    if (sp.startLine == sp.endLine) {
+      val line = getSourceLine(sp.file, sp.startLine)
+      val mline = line.substring(0, sp.startColumn) ++ line.substring(sp.startColumn, sp.endColumn + 1).red ++ line.substring(sp.endColumn + 1)
+      return mline ++ "\n" ++ " ".repeat(sp.startColumn - 1) ++ "^".repeat(sp.endColumn - sp.startColumn)
+    } else {
+      val prefix = getSourceLine(sp.file, sp.startLine).substring(0, sp.startColumn)
+      val suffix = getSourceLine(sp.file, sp.endLine).substring(sp.endColumn + 1)
+      val text = getSourceText(sp)
+      return prefix ++ text.red ++ suffix
+    }
+  } with stop {
+    "(invalid source position)" 
+  } with Exception[IOError] { 
+    def raise(e, m) =
+      "(can't open source file: " ++ m ++ ")"
+  }
+}