@effekt-lang/effekt 0.3.0 → 0.5.0

package/libraries/common/process.effekt

@@ -7,4 +7,3 @@ extern io def exit(errorCode: Int): Nothing =
     ret %Pos zeroinitializer
   """
   chez "(exit ${errorCode})"
-  ml "(Posix.Process.exit (Word8.fromInt ${errorCode}))"

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

@@ -3,21 +3,17 @@ module ref
 import effekt
 
 extern js """
-function set$impl(ref, value) {
-  ref.value = value;
-  return $effekt.unit;
-}
+  function set$impl(ref, value) {
+    ref.value = value;
+    return $effekt.unit;
+  }
 """
 
-/**
- * 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,38 +22,29 @@ 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})"
-  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.
- */
+/// 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.
- */
+/// 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

@@ -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/tty.effekt

@@ -0,0 +1,66 @@
+module string/tty
+
+// ANSI escape codes
+namespace ANSI {
+  val CSI = "\u001b["
+
+  def escape(s: String) = CSI ++ s ++ "m"
+
+  val BLACK = escape("30")
+  val RED = escape("31")
+  val GREEN = escape("32")
+  val YELLOW = escape("33")
+  val BLUE = escape("34")
+  val MAGENTA = escape("35")
+  val CYAN = escape("36")
+  val WHITE = escape("37")
+
+  val BG_BLACK = escape("40")
+  val BG_RED = escape("41")
+  val BG_GREEN = escape("42")
+  val BG_YELLOW = escape("43")
+  val BG_BLUE = escape("44")
+  val BG_MAGENTA = escape("45")
+  val BG_CYAN = escape("46")
+  val BG_WHITE = escape("47")
+
+  val RESET = escape("0")
+
+  val BOLD = escape("1")
+  val FAINT = escape("2")
+  val ITALIC = escape("3")
+  val UNDERLINE = escape("4")
+  val BLINK = escape("5")
+  val REVERSE = escape("7")
+  val CROSSOUT = escape("9")
+  val OVERLINE = escape("53")
+}
+
+def red(text: String) = Formatted::colored(text, ANSI::RED)
+def green(text: String) = Formatted::colored(text, ANSI::GREEN)
+def dim(text: String) = Formatted::colored(text, ANSI::FAINT)
+def bold(text: String) = Formatted::colored(text, ANSI::BOLD)
+
+interface Formatted {
+  def supportsEscape(escape: String): Bool
+}
+
+namespace Formatted {
+  /// Run given block of code, allowing all formatting
+  def formatting[R] { prog : => R / Formatted }: R =
+    try { prog() } with Formatted {
+      def supportsEscape(escape: String) = resume(true)
+    }
+
+  /// Run given block of code, ignoring all formatting
+  def noFormatting[R] { prog : => R / Formatted }: R =
+    try { prog() } with Formatted {
+      def supportsEscape(escape: String) = resume(false)
+    }
+
+  def tryEmit(escape: String): String / Formatted =
+    if (do supportsEscape(escape)) escape else ""
+
+  def colored(text: String, colorEscape: String): String / Formatted =
+    tryEmit(colorEscape) ++ text ++ tryEmit(ANSI::RESET)
+}

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,17 +176,13 @@ def toInt(str: String, base: Int): Int / Exception[WrongFormat] = {
   }
 }
 
-// Native versions of toInt (unused right now)
-//   ML: also accepts sml style `~2` for unary minus along with `+2` and `-2`
+/// 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})"
-  ml "Int.fromString ${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)
 
@@ -204,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)
 
@@ -243,36 +233,11 @@ def string[T] { prog: => T / Stream }: (T, String) = <>
 def printing[T] { prog: => T / Stream }: T = <>
 
 
-// ANSI escape codes
-namespace ANSI {
-  val BLACK = "\u001b[30m"
-  val RED = "\u001b[31m"
-  val GREEN = "\u001b[32m"
-  val YELLOW = "\u001b[33m"
-  val BLUE = "\u001b[34m"
-  val MAGENTA = "\u001b[35m"
-  val CYAN = "\u001b[36m"
-  val WHITE = "\u001b[37m"
-
-  val BG_BLACK = "\u001b[40m"
-  val BG_RED = "\u001b[41m"
-  val BG_GREEN = "\u001b[42m"
-  val BG_YELLOW = "\u001b[43m"
-  val BG_BLUE = "\u001b[44m"
-  val BG_MAGENTA = "\u001b[45m"
-  val BG_CYAN = "\u001b[46m"
-  val BG_WHITE = "\u001b[47m"
-
-  val RESET = "\u001b[0m"
-}
-
-
 // Characters
 // ----------
 //
 //   JS: Int (Unicode codepoints)
 //   CS: ?
-//   ML: 8-bit https://smlfamily.github.io/Basis/char.html
 //   LLVM: i64 representing utf-8 (varying length 1-4 bytes)
 
 extern pure def toString(ch: Char): String =
@@ -287,20 +252,17 @@ extern pure def toString(ch: Char): String =
 extern pure def toInt(ch: Char): Int =
   js "${ch}"
   chez "${ch}"
-  ml "${ch}"
   llvm "ret %Int ${ch}"
 
 extern pure def toChar(codepoint: Int): Char =
   js "${codepoint}"
   chez "${codepoint}"
-  ml "${codepoint}"
   llvm "ret %Int ${codepoint}"
 
 
 extern pure def infixLt(x: Char, y: Char): Bool =
   js "(${x} < ${y})"
   chez "(< ${x} ${y})"
-  ml "(${x}: int) < ${y}"
   llvm """
     %z = icmp slt %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -311,7 +273,6 @@ extern pure def infixLt(x: Char, y: Char): Bool =
 extern pure def infixLte(x: Char, y: Char): Bool =
   js "(${x} <= ${y})"
   chez "(<= ${x} ${y})"
-  ml "(${x}: int) <= ${y}"
   llvm """
     %z = icmp sle %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -322,7 +283,6 @@ extern pure def infixLte(x: Char, y: Char): Bool =
 extern pure def infixGt(x: Char, y: Char): Bool =
   js "(${x} > ${y})"
   chez "(> ${x} ${y})"
-  ml "(${x}: int) > ${y}"
   llvm """
     %z = icmp sgt %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -333,7 +293,6 @@ extern pure def infixGt(x: Char, y: Char): Bool =
 extern pure def infixGte(x: Char, y: Char): Bool =
   js "(${x} >= ${y})"
   chez "(>= ${x} ${y})"
-  ml "(${x}: int) >= ${y}"
   llvm """
     %z = icmp sge %Int ${x}, ${y}
     %fat_z = zext i1 %z to i64
@@ -388,7 +347,6 @@ def charAt(str: String, index: Int): Char / Exception[OutOfBounds] =
 extern pure def unsafeCharAt(str: String, n: Int): Char =
   js "${str}.codePointAt(${n})"
   chez "(char->integer (string-ref ${str} ${n}))"
-  ml "(Char.ord (String.sub (${str}, ${n})))"
   llvm """
     %x = call %Int @c_buffer_character_at(%Pos ${str}, i64 ${n})
     ret %Int %x

package/libraries/common/test.effekt

@@ -1,5 +1,6 @@
-import string
+import string/tty
 import process
+import bench
 
 interface Assertion {
   def assert(condition: Bool, msg: String): Unit
@@ -29,70 +30,131 @@ def assert(obtained: Char, expected: Char, msg: String): Unit / Assertion =
 def assert(obtained: String, expected: String, msg: String): Unit / Assertion =
   assertEqual(obtained, expected, msg) { (x, y) => x == y }
 
-def assert(obtained: Int, expected: Int): Unit / Assertion =
+def assert(obtained: Int, expected: Int): Unit / { Assertion, Formatted } =
   assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
 
-def assert(obtained: Bool, expected: Bool): Unit / Assertion =
+def assert(obtained: Bool, expected: Bool): Unit / { Assertion, Formatted } =
   assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
 
-def assert(obtained: Char, expected: Char): Unit / Assertion =
+def assert(obtained: Char, expected: Char): Unit / { Assertion, Formatted } =
   assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
 
-def assert(obtained: String, expected: String): Unit / Assertion =
+def assert(obtained: String, expected: String): Unit / { Assertion, Formatted } =
   assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
 
 def assertEqual[A](obtained: A, expected: A, msg: String): Unit / Assertion =
   assertEqual(obtained, expected, msg) { (x, y) => x.equals(y) }
 
-def assertEqual[A](obtained: A, expected: A): Unit / Assertion =
+def assertEqual[A](obtained: A, expected: A): Unit / { Assertion, Formatted } =
   assertEqual(obtained, expected) { (x, y) => x.equals(y) } { x => x.genericShow }
 
 def assertEqual[A](obtained: A, expected: A, msg: String) { equals: (A, A) => Bool }: Unit / Assertion =
   do assert(equals(obtained, expected), msg)
 
-def assertEqual[A](obtained: A, expected: A) { equals: (A, A) => Bool } { show: A => String }: Unit / Assertion =
-  do assert(equals(obtained, expected), "Obtained: " ++ show(obtained) ++ "\n but expected:" ++ show(expected))
+def assertEqual[A](obtained: A, expected: A) { equals: (A, A) => Bool } { show: A => String }: Unit / { Assertion, Formatted } =
+  do assert(equals(obtained, expected), Formatted::tryEmit(ANSI::RESET) ++ "Expected: ".dim ++ show(expected).green ++ "\n  Obtained: ".dim ++ show(obtained).red)
+  // NOTE:                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  //             Here's an accidental capture! Can we prevent this somehow nicely?
 
 
 interface Test {
-  def success(name: String): Unit
-  def failure(name: String, msg: String): Unit
+  def success(name: String, duration: Int): Unit
+  def failure(name: String, msg: String, duration: Int): Unit
 }
 
-def test(name: String) { body: => Unit / Assertion } =
-  try { body(); do success(name) } with Assertion {
-    def assert(condition, msg) = if (condition) resume(()) else do failure(name, msg)
+/// Runs the `body` as a test under the given `name`
+/// See `suite` for examples.
+def test(name: String) { body: => Unit / Assertion } = {
+  val startTime = bench::relativeTimestamp()
+  try {
+    body()
+    val duration = Duration::diff(startTime, bench::relativeTimestamp())
+    do success(name, duration)
+  } with Assertion {
+    def assert(condition, msg) =
+      if (condition) resume(())
+      else {
+        val duration = Duration::diff(startTime, bench::relativeTimestamp())
+        do failure(name, msg, duration)
+      }
   }
+}
+
+/// Run a test suite with a given `name`.
+/// - If `printTimes` is `true` (or missing), prints out time in milliseconds.
+/// - Formats automatically using ANSI escapes.
+/// - Returns `true` if all tests succeed, otherwise returns `false`. If you want to exit the program on failure, see `mainSuite`.
+///
+/// Example:
+/// ```effekt
+/// suite("My Tests") {
+///   test("1 + 1 == 2") {
+///     assertEqual(1 + 1, 2)
+///   }
+/// }
+/// ```
+def suite(name: String, printTimes: Bool) { body: => Unit / { Test, Formatted } }: Bool / {} = {
+  with Formatted::formatting;
+
+  def ms(duration: Int): String / Formatted =
+    if (printTimes) {
+      " " ++ ("[" ++ bench::formatMs(duration) ++ "]").dim
+    } else {
+      ""
+    }
+
+  def dimWhenZeroElse(s: String, n: Int) { colorIfNonZero: String => String / Formatted } =
+    if (n == 0) { dim(s) }
+    else { colorIfNonZero(s) }
 
-def suite(name: String) { body: => Unit / Test }: Bool = {
-  println("Running suite: " ++ name);
   var failed = 0
   var passed = 0
 
-  try { body() } with Test {
-    def success(name) = {
-      passed = passed + 1
-      println(ANSI::GREEN ++ "+ " ++ name ++ "" ++ ANSI::RESET);
-      resume(())
-    }
-    def failure(name, msg) = {
-      failed = failed + 1
-      println(ANSI::RED ++ "- (FAIL) " ++ name ++ "\n    " ++ msg ++ ANSI::RESET);
-      resume(())
+  // 1) Print the name of the test
+  println(name.bold)
+
+  // 2) Run the tests, timing them
+  val totalDuration = timed {
+    try { body() } with Test {
+      // 2a) Handle a passing test on success
+      def success(name, duration) = {
+        passed = passed + 1
+        println("✓".green ++ " " ++ name ++ duration.ms)
+        resume(())
+      }
+
+      // 2b) Handle a failing test on failure, additionally printing its message
+      def failure(name, msg, duration) = {
+        failed = failed + 1
+        println("✕".red ++ " " ++ name ++ duration.ms)
+        println("  " ++ msg.red)
+        resume(())
+      }
     }
   }
-  if (failed > 0) {
-    println(ANSI::RED ++ "Some tests failed (" ++ passed.show ++ " passed, " ++ failed.show ++ " failed)" ++ ANSI::RESET)
-    false
-  } else {
-    println(ANSI::GREEN ++ "All tests passed (" ++ passed.show ++ " passed)" ++ ANSI::RESET)
-    true
-  }
+
+  // 3) Format the test results
+  println("")
+  println(" " ++ (passed.show ++ " pass").dimWhenZeroElse(passed) { green })
+  println(" " ++ (failed.show ++ " fail").dimWhenZeroElse(failed) { red })
+  println(" " ++ (passed + failed).show ++ " tests total" ++ totalDuration.ms)
+
+  // 4) Return true if all tests succeeded, otherwise false
+  return failed == 0
 }
 
+/// See `suite` above.
+def suite(name: String) { body: => Unit / { Test, Formatted } }: Bool / {} =
+  suite(name, true) { body }
+
 /// Use as `def main() = mainSuite("...") { ... }`
-def mainSuite(name: String) { body: => Unit / Test }: Unit = {
-  val result = suite(name) { body() }
+/// Recommended for standalone test files ran by CI.
+///
+/// Exits after running all tests:
+/// - if all tests succeed, exits the program with success (exit code 0)
+/// - otherwise exits the program with failure (exit code 1)
+def mainSuite(name: String) { body: => Unit / { Test, Formatted } }: Unit = {
+  val result = suite(name, true) { body }
   val exitCode = if (result) 0 else 1
   exit(exitCode)
 }

package/libraries/js/unsafe/cont.effekt

@@ -8,4 +8,4 @@ extern io def cont[A, B] { r: A => B / {} }: Cont[A, B] = js "${box r}"
 
 // This is unsafe if the continuation left the scope of the
 // capabilities it closed over
-extern control def apply[A, B](k: Cont[A, B], a: A): B / {} = js "${k}(${a})"
+extern async def apply[A, B](k: Cont[A, B], a: A): B / {} = js "${k}(${a})"