@effekt-lang/effekt 0.2.2 → 0.3.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.effekt

@@ -0,0 +1,395 @@
+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)
+//   ML: also accepts sml style `~2` for unary minus along with `+2` and `-2`
+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`
+ */
+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 = <>
+
+
+// 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 =
+  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}"
+  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
+    %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})"
+  ml "(${x}: int) <= ${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})"
+  ml "(${x}: int) > ${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})"
+  ml "(${x}: int) >= ${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}))"
+  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

@@ -0,0 +1,98 @@
+import string
+import process
+
+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 =
+  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+
+def assert(obtained: Bool, expected: Bool): Unit / Assertion =
+  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+
+def assert(obtained: Char, expected: Char): Unit / Assertion =
+  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+
+def assert(obtained: String, expected: String): Unit / Assertion =
+  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 =
+  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))
+
+
+interface Test {
+  def success(name: String): Unit
+  def failure(name: String, msg: String): 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)
+  }
+
+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(())
+    }
+  }
+  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
+  }
+}
+
+/// Use as `def main() = mainSuite("...") { ... }`
+def mainSuite(name: String) { body: => Unit / Test }: Unit = {
+  val result = suite(name) { body() }
+  val exitCode = if (result) 0 else 1
+  exit(exitCode)
+}

package/libraries/js/effekt_builtins.js

@@ -1,7 +1,7 @@
-function show$impl(obj) {
+$effekt.show = function(obj) {
   if (!!obj && !!obj.__reflect) {
     const meta = obj.__reflect()
-    return meta.__name + "(" + meta.__data.map(show$impl).join(", ") + ")"
+    return meta.__name + "(" + meta.__data.map($effekt.show).join(", ") + ")"
   }
   else if (!!obj && obj.__unit) {
     return "()";
@@ -10,7 +10,7 @@ function show$impl(obj) {
   }
 }
 
-function equals$impl(obj1, obj2) {
+$effekt.equals = function(obj1, obj2) {
   if (!!obj1.__equals) {
     return obj1.__equals(obj2)
   } else {
@@ -18,9 +18,40 @@ function equals$impl(obj1, obj2) {
   }
 }
 
-function println$impl(obj) {
-  //return $effekt.delayed(() => { console.log(show(obj)); return $effekt.unit; });
-  console.log(show$impl(obj)); return $effekt.unit;
+function compare$prim(n1, n2) {
+  if (n1 == n2) { return 0; }
+  else if (n1 > n2) { return 1; }
+  else { return -1; }
+}
+
+$effekt.compare = function(obj1, obj2) {
+  if ($effekt.equals(obj1, obj2)) { return 0; }
+
+  if (!!obj1 && !!obj2) {
+    if (!!obj1.__reflect && !!obj2.__reflect) {
+      const tagOrdering = compare$prim(obj1.__tag, obj2.__tag)
+      if (tagOrdering != 0) { return tagOrdering; }
+
+      const meta1 = obj1.__reflect().__data
+      const meta2 = obj2.__reflect().__data
+
+      const lengthOrdering = compare$prim(meta1.length, meta2.length)
+      if (lengthOrdering != 0) { return lengthOrdering; }
+
+      for (let i = 0; i < meta1.length; i++) {
+        const contentOrdering = $effekt.compare(meta1[i], meta2[i])
+        if (contentOrdering != 0) { return contentOrdering; }
+      }
+
+      return 0;
+    }
+  }
+
+  return compare$prim(obj1, obj2);
+}
+
+$effekt.println = function println$impl(str) {
+  console.log(str); return $effekt.unit;
 }
 
 $effekt.unit = { __unit: true }