@effekt-lang/effekt 0.14.0 → 0.16.0

package/libraries/common/char.effekt

@@ -15,33 +15,57 @@ def isWhitespace(c: Char): Bool = c match {
   case _      => false
 }
 
-/// Checks if the given character is an ASCII digit in base 10
-/// Use `digitValue(c: Char)` to get the numeric value out.
-def isDigit(c: Char): Bool = { c >= '0' && c <= '9' }
-
-/// Checks if the given character is an ASCII digit in the given base
-/// Use `digitValue(c: Char, base: Int)` to get the numeric value out.
-def isDigit(c: Char, base: Int): Bool = {
-  with on[WrongFormat].default { false }
-  val _ = digitValue(c, base)
-  true
-}
-
 /// Gets the value of a given ASCII digit in base 10
-def digitValue(c: Char): Int / Exception[WrongFormat] =
-  digitValue(c, 10)
-
-/// Gets the value of a given ASCII digit in the given base
-def digitValue(c: Char, base: Int): Int / Exception[WrongFormat] = {
-  val v = c match {
-    case c and c >= '0' && c <= '9' => (c.toInt - '0'.toInt)
-    case c and c >= 'a' && c <= 'z' => (c.toInt - 'a'.toInt) + 10
-    case c and c >= 'A' && c <= 'Z' => (c.toInt - 'A'.toInt) + 10
-    case _ => wrongFormat("'" ++ c.toString ++ "' is not a digit")
+def digitValue(char: Char): Option[Int] =
+  // TODO use fail
+  if (char >= '0' && char <= '9') {
+    Some(char.toInt - '0'.toInt)
+  } else {
+    None()
+  }
+
+/// Gets the value of a given ASCII digit in base 16
+def hexDigitValue(char: Char): Option[Int] =
+  // TODO use fail
+  char match {
+    case char and char >= '0' && char <= '9' => Some(char.toInt - '0'.toInt)
+    case char and char >= 'A' && char <= 'F' => Some((char.toInt - 'A'.toInt) + 10)
+    case char and char >= 'a' && char <= 'f' => Some((char.toInt - 'a'.toInt) + 10)
+    case _ => None()
+  }
+
+/// Gets the value of a given ASCII digit in the given base up to 36
+def digitValue(char: Char, base: Int): Option[Int] = {
+  // TODO use fail
+  val perhapsDigit = char match {
+      case char and char >= '0' && char <= '9' => Some(char.toInt - '0'.toInt)
+      case char and char >= 'A' && char <= 'Z' => Some((char.toInt - 'A'.toInt) + 10)
+      case char and char >= 'a' && char <= 'z' => Some((char.toInt - 'a'.toInt) + 10)
+      case _ => None()
+    }
+  perhapsDigit match {
+    case Some(digit) =>
+      if (digit < base) {
+        Some(digit)
+      } else {
+        None()
+      }
+    case None() => None()
   }
-  if (v >= base) { wrongFormat(c.toString ++ " is not a valid digit in base " ++ base.show) } else { v }
 }
 
+/// Checks if the given character is an ASCII digit in base 10
+/// Use `digitValue(c: Char)` to get the numeric value out.
+def isDigit(char: Char): Bool = digitValue(char).isDefined
+
+/// Checks if the given character is an ASCII digit in base 16
+/// Use `hexDigitValue(c: Char)` to get the numeric value out.
+def isHexDigit(char: Char): Bool = hexDigitValue(char).isDefined
+
+/// Checks if the given character is an ASCII digit in base 10
+/// Use `digitValue(c: Char)` to get the numeric value out.
+def isDigit(char: Char, base: Int): Bool = digitValue(char, base).isDefined
+
 /// Checks if a given character is a 7-bit ASCII character
 def isASCII(c: Char): Bool = { c.toInt < 128 }
 

package/libraries/common/effekt.effekt

@@ -85,6 +85,7 @@ extern pure def show(value: Char): String =
   """
 
 extern pure def show(value: Byte): String =
+  js "'' + ${value}"
   llvm """
     %z = call %Pos @c_bytearray_show_Byte(i8 ${value})
     ret %Pos %z
@@ -114,7 +115,6 @@ extern pure def length(str: String): Int =
   chez "(string-length ${str})"
   llvm """
     %x = call %Int @c_bytearray_size(%Pos ${str})
-    call void @erasePositive(%Pos ${str})
     ret %Int %x
   """
 
@@ -367,7 +367,11 @@ def pow(base: Double, exponent: Int): Double = {
     else if (exponent.mod(2) == 0) loop(base * base, exponent / 2, acc)  // even exponent
     else loop(base, exponent - 1, acc * base)  // odd exponent
   }
-  loop(base, exponent, 1.0)
+  if (exponent < 0) {
+    loop(1.0 / base, 0 - exponent, 1.0)
+  } else {
+    loop(base, exponent, 1.0)
+  }
 }
 
 extern pure def pow(base: Double, exponent: Double): Double =

package/libraries/common/io/filesystem.effekt

@@ -198,6 +198,7 @@ namespace internal {
       ret void
     """
 
+  /// The buffer must be kept alive by using it after the call
   extern async def read(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int): Int =
     jsNode "$effekt.capture(callback => read(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
@@ -205,6 +206,7 @@ namespace internal {
       ret void
     """
 
+  /// The buffer must be kept alive by using it after the call
   extern async def write(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int): Int =
     jsNode "$effekt.capture(callback => write(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """

package/libraries/common/io.effekt

@@ -16,7 +16,8 @@ extern async def spawn(task: Task[Unit]): Unit =
   js "$effekt.capture(k => { setTimeout(() => k($effekt.unit), 0); return $effekt.run(${task}) })"
   llvm """
     call void @c_yield(%Stack %stack)
-    call void @run(%Neg ${task})
+    %unboxed = call ccc %Neg @unbox(%Pos ${task})
+    call void @run(%Neg %unboxed)
     ret void
   """
 

package/libraries/common/json.effekt

@@ -0,0 +1,385 @@
+module json
+
+import char
+import scanner
+import stream
+
+/// for constructing a json value
+interface JsonBuilder {
+  def null(): Unit
+  def bool(b: Bool): Unit
+  def number(n: Double): Unit
+  def string(s: String): Unit
+  def list[R](){ elements: => R / JsonBuilder }: R
+  def dict[R](){ elements: => R / JsonObjectBuilder }: R
+}
+/// for constructing a json object
+interface JsonObjectBuilder {
+  def field[R](k: String){ contents: => R / JsonBuilder }: R
+}
+
+def escape(s: String): String = "\"" ++ s ++ "\"" // TODO handle escapes
+
+/// Make explicitly bound JsonBuilder instance implicit
+def handleJsonBuilder[R]{b: JsonBuilder}{ body: => R / JsonBuilder }: R = try body() with JsonBuilder {
+  def null() = resume(b.null())
+  def bool(v) = resume(b.bool(v))
+  def number(n) = resume(b.number(n))
+  def string(s) = resume(b.string(s))
+  def list() = resume { {c} => b.list{c} }
+  def dict() = resume { {c} => b.dict{c} }
+}
+/// Make explicitly bound JsonObjectBuilder instance implicit
+def handleJsonObjectBuilder[R]{b: JsonObjectBuilder}{ body: => R / JsonObjectBuilder }: R = try body() with JsonObjectBuilder {
+  def field(k) = resume { {c} => b.field(k){c} }
+}
+
+// --------------------------------------------------------------------------------
+// Encoding
+// --------------------------------------------------------------------------------
+def encodeJsonList[R]{ body: => R / JsonBuilder }: R / emit[String] = {
+  var first = true
+  do emit("[")
+  def c() = {
+    if (not(first)) { do emit(",") }
+    first = false
+  }
+  val r = encodeJson {
+    try { body() } with JsonBuilder {
+      def null() = { c(); resume(do null()) }
+      def bool(v) = { c(); resume(do bool(v)) }
+      def number(n) = { c(); resume(do number(n)) }
+      def string(s) = { c(); resume(do string(s)) }
+      def list() = resume { { b } => c(); do list{b} }
+      def dict() = resume { { b } => c(); do dict{b} }
+    }
+  }
+  do emit("]")
+  r
+}
+def encodeJsonObject[R]{ body: => R / JsonObjectBuilder }: R / emit[String] = {
+  var first = true
+  do emit("{")
+  def c(k: String) = {
+    if (not(first)) { do emit(",") }
+    do emit(escape(k)); do emit(":") 
+    first = false
+  }
+  val r = encodeJson {
+    try body() with JsonObjectBuilder {
+      def field(k) = resume { {b} => c(k); b() }
+    }
+  }
+  do emit("}")
+  r
+}
+/// Main entry point for encoding json.
+/// Emits individual tokens of the resulting json.
+def encodeJson[R]{ body: => R / JsonBuilder }: R / emit[String] = {
+  try body() with JsonBuilder { 
+      def null() = { resume(do emit("null")) }
+      def bool(v) = { resume(do emit( if(v){ "true" } else { "false" } )) }
+      def number(n) = { resume(do emit(show(n))) }
+      def string(s) = { resume(do emit(escape(s))) }
+      def list() = resume { {b} => encodeJsonList { b() } }
+      def dict() = resume { {b} => encodeJsonObject { b() } }
+  }
+}
+
+// --------------------------------------------------------------------------------
+// Decoding
+// --------------------------------------------------------------------------------
+
+
+/// Read a double value, in the common format (TODO document)
+def readDouble(): Double / Scan[Char] = {
+  def exponent(pre: Double) = {
+    try {
+      if(do peek() == 'e' || do peek() == 'E') {
+        do skip[Char]()
+        val e = do peek[Char]() match {
+          case '+' => do skip[Char](); readDecimal()
+          case '-' => do skip[Char](); neg(readDecimal())
+          case _ => readDecimal()
+        }
+        pre * pow(10.0, e)
+      } else { pre }
+    } with stop {
+      pre
+    }
+  }
+  def fraction(pre: Int) = {
+    if (optionally { readIf('.') }) {
+      var b = 0.1
+      var r = pre.toDouble
+      while (optionally[Int] { readDigit() } is Some(d)) {
+        r = r + b * d.toDouble
+        b = b * 0.1
+      }
+      exponent(r)
+    } else {
+      pre.toDouble
+    }
+  }
+  fraction(readInteger())
+}
+
+def expectString(string: String): Unit / { Scan[Char], Exception[WrongFormat] } =
+  for[Char] { string.each } { char =>
+    expect[Unit]("Expected " ++ string) { readIf(char) }
+  }
+
+/// Read and unescape a string in ""
+def readQuotedString(): Unit / { Scan[Char], emit[Char], Exception[WrongFormat] } = {
+  try {
+    skipWhitespace()
+    expect[Unit]("Expected \"") { readIf('"') }
+    while(read[Char]() is c and c != '"') {
+      c match {
+        case '\\' => read[Char]() match {
+          case '"' => do emit('\"')
+          case '\\' => do emit('\\')
+          case '/' => do emit('/')
+          case 'b' => <>
+          case 'f' => <>
+          case 'n' => do emit('\n')
+          case 'r' => do emit('\r')
+          case 't' => do emit('\t')
+          case c => wrongFormat("Invalid escape sequence '\\" ++ c.toString ++ "'")
+        }
+        case o => do emit(o)
+      }
+    }
+  } with stop {
+    wrongFormat("Unexpected end of input while reading a string")
+  }
+}
+
+/// Decode a json string and do the appropriate calls to an implicitly bound JsonBuilder
+def decodeJson(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} = {
+  with boundary
+  skipWhitespace()
+  if(do peek[Char]() is c) {
+    c match {
+      case 'n' => expectString("null"); do null()
+      case 't' => expectString("true"); do bool(true)
+      case 'f' => expectString("false"); do bool(false)
+      case '-' => do number(readDouble())
+      case d and d.isDigit => do number(readDouble())
+      case '"' => do string(collectString { readQuotedString() })
+      case '{' => do dict{ decodeJsonObject() }
+      case '[' => do list{ decodeJsonList() }
+      case _ => println("Unexpected " ++ c.toString); <>
+    }
+  }
+}
+def decodeJsonObject(): Unit / {Scan[Char], JsonObjectBuilder, Exception[WrongFormat]} = {
+  var first = true
+  expectString("{")
+  with boundary
+  skipWhitespace()
+  while(do peek[Char]() is c and (c != '}')) {
+    if (not(first)) { expectString(",") }
+    val k: String = collectString { readQuotedString() }
+    skipWhitespace()
+    expectString(":")
+    do field(k){
+      decodeJson()
+    }
+    skipWhitespace()
+    first = false
+  }
+  do skip[Char]()
+}
+def decodeJsonList(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} = { 
+  var first = true
+  expectString("[")
+  with boundary
+  skipWhitespace()
+  while(do peek[Char]() is c and (c != ']')) {
+    if (not(first)) { expectString(",") }
+    decodeJson()
+    skipWhitespace()
+    first = false
+  }
+  do skip[Char]()
+}
+
+// --------------------------------------------------------------------------------
+// Ignoring
+// --------------------------------------------------------------------------------
+/// Ignore the generated calls to JsonObjectBuilder
+def ignoreDict[R](){ body: => R / JsonObjectBuilder }: R = try body() with JsonObjectBuilder {
+  def field(k) = resume { {v} => ignore{v} }
+}
+
+/// Ignore the generated calls to JsonBuilder
+def ignore[R](){ body: => R / JsonBuilder }: R = try body() with JsonBuilder {
+  def number(n) = resume(())
+  def bool(b) = resume(())
+  def null() = resume(())
+  def string(s) = resume(())
+  def list() = resume { {e} => ignore{e} }
+  def dict() = resume { {e} => ignoreDict{e} }
+}
+
+// --------------------------------------------------------------------------------
+// Residualized
+// --------------------------------------------------------------------------------
+/// Residualized Json value
+type JsonValue {
+  Number(n: Double);
+  Bool(b: Bool);
+  Null();
+  String(s: String);
+  List(l: List[JsonValue]);
+  Dict(els: List[(String, JsonValue)])
+}
+
+// --------------------------------------------------------------------------------
+// Residualized --> Effect
+// --------------------------------------------------------------------------------
+/// Emit the appropriate calls to JsonBuilder to recreate the given JsonValue
+def unbuild(v: JsonValue): Unit / JsonBuilder = v match {
+  case Number(n) => do number(n)
+  case Bool(b) => do bool(b)
+  case Null() => do null()
+  case String(s) => do string(s)
+  case List(l) => do list {
+    l.foreach { e => unbuild(e) }
+  }
+  case Dict(els) => do dict {
+    els.foreach {
+      case (k, v) => do field(k){ unbuild(v) }
+    }
+  }
+}
+
+// --------------------------------------------------------------------------------
+// Effect --> Residualized
+// --------------------------------------------------------------------------------
+def build[R](){ body: => R / JsonBuilder }: (R, JsonValue) = {
+  var r = Null()
+  val x = try body() with JsonBuilder {
+    def number(n) = { r = Number(n); resume(()) }
+    def bool(b) = { r = Bool(b); resume(()) }
+    def null() = { r = Null(); resume(()) }
+    def string(s) = { r = String(s); resume(()) }
+    def list() = resume { {els} =>
+      val x = buildList {els}
+      r = List(x.second)
+      x.first
+    }
+    def dict() = resume { {fs} =>
+      val x = buildDict {fs}
+      r = Dict(x.second)
+      x.first
+    }
+  }
+  (x, r)
+}
+def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = collectList[JsonValue, R] {
+  try body() with JsonBuilder {
+    def number(n) = { do emit(Number(n)); resume(()) }
+    def bool(b) = { do emit(Bool(b)); resume(()) }
+    def null() = { do emit(Null()); resume(()) }
+    def string(s) = { do emit(String(s)); resume(()) }
+    def list() = resume { {els} =>
+      val x = buildList {els}
+      do emit(List(x.second))
+      x.first
+    }
+    def dict() = resume { {fs} =>
+      val x = buildDict {fs}
+      do emit(Dict(x.second))
+      x.first
+    }
+  }
+}
+def buildDict[R](){ body: => R / JsonObjectBuilder }: (R, List[(String, JsonValue)]) = collectList[(String, JsonValue), R] {
+  try body() with JsonObjectBuilder {
+    def field(k) = resume { {v} =>
+      val x = build{v}
+      do emit((k, x.second))
+      x.first
+    }
+  }
+}
+
+// --------------------------------------------------------------------------------
+// Examples
+// --------------------------------------------------------------------------------
+namespace test {
+  def main() = {
+    with on[WrongFormat].panic
+
+    // Read quoted string
+    feed("\"\ta\n\ra\"") {
+      with scanner[Char, Unit]
+      println(collectString { readQuotedString() })
+    }
+
+    // Parse example
+    feed("""{ "a": null, "b": [true,false,false,true], "f": 12.532   }"""){
+      with scanner[Char]
+
+      def k = new JsonObjectBuilder {
+        def field(k){v} = { println(k); ignore{v} }
+      }
+      def d = new JsonBuilder {
+        def number(n) = println(n)
+        def bool(b) = ()
+        def null() = println("NULL")
+        def string(s) = ()
+        def list(){e} = handleJsonBuilder{d}{e}
+        def dict(){e} = handleJsonObjectBuilder{k}{e}
+      }
+      handleJsonBuilder{d}{ decodeJson() }
+    }
+    try{
+  
+      // Encode example
+      encodeJson {
+        do dict{
+          do field("x"){
+            do string("Hallo")
+          }
+          do field("y"){
+            do null()
+          }
+          do field("z"){
+            do number(12.3783)
+          }
+        }
+      }
+  
+      // format with intermediate value
+      val j = feed("""{ 
+                  "a": null, 
+                  "b": [true, false, false, true], "f": 12.532   
+                } """){
+        with scanner[Char, JsonValue]
+        build {
+          decodeJson()
+        }.second
+      }
+      encodeJson{
+        unbuild(j)
+      }
+      
+      // format (minify) example
+      encodeJson{
+        feed("""{ 
+                  "a": null, 
+                  "b": [true, false, false, true], "f": 12.532   
+                } """){
+          with scanner[Char, Unit]
+          decodeJson()
+        }
+      }
+  
+    } with emit[String] { e =>
+      resume(println(e))
+    }
+  }
+}

package/libraries/common/scanner.effekt

@@ -0,0 +1,171 @@
+module scanner
+
+import char
+import stream
+
+interface Scan[A] {
+  /// Return the next character, not advancing.
+  /// That is, this does not change what any future calls on the Scanner return.
+  def peek(): A / stop
+  /// Advance the Scanner to the next character.
+  def skip(): Unit / stop
+}
+
+/// Advance the Scanner to the next character, returning it.
+def read[A](): A / { Scan[A], stop } = {
+  val t = do peek[A]()
+  do skip[A]()
+  return t
+}
+
+/// Run a scanner by reading from an input stream, discarding its output.
+def scanner[A] { scanner: () => Unit / Scan[A] }: Unit / read[A] =
+  returning::scanner[A, Unit]{scanner}
+
+def expect(message: String) { scanner: () => Unit / stop }: Unit / Exception[WrongFormat] =
+  returning::expect[Unit](message){scanner}
+
+/// Check that the next token satisfies the predicate and skip and return it when it does.
+def readIf[A] { predicate: A => Bool }: A / { Scan[A], stop } = {
+  val t = do peek[A]()
+  if (predicate(t)) {
+    do skip[A]()
+    return t
+  } else {
+    do stop()
+  }
+}
+
+/// Check that the next token satisfies the predicate and skip it when it does.
+def skipIf[A] { predicate: A => Bool }: Unit / { Scan[A], stop } = {
+  readIf{predicate}; ()
+}
+
+def readSome[A, B] { convert: A => Option[B] }: B / { Scan[A], stop } =
+  if (convert(do peek()) is Some(t)) {
+    do skip[A]()
+    return t
+  } else {
+    do stop()
+  }
+
+/// Reads until the predicate does not hold for the next token.
+/// Emits the tokens read.
+def readWhile[A] { predicate: A => Bool }: Unit / { Scan[A], emit[A] } =
+  many { readIf{predicate} }
+
+/// Skips until the predicate does not hold for the next token.
+def skipWhile[A] { predicate: A => Bool }: Unit / { Scan[A] } =
+  for[A] { readWhile{predicate} } { _ => () }
+
+
+/// Read the next character if it is the given one and return true in this case.
+def readIf(e: Char): Unit / { Scan[Char], stop } = {
+  readIf[Char] { c => c == e }; ()
+}
+
+/// Check that the next token satisfies the predicate and skip it when it does.
+def skipIf(e: Char): Unit / { Scan[Char], stop } =
+  skipIf { c => c == e }
+
+/// Skip until the next character is not a whitespace character
+def skipWhitespace(): Unit / Scan[Char] =
+  skipWhile { c => c.isWhitespace }
+
+/// Read as many characters corresponding to the given string as possible.
+def readString(string: String): Unit / { Scan[Char], stop } =
+  for[Char] { string.each } { char => readIf(char) }
+
+/// Check that the next character is a digit in base 10, and if so read and return it.
+def readDigit(): Int / { Scan[Char], stop } =
+  readSome[Char, Int]{ char => digitValue(char) }
+
+/// Read a positive decimal number.
+def readDecimal(): Int / Scan[Char] = {
+  var result = 0
+  for[Int] { many { readDigit() } } { digit =>
+    result = result * 10 + digit
+  }
+  result
+}
+
+/// Check that the next character is a digit in base 16, and if so read and return it.
+def readHexDigit(): Int / { Scan[Char], stop } =
+  readSome[Char, Int]{ char => hexDigitValue(char) }
+
+/// Read a hexadecimal number.
+def readHexadecimal(): Int / Scan[Char] = {
+  var result = 0
+  for[Int] { many { readHexDigit() } } { digit =>
+    result = result * 16 + digit
+  }
+  result
+}
+
+/// Read a decimal integer.
+def readInteger(): Int / Scan[Char] =
+  if (optionally { readIf('-') }) {
+    neg(readDecimal())
+  } else {
+    readDecimal()
+  }
+
+
+namespace returning {
+
+/// Run a scanner by reading from an input stream.
+def scanner[A, R] { scanner: () => R / Scan[A] }: R / read[A] = {
+  var last = None()
+  try {
+    scanner()
+  } with Scan[A] {
+    def peek() = resume {
+      last match {
+        case None() =>
+          val t = do read[A]()
+          last = Some(t)
+          return t
+        case Some(t) =>
+          return t
+      }
+    }
+    def skip() = resume {
+      last match {
+        case None() =>
+          val _ = do read[A]()
+          return ()
+        case Some(t) =>
+          last = None()
+          return ()
+      }
+    }
+  }
+}
+
+def expect[R](message: String) { scanner: () => R / stop }: R / Exception[WrongFormat] =
+  attempt { scanner() } { wrongFormat(message) }
+
+}
+
+
+namespace test {
+  def main(): Unit = {
+  
+    val input =
+      """
+      12
+      -13
+      A1B2
+      """
+
+    with feed(input)
+    with scanner[Char]
+
+    skipWhitespace()
+    println(readInteger().show)
+    skipWhitespace()
+    println(readInteger().show)
+    skipWhitespace()
+    println(readHexadecimal().show)
+  }
+}