@effekt-lang/effekt 0.58.0 → 0.59.0

package/libraries/common/char.effekt

@@ -2,9 +2,8 @@
 module char
 
 import effekt
-import exception
 import option
-import result
+import partial
 import stream
 
 
@@ -19,51 +18,49 @@ def isWhitespace(c: Char): Bool = c match {
   case _      => false
 }
 
-/// Gets the value of a given ASCII digit in base 10,
-/// throwing an exception on wrong format
-def digitValue(char: Char): Int / Exception[WrongFormat] =
+/// Gets the value of a given ASCII digit in base 10 or fails
+def digitValue(char: Char): Int / fail =
   if (char >= '0' && char <= '9') {
     char.toInt - '0'.toInt
   } else {
-    wrongFormat("Not a valid digit: '" ++ char.toString ++ "' in base 10")
+    do fail()
   }
 
-/// Gets the value of a given ASCII digit in base 16,
-/// throwing an exception on wrong format
-def hexDigitValue(char: Char): Int / Exception[WrongFormat] =
+/// Gets the value of a given ASCII digit in base 16 or fails
+def hexDigitValue(char: Char): Int / fail =
   char match {
     case char and char >= '0' && char <= '9' => char.toInt - '0'.toInt
     case char and char >= 'A' && char <= 'F' => (char.toInt - 'A'.toInt) + 10
     case char and char >= 'a' && char <= 'f' => (char.toInt - 'a'.toInt) + 10
-    case _ => wrongFormat("Not a valid digit: '" ++ char.toString ++ "' in base 16")
+    case _ => do fail()
   }
 
 /// Gets the value of a given ASCII digit in the given base up to 36,
 /// throwing an exception on wrong format
-def digitValue(char: Char, base: Int): Int / Exception[WrongFormat] = {
+def digitValue(char: Char, base: Int): Int / fail = {
   val digit = char match {
     case char and char >= '0' && char <= '9' => char.toInt - '0'.toInt
     case char and char >= 'A' && char <= 'Z' => (char.toInt - 'A'.toInt) + 10
     case char and char >= 'a' && char <= 'z' => (char.toInt - 'a'.toInt) + 10
-    case _ => wrongFormat("Not a valid digit: '" ++ char.toString ++ "'")
+    case _ => do fail()
   }
   if (digit >= base) {
-    wrongFormat("Digit '" ++ digit.show ++ "' is too big for base " ++ base.show)
+    do fail()
   }
   digit
 }
 
 /// Checks if the given character is an ASCII digit in base 10
 /// Prefer using `digitValue(c: Char)` to get the numeric value out.
-def isDigit(char: Char): Bool = result[Int, WrongFormat] { digitValue(char) }.isSuccess
+def isDigit(char: Char): Bool = optionally[Int] { digitValue(char) }.isDefined
 
 /// Checks if the given character is an ASCII digit in base 16
 /// Prefer using `hexDigitValue(c: Char)` to get the numeric value out.
-def isHexDigit(char: Char): Bool = result[Int, WrongFormat] { hexDigitValue(char)}.isSuccess
+def isHexDigit(char: Char): Bool = optionally[Int] { hexDigitValue(char)}.isDefined
 
 /// Checks if the given character is an ASCII digit in base 10
 /// Prefer using `digitValue(c: Char, base: Int)` to get the numeric value out.
-def isDigit(char: Char, base: Int): Bool = result[Int, WrongFormat] { digitValue(char, base) }.isSuccess
+def isDigit(char: Char, base: Int): Bool = optionally[Int] { digitValue(char, base) }.isDefined
 
 /// Checks if a given character is a 7-bit ASCII character
 def isASCII(c: Char): Bool = { c.toInt < 128 }
@@ -178,36 +175,6 @@ extern def charWidth(c: Char) at {}: Int =
   js "(${c} > 0xffff) ? 2 : 1"
 
 
-def writeLine { body: () => Unit / emit[Char] }: Unit / emit[Char] =
-  returning::writeLine[Unit]{body}
-
-def readLine { body: () => Unit / read[Char] }: Unit / {read[Char], stop} =
-  returning::readLine[Unit]{body}
-
-namespace returning {
-  def writeLine[R] { body: () => R / emit[Char] }: R / emit[Char] = {
-    val result = body()
-    do emit('\n')
-    return result
-  }
-
-  def readLine[R] { body: () => R / read[Char] }: R / {read[Char], stop} = {
-    var stopped = false
-    try {
-      body()
-    } with read[Char] {
-      if(stopped){
-        resume { do stop() }
-      } else {
-        do read() match {
-          case '\n' => stopped = true; resume { do stop() }
-          case char => resume { return char }
-        }
-      }
-    }
-  }
-}
-
 def decodeChar(): Char / {read[Byte], stop} = {
   val b = do read().toInt
   if (b < 128) {

package/libraries/common/effekt.effekt

@@ -127,6 +127,16 @@ extern def inspect[R](value: R) at io: Unit =
   chez { println(genericShow(value)) }
   vm "effekt::inspect(Any)"
 
+/// A fatal runtime error that cannot be caught
+extern def panic(msg: String) at io: Nothing =
+  js "(function() { throw ${msg} })()"
+  chez "(raise ${msg})"
+  llvm """
+    call void @c_io_println(%Pos ${msg})
+    call void @exit(i32 1)
+    ret %Pos zeroinitializer ; Unit
+  """
+
 
 // Strings
 // =======

package/libraries/common/exception.effekt

@@ -47,19 +47,6 @@ def wrongFormat(msg: String): Nothing / Exception[WrongFormat] =
   do raise(WrongFormat(), msg)
 
 
-/**
- * A fatal runtime error that cannot be caught
- */
-extern def panic(msg: String) at io: Nothing =
-  js "(function() { throw ${msg} })()"
-  chez "(raise ${msg})"
-  llvm """
-    call void @c_io_println(%Pos ${msg})
-    call void @exit(i32 1)
-    ret %Pos zeroinitializer ; Unit
-  """
-
-
 // Exception Handlers
 // ==================
 

package/libraries/common/json.effekt

@@ -91,8 +91,8 @@ def encodeJson[R]{ body: => R / JsonBuilder }: R / emit[String] = {
 
 
 /// Read a double value, in the common format (TODO document)
-def readDouble(): Double / Scan[Char] = {
-  def exponent(pre: Double) = {
+def readDouble(): Double / { Scan[Char], Exception[WrongFormat]} = {
+  def exponent(pre: Double): Double / fail = {
     try {
       if(do peek() == 'e' || do peek() == 'E') {
         do skip[Char]()
@@ -107,11 +107,11 @@ def readDouble(): Double / Scan[Char] = {
       pre
     }
   }
-  def fraction(pre: Int) = {
-    if (optionally { readIf('.') }) {
+  def fraction(pre: Int): Double / fail = {
+    if (succeeds { must { readIf('.') } }) {
       var b = 0.1
       var r = pre.toDouble
-      while (returning::optionally[Int] { readDigit() } is Some(d)) {
+      while (optionally[Int] { must { readDigit() } } is Some(d)) {
         r = r + b * d.toDouble
         b = b * 0.1
       }
@@ -120,45 +120,41 @@ def readDouble(): Double / Scan[Char] = {
       pre.toDouble
     }
   }
+  with returning::expect("Expected double") 
   fraction(readInteger())
 }
 
 def expectString(string: String): Unit / { Scan[Char], Exception[WrongFormat] } =
-  for[Char] { string.each } { char =>
-    expect("Expected " ++ string) { readIf(char) }
-  }
+  expect("Expected " ++ string) { readString(string) }
+
 
 /// Read and unescape a string in ""
 def readQuotedString(): Unit / { Scan[Char], emit[Char], Exception[WrongFormat] } = {
-  try {
-    skipWhitespace()
-    expect("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 expect("Unexpected end of input while reading a string")
+  skipWhitespace()
+  expect("Expected \"") { must { readIf('"') } }
+  while(must { read[Char]() } is c and c != '"') {
+    c match {
+      case '\\' => must { 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() is c) {
+  if(optionally { must { do peek() } } is Some(c)) {
     c match {
       case 'n' => expectString("null"); do null()
       case 't' => expectString("true"); do bool(true)
@@ -175,9 +171,9 @@ def decodeJson(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} = {
 def decodeJsonObject(): Unit / {Scan[Char], JsonObjectBuilder, Exception[WrongFormat]} = {
   var first = true
   expectString("{")
-  with boundary
+  with expect("Expected whitespace")
   skipWhitespace()
-  while(do peek() is c and (c != '}')) {
+  while(must { do peek() } is c and (c != '}')) {
     if (not(first)) { expectString(",") }
     val k = string::collect { readQuotedString() }
     skipWhitespace()
@@ -188,20 +184,20 @@ def decodeJsonObject(): Unit / {Scan[Char], JsonObjectBuilder, Exception[WrongFo
     skipWhitespace()
     first = false
   }
-  do skip()
+  must { do skip() }
 }
 def decodeJsonList(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} = {
   var first = true
   expectString("[")
-  with boundary
+  with expect("Expected whitespace")
   skipWhitespace()
-  while(do peek() is c and (c != ']')) {
+  while(must { do peek() } is c and (c != ']')) {
     if (not(first)) { expectString(",") }
     decodeJson()
     skipWhitespace()
     first = false
   }
-  do skip()
+  must { do skip() }
 }
 
 // --------------------------------------------------------------------------------

package/libraries/common/partial.effekt

@@ -0,0 +1,48 @@
+module partial
+
+import effekt
+import option
+
+
+effect fail(): Nothing
+
+def attempt[R] { program: () => R / fail } { fallback: () => R }: R =
+  try {
+    program()
+  } with fail {
+    fallback()
+  }
+
+def succeeds { program: () => Unit / fail }: Bool =
+  try { program(); true } with fail { false }
+
+def optionally[R] { program: () => R / fail }: Option[R] =
+  try {
+    Some(program())
+  } with fail {
+    None()
+  }
+
+def must[R] { program: () => R / stop }: R / fail =
+  try { program() } with stop { resume(do fail()) }
+
+/// Run `program` forever until `fail` is thrown.
+def exhaustively { program: () => Unit / fail }: Unit =
+  try {
+    def go(): Unit = {
+      program()
+      go()
+    }
+    go()
+  } with fail {
+    ()
+  }
+
+def crash[R](message: String) { program: () => R / fail }: R =
+  attempt { program() } { panic(message) }
+
+def suchThat[A](value: A){ predicate: A => Bool }: Option[A] =
+  if (predicate(value)) { Some(value) } else { None() }
+
+def getOrFail[A](option: Option[A]): A / fail =
+  option.getOrElse { do fail() }

package/libraries/common/scanner.effekt

@@ -10,20 +10,29 @@ interface Scan[A] {
   def skip(): Unit / stop
 }
 
-/// Advance the Scanner to the next character, returning it.
+
+/// Advance the Scanner to the next token, returning it.
 def read[A](): A / { Scan[A], stop } = {
   val t = do peek()
   do skip()
   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] =
+def expect(message: String) { scanner: () => Unit / fail }: Unit / Exception[WrongFormat] =
   returning::expect[Unit](message){scanner}
 
+/// If conversion is successful read the next token, otherwise stop.
+def readWhen[A, B] { convert: A => B / fail }: B / { Scan[A], stop } = {
+  val t = attempt { convert(do peek()) } { do stop() };
+  do skip();
+  return t
+}
+
 /// 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()
@@ -40,57 +49,97 @@ 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()
-    return t
-  } else {
-    do stop()
-  }
-
-/// like `readSome`, but for functions `A => B / Exception[WrongFormat]` such as `char::digitValue`
-def tryRead[A, B] { convert: A => B / Exception[WrongFormat] }: B / { Scan[A], stop } = {
-  with on[WrongFormat].default { do stop() }
+/// Skips the next token but fails instead of stopping.
+def mustSkip[A](): Unit / { Scan[A], fail } =
+  must { do skip() }
 
-  val t = convert(do peek())
-  do skip()
-  return t
-}
+/// Skips the next character but fails if it is not the given one.
+def mustSkip(token: Char): Unit / { Scan[Char], fail } =
+  must { skipIf(token) }
 
 /// 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] } =
+def readMany[A] { predicate: A => Bool }: Unit / { Scan[A], emit[A] } =
   many { readIf{predicate} }
 
+/// Reads until the predicate does not hold for the next token.
+/// Must read at least one token, else fails.
+/// Emits the tokens read.
+def readSome[A] { predicate: A => Bool }: Unit / { Scan[A], emit[A], fail } =
+  some { 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} } { _ => () }
+def skipMany[A] { predicate: A => Bool }: Unit / Scan[A] =
+  for[A] { readMany{predicate} } { _ => () }
 
+/// Skips until the predicate does not hold for the next token.
+/// Must skip at least one token, else fail.
+def skipSome[A] { predicate: A => Bool }: Unit / { Scan[A], fail } =
+  for[A] { readSome{predicate} } { _ => () }
 
-/// Read the next character if it is the given one and return true in this case.
+/// Read the next character if it is the given one.
 def readIf(e: Char): Unit / { Scan[Char], stop } = {
-  readIf[Char] { c => c == e }; ()
+  readIf { 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
+/// Read tokens and supply them to the given scanner.
+/// Stop and skip whenn the predicate is true.
+/// Immediately stops when already at the end.
+def until[A, R] { predicate: A => Bool } { scanner: () => R / Scan[A] }: R / { Scan[A], stop } = {
+  var stopped = false
+  if (predicate(do peek())) { stopped = true; do skip() }
+  try {
+    scanner()
+  } with Scan[A] {
+    def peek() = resume {
+      if (stopped) { do stop() } else { do peek() }
+    }
+    def skip() = resume {
+      if (stopped) { do stop() } else {
+        do skip()
+        boundary {
+          if (predicate(do peek())) { stopped = true; do skip() }
+        }
+      }
+    }
+  }
+}
+
+/// Read the next line and supply each character to the given scanner.
+def line[R] { scanner: () => R / Scan[Char] }: R / { Scan[Char], stop } =
+  until { c => c == '\n' } { scanner() }
+
+/// Read values produced by `action` followed by `separator` until one of them stops.
+/// Will consume a trailing separator.
+def list[A] { seperator: () => Unit / stop } { action: () => A / stop }: Unit / emit[A] =
+  loop { do emit(action()); seperator() }
+
+/// Read a sequence separated by `separator`.
+/// Will consume a trailing separator.
+def list[A](seperator: Char) { action: () => A / stop }: Unit / { Scan[Char], emit[A] } =
+  list { skipIf(seperator) } {action}
+
+/// Skip until the next character is not a whitespace character.
 def skipWhitespace(): Unit / Scan[Char] =
-  skipWhile { c => c.isWhitespace }
+  skipMany { 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) }
+/// Read a prefix of the characters of the given string.
+/// Fails when it cannot read all of them.
+def readString(string: String): Unit / { Scan[Char], fail } =
+  for[Char] { string.each } { char => must { 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 } =
-  tryRead[Char, Int]{ char => digitValue(char) }
+  readWhen { char => digitValue(char) }
 
 /// Read a positive decimal number.
-def readDecimal(): Int / Scan[Char] = {
-  var result = 0
+/// Fails when there isn't at least one digit.
+def readDecimal(): Int / { Scan[Char], fail } = {
+  var result = must { readDigit() }
   for[Int] { many { readDigit() } } { digit =>
     result = result * 10 + digit
   }
@@ -99,11 +148,12 @@ def readDecimal(): Int / Scan[Char] = {
 
 /// Check that the next character is a digit in base 16, and if so read and return it.
 def readHexDigit(): Int / { Scan[Char], stop } =
-  tryRead[Char, Int]{ char => hexDigitValue(char) }
+  readWhen { char => hexDigitValue(char) }
 
 /// Read a hexadecimal number.
-def readHexadecimal(): Int / Scan[Char] = {
-  var result = 0
+/// Fails when there isn't at least one digit.
+def readHexadecimal(): Int / { Scan[Char], fail } = {
+  var result = must { readHexDigit() }
   for[Int] { many { readHexDigit() } } { digit =>
     result = result * 16 + digit
   }
@@ -111,14 +161,15 @@ def readHexadecimal(): Int / Scan[Char] = {
 }
 
 /// Read a decimal integer.
-def readInteger(): Int / Scan[Char] =
-  if (optionally { readIf('-') }) {
-    neg(readDecimal())
-  } else {
-    readDecimal()
+/// Will consume a minus sign if it is not followed by a digit.
+/// Fails whenn there isn't at least one digit.
+def readInteger(): Int / { Scan[Char], fail } =
+  must { do peek() } match {
+    case '-' => must { do skip() }; neg(readDecimal())
+    case c and isDigit(c) => readDecimal()
+    case _ => do fail()
   }
 
-
 namespace returning {
 
 /// Run a scanner by reading from an input stream.
@@ -150,8 +201,8 @@ def scanner[A, R] { scanner: () => R / Scan[A] }: R / read[A] = {
   }
 }
 
-def expect[R](message: String) { scanner: () => R / stop }: R / Exception[WrongFormat] =
-  attempt { scanner() } { wrongFormat(message) }
+def expect[R](message: String) { scanner: () => R / fail }: R / Exception[WrongFormat] =
+  try { scanner() } with fail { wrongFormat(message) }
 
 }
 
@@ -166,6 +217,8 @@ namespace test {
       A1B2
       """
 
+    with on[WrongFormat].panic
+    with expect("this grammar")
     with feed(input)
     with scanner[Char]
 

package/libraries/common/stream.effekt

@@ -2,7 +2,7 @@ module stream
 
 import effekt
 import option
-import exception
+import partial
 
 // Effects
 // -------
@@ -51,21 +51,11 @@ def fix[T] { one: T => Unit / emit[T] } { stream: => Unit / emit[T] }: Unit =
 def many[A] { action: () => A / stop }: Unit / emit[A] =
   loop { do emit(action()) }
 
-def some[A] { action: () => A / stop }: Unit / { emit[A], stop } = {
-  do emit(action())
+def some[A] { action: () => A / stop }: Unit / { emit[A], fail } = {
+  do emit(must { action() })
   many { action() }
 }
 
-def optionally { program: () => Unit / stop }: Bool =
-  returning::optionally[Unit]{program}.isDefined
-
-def attempt[R] { program: () => R / stop } { fallback: () => R }: R =
-  try {
-    program()
-  } with stop {
-    fallback()
-  }
-
 
 /// In Effekt lower bounds are inclusive and upper bounds are exclusive
 record Indexed[A](index: Int, value: A)
@@ -330,14 +320,14 @@ def tee[A]{ cons1: { => Unit / emit[A] } => Unit }{ cons2: { => Unit / emit[A] }
 /// > first[Bool] { do emit(true) }
 /// true
 /// > first[String] { () } // empty stream
-/// <Exception MissingValue: code in first did not emit any values>
+/// <fail>
 /// ```
-def first[A] { body: => Unit / emit[A] }: A / Exception[MissingValue] =
+def first[A] { stream: () => Unit / emit[A] }: A / fail = {
   try {
+    def body(): A = { stream(); do fail() }
     body()
-    val r: A = do raise[MissingValue](MissingValue(), "code in first did not emit any values")
-    r
   } with emit[A] { a => a }
+}
 
 namespace returning {
 
@@ -371,13 +361,6 @@ def boundary[R] { program: () => R / stop }: Option[R] =
     None()
   }
 
-def optionally[R] { program: () => R / stop }: Option[R] =
-  try {
-    Some(program())
-  } with stop {
-    None()
-  }
-
 def index[A, R] { stream: () => R / emit[A] }: R / emit[Indexed[A]] = {
   var i = 0;
   try {

package/libraries/common/string.effekt

@@ -5,6 +5,7 @@ import option
 import stream
 import list
 import exception
+import partial
 import result
 import char
 import bytearray
@@ -118,14 +119,14 @@ extern def trim(str: String) at {}: String =
 
 // Parsing
 // -------
-def toBool(s: String): Bool / Exception[WrongFormat] = s match {
+def toBool(s: String): Bool / fail = s match {
   case "true"  => true
   case "false" => false
-  case _ => wrongFormat("Not a boolean value: '" ++ s ++ "'")
+  case _ => do fail()
 }
 
 // TODO optimize (right now this will be horribly slow (compared to the native JS version)
-def toInt(str: String): Int / Exception[WrongFormat] = {
+def toInt(str: String): Int / fail = {
   def go(index: Int, acc: Int): Int = {
     // wrong index means we're done parsing
     with on[OutOfBounds].default { () => acc };
@@ -136,7 +137,7 @@ def toInt(str: String): Int / Exception[WrongFormat] = {
   }
 
   with on[OutOfBounds].default {
-    wrongFormat("Empty string is not a valid number")
+    do fail()
   }
 
   str.charAt(0) match {
@@ -146,9 +147,9 @@ def toInt(str: String): Int / Exception[WrongFormat] = {
 }
 
 // TODO optimize (right now this will be horribly slow (compared to the native JS version)
-def toInt(str: String, base: Int): Int / Exception[WrongFormat] = {
+def toInt(str: String, base: Int): Int / fail = {
   if (base > 36 || base < 1) {
-    wrongFormat("Invalid base: " ++ base.show)
+    do fail()
   }
 
   def go(index: Int, acc: Int): Int = {
@@ -161,7 +162,7 @@ def toInt(str: String, base: Int): Int / Exception[WrongFormat] = {
   }
 
   with on[OutOfBounds].default {
-    wrongFormat("Empty string is not a valid number")
+    do fail()
   }
 
   str.charAt(0) match {