@effekt-lang/effekt 0.66.0 → 0.67.0

package/libraries/common/args.effekt

@@ -7,7 +7,7 @@ extern def commandLineArgs() at io: List[String] =
   vm { Nil() }
 
 namespace js {
-  extern type Args // = Array[String]
+  extern type Args = js "Array[String]"
 
   extern def nativeArgs() at io: Args = js "process.argv.slice(1)"
 
@@ -26,7 +26,7 @@ namespace js {
 }
 
 namespace chez {
-  extern type Args // = CSList[String]
+  extern type Args = chez "CSList[String]"
 
   extern def nativeArgs() at io: Args =
     chez "(cdr (command-line))"

package/libraries/common/array.effekt

@@ -8,7 +8,10 @@ import list
 import exception
 
 /// A mutable 0-indexed fixed-sized array.
-extern type Array[T]
+extern type Array[T] =
+  js "Array"
+  chez "vector"
+  llvm "%Pos"
 
 /// We represent arrays like positive types.
 /// The tag is 0 and the obj points to memory with the following layout:
@@ -659,12 +662,12 @@ def each[T](array: Array[T]): Unit / emit[T] = {
   go(0)
 }
 
-/// Connects `array` as a producer to a given pull stream `reader` acting as a consumer.
-def feed[T, R](array: Array[T]) { reader: () => R / read[T] }: R = {
+/// Connects `array` as a producer to a given pull stream `driver` acting as a consumer.
+def feed[T, R](array: Array[T]) { driver: () => R / next[T] }: R = {
   var i = 0
   try {
-    reader()
-  } with read[T] {
+    driver()
+  } with next[T] {
     resume {
       if (i < array.size) {
         val c = i

package/libraries/common/bytearray.effekt

@@ -19,10 +19,10 @@ import array
  *
  * The eraser does nothing.
  */
-extern type ByteArray
-  // = llvm "%Pos"
-  // = js "Uint8Array"
-  // = chez "bytevector"
+extern type ByteArray =
+  llvm "%Pos"
+  js "Uint8Array"
+  chez "bytevector"
 
 /// Allocates a new bytearray with the given `size`, its values are zero bytes.
 extern def allocate(size: Int) at global: ByteArray =
@@ -283,11 +283,11 @@ def each(bytes: ByteArray): Unit / emit[Byte] = {
   go(0)
 }
 
-def feed[R](bytes: ByteArray) { reader: () => R / read[Byte] }: R = {
+def feed[R](bytes: ByteArray) { driver: () => R / next[Byte] }: R = {
   var i = 0
   try {
-    reader()
-  } with read[Byte] {
+    driver()
+  } with next[Byte] {
     resume {
       if (i < bytes.size) {
         val c = i

package/libraries/common/bytestream.effekt

@@ -103,7 +103,7 @@ def hex{ body: => Unit / { write, HexSplices } }: Unit / emit[Byte] = {
       body()
     }
     with splice[String] { s =>
-      feed(s){ loop { do splice[Char](do read[Char]()) } }
+      feed(s){ loop { do splice[Char](do next[Char]()) } }
       resume(())
     }
     with splice[ByteArray] { ba =>
@@ -115,8 +115,8 @@ def hex{ body: => Unit / { write, HexSplices } }: Unit / emit[Byte] = {
       feed(s){
         loop {
           attempt {
-            val upper: Int = hexDigitValue(do read[Char]())
-            val lower: Int = hexDigitValue(do read[Char]())
+            val upper: Int = hexDigitValue(do next[Char]())
+            val lower: Int = hexDigitValue(do next[Char]())
             do emit[Byte]((16 * upper + lower).toByte)
           } { () }
         }
@@ -296,7 +296,7 @@ def bit{ body: => Unit / { write, BitSplices } }: Unit / emit[Bit] = {
   with write { s =>
     feed(s){
       loop {
-        do read[Char]() match {
+        do next[Char]() match {
           case '0' => do emit(B0())
           case '1' => do emit(B1())
           case _ => ()

package/libraries/common/char.effekt

@@ -175,24 +175,24 @@ extern def charWidth(c: Char) at {}: Int =
   js "(${c} > 0xffff) ? 2 : 1"
 
 
-def decodeChar(): Char / {read[Byte], stop} = {
-  val b = do read().toInt
+def decodeChar(): Char / {next[Byte], stop} = {
+  val b = do next().toInt
   if (b < 128) {
     b.toChar
   } else if (b < 224) {
     val part1 = bitwiseShl(bitwiseAnd(b, 31), 6)
-    val part2 = bitwiseAnd(do read().toInt, 63)
+    val part2 = bitwiseAnd(do next().toInt, 63)
     bitwiseOr(part1, part2).toChar
   } else if (b < 240) {
     val part1 = bitwiseShl(bitwiseAnd(b, 15), 12)
-    val part2 = bitwiseShl(bitwiseAnd(do read().toInt, 63), 6)
-    val part3 = bitwiseAnd(do read().toInt, 63)
+    val part2 = bitwiseShl(bitwiseAnd(do next().toInt, 63), 6)
+    val part3 = bitwiseAnd(do next().toInt, 63)
     bitwiseOr(bitwiseOr(part1, part2), part3).toChar
   } else {
     val part1 = bitwiseShl(bitwiseAnd(b, 7), 18)
-    val part2 = bitwiseShl(bitwiseAnd(do read().toInt, 63), 12)
-    val part3 = bitwiseShl(bitwiseAnd(do read().toInt, 63), 6)
-    val part4 = bitwiseAnd(do read().toInt, 63)
+    val part2 = bitwiseShl(bitwiseAnd(do next().toInt, 63), 12)
+    val part3 = bitwiseShl(bitwiseAnd(do next().toInt, 63), 6)
+    val part4 = bitwiseAnd(do next().toInt, 63)
     bitwiseOr(bitwiseOr(bitwiseOr(part1, part2), part3), part4).toChar
   }
 }
@@ -216,10 +216,10 @@ def encodeChar(char: Char): Unit / emit[Byte] = {
   }
 }
 
-def decodeUTF8[R] { reader: () => R / read[Char] }: R / read[Byte] =
+def decodeUTF8[R] { reader: () => R / next[Char] }: R / next[Byte] =
   try {
     reader()
-  } with read[Char] {
+  } with next[Char] {
     resume { decodeChar() }
   }
 

package/libraries/common/dictionary.effekt

@@ -1,26 +1,33 @@
 module dictionary
 
+import ref
 import array
 import bytearray
 import stream
 
-
-/// A trie-based dictionary for efficient key-value storage with bytearray keys.
-/// Supports String and ByteArray keys with fast lookup and insertion.
-type Dictionary[A] {
+/// Internal trie node type.
+type Trie[A] {
   Empty()
   Leaf(value: A)
-  Branch(children: Array[Dictionary[A]])
-  Node(value: A, children: Array[Dictionary[A]])
+  Branch(children: Array[Trie[A]])
+  Node(value: A, children: Array[Trie[A]])
 }
 
+/// A mutable trie-based dictionary for efficient key-value storage with bytearray keys.
+type Dictionary[A] = Ref[Trie[A]]
+
+/// A record pairing a key with a value for use in streams.
+record Tagged[A](key: ByteArray, value: A)
+
+def empty[A](): Dictionary[A] = ref(Empty())
+
 /// Insert a value with a String key.
-def insert[A](trie: Dictionary[A], key: String, value: A): Dictionary[A] =
-  insert(trie, key.fromString, value)
+def insert[A](dictionary: Dictionary[A], key: String, value: A): Unit =
+  insert(dictionary, key.fromString, value)
 
 /// Insert a key-value pair into the dictionary with a ByteArray key.
-def insert[A](trie: Dictionary[A], key: ByteArray, value: A): Dictionary[A] = {
-  def go(trie: Dictionary[A], i: Int): Dictionary[A] =
+def insert[A](dictionary: Dictionary[A], key: ByteArray, value: A): Unit = {
+  def go(trie: Trie[A], i: Int): Trie[A] =
     if (i < key.size) {
       trie match {
         case Empty() =>
@@ -50,16 +57,16 @@ def insert[A](trie: Dictionary[A], key: ByteArray, value: A): Dictionary[A] = {
         case Branch(children) => Node(value, children)
       }
     }
-  go(trie, 0)
+  dictionary.set(go(dictionary.get, 0))
 }
 
 /// Look up a value in the dictionary by string key.
-def lookup[A](trie: Dictionary[A], key: String): Option[A] =
-  lookup(trie, key.fromString)
+def lookup[A](dictionary: Dictionary[A], key: String): Option[A] =
+  lookup(dictionary, key.fromString)
 
 /// Look up a value in the dictionary by bytearray key.
-def lookup[A](trie: Dictionary[A], key: ByteArray): Option[A] = {
-  def go(trie: Dictionary[A], i: Int): Option[A] =
+def lookup[A](dictionary: Dictionary[A], key: ByteArray): Option[A] = {
+  def go(trie: Trie[A], i: Int): Option[A] =
     if (i < key.size) {
       trie match {
         case Empty() => None()
@@ -75,45 +82,41 @@ def lookup[A](trie: Dictionary[A], key: ByteArray): Option[A] = {
         case Node(value, _) => Some(value)
       }
     }
-  go(trie, 0)
+  go(dictionary.get, 0)
 }
 
-/// A record pairing a key with a value for use in streams.
-record Tagged[A](key: ByteArray, value: A)
-
-/// Collect key-value pairs from a stream of Tagged elements into a Dictionary.
+/// Collect key-value pairs from a stream of Tagged elements into a fresh Dictionary.
 def collect[A] { stream: () => Unit / emit[Tagged[A]] }: Dictionary[A] = {
-  var trie = Empty()
+  val dictionary = ref(Empty())
   for[Tagged[A]] { stream() } { case Tagged(bytes, value) =>
-    trie = trie.insert(bytes, value)
+    dictionary.insert(bytes, value)
   }
-  return trie
+  return dictionary
 }
 
 /// Emit all values stored in the dictionary as a push stream.
-def each[A](trie: Dictionary[A]): Unit / emit[A] =
-  trie match {
-    case Empty() => ()
-    case Leaf(value) => do emit(value)
-    case Branch(children) =>
-      each(0, children.size) { i =>
-        each(children.get(i))
-      }
-    case Node(value, children) =>
-      do emit(value)
-      each(0, children.size) { i =>
-        each(children.get(i))
-      }
-  }
+def each[A](dictionary: Dictionary[A]): Unit / emit[A] = {
+  def go(trie: Trie[A]): Unit / emit[A] =
+    trie match {
+      case Empty() => ()
+      case Leaf(value) => do emit(value)
+      case Branch(children) =>
+        each(0, children.size) { i => go(children.get(i)) }
+      case Node(value, children) =>
+        do emit(value)
+        each(0, children.size) { i => go(children.get(i)) }
+    }
+  go(dictionary.get)
+}
 
 /// Emit all key-value pairs stored in the dictionary as a push stream of Tagged elements.
-def eachTagged[A](trie: Dictionary[A]): Unit / emit[Tagged[A]] = {
+def eachTagged[A](dictionary: Dictionary[A]): Unit / emit[Tagged[A]] = {
   def fromBytesReverse(bytes: List[Byte], n: Int): ByteArray = {
     val key = bytearray::allocate(n)
     foreachIndex(bytes) { (i, b) => key.set(n - 1 - i, b) }
     key
   }
-  def go(trie: Dictionary[A], key: List[Byte], n: Int): Unit =
+  def go(trie: Trie[A], key: List[Byte], n: Int): Unit =
     trie match {
       case Empty() => ()
       case Leaf(value) => do emit(Tagged(fromBytesReverse(key, n), value))
@@ -127,7 +130,5 @@ def eachTagged[A](trie: Dictionary[A]): Unit / emit[Tagged[A]] = {
           go(children.get(i), Cons(i.toByte, key), n + 1)
         }
     }
-  go(trie, Nil(), 0)
-}
-
-
+  go(dictionary.get, Nil(), 0)
+}

package/libraries/common/effekt.effekt

@@ -83,6 +83,7 @@ def println(value: Unit): Unit = println(value.show)
 def println(value: Double): Unit = println(value.show)
 def println(value: Bool): Unit = println(value.show)
 def println(value: Byte): Unit = println(value.show)
+def println(value: Char): Unit = println(value.show)
 
 extern def showBuiltin(value: Int) at {}: String =
   js "'' + ${value}"
@@ -135,8 +136,8 @@ extern def panic(msg: String) at io: Nothing =
   """
 
 extern def show[R](value: R) at {}: String =
-  js "$effekt.show(${value})"
-  chez "(show_impl ${value})"
+  js "undefined"
+  chez "(void)"
   llvm "ret %Pos poison"
 
 extern def genericShow[R](value: R) at {}: String =
@@ -746,6 +747,15 @@ extern def isUndefined[A](value: A) at {}: Bool =
   chez "(eq? ${value} #f)"
   vm "effekt::isUndefined[A](A)"
 
+// Ascription
+// ==========
+
+/// Ascribe a type, for example `f().as[Int]`.
+def as[A](x: A): A = x
+
+/// Witness absurdity, for example `f().absurd`.
+/// Very often the type argument is inferred.
+def absurd[A](x: Nothing): A = x match {}
 
 // Tuples
 // ======

package/libraries/common/io/channel.effekt

@@ -33,7 +33,7 @@ def send[A, B](sender: Sender[A, B], value: A): B = {
   sender.set(rest)
   // TODO avoid yield
   yield()
-  this.unsafeFire(value)
+  this.fire(value)
 }
 
 /// Receives a value from a channel and blocks until a sender arrives.
@@ -51,7 +51,7 @@ def receive[A, B](receiver: Receiver[A, B], value: B): A = {
   receiver.set(rest)
   // TODO avoid yield
   yield()
-  this.unsafeWait(value)
+  this.wait(value)
 }
 
 // TODO streaming

package/libraries/common/io/console.effekt

@@ -26,7 +26,8 @@ namespace js {
     const readline = require('node:readline');
   """
 
-  extern type JSConsole
+  extern type JSConsole =
+    js "readline.createInterface return type"
 
   extern def newConsole() at io: JSConsole =
     jsNode """readline.createInterface({

package/libraries/common/io/filesystem.effekt

@@ -74,8 +74,8 @@ def appendFile(path: String, contents: String): Unit / Exception[IOError] = {
 def writeFileUTF8[R](path: String) { stream: () => R / emit[Char] }: R / Exception[IOError] =
   writeFile(path) { encodeUTF8 { stream() } }
 
-def readFileUTF8[R](path: String) { reader: () => R / read[Char] }: R / Exception[IOError] =
-  readFile(path) { decodeUTF8 { reader() } }
+def readFileUTF8[R](path: String) { driver: () => R / next[Char] }: R / Exception[IOError] =
+  readFile(path) { decodeUTF8 { driver() } }
 
 def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[IOError] = {
 
@@ -108,7 +108,7 @@ def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[I
   }
 }
 
-def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IOError] = {
+def readFile[R](path: String) { driver: () => R / next[Byte] }: R / Exception[IOError] = {
 
   val file = openForReading(path);
   with on[IOError].finalize { close(file) }
@@ -128,8 +128,8 @@ def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IO
   }
 
   try {
-    reader()
-  } with read[Byte] {
+    driver()
+  } with next[Byte] {
     resume {
       if (offset >= length) {
         pull()

package/libraries/common/io/network.effekt

@@ -42,13 +42,13 @@ def listen(listener: Listener, handler: Connection => Unit at {io, async, global
 def shutdown(listener: Listener): Unit =
   internal::shutdown(listener)
 
-def streaming[R](connection: Connection) { program: () => R / {read[ByteArray], emit[ByteArray]} }: R / Exception[IOError] =
+def streaming[R](connection: Connection) { program: () => R / {next[ByteArray], emit[ByteArray]} }: R / Exception[IOError] =
   try {
     program()
   } with emit[ByteArray] { bytes =>
     write(connection, bytes, 0, bytes.size)
     resume(())
-  } with read[ByteArray] { () =>
+  } with next[ByteArray] { () =>
     val bytes = bytearray::allocate(4096)
     read(connection, bytes, 0, bytes.size) match {
       case r and r == bytes.size => resume { return bytes }

package/libraries/common/io/promise.effekt

@@ -37,7 +37,7 @@ def await[T](promise: Promise[T]): T =
       val signal = signal()
       promise.set(Pending(Cons(signal, signals)))
       // TODO perhaps yield to avoid stack overflow
-      signal.unsafeWait(())
+      signal.wait(())
   }
 
 /// Resolves the given promise, unblocking all awaiting tasks.
@@ -48,6 +48,6 @@ def resolve[T](promise: Promise[T], value: T): Unit =
     case Pending(signals) =>
       promise.set(Resolved(value))
       // TODO perhaps yield to avoid stack overflow
-      signals.reverse.foreach { signal => unsafeFire(signal, value) }
+      signals.reverse.foreach { signal => fire(signal, value) }
   }
 

package/libraries/common/io/signal.effekt

@@ -5,32 +5,29 @@ module io/signal
 
 /// Must be fired exactly once with an A receiving a B,
 /// and must be waited for exactly once with a B receiving an A.
-extern type Signal[A, B]
+extern type Signal[A, B] =
+  js "{ state: int, value, stack }"
+  llvm "%Pos"
 
-extern def signal[A, B]() at global: Signal[A, B] =
-  js "signal$make()"
-  llvm """
-    %signal = call %Pos @c_signal_make()
-    ret %Pos %signal
-  """
+extern llvm """
+%Signal = type { %Header, i64, ptr, %Pos }
 
-extern def unsafeFire[A, B](signal: Signal[A, B], value: A) at async: B =
-  js "$effekt.capture(callback => signal$notify(${signal}, ${value}, callback))"
-  llvm """
-    call void @c_signal_notify(%Pos ${signal}, %Pos ${value}, %Stack %stack)
+define void @signal_erase(ptr %envPtr) {
+    %base = getelementptr %Header, ptr %envPtr, i64 -1
+    %statePtr = getelementptr %Signal, ptr %base, i64 0, i32 1
+    %stackPtr = getelementptr %Signal, ptr %base, i64 0, i32 2
+    %valuePtr = getelementptr %Signal, ptr %base, i64 0, i32 3
+    %state = load i64, ptr %statePtr
+    switch i64 %state, label %none [i64 0, label %free i64 1, label %free i64 2, label %free]
+  free:
+    %stack = load %Stack, ptr %stackPtr
+    %value = load %Pos, ptr %valuePtr
+    call void @erasePositive(%Pos %value)
+    call void @eraseStack(%Stack %stack)
     ret void
-  """
-
-extern def unsafeWait[A, B](signal: Signal[A, B], value: B) at async: A =
-  js "$effekt.capture(callback => signal$notify(${signal}, ${value}, callback))"
-  llvm """
-    call void @c_signal_notify(%Pos ${signal}, %Pos ${value}, %Stack %stack)
+  none:
     ret void
-  """
-
-extern llvm """
-  declare %Pos @c_signal_make()
-  declare void @c_signal_notify(%Pos, %Pos, %Stack)
+}
 """
 
 extern js """
@@ -53,3 +50,70 @@ extern js """
     }
   }
 """
+
+extern def signal[A, B]() at global: Signal[A, B] =
+  js "signal$make()"
+  llvm """
+    %base = call ptr @calloc(i64 1, i64 48)
+    %eraserPtr = getelementptr %Signal, ptr %base, i64 0, i32 0, i32 1
+    store ptr @signal_erase, ptr %eraserPtr
+    %result = insertvalue %Pos { i64 0, ptr poison }, ptr %base, 1
+    ret %Pos %result
+  """
+
+extern def fire[A, B](signal: Signal[A, B], value: A) at async: B =
+  js "$effekt.capture(callback => signal$notify(${signal}, ${value}, callback))"
+  llvm """
+    %base = extractvalue %Pos ${signal}, 1
+    %statePtr = getelementptr %Signal, ptr %base, i64 0, i32 1
+    %stackPtr = getelementptr %Signal, ptr %base, i64 0, i32 2
+    %valuePtr = getelementptr %Signal, ptr %base, i64 0, i32 3
+    %state = load i64, ptr %statePtr
+    switch i64 %state, label %panic [i64 0, label %init i64 1, label %fire]
+  init:
+    store i64 2, ptr %statePtr
+    store %Stack %stack, ptr %stackPtr
+    store %Pos ${value}, ptr %valuePtr
+    call void @erasePositive(%Pos ${signal})
+    ret void
+  fire:
+    %otherStack = load %Stack, ptr %stackPtr
+    %otherValue = load %Pos, ptr %valuePtr
+    store i64 3, ptr %statePtr
+    call void @erasePositive(%Pos ${signal})
+    call void @resume_Pos(%Stack %otherStack, %Pos ${value})
+    call void @resume_Pos(%Stack %stack, %Pos %otherValue)
+    ret void
+  panic:
+    call void @exit(i64 1)
+    ret void
+  """
+
+extern def wait[A, B](signal: Signal[A, B], value: B) at async: A =
+  js "$effekt.capture(callback => signal$notify(${signal}, ${value}, callback))"
+  llvm """
+    %base = extractvalue %Pos ${signal}, 1
+    %statePtr = getelementptr %Signal, ptr %base, i64 0, i32 1
+    %stackPtr = getelementptr %Signal, ptr %base, i64 0, i32 2
+    %valuePtr = getelementptr %Signal, ptr %base, i64 0, i32 3
+    %state = load i64, ptr %statePtr
+    switch i64 %state, label %panic [i64 0, label %init i64 2, label %wait]
+  init:
+    store i64 1, ptr %statePtr
+    store %Stack %stack, ptr %stackPtr
+    store %Pos ${value}, ptr %valuePtr
+    call void @erasePositive(%Pos ${signal})
+    ret void
+  wait:
+    %otherStack = load %Stack, ptr %stackPtr
+    %otherValue = load %Pos, ptr %valuePtr
+    store i64 3, ptr %statePtr
+    call void @erasePositive(%Pos ${signal})
+    call void @resume_Pos(%Stack %otherStack, %Pos ${value})
+    call void @resume_Pos(%Stack %stack, %Pos %otherValue)
+    ret void
+  panic:
+    call void @exit(i64 1)
+    ret void
+  """
+

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()
         }
       }