@effekt-lang/effekt 0.2.2 → 0.4.0

package/libraries/{llvm/immutable → common}/list.effekt

@@ -1,13 +1,8 @@
-module immutable/list
+module list
 
 import effekt
-import immutable/option
-
-// Used as a type for `Exception` in functions which expect a nonempty list.
-record EmptyList()
-
-// Used as a type for `Exception` in functions where an index can be out of bounds.
-record OutOfBounds()
+import option
+import exception
 
 // Immutable linked list for finite sequences of elements.
 type List[A] {
@@ -46,7 +41,7 @@ def build[A](size: Int) { index: Int => A }: List[A] = {
 // Check if list is empty.
 //
 // O(1)
-def isEmpty[A](l: List[A]): Boolean = l match {
+def isEmpty[A](l: List[A]): Bool = l match {
   case Nil() => true
   case Cons(a, rest) => false
 }
@@ -54,26 +49,26 @@ def isEmpty[A](l: List[A]): Boolean = l match {
 // Check if list is nonempty.
 //
 // O(1)
-def nonEmpty[A](l: List[A]): Boolean = l match {
+def nonEmpty[A](l: List[A]): Bool = l match {
   case Nil() => false
   case Cons(a, rest) => true
 }
 
 // Return the first element of a given list.
-// Throws a `EmptyList` exception if it's empty.
+// Throws a `MissingValue` exception if it's empty.
 //
 // O(1)
-def head[A](l: List[A]): A / Exception[EmptyList] = l match {
-  case Nil() => do raise(EmptyList(), "Trying to get the head of an empty list")
+def head[A](l: List[A]): A / Exception[MissingValue] = l match {
+  case Nil() => do raise(MissingValue(), "Trying to get the head of an empty list")
   case Cons(a, rest) => a
 }
 
 // Return all elements of a given list except the first element.
-// Throws a `EmptyList` exception if it's empty.
+// Throws a `MissingValue` exception if it's empty.
 //
 // O(1)
-def tail[A](l: List[A]): List[A] / Exception[EmptyList] = l match {
-  case Nil() => do raise(EmptyList(), "Trying to get the head of an empty list")
+def tail[A](l: List[A]): List[A] / Exception[MissingValue] = l match {
+  case Nil() => do raise(MissingValue(), "Trying to get the head of an empty list")
   case Cons(a, rest) => rest
 }
 
@@ -86,19 +81,30 @@ def headOption[A](l: List[A]): Option[A] = l match {
   case Cons(a, rest) => Some(a)
 }
 
+// Returns the last element of a given list.
+//
+// O(N)
+def last[A](l: List[A]): A / Exception[MissingValue] = {
+  def go(list: List[A]): A = {
+    list match {
+      case Nil() => do raise(MissingValue(), "Trying to get the last element of an empty list")
+      case Cons(x, Nil()) => x
+      case Cons(x, xs) => go(xs)
+    }
+  }
+
+  go(l)
+}
+
 // Get the value at given index.
 //
 // O(N)
 def get[A](list: List[A], index: Int): A / Exception[OutOfBounds] = {
-  def go(list: List[A], i: Int): A / Exception[OutOfBounds] = {
+  def go(list: List[A], i: Int): A = {
     list match {
       case Nil() => do raise(OutOfBounds(), "Trying to get an element outside the bounds of a list")
-      case Cons(x, xs) =>
-        if (i == 0) {
-          x
-        } else {
-          go(xs, i - 1)
-        }
+      case Cons(x, xs) and i == 0 => x
+      case Cons(x, xs)            => go(xs, i - 1)
     }
   }
 
@@ -108,36 +114,53 @@ def get[A](list: List[A], index: Int): A / Exception[OutOfBounds] = {
 // Traverse a list, applying the given action on every element.
 //
 // O(N)
-def foreach[A](l: List[A]) { f: A => Unit / Control } : Unit = {
+def foreach[A](l: List[A]) { f: (A) => Unit } : Unit = l match {
+  case Nil() => ()
+  case Cons(head, tail) => f(head); tail.foreach {f}
+}
+
+// Traverse a list, applying the given action on every element.
+//
+// O(N)
+def foreach[A](l: List[A]) { f: (A) {Control} => Unit } : Unit = {
   var remainder = l
-  loop {
-    if (not(remainder.isEmpty)) {
-      remainder match {
-        case Nil() => ()
-        case Cons(a, as) =>
-          remainder = as
-          f(a)
-      }
-    } else { do break() }
+  loop { {label} =>
+    remainder match {
+      case Nil() => label.break()
+      case Cons(head, tail) =>
+        remainder = tail
+        f(head) {label}
+    }
   }
 }
 
 // Traverse a list, applying the given action on every element and its (zero-based) index.
 //
 // O(N)
-def foreachIndex[A](list: List[A]){ f: (Int, A) => Unit / Control }: Unit = {
+def foreachIndex[A](list: List[A]){ f: (Int, A) => Unit }: Unit = {
+  def loop(index: Int, remainder: List[A]): Unit = remainder match {
+    case Nil() => ()
+    case Cons(head, tail) =>
+      f(index, head);
+      loop(index + 1, tail)
+  }
+  loop(0, list)
+}
+
+// Traverse a list, applying the given action on every element and its (zero-based) index.
+//
+// O(N)
+def foreachIndex[A](list: List[A]){ f: (Int, A) {Control} => Unit }: Unit = {
   var remainder = list
   var i = -1
-  loop {
-    if (not(remainder.isEmpty)) {
+  loop { {label} =>
       remainder match {
-        case Nil() => ()
-        case Cons(a, as) =>
-          remainder = as
+        case Nil() => label.break()
+        case Cons(head, tail) =>
+          remainder = tail
           i = i + 1
-          f(i, a)
+          f(i, head) {label}
       }
-    } else { do break() }
   }
 }
 
@@ -182,7 +205,7 @@ 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 => Boolean }: Boolean = {
+def all[A](list: List[A]) { predicate: A => Bool }: Bool = {
   list match {
     case Cons(x, xs) => predicate(x) && all(xs) { predicate }
     case Nil() => true
@@ -192,13 +215,31 @@ def all[A](list: List[A]) { predicate: A => Boolean }: Boolean = {
 // Check if predicate is true for at least one element of the given list.
 //
 // O(N)
-def any[A](list: List[A]) { predicate: A => Boolean }: Boolean = {
+def any[A](list: List[A]) { predicate: A => Bool }: Bool = {
   list match {
     case Cons(x, xs) => predicate(x) || any(xs) { predicate }
     case Nil() => false
   }
 }
 
+// Fold a list using `f`, starting from the left given a starting value.
+//
+// O(N)
+def foldLeft[A, B](l: List[A], init: B) { f: (B, A) => B }: B = {
+  var acc = init;
+  l.foreach { x => acc = f(acc, x) };
+  acc
+}
+
+// Fold a list using `f`, starting from the right given a starting value.
+//
+// O(N)
+def foldRight[A, B](l: List[A], init: B) { f: (A, B) => B }: B = {
+  var acc = init;
+  l.reverse.foreach { x => acc = f(x, acc) };
+  acc
+}
+
 // Sum the elements of the list.
 //
 // O(N)
@@ -594,7 +635,7 @@ def unzip[A, B](pairs: List[(A, B)]): (List[A], List[B]) = {
 // the right list contains the elements that do not.
 //
 // O(N)
-def partition[A](l: List[A]) { pred: A => Boolean }: (List[A], List[A]) = {
+def partition[A](l: List[A]) { pred: A => Bool }: (List[A], List[A]) = {
   var lefts: List[A] = Nil()
   var rights: List[A] = Nil()
   l.foreach { el =>
@@ -613,7 +654,7 @@ def partition[A](l: List[A]) { pred: A => Boolean }: (List[A], List[A]) = {
 // Note: this implementation is not stacksafe!
 //
 // O(N log N)
-def sortBy[A](l: List[A]) { compare: (A, A) => Boolean }: List[A] =
+def sortBy[A](l: List[A]) { compare: (A, A) => Bool }: List[A] =
   l match {
     case Nil() => Nil()
     case Cons(pivot, rest) =>
@@ -624,14 +665,13 @@ def sortBy[A](l: List[A]) { compare: (A, A) => Boolean }: List[A] =
   }
 
 def sort(l: List[Int]): List[Int] = l.sortBy { (a, b) => a < b }
-// def sort(l: List[Double]): List[Double] = l.sortBy { (a, b) => a < b }
-// Future work: ^ needs `le` for `Double`
+def sort(l: List[Double]): List[Double] = l.sortBy { (a, b) => a < b }
 
 // Check if a list is sorted according to the given comparison function.
 //
 // O(N)
-def isSortedBy[A](list: List[A]) { compare: (A, A) => Boolean }: Boolean = {
-  def go(list: List[A]): Boolean = {
+def isSortedBy[A](list: List[A]) { compare: (A, A) => Bool }: Bool = {
+  def go(list: List[A]): Bool = {
     list match {
       case Nil() => true
       case Cons(x, Nil()) => true
@@ -643,36 +683,23 @@ def isSortedBy[A](list: List[A]) { compare: (A, A) => Boolean }: Boolean = {
   go(list)
 }
 
-// =========================================
-// `show` / `println` overloads for options:
-// =========================================
 
-// uses the same crude format as other backends
-def showList[A](l: List[A]){ showA: A => String }: String = {
+// Show Instances
+// --------------
+
+def show[A](l: List[A]) { showA: A => String }: String = {
   def go(l: List[A]): String = l match {
     case Nil() => "Nil()"
     case Cons(x, xs) => "Cons(" ++ showA(x) ++ ", " ++ go(xs) ++ ")"
   }
   go(l)
 }
-def show(l: List[Int]): String = showList(l){e => show(e)}
-def show(l: List[Double]): String = showList(l){e => show(e)}
-def show(l: List[Boolean]): String = showList(l){e => show(e)}
-def show(l: List[String]): String = showList(l){e => e}
+def show(l: List[Int]): String = show(l) { e => show(e) }
+def show(l: List[Double]): String = show(l) { e => show(e) }
+def show(l: List[Bool]): String = show(l) { e => show(e) }
+def show(l: List[String]): String = show(l) { e => e }
 
-def println(l: List[Int]): Unit = {
-  val s: String = show(l)
-  println(s)
-}
-def println(l: List[Double]): Unit = {
-  val s: String = show(l)
-  println(s)
-}
-def println(l: List[Boolean]): Unit = {
-  val s: String = show(l)
-  println(s)
-}
-def println(l: List[String]): Unit = {
-  val s: String = show(l)
-  println(s)
-}
+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))

package/libraries/common/option.effekt

@@ -0,0 +1,72 @@
+module option
+
+import effekt
+import exception
+
+type Option[A] {
+  None();
+  Some(value: A)
+}
+
+def isDefined[A](self: Option[A]): Bool = self match {
+  case None()  => false
+  case Some(v) => true
+}
+
+def isEmpty[A](self: Option[A]): Bool =
+  self.isDefined.not
+
+def orElse[A](self: Option[A]) { that: => Option[A] }: Option[A] = self match {
+  case None()  => that()
+  case Some(v) => Some(v)
+}
+
+def getOrElse[A](self: Option[A]) { that: => A }: A = self match {
+  case None() => that()
+  case Some(v) => v
+}
+
+def map[A, B](self: Option[A]) { f: A => B }: Option[B] = self match {
+  case None()  => None()
+  case Some(v) => Some(f(v))
+}
+
+def foreach[A](self: Option[A]) { f: A => Unit }: Unit = self match {
+  case None()  => ()
+  case Some(v) => f(v)
+}
+
+def value[A](self: Option[A]): A / Exception[MissingValue] = self match {
+  case None() => do raise(MissingValue(), "Trying to get the value of an empty option")
+  case Some(v) => v
+}
+
+def option[A] { p: => A / Exception[MissingValue] }: Option[A] =
+  try { Some(p()) }
+  with Exception[MissingValue] { def raise(_, _) = None() }
+
+def option[A, E](proxy: on[E]) { p: => A / Exception[E] }: Option[A] =
+  try { Some(p()) }
+  with Exception[E] { def raise(_, _) = None() }
+
+// Interop with FFI
+// ---------------
+// These functions should only be used by libraries that interface with FFI
+def undefinedToOption[A](value: A): Option[A] =
+  if (value.isUndefined) { None() } else { Some(value) }
+
+
+// Show Instances
+// --------------
+
+def show[A](o: Option[A]) { showA: A => String }: String = o match {
+  case None() => "None()"
+  case Some(v) => "Some(" ++ showA(v) ++ ")"
+}
+def show(o: Option[Int]): String = show(o) { e => show(e) }
+def show(o: Option[Double]): String = show(o) { e => show(e) }
+def show(o: Option[Bool]): String = show(o) { e => show(e) }
+
+def println(o: Option[Int]): Unit = println(show(o))
+def println(o: Option[Double]): Unit = println(show(o))
+def println(o: Option[Bool]): Unit = println(show(o))

package/libraries/common/process.effekt

@@ -0,0 +1,9 @@
+module process
+
+extern io def exit(errorCode: Int): Nothing =
+  js   "(function() { process.exit(${errorCode}) })()"
+  llvm """
+    call void @exit(i64 ${errorCode})
+    ret %Pos zeroinitializer
+  """
+  chez "(exit ${errorCode})"

package/libraries/common/queue.effekt

@@ -0,0 +1,140 @@
+module queue
+
+import array
+
+/**
+ * Mutable, automatically resizing queue.
+ */
+interface Queue[T] {
+  def empty?(): Bool
+
+  def popFront(): Option[T]
+
+  def popBack(): Option[T]
+
+  def peekFront(): Option[T]
+
+  def peekBack(): Option[T]
+
+  def pushFront(el: T): Unit
+
+  def pushBack(el: T): Unit
+}
+
+
+def emptyQueue[T](): Queue[T] at {global} =
+  emptyQueue[T](64)
+
+def emptyQueue[T](initialCapacity: Int): Queue[T] at {global} = {
+
+  var contents in global = array[Option[T]](initialCapacity, None())
+  var head in global = 0
+  var tail in global = 0
+  var size in global = 0
+  var capacity in global = initialCapacity
+
+  def remove(arr: Array[Option[T]], index: Int): Option[T] = {
+    with on[OutOfBounds].default { None() };
+    val value = arr.get(index);
+    arr.set(index, None());
+    value
+  }
+
+  def nonEmpty[T] { p: => Option[T] / Exception[OutOfBounds] }: Option[T] =
+    if (size <= 0) None() else on[OutOfBounds].default { None() } { p() }
+
+  // Exponential back-off
+  def resizeTo(requiredSize: Int): Unit =
+    if (requiredSize <= capacity) () else {
+      with on[OutOfBounds].ignore // should not happen
+
+      val oldSize = capacity
+      val newSize = capacity * 2
+      val oldContents = contents
+      val newContents = array::allocate[Option[T]](newSize)
+
+      if (head < tail) {
+        // The queue does not wrap around; direct copy is possible.
+        copy(oldContents, head, newContents, 0, size) // changed tail to size
+      } else if (size > 0) {
+        // The queue wraps around; copy in two segments.
+        copy(oldContents, head, newContents, 0, oldSize - head) // changed oldSize to oldSize - head
+        copy(oldContents, 0, newContents, oldSize - head, tail) // changed oldSize - head to oldSize - head
+      }
+
+      contents = newContents
+      capacity = newSize
+      head = 0
+      tail = oldSize
+    }
+
+  def queue = new Queue[T] {
+    def empty?() = size <= 0
+
+    def popFront() =
+      nonEmpty {
+        val result = contents.remove(head)
+        head = mod(head + 1, capacity)
+        size = size - 1
+        result
+      }
+
+    def popBack() =
+      nonEmpty {
+        tail = mod(tail - 1 + capacity, capacity)
+        val result = contents.remove(tail)
+        size = size - 1
+        result
+      }
+
+    def peekFront() = nonEmpty { contents.get(head) }
+
+    def peekBack() = nonEmpty { contents.get(tail) }
+
+    def pushFront(el: T) = {
+      resizeTo(size + 1);
+      head = mod(head - 1 + capacity, capacity);
+      size = size + 1;
+      contents.unsafeSet(head, Some(el))
+    }
+
+    def pushBack(el: T) = {
+      resizeTo(size + 1);
+      contents.unsafeSet(tail, Some(el));
+      size = size + 1;
+      tail = mod(tail + 1, capacity)
+    }
+  }
+  queue
+}
+
+namespace examples {
+  def main() = {
+    // queue with initial capacity 4
+    def b = emptyQueue[Int](4);
+    println(b.empty?);
+    b.pushFront(1);
+    b.pushBack(2);
+    b.pushFront(3);
+    b.pushBack(4);
+    // this will cause resizing:
+    b.pushBack(5);
+    b.pushBack(6);
+    b.pushBack(7);
+    b.pushBack(8);
+    // and again:
+    b.pushBack(9);
+
+    println(b.empty?);
+    println(b.popFront()); // Some(3)
+    println(b.popFront()); // Some(1)
+    println(b.popFront()); // Some(2)
+    println(b.popFront()); // Some(4)
+    println(b.popFront()); // Some(5)
+    println(b.popFront()); // Some(6)
+    println(b.popFront()); // Some(7)
+    println(b.popFront()); // Some(8)
+    println(b.popFront()); // Some(9)
+    println(b.popFront()); // None()
+  }
+}

package/libraries/common/ref.effekt

@@ -0,0 +1,60 @@
+module ref
+
+import effekt
+
+extern js """
+  function set$impl(ref, value) {
+    ref.value = value;
+    return $effekt.unit;
+  }
+"""
+
+/**
+ * Global, mutable references
+ */
+extern type Ref[T]
+
+/**
+ * Allocates a new reference of size `size`, keeping its value _undefined_.
+ * Prefer using `ref` constructor instead to ensure that the value is defined.
+ */
+extern global def allocate[T](): Ref[T] =
+  js "{ value: undefined }"
+  chez "(box #f)"
+  llvm """
+    %z = call %Pos @c_ref_fresh(%Pos zeroinitializer)
+    ret %Pos %z
+  """
+
+/**
+ * Creates a new reference with the initial value `init`.
+ */
+extern global def ref[T](init: T): Ref[T] =
+  js "{ value: ${init} }"
+  chez "(box ${init})"
+  llvm """
+    %z = call %Pos @c_ref_fresh(%Pos ${init})
+    ret %Pos %z
+  """
+
+/**
+ * Gets the referenced element of the `ref` in constant time.
+ */
+extern global def get[T](ref: Ref[T]): T =
+  js "${ref}.value"
+  chez "(unbox ${ref})"
+  llvm """
+    %z = call %Pos @c_ref_get(%Pos ${ref})
+    ret %Pos %z
+  """
+
+/**
+ * Sets the referenced element of the `ref` to `value` in constant time.
+ */
+extern global def set[T](ref: Ref[T], value: T): Unit =
+  js "set$impl(${ref}, ${value})"
+  chez "(set-box! ${ref} ${value})"
+  llvm """
+    %z = call %Pos @c_ref_set(%Pos ${ref}, %Pos ${value})
+    ret %Pos %z
+  """

package/libraries/common/result.effekt

@@ -0,0 +1,45 @@
+module result
+
+import effekt
+import option
+import exception
+
+/**
+ * Represents the result of a potentially failing computation.
+ * It is the "reification" of the Exception[E] effect.
+ */
+type Result[A, E] {
+  Error(exception: E, msg: String);
+  Success(a: A)
+}
+
+/**
+ * Represent ("reify") the result of a potentially failing computation.
+ */
+def result[A, E] { f: => A / Exception[E] }: Result[A, E] = try {
+  Success(f())
+} with Exception[E] {
+  def raise(exc, msg) = Error(exc, msg)
+}
+def result[A, E](proxy: on[E]) { f: => A / Exception[E] }: Result[A, E] = try {
+  Success(f())
+} with Exception[E] {
+  def raise(exc, msg) = Error(exc, msg)
+}
+
+/**
+ * Extracts the value of a result, if available
+ * Monadic "reflection"
+ */
+def value[A, E](r: Result[A, E]): A / Exception[E] = r match {
+  case Success(a) => a
+  case Error(exc, msg) => do raise(exc, msg)
+}
+
+/**
+ * Converts a result to an option forgetting the error details
+ */
+def toOption[A, E](r: Result[A, E]): Option[A] = r match {
+  case Success(a) => Some(a)
+  case Error(exc, msg) => None()
+}