@effekt-lang/effekt 0.2.1 → 0.3.0

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

@@ -0,0 +1,57 @@
+$effekt.show = function(obj) {
+  if (!!obj && !!obj.__reflect) {
+    const meta = obj.__reflect()
+    return meta.__name + "(" + meta.__data.map($effekt.show).join(", ") + ")"
+  }
+  else if (!!obj && obj.__unit) {
+    return "()";
+  } else {
+    return "" + obj;
+  }
+}
+
+$effekt.equals = function(obj1, obj2) {
+  if (!!obj1.__equals) {
+    return obj1.__equals(obj2)
+  } else {
+    return (obj1.__unit && obj2.__unit) || (obj1 === obj2);
+  }
+}
+
+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 }