@effekt-lang/effekt 0.2.2 → 0.4.0

package/libraries/{ml/immutable → common}/seq.effekt

@@ -1,4 +1,4 @@
-module immutable/seq
+module seq
 
 /**
  * This file implements the [[Seq]] type as a general purpose functional sequence.
@@ -361,12 +361,12 @@ def concat[A](first: Seq[A], second: Seq[A]): Seq[A] = {
 // Predicates
 // ----------
 
-def isEmpty[A](seq: Seq[A]): Boolean = seq match {
+def isEmpty[A](seq: Seq[A]): Bool = seq match {
   case Empty() => true
   case _ => false
 }
 
-def nonEmpty[A](seq: Seq[A]): Boolean = seq match {
+def nonEmpty[A](seq: Seq[A]): Bool = seq match {
   case Empty() => false
   case _ => true
 }
@@ -563,13 +563,8 @@ def update[A](seq: Seq[A], index: Int, value: A): Seq[A] / Exception[NoSuchEleme
   }
 }
 
-def each[A](seq: Seq[A]) { f: A => Unit / Control }: Unit = try {
 
-  def consume(a: A): Unit =
-    try { f(a) } with Control {
-      def break() = outer.break()
-      def continue() = ()
-    }
+def each[A](seq: Seq[A]) { consume: (A) => Unit }: Unit = {
 
   def go(digit: Digit[A]): Unit = digit match {
     case One(a) => consume(a)
@@ -603,18 +598,21 @@ def each[A](seq: Seq[A]) { f: A => Unit / Control }: Unit = try {
     case Single(v) => consume(v)
     case Deep(_, p, m, s) => go(p); go(m); go(s)
   }
-} with outer: Control {
-  def break() = ()
-  def continue() = ()
 }
 
-def eachReverse[A](seq: Seq[A]) { f: A => Unit / Control }: Unit = try {
-
-  def consume(a: A): Unit =
-    try { f(a) } with Control {
+def each[A](seq: Seq[A]) { f: (A) {Control} => Unit }: Unit = try {
+  seq.each { (el) =>
+    try { f(el) {inner} } with inner: Control {
       def break() = outer.break()
       def continue() = ()
     }
+  }
+} with outer: Control {
+  def break() = ()
+  def continue() = ()
+}
+
+def eachReverse[A](seq: Seq[A]) { consume: A => Unit }: Unit = {
 
   def go(digit: Digit[A]): Unit = digit match {
     case One(a) => consume(a)
@@ -648,6 +646,15 @@ def eachReverse[A](seq: Seq[A]) { f: A => Unit / Control }: Unit = try {
     case Single(v) => consume(v)
     case Deep(_, p, m, s) => go(s); go(m); go(p)
   }
+}
+
+def eachReverse[A](seq: Seq[A]) { f: (A) {Control} => Unit }: Unit = try {
+  seq.eachReverse { (el) =>
+    try { f(el) {inner} } with inner: Control {
+      def break() = outer.break()
+      def continue() = ()
+    }
+  }
 } with outer: Control {
   def break() = ()
   def continue() = ()
@@ -668,8 +675,6 @@ def toSeq[A](l: List[A]): Seq[A] = {
 }
 
 
-
-
 record Split[A, R](prefix: R, element: A, suffix: R)
 
 def splitAt[A](seq: Seq[A], index: Int): (Seq[A], Seq[A]) / Exception[IndexOutOfBounds] = {
@@ -864,12 +869,18 @@ def toList[A](digit: Digit[A]): List[A] = digit match {
   case Four(a, b, c, d) => Cons(a, Cons(b, Cons(c, Cons(d, Nil()))))
 }
 
-def map[A, B](seq: Seq[A]) { f: A => B / Control }: Seq[B] = {
+def map[A, B](seq: Seq[A]) { f: A => B }: Seq[B] = {
   var result: Seq[B] = Empty()
   seq.each { a => result = result.consRight(f(a)) }
   result
 }
 
+def map[A, B](seq: Seq[A]) { f: (A) {Control} => B }: Seq[B] = {
+  var result: Seq[B] = Empty()
+  seq.each { (a) {label} => result = result.consRight(f(a) {label}) }
+  result
+}
+
 
 // TODO iterator interface
 //

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

@@ -0,0 +1,361 @@
+module string
+
+import effekt
+import option
+import list
+import exception
+import result
+
+// TODO
+// - [ ] handle unicode codepoints (that can span two indices) correctly
+// - [ ] use string buffers or other buffers to implement repeated concatenation more efficiently (and `join`)
+// - [ ] maybe use native implementations for toInt, repeat, split, indexOf, etc.
+
+/**
+ * Strings
+ * - JS: Strings are represented as UTF-16 code units where some characters take 2 slots (surrogate pairs)
+ * - ML: Strings are sequences of 8-bit characters (https://smlfamily.github.io/Basis/string.html)
+ * - Chez: Strings are sequences of unicode characters (?)
+ * - LLVM: UTF-8 (characters can take from 1-4 bytes).
+ */
+
+
+// Operations
+// ----------
+
+def substring(str: String, from: Int, to: Int): String = {
+  def clamp(lower: Int, x: Int, upper: Int) = max(lower, min(x, upper))
+  val lower = clamp(0, from, to)
+  val upper = clamp(0, to, str.length)
+  str.unsafeSubstring(lower, upper)
+}
+
+def substring(str: String, from: Int): String =
+  str.substring(from, str.length)
+
+
+/**
+ * Checks whether str starts with the given prefix at `from`
+ */
+def isSubstringAt(str: String, prefix: String, from: Int): Bool = {
+  with default[OutOfBounds, Bool] { false };
+
+  val stringLength = str.length
+  val prefixLength = prefix.length
+
+  def done?(index: Int): Bool = index >= prefixLength
+  def matches?(index: Int): Bool = prefix.charAt(index) == str.charAt(index + from)
+
+  def go(index: Int): Bool =
+    if (index.done?) true
+    else if (index.matches?) go(index + 1) else false
+
+  go(0)
+}
+
+def startsWith(str: String, prefix: String): Bool =
+  isSubstringAt(str, prefix, 0)
+
+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
+ */
+def repeat(str: String, n: Int): String = {
+  def go(n: Int, result: String): String = {
+    if (n == 0) result
+    else go(n - 1, result ++ str)
+  }
+  go(n, "")
+}
+
+// TODO use .split() in JS
+def split(str: String, sep: String): List[String] = {
+  val strLength = str.length
+  val sepLength = sep.length
+
+  // special case: seperator is empty, just emit individual chars
+  def empty(index: Int, components: List[String]): List[String] =
+    if (index >= strLength) components.reverse
+    else empty(index + 1, Cons(str.substring(index, index + 1), components))
+
+  def go(lastIndex: Int, components: List[String]): List[String] =
+    indexOf(str, sep, lastIndex) match {
+      case None() =>
+        Cons(str.substring(lastIndex, strLength), components).reverse
+      case Some(index) =>
+        go(index + sepLength, Cons(str.substring(lastIndex, index), components))
+    }
+
+  if (sepLength == 0) empty(0, Nil())
+  else go(0, Nil())
+}
+
+def join(strings: List[String], sep: String): String = {
+  def go(strings: List[String], result: String): String = strings match {
+    case Nil() => result
+    case Cons(s, rest) => go(rest, result ++ sep ++ s)
+  }
+  strings match {
+    case Nil() => ""
+    case Cons(first, rest) => go(rest, first)
+  }
+}
+
+extern pure def trim(str: String): String =
+  js "${str}.trim()"
+
+// Parsing
+// -------
+def toBool(s: String): Bool / Exception[WrongFormat] = s match {
+  case "true"  => true
+  case "false" => false
+  case _ => wrongFormat("Not a boolean value: '" ++ s ++ "'")
+}
+
+// TODO optimize (right now this will be horribly slow (compared to the native JS version)
+def toInt(str: String): Int / Exception[WrongFormat] = {
+
+  val zero = '0'.toInt
+
+  def go(index: Int, acc: Int): Int = {
+    result[Char, OutOfBounds] { str.charAt(index) } match {
+      case Success(c) and c >= '0' and c <= '9' =>
+        go(index + 1, 10 * acc + (c.toInt - zero))
+      case Success(c) => wrongFormat("Not a valid number: '" ++ str ++ "'")
+      // wrong index means we are done parsing
+      case Error(_, _) => acc
+    }
+  }
+
+  with default[OutOfBounds, Int] { wrongFormat("Empty string is not a valid number") };
+
+  str.charAt(0) match {
+    case '-' => 0 - go(1, 0)
+    case _   => go(0, 0)
+  }
+}
+
+// TODO optimize (right now this will be horribly slow (compared to the native JS version)
+def toInt(str: String, base: Int): Int / Exception[WrongFormat] = {
+
+  if( base > 36 || base < 1 ) {
+    wrongFormat("Invalid base: " ++ base.show)
+  }
+
+  val zero = '0'.toInt
+  val l_a = 'a'.toInt
+  val u_a = 'A'.toInt
+
+  def parseDigit(c: Char): Option[Int] = {
+    if( c >= '0' and c <= '9' and c.toInt - zero < base ) {
+      Some(c.toInt - zero)
+    } else if( c >= 'a' and c <= 'z' and c.toInt - l_a < base - 10 ) {
+      Some(c.toInt - l_a + 10)
+    } else if( c >= 'A' and c <= 'Z' and c.toInt - u_a < base - 10) {
+      Some(c.toInt - u_a + 10)
+    } else {
+      None()
+    }
+  }
+
+  def go(index: Int, acc: Int): Int = {
+    result[Char, OutOfBounds] { str.charAt(index) } match {
+      case Success(c) and parseDigit(c) is Some(d) =>
+        go(index + 1, base * acc + d)
+      case Success(c) => wrongFormat("Not a valid number: '" ++ str ++ "'")
+      // wrong index means we are done parsing
+      case Error(_, _) => acc
+    }
+  }
+
+  with default[OutOfBounds, Int] { wrongFormat("Empty string is not a valid number") };
+
+  str.charAt(0) match {
+    case '-' => 0 - go(1, 0)
+    case _   => go(0, 0)
+  }
+}
+
+// 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`
+ */
+def indexOf(str: String, sub: String): Option[Int] =
+  indexOf(str, sub, 0)
+
+def indexOf(str: String, sub: String, from: Int): Option[Int] = {
+  val len = str.length
+  def go(index: Int): Option[Int] =
+    if (index >= len) None()
+    else if (str.isSubstringAt(sub, index)) Some(index)
+    else go(index + 1)
+
+  go(from)
+}
+
+/**
+ * Returns the index of the last occurence of `sub` in `str`
+ */
+def lastIndexOf(str: String, sub: String): Option[Int] =
+  lastIndexOf(str, sub, str.length)
+
+def lastIndexOf(str: String, sub: String, from: Int): Option[Int] = {
+  def go(index: Int): Option[Int] =
+    if (index < 0) None()
+    else if (str.isSubstringAt(sub, index)) Some(index)
+    else go(index - 1)
+
+  go(from)
+}
+
+// TODO more efficient (native) implementations could be integrated as follows
+
+// extern pure def indexOf(str: String, sub: String): Option[Int] =
+//   //js { nativeIndexOf(str, sub) }
+//   default { indexOf(str, sub, 0) }
+
+// def nativeIndexOf(str: String, sub: String): Option[Int] = {
+//   val index = str.unsafeIndexOf(sub)
+//   if (index < 0) { None() } else { Some(index) }
+// }
+
+// extern pure def unsafeIndexOf(str: String, sub: String): Int =
+//   js "${str}.indexOf(${sub})"
+
+interface Stream {
+  def emit(string: Char): Unit
+}
+
+def string[T] { prog: => T / Stream }: (T, String) = <>
+
+// TODO implement after concurrent IO (we need to stub `process.stdout` in JS for browsers).
+def printing[T] { prog: => T / Stream }: T = <>
+
+
+// Characters
+// ----------
+//
+//   JS: Int (Unicode codepoints)
+//   CS: ?
+//   LLVM: i64 representing utf-8 (varying length 1-4 bytes)
+
+extern pure def toString(ch: Char): String =
+  js "String.fromCodePoint(${ch})"
+  chez "(string (integer->char ${ch}))"
+  llvm """
+    %z = call %Pos @c_buffer_show_Char(%Int ${ch})
+    ret %Pos %z
+  """
+
+// Since we currently represent Char by integers in all backends, we could reuse comparison
+extern pure def toInt(ch: Char): Int =
+  js "${ch}"
+  chez "${ch}"
+  llvm "ret %Int ${ch}"
+
+extern pure def toChar(codepoint: Int): Char =
+  js "${codepoint}"
+  chez "${codepoint}"
+  llvm "ret %Int ${codepoint}"
+
+
+extern pure def infixLt(x: Char, y: Char): Bool =
+  js "(${x} < ${y})"
+  chez "(< ${x} ${y})"
+  llvm """
+    %z = icmp slt %Int ${x}, ${y}
+    %fat_z = zext i1 %z to i64
+    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
+    ret %Pos %adt_boolean
+  """
+
+extern pure def infixLte(x: Char, y: Char): Bool =
+  js "(${x} <= ${y})"
+  chez "(<= ${x} ${y})"
+  llvm """
+    %z = icmp sle %Int ${x}, ${y}
+    %fat_z = zext i1 %z to i64
+    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
+    ret %Pos %adt_boolean
+  """
+
+extern pure def infixGt(x: Char, y: Char): Bool =
+  js "(${x} > ${y})"
+  chez "(> ${x} ${y})"
+  llvm """
+    %z = icmp sgt %Int ${x}, ${y}
+    %fat_z = zext i1 %z to i64
+    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
+    ret %Pos %adt_boolean
+  """
+
+extern pure def infixGte(x: Char, y: Char): Bool =
+  js "(${x} >= ${y})"
+  chez "(>= ${x} ${y})"
+  llvm """
+    %z = icmp sge %Int ${x}, ${y}
+    %fat_z = zext i1 %z to i64
+    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
+    ret %Pos %adt_boolean
+  """
+
+// TODO iterator over codepoints (maybe use the JS primitive feature???)
+
+extern type StringIterator
+
+
+/**
+ * Determines the number of bytes needed by a codepoint
+ *
+ * Also see: https://en.wikipedia.org/wiki/UTF-8
+ */
+def utf8ByteCount(codepoint: Char): Int = codepoint match {
+  case c and c >= \u0000  and c <= \u007F   => 1
+  case c and c >= \u0080  and c <= \u07FF   => 2
+  case c and c >= \u0800  and c <= \uFFFF   => 3
+  case c and c >= \u10000 and c <= \u10FFFF => 4
+  case c => panic("Not a valid code point")
+}
+
+def utf16UnitCount(codepoint: Char): Int = codepoint match {
+  case c and c >= \u0000  and c <= \uFFFF   => 1
+  case c and c >= \u10000 and c <= \u10FFFF => 4
+  case c => panic("Not a valid code point")
+}
+
+// TODO this is copied from the LLVM-backend stdlib. Do we need this?
+// def showQuoted(s: String): String =
+//  "\x22" ++ s.map { c =>
+//    if(c == "\x22") {
+//     "\\\x22"
+//    } else if (c == "\\") {
+//     "\\\\"
+//    } else c
+//  } ++ "\x22"
+
+extern pure def charWidth(c: Char): Int =
+  // JavaScript strings are UTF-16 where every unicode character after 0xffff takes two units
+  js "(${c} > 0xffff) ? 2 : 1"
+
+def charAt(str: String, index: Int): Char / Exception[OutOfBounds] =
+  if (index < 0 || index >= length(str))
+    do raise(OutOfBounds(), "Index out of bounds: " ++ show(index) ++ " in string: '" ++ str ++ "'")
+  else
+    unsafeCharAt(str, index)
+
+extern pure def unsafeCharAt(str: String, n: Int): Char =
+  js "${str}.codePointAt(${n})"
+  chez "(char->integer (string-ref ${str} ${n}))"
+  llvm """
+    %x = call %Int @c_buffer_character_at(%Pos ${str}, i64 ${n})
+    ret %Int %x
+  """

package/libraries/common/test.effekt

@@ -0,0 +1,160 @@
+import string/tty
+import process
+import bench
+
+interface Assertion {
+  def assert(condition: Bool, msg: String): Unit
+}
+
+def assertTrue(condition: Bool, msg: String) =
+  do assert(condition, msg)
+
+def assertTrue(condition: Bool) =
+  do assert(condition, "Assertion failed")
+
+def assertFalse(condition: Bool, msg: String) =
+  do assert(not(condition), msg)
+
+def assertFalse(condition: Bool) =
+  do assert(not(condition), "Assertion failed")
+
+def assert(obtained: Int, expected: Int, msg: String): Unit / Assertion =
+  assertEqual(obtained, expected, msg) { (x, y) => x == y }
+
+def assert(obtained: Bool, expected: Bool, msg: String): Unit / Assertion =
+  assertEqual(obtained, expected, msg) { (x, y) => x == y }
+
+def assert(obtained: Char, expected: Char, msg: String): Unit / Assertion =
+  assertEqual(obtained, expected, msg) { (x, y) => x == y }
+
+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, Formatted } =
+  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+
+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, Formatted } =
+  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+
+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, 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, 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, duration: Int): Unit
+  def failure(name: String, msg: String, duration: Int): Unit
+}
+
+/// 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) }
+
+  var failed = 0
+  var passed = 0
+
+  // 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(())
+      }
+    }
+  }
+
+  // 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("...") { ... }`
+/// 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)
+}