@effekt-lang/effekt 0.47.0 → 0.48.0

package/libraries/common/list.effekt

@@ -3,6 +3,7 @@ module list
 import effekt
 import option
 import exception
+import stream
 
 /// Immutable linked list for finite sequences of elements.
 type List[A] {
@@ -167,9 +168,52 @@ def foreachIndex[A](list: List[A]){ f: (Int, A) {Control} => Unit }: Unit = {
 /// Map a function `f` over elements in a given list.
 ///
 /// O(N)
-def map[A, B](l: List[A]) { f: A => B } : List[B] = {
-  var acc = Nil[B]()
-  l.foreach { el => acc = Cons(f(el), acc) }
+def map[A, B](l: List[A]) { f: A => B }: List[B] = {
+  var acc: List[B] = Nil()
+  l.foreach { el =>
+    acc = Cons(f(el), acc)
+  }
+  acc.reverse
+}
+
+/// Map a function `f` over elements and their indices in a given list.
+///
+/// O(N)
+def mapWithIndex[A, B](l: List[A]) { f: (Int, A) => B }: List[B] = {
+  var acc: List[B] = Nil()
+  l.foreachIndex { (i, el) =>
+    acc = Cons(f(i, el), acc)
+  }
+  acc.reverse
+}
+
+/// Map a function `f` over elements in a given list,
+/// keeping only the elements for which the function returned `true`,
+/// discarding the elements for which the function returned `false`.
+///
+/// O(N)
+def filter[A](l: List[A]) { shouldKeep: A => Bool }: List[A] = {
+  var acc: List[A] = Nil()
+  l.foreach { a =>
+    if (shouldKeep(a)) {
+      acc = Cons(a, acc)
+    }
+  }
+  acc.reverse
+}
+
+/// Map a function `f` over elements and their indices in a given list,
+/// keeping only the elements for which the function returned `true`,
+/// discarding the elements for which the function returned `false`.
+///
+/// O(N)
+def filterWithIndex[A](l: List[A]) { shouldKeep: (Int, A) => Bool }: List[A] = {
+  var acc: List[A] = Nil()
+  l.foreachIndex { (i, a) =>
+    if (shouldKeep(i, a)) {
+      acc = Cons(a, acc)
+    }
+  }
   acc.reverse
 }
 
@@ -178,13 +222,28 @@ def map[A, B](l: List[A]) { f: A => B } : List[B] = {
 /// discarding the elements for which the function returned `None()`.
 ///
 /// O(N)
-def collect[A, B](l: List[A]) { f : A => Option[B] }: List[B] = {
-  var acc = Nil[B]()
+def collectSome[A, B](l: List[A]) { f : A => Option[B] }: List[B] = {
+  var acc: List[B] = Nil()
   l.foreach { a =>
-    val optB = f(a)
-    optB match {
-      case None() => ();
-      case Some(b) => acc = Cons(b, acc);
+    f(a) match {
+      case None() => ()
+      case Some(b) => acc = Cons(b, acc)
+    }
+  }
+  acc.reverse
+}
+
+/// Map a function `f` over elements and their indices in a given list,
+/// keeping only the elements for which the function returned `Some(...)`,
+/// discarding the elements for which the function returned `None()`.
+///
+/// O(N)
+def collectWithIndex[A, B](l: List[A]) { f: (Int, A) => Option[B] }: List[B] = {
+  var acc: List[B] = Nil()
+  l.foreachIndex { (i, a) =>
+    f(i, a) match {
+      case None() => ()
+      case Some(b) => acc = Cons(b, acc)
     }
   }
   acc.reverse
@@ -205,21 +264,55 @@ def flatMap[A, B](l: List[A]) { f : A => List[B] }: List[B] = {
 /// Check if predicate is true for all elements of the given list.
 ///
 /// O(N)
-def all[A](list: List[A]) { predicate: A => Bool }: Bool = {
+def all[A](list: List[A]) { predicate: A => Bool }: Bool =
   list match {
     case Cons(x, xs) => predicate(x) && all(xs) { predicate }
     case Nil() => true
   }
-}
 
 /// Check if predicate is true for at least one element of the given list.
 ///
 /// O(N)
-def any[A](list: List[A]) { predicate: A => Bool }: Bool = {
+def any[A](list: List[A]) { predicate: A => Bool }: Bool =
   list match {
     case Cons(x, xs) => predicate(x) || any(xs) { predicate }
     case Nil() => false
   }
+
+/// Check if the list contains the given `element`,
+/// comparing for equality with the given `eq` function.
+///
+/// O(N)
+def contains[A](list: List[A], element: A) { eq: (A, A) => Bool }: Bool =
+  list.any { x => x.eq(element) }
+
+/// Find the first index of the given `element`,
+/// comparing for equality with the given `eq` function.
+///
+/// O(N)
+def indexOf[A](list: List[A], element: A) { eq: (A, A) => Bool }: Option[Int] = {
+  var result = None()
+  list.foreachIndex { (i, a) {label} =>
+    if (element.eq(a)) {
+      result = Some(i)
+      label.break()
+    }
+  }
+  result
+}
+
+/// Find the last index of the given `element`,
+/// comparing for equality with the given `eq` function.
+///
+/// O(N)
+def lastIndexOf[A](list: List[A], element: A) { eq: (A, A) => Bool }: Option[Int] = {
+  var result = None()
+  list.foreachIndex { (i, a) {label} =>
+    if (element.eq(a)) {
+      result = Some(i)
+    }
+  }
+  result
 }
 
 /// Count how many elements of a list satisfy the given predicate.
@@ -297,10 +390,11 @@ def reverse[A](l: List[A]): List[A] = {
 /// ```
 ///
 /// O(|l|)
-def reverseOnto[A](l: List[A], other: List[A]): List[A] = l match {
-  case Nil() => other
-  case Cons(a, rest) => rest.reverseOnto(Cons(a, other))
-}
+def reverseOnto[A](l: List[A], other: List[A]): List[A] =
+  l match {
+    case Nil() => other
+    case Cons(a, rest) => rest.reverseOnto(Cons(a, other))
+  }
 
 /// Concatenate list `l` with list `other`:
 ///
@@ -347,7 +441,7 @@ def join[A](lists: List[List[A]]): List[A] = {
 /// ```
 ///
 /// O(N)
-def join[A](lists: List[List[A]], between: List[A]): List[A] = {
+def join[A](lists: List[List[A]], between: List[A]): List[A] =
   lists match {
     case Nil() => Nil()
     case Cons(firstList, restOfLists) =>
@@ -355,7 +449,6 @@ def join[A](lists: List[List[A]], between: List[A]): List[A] = {
         restOfLists.flatMap { list => between.append(list)}
       )
   }
-}
 
 /// Take the first `n` elements of a given list.
 ///
@@ -836,3 +929,46 @@ def println(l: List[Int]): Unit = println(show(l))
 def println(l: List[Double]): Unit = println(show(l))
 def println(l: List[Bool]): Unit = println(show(l))
 def println(l: List[String]): Unit = println(show(l))
+
+
+// Streaming
+// ---------
+
+/// 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] =
+  list match {
+    case Nil() => ()
+    case Cons(head, tail) =>
+      do emit(head)
+      each(tail)
+  }
+
+def feed[T, R](list: List[T]) { reader: () => R / read[T] }: R = {
+  var l = list
+  try {
+    reader()
+  } with read[T] {
+    resume {
+      l match {
+        case Nil() => do stop()
+        case Cons(value, rest) =>
+          l = rest
+          return value
+      }
+    }
+  }
+}
+
+def collect[A] { stream: () => Unit / emit[A] }: List[A] =
+  returning::collect[A, Unit]{stream}.second
+
+namespace returning {
+  def collect[A, R] { stream: () => R / emit[A] }: (R, List[A]) =
+    try {
+      (stream(), Nil())
+    } with emit[A] { (v) =>
+      val (r, vs) = resume(());
+      (r, Cons(v, vs))
+    }
+}

package/libraries/common/map.effekt

@@ -1,5 +1,7 @@
 module map
 
+import stream
+
 /// Ordered finite immutable map, backed by balanced binary trees of logarithmic depth.
 record Map[K, V](tree: internal::Tree[K, V], compare: (K, K) => Ordering at {})
 
@@ -989,4 +991,36 @@ namespace internal {
 
     "[" ++ 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) }
+
+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 {
+  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))
+    }
+}

package/libraries/common/queue.effekt

@@ -103,7 +103,7 @@ def emptyQueue[T](initialCapacity: Int): Queue[T] at global = {
       tail.set(mod(tail.get + 1, capacity.get))
     }
   }
-  queue
+  box queue
 }
 
 namespace examples {

package/libraries/common/random.effekt

@@ -1,6 +1,7 @@
 module random
 
 import stream
+import io/filesystem
 import io/error
 
 /// Infinite pull stream of random bytes.

package/libraries/common/ref.effekt

@@ -104,3 +104,7 @@ extern def set[T](ref: Ref[T], value: T) at global: Unit =
     ret %Pos zeroinitializer
   """
   vm "ref::set[T](Ref[T], T)"
+
+/// Modifies the inner contents of the `ref` with a function `f`
+def map[T](ref: Ref[T]) { f: T => T }: Unit =
+  ref.set(f(ref.get))

package/libraries/common/seq.effekt

@@ -875,7 +875,7 @@ def map[A, B](seq: Seq[A]) { f: (A) {Control} => B }: Seq[B] = {
 
 // def iterate[A, R](seq: Seq[A]) { prog: {Iterator[A]} => R }: R = {
 
-//   var k: Unit => Unit at {} = fun(unit: Unit) { () }
+//   var k: Unit => Unit at {} = box { () => () }
 //   var v: Option[A] = None()
 
 //   try { seq.each { el => do yield(el) } } with Generator[A] {

package/libraries/common/set.effekt

@@ -1,6 +1,7 @@
 module set
 
 import map
+import stream
 
 /// 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 {})
@@ -231,4 +232,26 @@ def intersection[A](s1: Set[A], s2: Set[A], compare: (A, A) => Ordering at {}):
 ///
 /// O(???)
 def intersection[A](s1: Set[A], s2: Set[A]): Set[A] =
-  s1.intersection(s2, s1.compare)
+  s1.intersection(s2, s1.compare)
+
+
+// Streaming
+// ---------
+
+/// 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) }
+
+def collect[A](compare: (A, A) => Ordering at {}) { stream: () => Unit / emit[A] }: Set[A] =
+  returning::collect[A, Unit](compare){stream}.second
+
+namespace returning {
+  def collect[A, R](compare: (A, A) => Ordering at {}) { stream: () => R / emit[A] }: (R, Set[A]) =
+    try {
+      (stream(), empty(compare))
+    } with emit[A] { (v) =>
+      val (r, set) = resume(());
+      (r, set.insert(v))
+    }
+}