@effekt-lang/effekt 0.2.1 → 0.3.0

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,10 @@
+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})"
+  ml "(Posix.Process.exit (Word8.fromInt ${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,63 @@
+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})"
+  ml "ref ${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})"
+  ml "!${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})"
+  ml "${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()
+}