@effekt-lang/effekt 0.18.0 → 0.20.0

package/libraries/common/regex.effekt

@@ -0,0 +1,64 @@
+module regex
+
+import string
+
+extern include chez "text/pregexp.scm"
+
+extern type Regex
+
+record Match(matched: String, index: Int)
+
+extern pure def regex(str: String): Regex =
+  js "new RegExp(${str})"
+  chez "(pregexp ${str})"
+  vm "regex::regex(String)"
+
+def exec(reg: Regex, str: String): Option[Match] = {
+  val v = internal::exec(reg, str)
+  if (v.isUndefined)
+    None()
+  else
+    Some(Match(internal::matched(v), internal::index(v)))
+}
+
+namespace internal {
+
+  /// The type RegexMatch is used internally to represent platform
+  /// dependent results of matching a regex.
+  extern type RegexMatch
+    // js: { matched: String, index: Int } | undefined
+    // vm: scala.util.matching.Regex.Match | null
+
+  extern pure def matched(r: RegexMatch): String =
+    js "${r}.matched"
+    chez "(vector-ref ${r} 0)"
+    vm "regex::matched(RegexMatch)"
+
+  extern pure def index(r: RegexMatch): Int =
+    js "${r}.index"
+    chez "(vector-ref ${r} 1)"
+    vm "regex::index(RegexMatch)"
+
+  extern js """
+    function regex$exec(reg, str) {
+      var res = reg.exec(str);
+      if (res === null) { return undefined }
+      else { return { matched: res[0], index: res.index } }
+    }
+  """
+
+  extern chez """
+  (define regex-exec
+    (lambda (regex str)
+      (let* ([positions (pregexp-match-positions regex str)]
+        [match (pregexp-match regex str)])
+    (if (and positions match)
+        (vector (car match) (caar positions))
+        #f))))
+  """
+
+  extern io def exec(reg: Regex, str: String): RegexMatch =
+    js "regex$exec(${reg}, ${str})"
+    chez "(regex-exec ${reg} ${str})"
+    vm "regex::exec(Regex, String)"
+}

package/libraries/common/resizable_array.effekt

@@ -0,0 +1,235 @@
+module resizable_array
+
+import ref
+import array
+
+record ResizableArray[T](rawSizePtr: Ref[Int], rawContentPtr: Ref[Array[T]])
+
+// These numbers should be optimized based on benchmarking
+// According to https://en.wikipedia.org/wiki/Dynamic_array most use 1.5 or 2
+
+/// Factor by which to grow the capacity when it becomes too small
+val growFactor = 1.5
+/// shrink array when size / capacity falls below this threshold
+/// should be < 1/growFactor
+val shrinkThreshold = 0.4
+
+/// Number of elements in the dynamic array
+///
+/// O(1)
+def size[T](arr: ResizableArray[T]) = arr.rawSizePtr.get
+
+/// Allocate a new, empty dynamic array with given initial capacity
+def resizableArray[T](capacity: Int): ResizableArray[T] = {
+  ResizableArray(ref(0), ref(allocate(capacity)))
+}
+
+/// Allocate a new, empty dynamic array
+def resizableArray[T](): ResizableArray[T] = resizableArray(8)
+
+/// Throw an OutOfBounds exception if index is not a valid index into arr
+def boundsCheck[T](arr: ResizableArray[T], index: Int): Unit / Exception[OutOfBounds] = {
+  if (index < 0 && index >= arr.size) {
+    do raise(OutOfBounds(), "Array index out of bounds: " ++ show(index))
+  }
+}
+
+/// get the element at position index in the array
+///
+/// precondition: index is a valid index into the array
+///
+/// O(1)
+def unsafeGet[T](arr: ResizableArray[T], index: Int): T = {
+  arr.rawContentPtr.get.unsafeGet(index)
+}
+/// get the element at position index in the array
+///
+/// O(1)
+def get[T](arr: ResizableArray[T], index: Int): T / Exception[OutOfBounds] = {
+  arr.boundsCheck(index);
+  arr.unsafeGet(index)
+}
+
+/// set the element at position index in the array
+///
+/// precondition: index is a valid index into the array
+///
+/// O(1)
+def unsafeSet[T](arr: ResizableArray[T], index: Int, value: T): Unit = {
+  arr.rawContentPtr.get.unsafeSet(index, value)
+}
+
+/// set the element at position index in the array
+///
+/// O(1)
+def set[T](arr: ResizableArray[T], index: Int, value: T): Unit / Exception[OutOfBounds] = {
+  arr.boundsCheck(index);
+  arr.unsafeSet(index, value)
+}
+
+/// swap the elements at the given positions in the array
+///
+/// precondition: both are valid indices into the array
+///
+/// O(1)
+def unsafeSwap[T](arr: ResizableArray[T], index1: Int, index2: Int): Unit = {
+  val raw = arr.rawContentPtr.get
+  val tmp = raw.unsafeGet(index1)
+  raw.unsafeSet(index1, raw.unsafeGet(index2))
+  raw.unsafeSet(index2, tmp)
+}
+
+/// swap the elements at the given positions in the array
+///
+/// O(1)
+def swap[T](arr: ResizableArray[T], index1: Int, index2: Int): Unit / Exception[OutOfBounds] = {
+  arr.boundsCheck(max(index1, index2))
+  arr.unsafeSwap(index1, index2)
+}
+
+/// Change the dynamic to have exactly the given capacity
+///
+/// precondition: given capacity is at least the size of the array
+///
+/// O(n)
+def unsafeSetCapacity[T](arr: ResizableArray[T], capacity: Int): Unit = {
+  with on[OutOfBounds].panic
+  val oldRaw = arr.rawContentPtr.get
+  if (oldRaw.size != capacity) { 
+    val newRaw = array::allocate(capacity)
+    oldRaw.copy(0, newRaw, 0, arr.size)
+    arr.rawContentPtr.set(newRaw)
+  }
+}
+
+/// Change the resizable array to have exactly the given capacity.
+/// This only changes the size of the backing array, not the `size`.
+///
+/// O(n)
+def setCapacity[T](arr: ResizableArray[T], capacity: Int): Unit / Exception[OutOfBounds] = {
+  if (arr.size > capacity) {
+    do raise(OutOfBounds(), "Cannot change capacity of ResizableArray to " ++ capacity.show ++ " below size " ++ arr.size.show)
+  }
+  arr.unsafeSetCapacity(capacity)
+}
+
+/// If the shrinkThreshold is reached, shrink by growFactor, otherwise do nothing
+///
+/// O(n)
+def maybeShrink[T](arr: ResizableArray[T]): Unit = {
+  if(arr.size.toDouble < arr.rawContentPtr.get.size.toDouble * shrinkThreshold) {
+    val newCap = max(arr.size, (arr.rawContentPtr.get.size.toDouble / growFactor).ceil)
+    arr.unsafeSetCapacity(newCap)
+  }
+}
+
+/// makes sure capacity is at least the given one
+///
+/// O(given capacity - current capacity) amortized, O(n) worst case // TODO ?
+def ensureCapacity[T](arr: ResizableArray[T], capacity: Int): Unit / Exception[OutOfBounds] = {
+  if (arr.rawContentPtr.get.size < capacity) {
+    val curCapd: Double = arr.rawContentPtr.get.size.toDouble
+    val minGrowCapacity: Int = (curCapd * growFactor + 1.0).toInt
+    val newCapacity = max(capacity, minGrowCapacity)
+    arr.setCapacity(newCapacity)
+  }
+}
+
+/// Set the value at given position, resizing if necessary
+/// Note: New elements might be uninitialized!!!
+///
+/// O(max(1,index - n)) amortized, O(n) worst case if index > capacity
+def setResizing[T](arr: ResizableArray[T], index: Int, value: T): Unit / Exception[OutOfBounds] = {
+  if (index < 0) {
+    do raise(OutOfBounds(), "Negative index " ++ index.show)
+  }
+  if (index < arr.size) {
+    arr.rawContentPtr.get.unsafeSet(index, value)
+  }
+  ensureCapacity(arr, index + 1)
+  arr.rawContentPtr.get.unsafeSet(index, value)
+  arr.rawSizePtr.set(index + 1)
+}
+
+/// Add a new element at the end of the resizable array.
+/// Return the index of the new element
+///
+/// O(1) amortized, O(n) worst case
+def add[T](arr: ResizableArray[T], value: T): Int = {
+  with on[OutOfBounds].panic();
+  val idx = arr.size
+  arr.setResizing(idx, value)
+  idx
+}
+
+/// Remove and return the rightmost element in the resizable array.
+///
+/// O(1) amortized, O(n) worst case
+def popRight[T](arr: ResizableArray[T]): T / Exception[OutOfBounds] = {
+  arr.boundsCheck(arr.size - 1)
+  arr.rawSizePtr.set(arr.size - 1)
+  val r = arr.unsafeGet(arr.size)
+  arr.maybeShrink()
+  r
+}
+
+
+def foreachIndex[T](arr: ResizableArray[T]){ body: (Int, T) => Unit }: Unit = {
+  each(0, arr.size) { i =>
+    body(i, arr.rawContentPtr.get.unsafeGet(i))
+  }
+}
+def foreachIndex[T](arr: ResizableArray[T]){ body: (Int, T) {Control} => Unit }: Unit = {
+  each(0, arr.size) { (i){label} =>
+    body(i, arr.rawContentPtr.get.unsafeGet(i)){label}
+  }
+}
+def foreach[T](arr: ResizableArray[T]){ body: T => Unit }: Unit = {
+  each(0, arr.size) { i =>
+    body(arr.rawContentPtr.get.unsafeGet(i))
+  }
+}
+def foreach[T](arr: ResizableArray[T]){ body: (T) {Control} => Unit }: Unit = {
+  each(0, arr.size) { (i){label} =>
+    body(arr.rawContentPtr.get.unsafeGet(i)){label}
+  }
+}
+def foreachIndexReversed[T](arr: ResizableArray[T]){ body: (Int, T){Control} => Unit }: Unit = {
+  var i = arr.size - 1
+  loop { {l} =>
+    if (i < 0) { l.break() }
+    body(i, arr.rawContentPtr.get.unsafeGet(i)){l}
+    i = i - 1
+  }
+}
+def foreachIndexReversed[T](arr: ResizableArray[T]){ body: (Int, T) => Unit }: Unit = {
+  var i = arr.size - 1
+  while(i >= 0) {
+    body(i, arr.rawContentPtr.get.unsafeGet(i))
+    i = i - 1
+  }
+}
+def foreachReversed[T](arr: ResizableArray[T]){ body: (T){Control} => Unit }: Unit = {
+  var i = arr.size - 1
+  loop { {l} =>
+    if (i < 0) { l.break() }
+    body(arr.rawContentPtr.get.unsafeGet(i)){l}
+    i = i - 1
+  }
+}
+def foreachReversed[T](arr: ResizableArray[T]){ body: T => Unit }: Unit = {
+  var i = arr.size - 1
+  while (i >= 0) { 
+    body(arr.rawContentPtr.get.unsafeGet(i))
+    i = i - 1
+  }
+}
+
+def toList[T](arr: ResizableArray[T]): List[T] = {
+  def go(i: Int, acc: List[T]): List[T] = {
+    if (i < 0) { acc } else {
+      go(i - 1, Cons(arr.unsafeGet(i), acc))
+    }
+  }
+  go(arr.size - 1, Nil())
+}

package/libraries/common/set.effekt

@@ -0,0 +1,234 @@
+module set
+
+import map
+
+/// Ordered finite immutable set, backed by balanced binary trees of logarithmic depth.
+record Set[A](tree: internal::Tree[A, Unit], compare: (A, A) => Ordering at {})
+
+/// Create a new empty set using a pure, first-class comparison function.
+///
+/// O(1)
+def empty[A](compare: (A, A) => Ordering at {}): Set[A] =
+  Set(internal::empty(), compare)
+
+/// Create a new empty set using a generic comparison function.
+/// Only available on JavaScript backends!
+///
+/// O(1)
+def emptyGeneric[A](): Set[A] =
+  Set(
+    internal::empty(),
+    box { (left: A, right: A) => genericCompare(left, right) }
+  )
+
+/// Check if set `s` is empty.
+///
+/// O(1)
+def isEmpty[A](s: Set[A]): Bool = internal::isEmpty(s.tree)
+
+/// Check if set `s` is nonempty.
+///
+/// O(1)
+def nonEmpty[A](s: Set[A]): Bool = internal::nonEmpty(s.tree)
+
+/// Create a new set containing a single `element`.
+/// Requires a pure, first-class comparison function.
+///
+/// O(1)
+def singleton[A](element: A, compare: (A, A) => Ordering at {}): Set[A] =
+  Set(internal::singleton(element, ()), compare)
+
+/// Create a new set containing a single `element` and a generic comparison function.
+/// Only available on the JavaScript backends!
+///
+/// O(1)
+def singletonGeneric[A](element: A): Set[A] =
+  Set(
+    internal::singleton(element, ()),
+    box { (left: A, right: A) => genericCompare(left, right) }
+  )
+
+/// Get the size of the set (the number of its elements).
+///
+/// O(1)
+def size[A](s: Set[A]): Int = internal::size(s.tree)
+
+/// Insert a new element `a` into the set `s`.
+///
+/// O(log N)
+def insert[A](s: Set[A], a: A): Set[A] = {
+  val newTree = internal::put(s.tree, s.compare, a, ())
+  Set(newTree, s.compare)
+}
+
+/// Create a set from a given map by ignoring the values.
+///
+/// O(N)
+def fromMapKeys[K, V](map: Map[K, V]): Set[K] =
+  Set(internal::forget(map.tree), map.compare)
+
+/// Create a map from a set and a function,
+/// reusing the set's comparison.
+///
+/// O(N)
+def toMap[K, V](keys: Set[K]) { valueOf: K => V }: Map[K, V] = {
+  val newTree: internal::Tree[K, V] = internal::map(keys.tree) { (k, _v) => valueOf(k) }
+  Map(newTree, keys.compare)
+}
+
+/// 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)
+}
+
+/// 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
+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)
+}
+
+/// Traverse all elements in order, running the function `action` on each element.
+///
+/// Law: `s.foreach { action } === s.toList.foreach { action }`
+///
+/// O(N)
+def foreach[A](s: Set[A]) { action: A => Unit }: Unit =
+  internal::foreach(s.tree) { (k, _v) => action(k) }
+
+/// Create a list from a given set.
+///
+/// O(N)
+def toList[A](s: Set[A]): List[A] = {
+  var acc = Nil()
+  s.foreach { a =>
+    acc = Cons(a, acc)
+  }
+  acc.reverse
+}
+
+/// Check if a predicate holds for all elements in a given set.
+///
+/// O(N)
+def all[A](s: Set[A]) { predicate : A => Bool }: Bool = {
+  var result = true
+  s.foreach { a =>
+    if (not(predicate(a))) { result = false }
+  }
+  result
+}
+
+/// Check if a predicate holds for at least one element in a given set.
+///
+/// O(N)
+def any[A](s: Set[A]) { predicate: A => Bool }: Bool = {
+  var result = false
+  s.foreach { a =>
+    if (predicate(a)) { result = true }
+  }
+  result
+}
+
+/// Check if a set contains a given element.
+///
+/// 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
+  }
+
+
+/// Check if set `s1` is a subset of set `s2`.
+///
+/// O(N log N)
+def subset[A](s1: Set[A], s2: Set[A]): Bool = {
+  s1.all { a =>
+    s2.contains(a)
+  }
+}
+
+/// Check if set `s1` is a superset of set `s2`.
+///
+/// O(N log N)
+def superset[A](s1: Set[A], s2: Set[A]): Bool = {
+  s2.subset(s1)
+}
+
+/// Remove an element from a set.
+/// If the element is not in the set, the original set is returned.
+///
+/// O(log N)
+def delete[A](s: Set[A], a: A): Set[A] = {
+  val newTree = internal::delete(s.tree, s.compare, a)
+  Set(newTree, s.compare)
+}
+
+/// Remove many elements from a set.
+///
+/// O(M log N) where M is the size of the list.
+def deleteMany[A](s: Set[A], list: List[A]): Set[A] = {
+  var tmp = s
+  list.foreach { a =>
+    tmp = tmp.delete(a)
+  }
+  tmp
+}
+
+/// Construct a new set which contains all elements of `s1`
+/// except those where the element is in `s2`.
+/// Uses an explicit comparison function.
+///
+/// O(???)
+def difference[A](s1: Set[A], s2: Set[A], compare: (A, A) => Ordering at {}): Set[A] = {
+  val newTree = internal::difference(s1.tree, s2.tree, compare)
+  Set(newTree, compare)
+}
+
+/// Construct a new set which contains all elements of `s1`
+/// except those where the element is in `s2`.
+/// Uses a comparison function from `s1`.
+///
+/// O(???)
+def difference[A](s1: Set[A], s2: Set[A]): Set[A] =
+  s1.difference(s2, s1.compare)
+
+/// Construct a new set which contains both elements of `s1` and `s2`.
+/// Uses an explicit comparison function.
+///
+/// O(???)
+def union[A](s1: Set[A], s2: Set[A], compare: (A, A) => Ordering at {}): Set[A] = {
+  val newTree = internal::union(s1.tree, s2.tree, compare) { (_k, _v1, _v2) => () }
+  Set(newTree, compare)
+}
+
+/// Construct a new set which contains both elements of `s1` and `s2`.
+/// Uses a comparison function from `s1`.
+///
+/// O(???)
+def union[A](s1: Set[A], s2: Set[A]): Set[A] =
+  s1.union(s2, s1.compare)
+
+/// Construct a new set which contains only elements which are in both of `s1` and `s2`.
+/// Uses an explicit comparison function.
+///
+/// O(???)
+def intersection[A](s1: Set[A], s2: Set[A], compare: (A, A) => Ordering at {}): Set[A] = {
+  val newTree = internal::intersection(s1.tree, s2.tree, compare) { (_k, _v1, _v2) => () }
+  Set(newTree, compare)
+}
+
+/// Construct a new set which contains only elements which are in both of `s1` and `s2`.
+/// Uses a comparison function from `s1`.
+///
+/// O(???)
+def intersection[A](s1: Set[A], s2: Set[A]): Set[A] =
+  s1.intersection(s2, s1.compare)

package/libraries/common/stream.effekt

@@ -2,6 +2,9 @@ module stream
 
 import array
 import bytearray
+import map
+import set
+
 import io/filesystem
 import io/error
 
@@ -63,6 +66,26 @@ def each(bytes: ByteArray): Unit / emit[Byte] = {
   go(0)
 }
 
+/// 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) }
+
+/// Turns a `set` into a producer of a push stream
+/// by emitting each contained *in order*.
+def each[A](set: Set[A]): Unit / emit[A] =
+  set.foreach { x => do emit(x) }
+
 // not option
 // not dequeue
 // not queue
@@ -168,6 +191,28 @@ def feed[T, R](list: List[T]) { reader: () => R / read[T] }: R = {
   }
 }
 
+def collectMap[K, V, R](compare: (K, K) => Ordering at {}) { stream: () => R / emit[(K, V)] }: (R, Map[K, V]) =
+  try {
+    (stream(), map::empty(compare))
+  } with emit[(K, V)] { case (k, v) =>
+    val (r, map) = resume(());
+    (r, map.put(k, v))
+  }
+
+def collectMap[K, V](compare: (K, K) => Ordering at {}) { stream: () => Any / emit[(K, V)] }: Map[K, V] =
+  collectMap[K, V, Any](compare){stream}.second
+
+def collectSet[A, R](compare: (A, A) => Ordering at {}) { stream: () => R / emit[A] }: (R, Set[A]) =
+  try {
+    (stream(), set::empty(compare))
+  } with emit[A] { (v) =>
+    val (r, set) = resume(());
+    (r, set.insert(v))
+  }
+
+def collectSet[A](compare: (A, A) => Ordering at {}) { stream: () => Any / emit[A] }: Set[A] =
+  collectSet[A, Any](compare){stream}.second
+
 def feed[T, R](array: Array[T]) { reader: () => R / read[T] }: R = {
   var i = 0
   try {
@@ -218,7 +263,7 @@ def zip[A, B] { stream1: () => Unit / emit[A] } { stream2: () => Unit / emit[B]
 
 def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[IOError] = {
 
-  val file = open(path, WriteOnly());
+  val file = openForWriting(path);
   with on[IOError].finalize { close(file) }
 
   val chunkSize = 1048576 // 1MB
@@ -246,7 +291,7 @@ def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[I
 
 def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IOError] = {
 
-  val file = open(path, ReadOnly());
+  val file = openForReading(path);
   with on[IOError].finalize { close(file) }
 
   val chunkSize = 1048576 // 1MB

package/libraries/common/string.effekt

@@ -243,11 +243,13 @@ extern pure def toInt(ch: Char): Int =
   js "${ch}"
   chez "${ch}"
   llvm "ret %Int ${ch}"
+  vm "string::toInt(Char)"
 
 extern pure def toChar(codepoint: Int): Char =
   js "${codepoint}"
   chez "${codepoint}"
   llvm "ret %Int ${codepoint}"
+  vm "string::toChar(Int)"
 
 
 extern pure def infixLt(x: Char, y: Char): Bool =
@@ -259,6 +261,7 @@ extern pure def infixLt(x: Char, y: Char): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "string::infixLt(Char, Char)"
 
 extern pure def infixLte(x: Char, y: Char): Bool =
   js "(${x} <= ${y})"
@@ -269,6 +272,7 @@ extern pure def infixLte(x: Char, y: Char): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "string::infixLte(Char, Char)"
 
 extern pure def infixGt(x: Char, y: Char): Bool =
   js "(${x} > ${y})"
@@ -279,6 +283,7 @@ extern pure def infixGt(x: Char, y: Char): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "string::infixGt(Char, Char)"
 
 extern pure def infixGte(x: Char, y: Char): Bool =
   js "(${x} >= ${y})"
@@ -289,6 +294,7 @@ extern pure def infixGte(x: Char, y: Char): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "string::infixGte(Char, Char)"
 
 
 /**
@@ -327,3 +333,4 @@ extern pure def unsafeCharAt(str: String, n: Int): Char =
     %x = call %Int @c_bytearray_character_at(%Pos ${str}, %Int ${n})
     ret %Int %x
   """
+  vm "string::unsafeCharAt(String, Int)"