@effekt-lang/effekt 0.66.0 → 0.68.0

package/libraries/common/json.effekt

@@ -90,40 +90,6 @@ def encodeJson[R]{ body: => R / JsonBuilder }: R / emit[String] = {
 // --------------------------------------------------------------------------------
 
 
-/// Read a double value, in the common format (TODO document)
-def readDouble(): Double / { Scan[Char], Exception[WrongFormat]} = {
-  def exponent(pre: Double): Double / fail = {
-    try {
-      if(do peek() == 'e' || do peek() == 'E') {
-        skip[Char]()
-        val e = do peek[Char]() match {
-          case '+' => skip[Char](); readDecimal()
-          case '-' => skip[Char](); neg(readDecimal())
-          case _ => readDecimal()
-        }
-        pre * pow(10.0, e)
-      } else { pre }
-    } with stop {
-      pre
-    }
-  }
-  def fraction(pre: Int): Double / fail = {
-    if (succeeds { must { readIf('.') } }) {
-      var b = 0.1
-      var r = pre.toDouble
-      while (optionally[Int] { must { readDigit() } } is Some(d)) {
-        r = r + b * d.toDouble
-        b = b * 0.1
-      }
-      exponent(r)
-    } else {
-      pre.toDouble
-    }
-  }
-  with returning::expect("Expected double") 
-  fraction(readInteger())
-}
-
 def expectString(string: String): Unit / { Scan[Char], Exception[WrongFormat] } =
   expect("Expected " ++ string) { readString(string) }
 
@@ -133,9 +99,9 @@ def readQuotedString(): Unit / { Scan[Char], emit[Char], Exception[WrongFormat]
   with expect("Unexpected end of input while reading a string")
   skipWhitespace()
   expect("Expected \"") { must { readIf('"') } }
-  while(must { do read[Char]() } is c and c != '"') {
+  while(must { do next[Char]() } is c and c != '"') {
     c match {
-      case '\\' => must { do read[Char]() } match {
+      case '\\' => must { do next[Char]() } match {
         case '"' => do emit('\"')
         case '\\' => do emit('\\')
         case '/' => do emit('/')
@@ -159,8 +125,8 @@ def decodeJson(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} = {
       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 number(returning::expect("Expected double") { readDouble() })
+      case d and d.isDigit => do number(returning::expect("Expected double") { readDouble() })
       case '"' => do string(collect { readQuotedString() })
       case '{' => do dict{ decodeJsonObject() }
       case '[' => do list{ decodeJsonList() }
@@ -310,15 +276,23 @@ namespace test {
 
     // Read quoted string
     feed("\"\ta\n\ra\"") {
-      with scanner[Char]
+      with peeking[Char]
       println(string::collect { readQuotedString() })
     }
 
     println("")
 
+    feed("-1.5") {
+      with peeking[Char]
+      with on[WrongFormat].report
+      println(returning::expect("Expected double") { readDouble() })
+    }
+
+    println("")
+
     // Parse example
     feed("""{ "a": null, "b": [true,false,false,true], "f": 12.532   }"""){
-      with scanner[Char]
+      with peeking[Char]
 
       def k = new JsonObjectBuilder {
         def field[T](k){v} = { println(k); ignore{v} }
@@ -362,7 +336,7 @@ namespace test {
                   "a": null,
                   "b": [true, false, false, true], "f": 12.532
                 } """){
-        with returning::scanner[Char, JsonValue]
+        with returning::peeking[Char, JsonValue]
         build {
           decodeJson()
         }.second
@@ -379,7 +353,7 @@ namespace test {
                   "a": null,
                   "b": [true, false, false, true], "f": 12.532
                 } """){
-          with scanner[Char]
+          with peeking[Char]
           decodeJson()
         }
       }

package/libraries/common/list.effekt

@@ -974,12 +974,12 @@ def tails[A](list: List[A]): Unit / emit[List[A]] =
     case Cons(head, tail) => do emit(list); tails(tail)
   }
 
-/// Connects `list` as a producer to a given pull stream `reader` acting as a consumer.
-def feed[T, R](list: List[T]) { reader: () => R / read[T] }: R = {
+/// Connects `list` as a producer to a given pull stream `driver` acting as a consumer.
+def feed[T, R](list: List[T]) { driver: () => R / next[T] }: R = {
   var l = list
   try {
-    reader()
-  } with read[T] {
+    driver()
+  } with next[T] {
     resume {
       l match {
         case Nil() => do stop()

package/libraries/common/process.effekt

@@ -25,7 +25,9 @@ extern llvm """
   declare %Pos @c_spawn(%Pos, %Pos, %Pos)
 """
 
-extern type SpawnOptions
+extern type SpawnOptions =
+  jsNode "{ stdio: list[int], onSpawn: fn => {} }"
+  llvm "%Pos"
 extern def default() at {}: SpawnOptions =
   jsNode """{ stdio: [0,1,2], onSpawn: (p) => {} }"""
   llvm """
@@ -64,7 +66,9 @@ extern def onStderr(opts: SpawnOptions, callback: String => Unit at {io, global}
     %opts = call %Pos @c_spawn_options_on_stderr(%Pos ${opts}, %Pos ${callback})
     ret %Pos %opts
   """
-extern type WritableStream
+extern type WritableStream =
+  jsNode "stream.Writable"
+  llvm "%Pos"
 extern def withStdin(opts: SpawnOptions, callback: WritableStream => Unit at {io, global}) at {}: SpawnOptions =
   jsNode """(function () {
     let old = ${opts};

package/libraries/common/random.effekt

@@ -1,6 +1,9 @@
 module random
 
 import stream
+import array
+import option
+import exception
 import io/filesystem
 import io/error
 
@@ -38,7 +41,7 @@ def minstd(seed: Int): Unit / emit[Byte] = {
     if (result < 0) result + m else result
   }
 
-  while (true) {
+  forever {
     state = nextInt()
     val b = state.mod(256).toByte
     do emit(b)
@@ -73,7 +76,7 @@ def devurandom { randomnessReader: () => Unit / random }: Unit / Exception[IOErr
   try {
     with readFile("/dev/urandom")
     try randomnessReader() with random {
-      resume(do read())
+      resume(do next())
     }
   } with stop {
     do raise(io::error::EOF(), "Unexpected EOF when reading /dev/urandom!")
@@ -88,14 +91,14 @@ def devurandom { randomnessReader: () => Unit / random }: Unit / Exception[IOErr
 
 def randomByte(): Byte / random = do random()
 def randomBytes(): Unit / {emit[Byte], random} =
-  while (true) do emit(do random())
+  forever { do emit(do random()) }
 
 def randomBool(): Bool / random = {
   val b = do random()
   b.toInt.mod(2) == 1
 }
 def randomBools(): Unit / {emit[Bool], random} =
-  while (true) do emit(randomBool())
+  forever { do emit(randomBool()) }
 
 def randomInt32(): Int / random = {
   var result = 0
@@ -107,7 +110,7 @@ def randomInt32(): Int / random = {
   result.mod(1.bitwiseShl(31)).abs * if (signBit) 1 else -1
 }
 def randomInt32s(): Unit / {emit[Int], random} =
-  while (true) do emit(randomInt32())
+  forever { do emit(randomInt32()) }
 
 /// `max` is _inclusive_!
 def randomInt(min: Int, max: Int): Int / random = {
@@ -126,9 +129,10 @@ def randomInt(min: Int, max: Int): Int / random = {
     min + (abs(result).mod(range))
   }
 }
+
 /// `max` is _inclusive_!
 def randomInts(min: Int, max: Int): Unit / {emit[Int], random} =
-  while (true) do emit(randomInt(min, max))
+  forever { do emit(randomInt(min, max)) }
 
 
 /// Random double between 0.0 and 1.0
@@ -136,7 +140,25 @@ def randomDouble(): Double / random =
   (randomInt32().toDouble / 1.bitwiseShl(31).toDouble).abs
   // This is not perfect, but it will do for now.
 def randomDoubles(): Unit / {emit[Double], random} =
-  while (true) do emit(randomDouble())
+  forever { do emit(randomDouble()) }
+
+/// Shuffle an array in-place using the Fisher-Yates algorithm.
+def shuffle[A](arr: Array[A]): Unit / random = {
+  val n = arr.size
+  each(0, n - 1) { i =>
+    arr.swap(i, randomInt(i, n - 1))
+  }
+}
+
+/// Pick a random element from an array.
+///
+/// Panics when called on an empty array.
+def pick[A](arr: Array[A]): A / random =
+  if (arr.size == 0) {
+    panic("Pick from an empty array")
+  } else {
+    arr.get(randomInt(0, arr.size - 1))
+  }
 
 
 namespace examples {

package/libraries/common/ref.effekt

@@ -18,7 +18,10 @@ define void @c_ref_erase_field(ptr %0) {
 """
 
 /// Global, mutable references
-extern type Ref[T]
+extern type Ref[T] =
+  js "{ value: T }"
+  chez "box"
+  llvm "%Pos"
 
 /** We represent references like positive types in LLVM
  *  The tag is 0 and the obj points to memory with the following layout:
@@ -69,7 +72,6 @@ extern def ref[T](init: T) at global: Ref[T] =
 
     ret %Pos %refWrap
   """
-  vm "ref::ref[T](T)"
 
 /// Gets the referenced element of the `ref` in constant time.
 extern def get[T](ref: Ref[T]) at global: T =
@@ -85,7 +87,6 @@ llvm """
 
     ret %Pos %refField
   """
-  vm "ref::get[T](Ref[T])"
 
 /// Sets the referenced element of the `ref` to `value` in constant time.
 extern def set[T](ref: Ref[T], value: T) at global: Unit =
@@ -103,7 +104,6 @@ extern def set[T](ref: Ref[T], value: T) at global: Unit =
 
     ret %Pos zeroinitializer
   """
-  vm "ref::set[T](Ref[T], T)"
 
 /// Modifies the inner contents of the `ref` with a function `f`
 def map[T](ref: Ref[T]) { f: T => T }: Unit =

package/libraries/common/regex.effekt

@@ -4,14 +4,15 @@ import string
 
 extern include chez "text/pregexp.scm"
 
-extern type Regex
+extern type Regex =
+  js "RegExp"
+  chez "pregexp"
 
 record Match(matched: String, index: Int)
 
 extern def regex(str: String) at {}: Regex =
   js "new RegExp(${str})"
   chez "(pregexp ${str})"
-  vm "regex::regex(String)"
 
 def exec(reg: Regex, str: String): Option[Match] = {
   val v = internal::exec(reg, str)
@@ -25,19 +26,17 @@ namespace internal {
 
   /// The type RegexMatch is used internally to represent platform
   /// dependent results of matching a regex.
-  extern type RegexMatch
-    // js: { matched: String, index: Int } | undefined
-    // vm: scala.util.matching.Regex.Match | null
+  extern type RegexMatch =
+    js "{ matched: String, index: Int } | undefined"
+    vm "scala.util.matching.Regex.Match | null"
 
   extern def matched(r: RegexMatch) at {}: String =
     js "${r}.matched"
     chez "(vector-ref ${r} 0)"
-    vm "regex::matched(RegexMatch)"
 
   extern def index(r: RegexMatch) at {}: Int =
     js "${r}.index"
     chez "(vector-ref ${r} 1)"
-    vm "regex::index(RegexMatch)"
 
   extern js """
     function regex$exec(reg, str) {
@@ -60,5 +59,4 @@ namespace internal {
   extern def exec(reg: Regex, str: String) at io: RegexMatch =
     js "regex$exec(${reg}, ${str})"
     chez "(regex-exec ${reg} ${str})"
-    vm "regex::exec(Regex, String)"
 }

package/libraries/common/resizable_array.effekt

@@ -224,12 +224,12 @@ def each[T](arr: ResizableArray[T]): Unit / emit[T] =
     do emit(arr.rawContentPtr.get.get(i))
   }
 
-/// Connects `arr` as a producer to a given pull stream `reader` acting as a consumer.
-def feed[R, T](arr: ResizableArray[T]) { reader: () => R / read[T] }: R = {
+/// Connects `arr` as a producer to a given pull stream `driver` acting as a consumer.
+def feed[R, T](arr: ResizableArray[T]) { driver: () => R / next[T] }: R = {
   var i = 0
   try {
-    reader()
-  } with read[T] {
+    driver()
+  } with next[T] {
     resume {
       if (i < arr.size) {
         val v = arr.rawContentPtr.get.get(i)

package/libraries/common/scanner.effekt

@@ -3,19 +3,10 @@ module scanner
 import stream
 
 
-/// Return the next character, not advancing.
-/// That is, this does not change what any future calls on the Scanner return.
-effect peek[A](): A / stop
-
-effect Scan[A] = {read[A], peek[A]}
+effect Scan[A] = {next[A], peek[A]}
 
 /// Advance the pull stream to the next element, discarding the current element.
-def skip[A](): Unit / {read[A], stop} = { do read(); () }
-
-
-/// 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 skip[A](): Unit / {next[A], stop} = { do next(); () }
 
 def expect(message: String) { scanner: () => Unit / fail }: Unit / Exception[WrongFormat] =
   returning::expect[Unit](message){scanner}
@@ -23,7 +14,7 @@ def expect(message: String) { scanner: () => Unit / fail }: Unit / Exception[Wro
 /// 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 read()
+  do next()
   return t
 }
 
@@ -31,7 +22,7 @@ def readWhen[A, B] { convert: A => B / fail }: B / { Scan[A], stop } = {
 def readIf[A] { predicate: A => Bool }: A / { Scan[A], stop } = {
   val t = do peek()
   if (predicate(t)) {
-    do read()
+    do next()
     return t
   } else {
     do stop()
@@ -92,10 +83,10 @@ def until[A, R] { predicate: A => Bool } { scanner: () => R / Scan[A] }: R / { S
     resume {
       if (stopped) { do stop() } else { do peek() }
     }
-  } with read[A] {
+  } with next[A] {
     resume {
       if (stopped) { do stop() } else {
-        val t = do read()
+        val t = do next()
         boundary {
           if (predicate(do peek())) { stopped = true; skip() }
         }
@@ -166,38 +157,42 @@ def readInteger(): Int / { Scan[Char], fail } =
     case _ => do fail()
   }
 
-namespace returning {
 
-/// Run a scanner by reading from an input stream.
-def scanner[A, R] { scanner: () => R / Scan[A] }: R / read[A] = {
-  def upstream(): A / stop = do read()
-  var last = None()
-  try {
-    scanner()
-  } with peek[A] { () =>
-    resume {
-      last match {
-        case None() =>
-          val t = upstream()
-          last = Some(t)
-          return t
-        case Some(t) =>
-          return t
-      }
+/// Read a decimal floating-point number with optional fraction and exponent.
+def readDouble(): Double / { Scan[Char], fail} = {
+  def exponent(pre: Double): Double / fail = {
+    try {
+      if(do peek() == 'e' || do peek() == 'E') {
+        skip[Char]()
+        val e = do peek[Char]() match {
+          case '+' => skip[Char](); readDecimal()
+          case '-' => skip[Char](); neg(readDecimal())
+          case _ => readDecimal()
+        }
+        pre * pow(10.0, e)
+      } else { pre }
+    } with stop {
+      pre
     }
-  } with read[A] {
-    resume {
-      last match {
-        case None() =>
-          upstream()
-        case Some(t) =>
-          last = None()
-          return t
+  }
+  def fraction(pre: Int): Double / fail = {
+    if (succeeds { must { readIf('.') } }) {
+      var b = if (pre >= 0) 0.1 else -0.1
+      var r = pre.toDouble
+      while (optionally[Int] { must { readDigit() } } is Some(d)) {
+        r = r + b * d.toDouble
+        b = b * 0.1
       }
+      exponent(r)
+    } else {
+      exponent(pre.toDouble)
     }
   }
+  fraction(readInteger())
 }
 
+namespace returning {
+
 def expect[R](message: String) { scanner: () => R / fail }: R / Exception[WrongFormat] =
   try { scanner() } with fail { wrongFormat(message) }
 
@@ -217,7 +212,7 @@ namespace test {
     with on[WrongFormat].panic
     with expect("this grammar")
     with feed(input)
-    with scanner[Char]
+    with peeking[Char]
 
     skipWhitespace()
     println(readInteger().show)