@effekt-lang/effekt 0.46.0 → 0.48.0

package/libraries/common/io/filesystem.effekt

@@ -71,6 +71,77 @@ def appendFile(path: String, contents: String): Unit / Exception[IOError] = {
   go()
 }
 
+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 writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[IOError] = {
+
+  val file = openForWriting(path);
+  with on[IOError].finalize { close(file) }
+
+  val chunkSize = 1048576 // 1MB
+  val buffer = bytearray::allocate(chunkSize)
+  var offset = 0
+
+  def push(i: Int, n: Int): Unit = {
+    val r = write(file, buffer, i, n, -1)
+    if (r < n) {
+      push(i + r, n - r)
+    }
+  }
+
+  try {
+    val r = stream()
+    push(0, offset)
+    return r
+  } with emit[Byte] { (byte) =>
+    if (offset >= buffer.size) {
+      push(0, buffer.size)
+      offset = 0
+    }
+    buffer.unsafeSet(offset, byte)
+    offset = offset + 1
+    resume(())
+  }
+}
+
+def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IOError] = {
+
+  val file = openForReading(path);
+  with on[IOError].finalize { close(file) }
+
+  val chunkSize = 1048576 // 1MB
+  val buffer = bytearray::allocate(chunkSize)
+  var offset = 0
+  var length = 0
+
+  def pull(): Unit / stop = {
+    read(file, buffer, 0, chunkSize, -1) match {
+      case 0 =>
+        do stop()
+      case n =>
+        length = n
+    }
+  }
+
+  try {
+    reader()
+  } with read[Byte] {
+    resume {
+      if (offset >= length) {
+        pull()
+        offset = 0
+      }
+      val byte = buffer.unsafeGet(offset)
+      offset = offset + 1
+      return byte
+    }
+  }
+}
+
 /// An abstract interface applications can program against.
 ///
 /// Can be interpreted with the `filesystem` handler, or virtualized etc.
@@ -171,64 +242,55 @@ namespace internal {
     declare void @c_fs_mkdir(%Pos, %Stack)
   """
 
-  extern async def openForReading(path: String): Int =
+  extern def openForReading(path: String) at async: Int =
     jsNode "$effekt.capture(callback => open(${path}, 'r', callback))"
     llvm """
       call void @c_fs_open_reading(%Pos ${path}, %Stack %stack)
       ret void
     """
 
-  extern async def openForWriting(path: String): Int =
+  extern def openForWriting(path: String) at async: Int =
     jsNode "$effekt.capture(callback => open(${path}, 'w', callback))"
     llvm """
       call void @c_fs_open_writing(%Pos ${path}, %Stack %stack)
       ret void
     """
 
-  extern async def openForAppending(path: String): Int =
+  extern def openForAppending(path: String) at async: Int =
     jsNode "$effekt.capture(callback => open(${path}, 'a', callback))"
     llvm """
       call void @c_fs_open_appending(%Pos ${path}, %Stack %stack)
       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 =
+  extern def read(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int) at async: Int =
     jsNode "$effekt.capture(callback => read(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
       call void @c_fs_read(%Int ${file}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Int ${position}, %Stack %stack)
       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 =
+  extern def write(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int) at async: Int =
     jsNode "$effekt.capture(callback => write(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
       call void @c_fs_write(%Int ${file}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Int ${position}, %Stack %stack)
       ret void
     """
 
-  extern async def close(file: Int): Int =
+  extern def close(file: Int) at async: Int =
     jsNode "$effekt.capture(callback => close(${file}, callback))"
     llvm """
       call void @c_fs_close(%Int ${file}, %Stack %stack)
       ret void
     """
 
-  extern async def mkdir(path: String): Int =
+  extern def mkdir(path: String) at async: Int =
     jsNode "$effekt.capture(callback => mkdir(${path}, callback))"
     llvm """
       call void @c_fs_mkdir(%Pos ${path}, %Stack %stack)
       ret void
     """
 
-  def checkResult(result: Int): Int / Exception[IOError] =
-    if (result < 0) {
-      val ioError = fromNumber(internal::errorNumber(result));
-      do raise[IOError](ioError, message(ioError))
-    } else {
-      result
-    }
 }
 
 namespace examples {

package/libraries/common/io/network.effekt

@@ -1,84 +1,116 @@
 module io/network
 
+import stream
 import bytearray
-import io
 
-namespace js {
-  extern jsNode """
-    const net = require('node:net');
+import io/error
 
-    function listen(server, port, host, listener) {
-      server.listen(port, host);
-      server.on('connection', listener);
-    }
-  """
 
-  extern type JSServer // = net.Server
-  extern type JSSocket // = net.Socket
-  extern io def server(): JSServer =
-    jsNode "net.createServer()"
-  extern io def listen(server: JSServer, port: Int, host: String, listener: JSSocket => Unit at {io, async, global}): Unit =
-    jsNode "listen(${server}, ${port}, ${host}, (socket) => $effekt.runToplevel((ks, k) => (${listener})(socket, ks, k)))"
+/// A TCP handle. Should not be inspected.
+type Connection = Int
 
-  extern async def send(socket: JSSocket, data: ByteArray): Unit =
-    jsNode "$effekt.capture(callback => ${socket}.write(${data}, callback))"
+/// Reads data from a TCP connection into a buffer at the given offset.
+def read(handle: Connection, buffer: ByteArray, offset: Int, size: Int): Int / Exception[IOError] =
+  internal::checkResult(internal::read(handle, buffer, offset, size))
 
-  extern async def receive(socket: JSSocket): ByteArray =
-    jsNode "$effekt.capture(callback => ${socket}.once('data', callback))"
-
-  extern async def end(socket: JSSocket): Unit =
-    jsNode "$effekt.capture(k => ${socket}.end(k))"
-}
+/// Writes data from a buffer at the given offset to a TCP connection.
+def write(handle: Connection, buffer: ByteArray, offset: Int, size: Int): Int / Exception[IOError] =
+  internal::checkResult(internal::write(handle, buffer, offset, size))
 
-interface Socket {
-  def send(message: ByteArray): Unit
-  def receive(): ByteArray
-  def end(): Unit
-}
-
-def server(host: String, port: Int, handler: () => Unit / Socket at {io, async, global}): Unit = {
-  val server = js::server();
-  js::listen(server, port, host, box { socket =>
-    println("New connection")
-    spawn(box {
-      try handler()
-      with Socket {
-        def send(message) =
-          resume(js::send(socket, message))
-        def receive() =
-          resume(js::receive(socket))
-        def end() =
-          resume(js::end(socket))
-      }
-    })
-  })
-}
+/// Establishes a TCP connection to the specified host and port.
+def connect(host: String, port: Int): Connection / Exception[IOError] =
+  internal::checkResult(internal::connect(host, port))
 
+/// Closes a TCP connection and releases associated resources.
+def close(handle: Connection): Unit =
+  internal::close(handle)
 
-namespace examples {
-  def helloWorldApp(): Unit / Socket = {
-    val request = do receive().toString;
+/// A TCP listener. Should not be inspected.
+type Listener = Int
 
-    println("Received a request: " ++ request)
+/// Creates a TCP listener bound to the specified host and port.
+def bind(host: String, port: Int): Listener / Exception[IOError] =
+  internal::checkResult(internal::bind(host, port))
 
-    def respond(s: String): Unit / Socket =
-      do send(s.fromString)
+/// Starts listening for incoming connections and handles them with the provided handler function.
+/// Runs until `shutdown` is called on this `Listener`.
+def listen(listener: Listener, handler: Connection => Unit at {io, async, global}): Unit / Exception[IOError] = {
+  internal::checkResult(internal::listen(listener, handler)); ()
+}
 
-    if (request.startsWith("GET /")) {
-      respond("HTTP/1.1 200 OK\r\n\r\nHello from Effekt!")
-    } else {
-      respond("HTTP/1.1 400 Bad Request\r\n\r\n")
+/// Stops a TCP listener and releases associated resources.
+def shutdown(listener: Listener): Unit =
+  internal::shutdown(listener)
+
+
+def streaming[R](connection: Connection) { program: () => R / {read[ByteArray], emit[ByteArray]} }: R / Exception[IOError] =
+  try {
+    program()
+  } with emit[ByteArray] { bytes =>
+    write(connection, bytes, 0, bytes.size)
+    resume(())
+  } with read[ByteArray] { () =>
+    val bytes = bytearray::allocate(4096)
+    read(connection, bytes, 0, bytes.size) match {
+      case r and r == bytes.size => resume { return bytes }
+      case r => resume { bytes.resize(r) }
     }
-    do end()
   }
 
-  // A server that just shows "Hello from Effekt!" on localhost:8080
-  def main() = {
-    val port = 8080
-    println("Starting server on http://localhost:" ++ port.show)
+namespace internal {
+
+  extern llvm """
+    declare void @c_tcp_connect(%Pos, %Int, %Stack)
+    declare void @c_tcp_read(%Int, %Pos, %Int, %Int, %Stack)
+    declare void @c_tcp_write(%Int, %Pos, %Int, %Int, %Stack)
+    declare void @c_tcp_close(%Int, %Stack)
+    declare void @c_tcp_bind(%Pos, %Int, %Int, %Stack)
+    declare void @c_tcp_listen(%Int, %Pos, %Stack)
+    declare void @c_tcp_shutdown(%Int, %Stack)
+  """
+
+  extern def connect(host: String, port: Int) at async: Int =
+    llvm """
+      call void @c_tcp_connect(%Pos ${host}, %Int ${port}, %Stack %stack)
+      ret void
+    """
+
+  extern def read(handle: Int, buffer: ByteArray, offset: Int, size: Int) at async: Int =
+    llvm """
+      call void @c_tcp_read(%Int ${handle}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Stack %stack)
+      ret void
+    """
+
+  extern def write(handle: Int, buffer: ByteArray, offset: Int, size: Int) at async: Int =
+    llvm """
+      call void @c_tcp_write(%Int ${handle}, %Pos ${buffer}, %Int ${offset}, %Int ${size}, %Stack %stack)
+      ret void
+    """
+
+  extern def close(handle: Int) at async: Unit =
+    llvm """
+      call void @c_tcp_close(%Int ${handle}, %Stack %stack)
+      ret void
+    """
+
+  extern def bind(host: String, port: Int) at io: Int =
+    llvm """
+      %result = call %Int @c_tcp_bind(%Pos ${host}, %Int ${port})
+      ret %Int %result
+    """
+
+  extern def listen(listener: Int, handler: Int => Unit at {io, async, global}) at async: Int =
+    llvm """
+      call void @c_tcp_listen(%Int ${listener}, %Pos ${handler}, %Stack %stack)
+      ret void
+    """
+
+  extern def shutdown(handle: Int) at async: Unit =
+    llvm """
+      call void @c_tcp_shutdown(%Int ${handle}, %Stack %stack)
+      ret void
+    """
 
-    server("localhost", port, box {
-      helloWorldApp()
-    })
-  }
 }
+
+

package/libraries/common/io/time.effekt

@@ -4,7 +4,7 @@ extern llvm """
   declare void @c_timer_start(%Int, %Stack)
 """
 
-extern async def wait(millis: Int): Unit =
+extern def wait(millis: Int) at async: Unit =
   js "$effekt.capture(k => setTimeout(() => k($effekt.unit), ${millis}))"
   llvm """
     call void @c_timer_start(%Int ${millis}, %Stack %stack)

package/libraries/common/io.effekt

@@ -12,23 +12,22 @@ extern llvm """
   declare void @c_yield(%Stack)
 """
 
-extern async def spawn(task: Task[Unit]): Unit =
+extern def spawn(task: Task[Unit]) at async: Unit =
   js "$effekt.capture(k => { setTimeout(() => k($effekt.unit), 0); return $effekt.run(${task}) })"
   llvm """
     call void @c_yield(%Stack %stack)
-    %unboxed = call ccc %Neg @coercePosNeg(%Pos ${task})
-    call void @run(%Neg %unboxed)
+    call void @run(%Pos ${task})
     ret void
   """
 
-extern async def yield(): Unit =
+extern def yield() at async: Unit =
   js "$effekt.capture(k => setTimeout(() => k($effekt.unit), 0))"
   llvm """
     call void @c_yield(%Stack %stack)
     ret void
   """
 
-extern async def abort(): Nothing =
+extern def abort() at async: Nothing =
   js "$effekt.capture(k => undefined)"
   llvm """
     call void @eraseStack(%Stack %stack)
@@ -55,14 +54,14 @@ extern llvm """
   declare void @c_promise_await(%Pos, %Neg)
 """
 
-extern async def await[T](promise: Promise[T]): T =
+extern def await[T](promise: Promise[T]) at async: T =
   js "$effekt.capture(k => ${promise}.promise.then(k))"
   llvm """
     call void @c_promise_await(%Pos ${promise}, %Stack %stack)
     ret void
   """
 
-extern async def resolve[T](promise: Promise[T], value: T): Unit =
+extern def resolve[T](promise: Promise[T], value: T) at async: Unit =
   js "$effekt.capture(k => { ${promise}.resolve(${value}); return k($effekt.unit) })"
   llvm """
     call void @c_promise_resolve(%Pos ${promise}, %Pos ${value}, %Stack %stack)
@@ -80,7 +79,7 @@ namespace promise {
     }
   """
 
-  extern io def make[T](): Promise[T] =
+  extern def make[T]() at io: Promise[T] =
     js "promise$make()"
     llvm """
       %promise = call %Pos @c_promise_make()

package/libraries/common/json.effekt

@@ -165,7 +165,7 @@ def decodeJson(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} = {
       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 string(collect { readQuotedString() })
       case '{' => do dict{ decodeJsonObject() }
       case '[' => do list{ decodeJsonList() }
       case _ => println("Unexpected " ++ c.toString); <>
@@ -179,7 +179,7 @@ def decodeJsonObject(): Unit / {Scan[Char], JsonObjectBuilder, Exception[WrongFo
   skipWhitespace()
   while(do peek[Char]() is c and (c != '}')) {
     if (not(first)) { expectString(",") }
-    val k: String = collectString { readQuotedString() }
+    val k = string::collect { readQuotedString() }
     skipWhitespace()
     expectString(":")
     do field(k){
@@ -277,7 +277,7 @@ def build[R](){ body: => R / JsonBuilder }: (R, JsonValue) = {
   }
   (x, r)
 }
-def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = returning::collectList[JsonValue, R] {
+def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = list::returning::collect[JsonValue, R] {
   try body() with JsonBuilder {
     def number(n) = { do emit(Number(n)); resume(()) }
     def bool(b) = { do emit(Bool(b)); resume(()) }
@@ -295,7 +295,7 @@ def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = returning
     }
   }
 }
-def buildDict[R](){ body: => R / JsonObjectBuilder }: (R, List[(String, JsonValue)]) = returning::collectList[(String, JsonValue), R] {
+def buildDict[R](){ body: => R / JsonObjectBuilder }: (R, List[(String, JsonValue)]) = list::returning::collect[(String, JsonValue), R] {
   try body() with JsonObjectBuilder {
     def field(k) = resume { {v} =>
       val x = build{v}
@@ -315,7 +315,7 @@ namespace test {
     // Read quoted string
     feed("\"\ta\n\ra\"") {
       with scanner[Char]
-      println(collectString { readQuotedString() })
+      println(string::collect { readQuotedString() })
     }
 
     println("")

package/libraries/common/list.effekt

@@ -3,6 +3,7 @@ module list
 import effekt
 import option
 import exception
+import stream
 
 /// Immutable linked list for finite sequences of elements.
 type List[A] {
@@ -167,9 +168,52 @@ def foreachIndex[A](list: List[A]){ f: (Int, A) {Control} => Unit }: Unit = {
 /// Map a function `f` over elements in a given list.
 ///
 /// O(N)
-def map[A, B](l: List[A]) { f: A => B } : List[B] = {
-  var acc = Nil[B]()
-  l.foreach { el => acc = Cons(f(el), acc) }
+def map[A, B](l: List[A]) { f: A => B }: List[B] = {
+  var acc: List[B] = Nil()
+  l.foreach { el =>
+    acc = Cons(f(el), acc)
+  }
+  acc.reverse
+}
+
+/// Map a function `f` over elements and their indices in a given list.
+///
+/// O(N)
+def mapWithIndex[A, B](l: List[A]) { f: (Int, A) => B }: List[B] = {
+  var acc: List[B] = Nil()
+  l.foreachIndex { (i, el) =>
+    acc = Cons(f(i, el), acc)
+  }
+  acc.reverse
+}
+
+/// Map a function `f` over elements in a given list,
+/// keeping only the elements for which the function returned `true`,
+/// discarding the elements for which the function returned `false`.
+///
+/// O(N)
+def filter[A](l: List[A]) { shouldKeep: A => Bool }: List[A] = {
+  var acc: List[A] = Nil()
+  l.foreach { a =>
+    if (shouldKeep(a)) {
+      acc = Cons(a, acc)
+    }
+  }
+  acc.reverse
+}
+
+/// Map a function `f` over elements and their indices in a given list,
+/// keeping only the elements for which the function returned `true`,
+/// discarding the elements for which the function returned `false`.
+///
+/// O(N)
+def filterWithIndex[A](l: List[A]) { shouldKeep: (Int, A) => Bool }: List[A] = {
+  var acc: List[A] = Nil()
+  l.foreachIndex { (i, a) =>
+    if (shouldKeep(i, a)) {
+      acc = Cons(a, acc)
+    }
+  }
   acc.reverse
 }
 
@@ -178,13 +222,28 @@ def map[A, B](l: List[A]) { f: A => B } : List[B] = {
 /// discarding the elements for which the function returned `None()`.
 ///
 /// O(N)
-def collect[A, B](l: List[A]) { f : A => Option[B] }: List[B] = {
-  var acc = Nil[B]()
+def collectSome[A, B](l: List[A]) { f : A => Option[B] }: List[B] = {
+  var acc: List[B] = Nil()
   l.foreach { a =>
-    val optB = f(a)
-    optB match {
-      case None() => ();
-      case Some(b) => acc = Cons(b, acc);
+    f(a) match {
+      case None() => ()
+      case Some(b) => acc = Cons(b, acc)
+    }
+  }
+  acc.reverse
+}
+
+/// Map a function `f` over elements and their indices in a given list,
+/// keeping only the elements for which the function returned `Some(...)`,
+/// discarding the elements for which the function returned `None()`.
+///
+/// O(N)
+def collectWithIndex[A, B](l: List[A]) { f: (Int, A) => Option[B] }: List[B] = {
+  var acc: List[B] = Nil()
+  l.foreachIndex { (i, a) =>
+    f(i, a) match {
+      case None() => ()
+      case Some(b) => acc = Cons(b, acc)
     }
   }
   acc.reverse
@@ -205,21 +264,55 @@ def flatMap[A, B](l: List[A]) { f : A => List[B] }: List[B] = {
 /// Check if predicate is true for all elements of the given list.
 ///
 /// O(N)
-def all[A](list: List[A]) { predicate: A => Bool }: Bool = {
+def all[A](list: List[A]) { predicate: A => Bool }: Bool =
   list match {
     case Cons(x, xs) => predicate(x) && all(xs) { predicate }
     case Nil() => true
   }
-}
 
 /// Check if predicate is true for at least one element of the given list.
 ///
 /// O(N)
-def any[A](list: List[A]) { predicate: A => Bool }: Bool = {
+def any[A](list: List[A]) { predicate: A => Bool }: Bool =
   list match {
     case Cons(x, xs) => predicate(x) || any(xs) { predicate }
     case Nil() => false
   }
+
+/// Check if the list contains the given `element`,
+/// comparing for equality with the given `eq` function.
+///
+/// O(N)
+def contains[A](list: List[A], element: A) { eq: (A, A) => Bool }: Bool =
+  list.any { x => x.eq(element) }
+
+/// Find the first index of the given `element`,
+/// comparing for equality with the given `eq` function.
+///
+/// O(N)
+def indexOf[A](list: List[A], element: A) { eq: (A, A) => Bool }: Option[Int] = {
+  var result = None()
+  list.foreachIndex { (i, a) {label} =>
+    if (element.eq(a)) {
+      result = Some(i)
+      label.break()
+    }
+  }
+  result
+}
+
+/// Find the last index of the given `element`,
+/// comparing for equality with the given `eq` function.
+///
+/// O(N)
+def lastIndexOf[A](list: List[A], element: A) { eq: (A, A) => Bool }: Option[Int] = {
+  var result = None()
+  list.foreachIndex { (i, a) {label} =>
+    if (element.eq(a)) {
+      result = Some(i)
+    }
+  }
+  result
 }
 
 /// Count how many elements of a list satisfy the given predicate.
@@ -297,10 +390,11 @@ def reverse[A](l: List[A]): List[A] = {
 /// ```
 ///
 /// O(|l|)
-def reverseOnto[A](l: List[A], other: List[A]): List[A] = l match {
-  case Nil() => other
-  case Cons(a, rest) => rest.reverseOnto(Cons(a, other))
-}
+def reverseOnto[A](l: List[A], other: List[A]): List[A] =
+  l match {
+    case Nil() => other
+    case Cons(a, rest) => rest.reverseOnto(Cons(a, other))
+  }
 
 /// Concatenate list `l` with list `other`:
 ///
@@ -347,7 +441,7 @@ def join[A](lists: List[List[A]]): List[A] = {
 /// ```
 ///
 /// O(N)
-def join[A](lists: List[List[A]], between: List[A]): List[A] = {
+def join[A](lists: List[List[A]], between: List[A]): List[A] =
   lists match {
     case Nil() => Nil()
     case Cons(firstList, restOfLists) =>
@@ -355,7 +449,6 @@ def join[A](lists: List[List[A]], between: List[A]): List[A] = {
         restOfLists.flatMap { list => between.append(list)}
       )
   }
-}
 
 /// Take the first `n` elements of a given list.
 ///
@@ -836,3 +929,46 @@ def println(l: List[Int]): Unit = println(show(l))
 def println(l: List[Double]): Unit = println(show(l))
 def println(l: List[Bool]): Unit = println(show(l))
 def println(l: List[String]): Unit = println(show(l))
+
+
+// Streaming
+// ---------
+
+/// Turns a `list` into a producer of a push stream
+/// by emitting each contained value left-to-right.
+def each[A](list: List[A]): Unit / emit[A] =
+  list match {
+    case Nil() => ()
+    case Cons(head, tail) =>
+      do emit(head)
+      each(tail)
+  }
+
+def feed[T, R](list: List[T]) { reader: () => R / read[T] }: R = {
+  var l = list
+  try {
+    reader()
+  } with read[T] {
+    resume {
+      l match {
+        case Nil() => do stop()
+        case Cons(value, rest) =>
+          l = rest
+          return value
+      }
+    }
+  }
+}
+
+def collect[A] { stream: () => Unit / emit[A] }: List[A] =
+  returning::collect[A, Unit]{stream}.second
+
+namespace returning {
+  def collect[A, R] { stream: () => R / emit[A] }: (R, List[A]) =
+    try {
+      (stream(), Nil())
+    } with emit[A] { (v) =>
+      val (r, vs) = resume(());
+      (r, Cons(v, vs))
+    }
+}