@effekt-lang/effekt 0.4.0 → 0.6.0

package/libraries/common/queue.effekt

@@ -2,9 +2,7 @@ module queue
 
 import array
 
-/**
- * Mutable, automatically resizing queue.
- */
+/// Mutable, automatically resizing queue.
 interface Queue[T] {
   def empty?(): Bool
 

package/libraries/common/ref.effekt

@@ -9,15 +9,11 @@ extern js """
   }
 """
 
-/**
- * Global, mutable references
- */
+/// 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.
- */
+/// 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)"
@@ -26,9 +22,7 @@ extern global def allocate[T](): Ref[T] =
     ret %Pos %z
   """
 
-/**
- * Creates a new reference with the initial value `init`.
- */
+/// Creates a new reference with the initial value `init`.
 extern global def ref[T](init: T): Ref[T] =
   js "{ value: ${init} }"
   chez "(box ${init})"
@@ -37,9 +31,7 @@ extern global def ref[T](init: T): Ref[T] =
     ret %Pos %z
   """
 
-/**
- * Gets the referenced element of the `ref` in constant time.
- */
+/// 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})"
@@ -48,13 +40,11 @@ extern global def get[T](ref: Ref[T]): T =
     ret %Pos %z
   """
 
-/**
- * Sets the referenced element of the `ref` to `value` in constant time.
- */
+/// 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

@@ -4,18 +4,14 @@ import effekt
 import option
 import exception
 
-/**
- * Represents the result of a potentially failing computation.
- * It is the "reification" of the Exception[E] effect.
- */
+/// 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.
- */
+/// 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] {
@@ -27,18 +23,14 @@ def result[A, E](proxy: on[E]) { f: => A / Exception[E] }: Result[A, E] = try {
   def raise(exc, msg) = Error(exc, msg)
 }
 
-/**
- * Extracts the value of a result, if available
- * Monadic "reflection"
- */
+/// 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
- */
+/// 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()

package/libraries/common/seq.effekt

@@ -1,41 +1,32 @@
+/// This file implements the [[Seq]] type as a general purpose functional sequence.
+///
+/// Implemented as a 2-3 finger tree, it supports
+/// - prepend and append in amortized O(1),
+/// - concat(m, n) in O(log(min(m, n)))
+/// - first and last in amortized O(1)
+/// - size in amortized O(1)
+///
+/// More information on finger trees:
+///   https://www.staff.city.ac.uk/~ross/papers/FingerTree.pdf
 module seq
 
-/**
- * This file implements the [[Seq]] type as a general purpose functional sequence.
- *
- * Implemented as a 2-3 finger tree, it supports
- * - prepend and append in amortized O(1),
- * - concat(m, n) in O(log(min(m, n)))
- * - first and last in amortized O(1)
- * - size in amortized O(1)
- *
- * More information on finger trees:
- *   https://www.staff.city.ac.uk/~ross/papers/FingerTree.pdf
- */
-
-/**
- * Sequences of elements
- *
- * They are represented as 2-3 finger trees.
- */
+/// Sequences of elements
+///
+/// They are represented as 2-3 finger trees.
 type Seq[A] {
   Empty()
   Single(value: A)
   Deep(size: Int, prefix: Digit[A], middle: Tree[A], suffix: Digit[A])
 }
 
-/**
- * Result of splitting a sequence at the front or back.
- */
+/// Result of splitting a sequence at the front or back.
 type View[A] {
   IsEmpty()
   View(element: A, remainder: Seq[A])
 }
 
-/**
- * Exception[NoSuchElement] is raised when accessing non-existing elements
- * or splitting empty collections.
- */
+/// Exception[NoSuchElement] is raised when accessing non-existing elements
+/// or splitting empty collections.
 record NoSuchElement()
 
 
@@ -61,11 +52,9 @@ record IndexOutOfBounds()
 // Internal Types
 // --------------
 
-/**
- * Internal grouping of 1-4 elements
- *
- * It is called digit since Okasaki (1998) calls finger trees "numerical operations".
- */
+/// Internal grouping of 1-4 elements
+///
+/// It is called digit since Okasaki (1998) calls finger trees "numerical operations".
 type Digit[A] {
   One(value: A)
   Two(first: A, second: A)
@@ -73,9 +62,7 @@ type Digit[A] {
   Four(first: A, second: A, third: A, fourth: A)
 }
 
-/**
- * Internal representation of a 2-3 tree
- */
+/// Internal representation of a 2-3 tree
 type Node[A] {
   // These are necessary to avoid polymorphic recursion
   Leaf2(first: A, second: A)
@@ -84,12 +71,10 @@ type Node[A] {
   Node3(size: Int, first: Node[A], second: Node[A], third: Node[A])
 }
 
-/**
- * Internal duplicate of Seq
- *
- * splitting into two type parameters is necessary since our MLton backend does
- * not support mutually recursive data type declarations.
- */
+/// Internal duplicate of Seq
+///
+/// splitting into two type parameters is necessary since our MLton backend does
+/// not support mutually recursive data type declarations.
 type Finger[A, N] {
   NoFinger()
   SingleFinger(value: Node[A])
@@ -141,9 +126,7 @@ def size[A](tree: Tree[A]): Int = tree match {
   case DeepFinger(size, _, _, _) => size
 }
 
-/**
- * The size of the given sequence
- */
+/// The size of the given sequence
 def size[A](seq: Seq[A]): Int = seq match {
   case Empty() => 0
   case Single(value) => 1
@@ -408,9 +391,7 @@ def reverse[A](seq: Seq[A]): Seq[A] = {
 }
 
 
-/**
- * Random access
- */
+/// Random access
 def index[A](seq: Seq[A], index: Int): A / Exception[NoSuchElement] = {
 
   // invariant for all internal functions: element is in the sequence
@@ -485,9 +466,7 @@ def index[A](seq: Seq[A], index: Int): A / Exception[NoSuchElement] = {
   }
 }
 
-/**
- * Random access
- */
+/// Random access
 def update[A](seq: Seq[A], index: Int, value: A): Seq[A] / Exception[NoSuchElement] = {
 
   // invariant for all internal functions: element is in the sequence
@@ -911,4 +890,4 @@ def map[A, B](seq: Seq[A]) { f: (A) {Control} => B }: Seq[B] = {
 
 
 // TODO equality comparison
-//
+//

package/libraries/common/string.effekt

@@ -34,9 +34,7 @@ def substring(str: String, from: Int): String =
   str.substring(from, str.length)
 
 
-/**
- * Checks whether str starts with the given prefix at `from`
- */
+/// Checks whether str starts with the given prefix at `from`
 def isSubstringAt(str: String, prefix: String, from: Int): Bool = {
   with default[OutOfBounds, Bool] { false };
 
@@ -59,11 +57,9 @@ def startsWith(str: String, prefix: String): Bool =
 def endsWith(str: String, suffix: String): Bool =
   isSubstringAt(str, suffix, str.length - suffix.length)
 
-/**
- * Repeats the given string n-times.
- *
- * TODO use a more efficient way of appending strings like a buffer
- */
+/// Repeats the given string n-times.
+///
+/// TODO use a more efficient way of appending strings like a buffer
 def repeat(str: String, n: Int): String = {
   def go(n: Int, result: String): String = {
     if (n == 0) result
@@ -180,15 +176,13 @@ def toInt(str: String, base: Int): Int / Exception[WrongFormat] = {
   }
 }
 
-// Native versions of toInt (unused right now)
+/// Native versions of toInt (unused right now)
 extern pure def unsafeToInt(str: String): Int =
   js "(Number.isNaN(parseInt(${str})) ? undefined : parseInt(${str}))"
   chez "(string->number ${str})"
 
 
-/**
- * Returns the index of the first occurrence of `sub` in `str`
- */
+/// Returns the index of the first occurrence of `sub` in `str`
 def indexOf(str: String, sub: String): Option[Int] =
   indexOf(str, sub, 0)
 
@@ -202,9 +196,7 @@ def indexOf(str: String, sub: String, from: Int): Option[Int] = {
   go(from)
 }
 
-/**
- * Returns the index of the last occurence of `sub` in `str`
- */
+/// Returns the index of the last occurence of `sub` in `str`
 def lastIndexOf(str: String, sub: String): Option[Int] =
   lastIndexOf(str, sub, str.length)
 

package/libraries/js/effekt_builtins.js

@@ -54,4 +54,8 @@ $effekt.println = function println$impl(str) {
   console.log(str); return $effekt.unit;
 }
 
-$effekt.unit = { __unit: true }
+$effekt.unit = { __unit: true }
+
+$effekt.emptyMatch = function() { throw "empty match" }
+
+$effekt.hole = function() { throw "not implemented, yet" }