@effekt-lang/effekt 0.22.0 → 0.24.0

package/libraries/common/array.effekt

@@ -3,6 +3,7 @@ module array
 import effekt
 import exception
 import list
+import option
 
 /// A mutable 0-indexed fixed-sized array.
 extern type Array[T]
@@ -18,12 +19,17 @@ extern global def allocate[T](size: Int): Array[T] =
   """
   vm "array::allocate(Int)"
 
+/// Fills a given array in-place.
+def fill[T](arr: Array[T], filler: T): Unit = {
+  arr.foreachIndex { (idx, _) =>
+    arr.unsafeSet(idx, filler)
+  }
+}
+
 /// Creates a new Array of size `size` filled with the value `init`
 def array[T](size: Int, init: T): Array[T] = {
   val arr = allocate[T](size);
-  each(0, size) { i =>
-    unsafeSet(arr, i, init)
-  };
+  arr.fill(init)
   arr
 }
 
@@ -81,8 +87,6 @@ extern global def unsafeSet[T](arr: Array[T], index: Int, value: T): Unit =
   """
   vm "array::unsafeSet[T](Array[T], Int, T)"
 
-
-
 // Derived operations:
 
 /// Gets the element of the `arr` at given `index` in constant time,
@@ -107,6 +111,9 @@ def build[T](size: Int) { index: Int => T }: Array[T] = {
   arr
 }
 
+/// Resizes an array to a given size.
+///
+/// O(N + M)
 def resize[T](source: Array[T], size: Int): Array[T] = {
   val target = allocate(size)
   val n = min(source.size, target.size)
@@ -147,6 +154,27 @@ def copy[T](from: Array[T], start: Int, to: Array[T], offset: Int, length: Int):
 
 // Utility functions:
 
+/// Swap the value at index i with that at index j.
+/// Warning: undefined behaviour if the indices are out bound.
+/// 
+/// O(1)
+def unsafeSwap[A](arr: Array[A], i: Int, j: Int): Unit = {
+  val tmp = arr.unsafeGet(i)
+  arr.unsafeSet(i, arr.unsafeGet(j))
+  arr.unsafeSet(j, tmp)
+}
+
+/// Swap the value at index i with that at index j.
+/// 
+/// O(1)
+def swap[A](arr: Array[A], i: Int, j: Int): Unit / Exception[OutOfBounds] = {
+  if (i < 0 || i >= arr.size || j < 0 || j >= arr.size) do raise(OutOfBounds(), "Index out of bounds")
+  arr.unsafeSwap(i, j)
+}
+
+/// Converts the given array into a list.
+/// 
+/// O(N)
 def toList[T](arr: Array[T]): List[T] = {
   var i = arr.size - 1;
   var l = Nil[T]()
@@ -157,34 +185,380 @@ def toList[T](arr: Array[T]): List[T] = {
   l
 }
 
+/// Traverse an array, applying the given action on every element.
+///
+/// O(N)
 def foreach[T](arr: Array[T]){ action: T => Unit }: Unit =
   each(0, arr.size) { i =>
     action(arr.unsafeGet(i))
   }
 
+/// Traverse an array, applying the given action on every element.
+///
+/// O(N)
 def foreach[T](arr: Array[T]){ action: (T) {Control} => Unit }: Unit =
   each(0, arr.size) { (i) {label} =>
     action(arr.unsafeGet(i)) {label}
   }
 
+/// Traverse an array, applying the given action on every element and its (zero-based) index.
+///
+/// O(N)
 def foreachIndex[T](arr: Array[T]){ action: (Int, T) => Unit }: Unit =
   each(0, arr.size) { i =>
     action(i, arr.unsafeGet(i))
   }
 
+/// Traverse an array, applying the given action on every element and its (zero-based) index.
+///
+/// O(N)
 def foreachIndex[T](arr: Array[T]){ action: (Int, T) {Control} => Unit }: Unit =
   each(0, arr.size) { (i) {label} =>
     action(i, arr.unsafeGet(i)) {label}
   }
 
-def sum(list: Array[Int]): Int = {
+/// Sum the elements of the array.
+/// 
+/// O(N)
+def sum(arr: Array[Int]): Int = {
   var acc = 0
-  list.foreach { x =>
+  arr.foreach { x =>
     acc = acc + x
   }
   acc
 }
 
+/// Checks whether two given arrays are equal with respect to an equalty funciton defined on their element.
+/// 
+/// O(N)
+def equals[A](this: Array[A], other: Array[A]) { eq: (A, A) => Bool }: Bool = {
+  if (this.size != other.size) false
+  else {
+    var res = true
+    this.foreachIndex { (idx, elem) {label} =>
+      if (not(eq(elem, other.unsafeGet(idx)))) {
+        res = false
+        label.break()
+      }
+    }
+    res
+  }
+}
+
+/// Map a function `f` over the elements in a given array.
+/// Modifies the array in-place.
+///
+/// O(N)
+def map[A](arr: Array[A]) { f: A => A }: Unit = {
+  arr.foreachIndex { (idx, elem) =>
+    arr.unsafeSet(idx, f(arr.unsafeGet(idx)))
+  }
+}
+
+/// Map a function over elements.
+/// Allocates a new array of the same size.
+///
+/// O(N)
+def mapped[A, B](arr: Array[A]) { f: A => B }: Array[B] = {
+  val res = allocate(arr.size)
+  arr.foreachIndex { (idx, elem) =>
+    res.unsafeSet(idx, f(arr.unsafeGet(idx)))
+  }
+  res
+}
+
+/// Reverses an array in-place.
+/// 
+/// O(N)
+def reverse[A](arr: Array[A]): Unit = {
+  val size = arr.size()
+  val mid = size / 2
+
+  // Swap elements from start and end, moving towards the middle
+  each(0, mid) { i =>
+    val temp = arr.unsafeGet(i)
+    val j = size - 1 - i
+    val other = arr.unsafeGet(j)
+    arr.unsafeSet(i, other)
+    arr.unsafeSet(j, temp)
+  }
+}
+/// Creates a new array with elements in reverse order.
+/// 
+/// O(N)
+def reversed[A](arr: Array[A]): Array[A] = {
+  val size = arr.size()
+  val result = allocate[A](size)
+  
+  // Copy elements in reverse order to new array
+  each(0, size) { i =>
+    val value = arr.unsafeGet(i)
+    result.unsafeSet(size - 1 - i, value)
+  }
+  result
+}
+
+/// Fold an array using `f`, starting from the left given a starting value.
+///
+/// O(N)
+def foldLeft[A, B](arr: Array[A], init: B) { f: (B, A) => B }: B = {
+  var acc = init;
+  arr.foreach { x => acc = f(acc, x) };
+  acc
+}
+
+/// Fold an array using `f`, starting from the right given a starting value.
+///
+/// O(N)
+def foldRight[A, B](arr: Array[A], init: B) { f: (A, B) => B }: B = {
+  var acc = init;
+  arr.reversed.foreach { x => acc = f(x, acc) };
+  acc
+}
+
+/// Filters a given array with respect to a given predicate such that a
+/// new array containing all the elements for which the predicate
+/// holds is allocated.
+/// 
+/// O(N)
+def filtered[A](arr: Array[A]) { shouldKeep: A => Bool }: Array[A] = {
+  val res = arr.copy()
+  var idx = 0
+  arr.foreach { x =>
+    if (shouldKeep(x)) {
+      res.unsafeSet(idx, x)
+      idx = idx + 1
+    }
+  }
+  res.resize(idx)
+}
+
+/// Check if predicate is true for all elements.
+///
+/// O(N)
+def all[A](arr: Array[A]) { predicate: A => Bool }: Bool = {
+  var result = true
+  arr.foreach { (x) {label} =>
+    if (not(predicate(x))) {
+      result = false
+      label.break()
+    }
+  }
+  result
+}
+
+/// Check if predicate is true for at least one element.
+///
+/// O(N)
+def any[A](arr: Array[A]) { predicate: A => Bool }: Bool = {
+  not(arr.all { x => not(predicate(x)) })
+}
+
+/// Count elements satisfying the predicate.
+///
+/// O(N)
+def count[A](arr: Array[A]) { predicate: A => Bool }: Int = {
+  var count = 0
+  arr.foreach { x =>
+    if (predicate(x)) count = count + 1
+  }
+  count
+}
+
+/// Take first n elements.
+/// Returns a new array.
+///
+/// O(N)
+def take[A](arr: Array[A], n: Int): Array[A] = {
+  val len = min(max(0, n), arr.size)
+  val result = allocate[A](len)
+  each(0, len) { i => 
+    result.unsafeSet(i, arr.unsafeGet(i))
+  }
+  result
+}
+
+// Drop first n elements.
+/// Returns a new array.
+/// 
+/// O(N)
+def drop[A](arr: Array[A], n: Int): Array[A] = {
+  val start = min(max(0, n), arr.size)
+  val len = arr.size - start
+  val result = allocate[A](len)
+  each(0, len) { i =>
+    result.unsafeSet(i, arr.unsafeGet(i + start))
+  }
+  result
+}
+
+/// Return a slice from start (inclusive) to end (exclusive).
+/// Returns a new array.
+///
+/// O(N)
+def sliced[A](arr: Array[A], start: Int, end: Int): Array[A] = {
+  val validStart = min(max(0, start), arr.size)
+  val validEnd = min(max(validStart, end), arr.size)
+  val len = validEnd - validStart
+  val result = allocate[A](len)
+  each(0, len) { i =>
+    result.unsafeSet(i, arr.unsafeGet(i + validStart))
+  }
+  result
+}
+
+/// Zip two arrays into an array of pairs.
+/// Length is minimum of input lengths.
+///
+/// O(min(N, M))
+def zipped[A, B](this: Array[A], other: Array[B]): Array[(A, B)] = {
+  val len = min(this.size, other.size)
+  val result = allocate[(A, B)](len)
+  each(0, len) { i =>
+    result.unsafeSet(i, (this.unsafeGet(i), other.unsafeGet(i)))
+  }
+  result
+}
+
+/// Combine two arrays using given function.
+/// Length is minimum of input lengths.
+///
+/// O(min(N, M))
+def zippedWith[A, B, C](this: Array[A], other: Array[B]) { f: (A, B) => C }: Array[C] = {
+  val len = min(this.size, other.size)
+  val result = allocate[C](len)
+  each(0, len) { i =>
+    result.unsafeSet(i, f(this.unsafeGet(i), other.unsafeGet(i)))
+  }
+  result
+}
+
+/// Produce a pair of arrays from an array of pairs.
+/// Allocates two new arrays as a result.
+///
+/// O(N)
+def unzipped[A, B](arr: Array[(A, B)]): (Array[A], Array[B]) = {
+  val arr1 = allocate(arr.size)
+  val arr2 = allocate(arr.size)
+  arr.foreachIndex { (idx, tpl) =>
+    val (x, y) = tpl
+    arr1.unsafeSet(idx, x)
+    arr2.unsafeSet(idx, y)
+  }
+  (arr1, arr2)
+}
+
+/// Partition a given array into two arrays.
+/// The left array contains the elements that satsify the predicate,
+/// the right array contains the elements that do not.
+///
+/// O(N)
+def partioned[A](arr: Array[A]) { pred: A => Bool }: (Array[A], Array[A]) = {
+  val tcases = arr.copy()
+  val fcases = arr.copy()
+  var tidx = 0
+  var fidx = 0
+  arr.foreach { x =>
+    if (pred(x)) {
+      tcases.unsafeSet(tidx, x)
+      tidx = tidx + 1
+    } else {
+      fcases.unsafeSet(fidx, x)
+      fidx = fidx + 1
+    }
+  }
+  (tcases.resize(tidx), fcases.resize(fidx))
+}
+
+/// Get the _first_ index of the last occurance of `elem`, if there is any.
+/// 
+/// O(N)
+def indexOf[A](arr: Array[A], toFind: A) { eq: (A, A) => Bool }: Option[Int] = {
+  var found = None[Int]()
+  arr.foreachIndex { (idx, elem) {label} =>
+    if (eq(elem, toFind) && found.isEmpty) {
+      found = Some(idx)
+      label.break()
+    }
+  }
+  found
+}
+
+/// Get the _last_ index of the last occurance of `elem`, if there is any.
+/// 
+/// O(N)
+def lastIndexOf[A](arr: Array[A], toFind: A) { eq: (A, A) => Bool }: Option[Int] = {
+  var lastFound = None[Int]()
+  arr.foreachIndex { (idx, elem) =>
+    if (eq(elem, toFind)) {
+      lastFound = Some(idx)
+    }
+  }
+  lastFound
+}
+
+/// Perform binary search to find the index of a given element.
+/// 
+/// O(log N)
+def binarySearch[A](arr: Array[A], toFind: A) { ord: (A, A) => Ordering }: Option[Int] = {
+  def binarySearch(lowerIdx: Int, upperIdx: Int): Option[Int] = {
+    if (lowerIdx > upperIdx) None()
+    else {
+      val mid = lowerIdx + (upperIdx - lowerIdx) / 2
+      val current = arr.unsafeGet(mid)
+      ord(current, toFind) match {
+        case Less() => binarySearch(mid + 1, upperIdx)
+        case Greater() => binarySearch(lowerIdx, mid - 1)
+        case Equal() => Some(mid)
+      }
+    }
+  }
+  binarySearch(0, arr.size - 1)
+}
+
+/// Sort an array in-place using provided comparison function.
+/// Note: sort is unstable since it uses QuickSort (unlike list::sortBy)
+///
+/// O(N log N) average case
+def sort[A](arr: Array[A]) { ord: (A, A) => Ordering }: Unit = {
+  def partition(low: Int, high: Int): Int = {
+    val pivot = arr.unsafeGet(high)
+    var i = low - 1
+    
+    each(low, high) { j =>
+      ord(arr.unsafeGet(j), pivot) match {
+        case Less() =>
+          i = i + 1
+          unsafeSwap(arr, i, j)
+        case _ => ()
+      }
+    }
+    unsafeSwap(arr, i + 1, high)
+    i + 1
+  }
+  
+  def quickSort(low: Int, high: Int): Unit = {
+    if (low < high) {
+      val par = partition(low, high)
+      quickSort(low, par - 1)
+      quickSort(par + 1, high)
+    }
+  }
+  
+  quickSort(0, arr.size - 1)
+}
+
+/// Sort an array using provided comparison function.
+/// A newly allocated sorted array is returned as result, i.e., the sorting is not in-place.
+/// Note: sort is unstable since it uses QuickSort (unlike list::sortBy)
+///
+/// O(N log N) average case
+def sorted[A](arr: Array[A]) { ord: (A, A) => Ordering }: Array[A] = {
+  val res = arr.copy()
+  res.sort { ord }
+  res
+}
+
 // Show Instances
 // --------------
 

package/libraries/common/stream.effekt

@@ -30,6 +30,17 @@ effect stop(): Nothing
 def for[A] { stream: () => Unit / emit[A] } { action: A => Unit }: Unit =
   returning::for[A, Unit]{stream}{action}
 
+/// Runs the stream as a message queue,
+/// handling each of its elements that can produce new elements ("messages"),
+/// until a fixed point is reached.
+def fix[T] { one: T => Unit / emit[T] } { stream: => Unit / emit[T] }: Unit =
+  try {
+    stream()
+  } with emit[T] { value =>
+    fix[T] {one} { one(value) }
+    resume(())
+  }
+
 /// Turns a `list` into a producer of a push stream
 /// by emitting each contained value left-to-right.
 def each[A](list: List[A]): Unit / emit[A] =

package/libraries/llvm/file.c

@@ -0,0 +1 @@
+