@effekt-lang/effekt 0.62.0 → 0.64.0

package/libraries/common/io/env.effekt

@@ -0,0 +1,74 @@
+module io/env
+
+/// Retrieve the value of an environment variable, returning `None()` if not set.
+extern def getEnvironmentVariable(name: String) at io: Option[String] =
+  jsNode { js::getEnvironmentVariable(name) }
+  chez { chez::getEnvironmentVariable(name) }
+  llvm { llvm::getEnvironmentVariable(name) }
+
+/// Check whether an environment variable is set.
+extern def hasEnvironmentVariable(name: String) at io: Bool =
+  llvm { llvm::hasEnvironmentVariable(name) }
+  default { if (getEnvironmentVariable(name) is Some(_)) true else false }
+
+namespace js {
+  extern def rawGetEnv(name: String) at io: String =
+    jsNode "process.env[${name}]"
+
+  def getEnvironmentVariable(name: String): Option[String] =
+    rawGetEnv(name).undefinedToOption
+}
+
+namespace chez {
+  extern def rawGetEnv(name: String) at io: String =
+    chez "(getenv ${name})"
+
+  def getEnvironmentVariable(name: String): Option[String] =
+    rawGetEnv(name).undefinedToOption  // Chez: getenv returns #f when not found
+}
+
+namespace llvm {
+  extern llvm """
+    declare %Int @c_getenv_size(%Pos)
+    declare %Pos @c_getenv_value(%Pos, %Int)
+  """
+
+  extern def getEnvSize(name: String) at io: Int =
+    llvm """
+      %size = call %Int @c_getenv_size(%Pos ${name})
+      ret %Int %size
+    """
+
+  extern def getEnvValue(name: String, size: Int) at io: String =
+    llvm """
+      %val = call %Pos @c_getenv_value(%Pos ${name}, %Int ${size})
+      ret %Pos %val
+    """
+
+  def getEnvironmentVariable(name: String): Option[String] = {
+    val size = getEnvSize(name)
+    if (size >= 0) Some(getEnvValue(name, size))
+    else None()
+  }
+
+  def hasEnvironmentVariable(name: String): Bool =
+    getEnvSize(name) >= 0
+}
+
+namespace examples {
+  def main() = {
+    val path = getEnvironmentVariable("PATH")
+    println(path.isDefined) // should be defined on all platforms
+
+    val doesNotExist = getEnvironmentVariable("THIS_ENV_VAR_OUGHT_NOT_EXIST__WOW__EFFEKT_IS_AWESOME")
+    println(doesNotExist.show) // should not be defined
+  }
+
+  def _unused_other() = {
+    val h = getEnvironmentVariable("HOME")
+    h match {
+      case Some(value) => println(s"HOME is set to: ${value}")
+      case None() => println("HOME is not set")
+    }
+  }
+}

package/libraries/common/io/network.effekt

@@ -42,7 +42,6 @@ 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] =
   try {
     program()
@@ -59,58 +58,148 @@ def streaming[R](connection: Connection) { program: () => R / {read[ByteArray],
 
 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)
+  // TODO: also in `io/filesystem`, perhaps we want this in a common place?
+  extern js """
+    function toBuffer(buffer) {
+      return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+  """
+
+  extern jsNode """
+    const net = require('net');
+
+    const tcp$handles = new Map();
+    let   tcp$next    = 1;
+    function tcp$alloc(entry) { const h = tcp$next++; tcp$handles.set(h, entry); return h; }
+    function tcp$free(h)      { tcp$handles.delete(h); }
+
+    function tcp$connect(host, port, callback) {
+      const socket = net.createConnection({ host, port });
+      socket.once('connect', () => { socket.pause(); callback(tcp$alloc({ socket })); });
+      socket.once('error',   err => callback(-(err.errno || 1)));
+    }
+
+    function tcp$read(handle, buffer, offset, size, callback) {
+      const { socket } = tcp$handles.get(handle);
+      function cleanup() {
+        socket.removeListener('readable', onReadable);
+        socket.removeListener('end',      onEnd);
+        socket.removeListener('error',    onError);
+      }
+      function onReadable() { cleanup(); tryRead(); }
+      function onEnd()      { cleanup(); callback(0); }
+      function onError(err) { cleanup(); callback(-(err.errno || 1)); }
+      function tryRead() {
+        const chunk = socket.read(size);
+        if (chunk !== null) { chunk.copy(toBuffer(buffer), offset); callback(chunk.length); return; }
+        if (socket.readableEnded) { callback(0); return; }
+        socket.once('readable', onReadable);
+        socket.once('end',      onEnd);
+        socket.once('error',    onError);
+      }
+      tryRead();
+    }
+
+    function tcp$write(handle, buffer, offset, size, callback) {
+      const { socket } = tcp$handles.get(handle);
+      socket.write(toBuffer(buffer).slice(offset, offset + size), err => {
+        if (err) callback(-(err.errno || 1)); else callback(size);
+      });
+    }
+
+    function tcp$close(handle, callback) {
+      const entry = tcp$handles.get(handle);
+      if (!entry || !entry.socket) { callback($effekt.unit); return; }
+      tcp$free(handle);
+      const { socket } = entry;
+      if (socket.destroyed) { callback($effekt.unit); return; }
+      socket.once('error', _err => {});
+      socket.end(() => { socket.destroy(); callback($effekt.unit); });
+    }
+
+    function tcp$bind(host, port) {
+      return tcp$alloc({ server: net.createServer(), host, port });
+    }
+
+    function tcp$listen(listenerHandle, handler, callback) {
+      const { server, host, port } = tcp$handles.get(listenerHandle);
+      server.once('error', err => callback(-(err.errno || 1)));
+      server.listen(port, host, () => {
+        server.removeAllListeners('error');
+        server.on('error', _err => {});
+        server.on('connection', socket => {
+          socket.pause();
+          const connHandle = tcp$alloc({ socket });
+          $effekt.runToplevel((ks, k) => handler(connHandle, ks, k));
+        });
+        callback(0);
+      });
+    }
+
+    function tcp$shutdown(listenerHandle, callback) {
+      const entry = tcp$handles.get(listenerHandle);
+      if (!entry || !entry.server) { callback($effekt.unit); return; }
+      tcp$free(listenerHandle);
+      entry.server.close(() => callback($effekt.unit));
+    }
   """
 
   extern def connect(host: String, port: Int) at async: Int =
+    jsNode "$effekt.capture(k => tcp$connect(${host}, ${port}, k))"
     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 =
+    jsNode "$effekt.capture(k => tcp$read(${handle}, ${buffer}, ${offset}, ${size}, k))"
     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 =
+    jsNode "$effekt.capture(k => tcp$write(${handle}, ${buffer}, ${offset}, ${size}, k))"
     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 =
+    jsNode "$effekt.capture(k => tcp$close(${handle}, k))"
     llvm """
       call void @c_tcp_close(%Int ${handle}, %Stack %stack)
       ret void
     """
 
   extern def bind(host: String, port: Int) at io: Int =
+    jsNode "tcp$bind(${host}, ${port})"
     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 =
+  extern def listen(listener: Int, handler: Connection => Unit at {io, async, global}) at async: Int =
+    jsNode "$effekt.capture(k => tcp$listen(${listener}, ${handler}, k))"
     llvm """
       call void @c_tcp_listen(%Int ${listener}, %Pos ${handler}, %Stack %stack)
       ret void
     """
 
   extern def shutdown(handle: Int) at async: Unit =
+    jsNode "$effekt.capture(k => tcp$shutdown(${handle}, k))"
     llvm """
       call void @c_tcp_shutdown(%Int ${handle}, %Stack %stack)
       ret void
     """
 
+  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 %Int @c_tcp_bind(%Pos, %Int)
+    declare void @c_tcp_listen(%Int, %Pos, %Stack)
+    declare void @c_tcp_shutdown(%Int, %Stack)
+  """
 }
-
-

package/libraries/common/json.effekt

@@ -95,10 +95,10 @@ def readDouble(): Double / { Scan[Char], Exception[WrongFormat]} = {
   def exponent(pre: Double): Double / fail = {
     try {
       if(do peek() == 'e' || do peek() == 'E') {
-        do skip[Char]()
+        skip[Char]()
         val e = do peek[Char]() match {
-          case '+' => do skip[Char](); readDecimal()
-          case '-' => do skip[Char](); neg(readDecimal())
+          case '+' => skip[Char](); readDecimal()
+          case '-' => skip[Char](); neg(readDecimal())
           case _ => readDecimal()
         }
         pre * pow(10.0, e)
@@ -133,9 +133,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 { read[Char]() } is c and c != '"') {
+  while(must { do read[Char]() } is c and c != '"') {
     c match {
-      case '\\' => must { read[Char]() } match {
+      case '\\' => must { do read[Char]() } match {
         case '"' => do emit('\"')
         case '\\' => do emit('\\')
         case '/' => do emit('/')
@@ -184,7 +184,7 @@ def decodeJsonObject(): Unit / {Scan[Char], JsonObjectBuilder, Exception[WrongFo
     skipWhitespace()
     first = false
   }
-  must { do skip() }
+  must { skip() }
 }
 def decodeJsonList(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} = {
   var first = true
@@ -197,7 +197,7 @@ def decodeJsonList(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} =
     skipWhitespace()
     first = false
   }
-  must { do skip() }
+  must { skip() }
 }
 
 // --------------------------------------------------------------------------------

package/libraries/common/list.effekt

@@ -962,6 +962,7 @@ 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 = {
   var l = list
   try {
@@ -978,10 +979,14 @@ def feed[T, R](list: List[T]) { reader: () => R / read[T] }: R = {
   }
 }
 
+/// Collects elements emitted by a push stream producer `stream` into a new list,
+/// discarding the result of the producer.
 def collect[A] { stream: () => Unit / emit[A] }: List[A] =
   returning::collect[A, Unit]{stream}.second
 
 namespace returning {
+  /// Collects elements emitted by a push stream producer `stream` into a new list,
+  /// returning the result of the producer as well as the collected list.
   def collect[A, R] { stream: () => R / emit[A] }: (R, List[A]) =
     try {
       (stream(), Nil())

package/libraries/common/map.effekt

@@ -1012,10 +1012,14 @@ def eachKey[K, V](map: Map[K, V]): Unit / emit[K] =
 def eachValue[K, V](map: Map[K, V]): Unit / emit[V] =
   map.foreach { (_k, v) => do emit(v) }
 
+/// Collects `(key, value)` pairs from a push stream producer `stream` into a new `map`
+/// using the provided `compare` function, discarding the result of the producer.
 def collect[K, V](compare: (K, K) => Ordering at {}) { stream: () => Unit / emit[(K, V)] }: Map[K, V] =
   returning::collect[K, V, Unit](compare){stream}.second
 
 namespace returning {
+  /// Collects `(key, value)` pairs from a push stream producer `stream` into a new `map`,
+  /// using the provided `compare` function, returning the result of the producer as well as the collected map.
   def collect[K, V, R](compare: (K, K) => Ordering at {}) { stream: () => R / emit[(K, V)] }: (R, Map[K, V]) =
     try {
       (stream(), empty(compare))

package/libraries/common/partial.effekt

@@ -13,6 +13,13 @@ def attempt[R] { program: () => R / fail } { fallback: () => R }: R =
     fallback()
   }
 
+def onFail[R] { fallback: () => R } { program: () => R / fail }: R =
+  try {
+    program()
+  } with fail {
+    fallback()
+  }
+
 def succeeds { program: () => Unit / fail }: Bool =
   try { program(); true } with fail { false }
 

package/libraries/common/resizable_array.effekt

@@ -3,6 +3,7 @@ module resizable_array
 import ref
 import array
 
+/// A resizable array, implemented as a wrapper around a mutable array and a size field.
 record ResizableArray[T](rawSizePtr: Ref[Int], rawContentPtr: Ref[Array[T]])
 
 // These numbers should be optimized based on benchmarking
@@ -20,11 +21,10 @@ val shrinkThreshold = 0.4
 def size[T](arr: ResizableArray[T]) = arr.rawSizePtr.get
 
 /// Allocate a new, empty dynamic array with given initial capacity
-def resizableArray[T](capacity: Int): ResizableArray[T] = {
+def resizableArray[T](capacity: Int): ResizableArray[T] =
   ResizableArray(ref(0), ref(unsafeAllocate(capacity)))
-}
 
-/// Aallocate a new, empty dynamic array
+/// Allocate a new, empty dynamic array
 def resizableArray[T](): ResizableArray[T] = resizableArray(8)
 
 
@@ -35,7 +35,7 @@ def boundsCheck[T](arr: ResizableArray[T], index: Int): Unit / Exception[OutOfBo
   }
 
 
-/// get the element at position index in the array
+/// Get the element at position `index` in the resizable array `arr`
 ///
 /// O(1)
 def get[T](arr: ResizableArray[T], index: Int): T / Exception[OutOfBounds] = {
@@ -43,7 +43,7 @@ def get[T](arr: ResizableArray[T], index: Int): T / Exception[OutOfBounds] = {
   arr.rawContentPtr.get.get(index)
 }
 
-/// set the element at position index in the array
+/// Set the element at position `index` in the resizable array `arr` to `value`
 ///
 /// O(1)
 def set[T](arr: ResizableArray[T], index: Int, value: T): Unit / Exception[OutOfBounds] = {
@@ -51,7 +51,7 @@ def set[T](arr: ResizableArray[T], index: Int, value: T): Unit / Exception[OutOf
   arr.rawContentPtr.get.set(index, value)
 }
 
-/// swap the elements at the given positions in the array
+/// Swap the elements at the given positions in the resizable array `arr`
 ///
 /// O(1)
 def swap[T](arr: ResizableArray[T], index1: Int, index2: Int): Unit / Exception[OutOfBounds] = {
@@ -71,7 +71,7 @@ def setCapacity[T](arr: ResizableArray[T], capacity: Int): Unit / Exception[OutO
     do raise(OutOfBounds(), "Cannot change capacity of ResizableArray to " ++ capacity.show ++ " below size " ++ arr.size.show)
   }
   val oldRaw = arr.rawContentPtr.get
-  if (oldRaw.size != capacity) { 
+  if (oldRaw.size != capacity) {
     val newRaw = array::unsafeAllocate(capacity)
     oldRaw.copy(0, newRaw, 0, arr.size)
     arr.rawContentPtr.set(newRaw)
@@ -82,13 +82,13 @@ def setCapacity[T](arr: ResizableArray[T], capacity: Int): Unit / Exception[OutO
 ///
 /// O(n)
 def maybeShrink[T](arr: ResizableArray[T]): Unit / Exception[OutOfBounds] = {
-  if(arr.size.toDouble < arr.rawContentPtr.get.size.toDouble * shrinkThreshold) {
+  if (arr.size.toDouble < arr.rawContentPtr.get.size.toDouble * shrinkThreshold) {
     val newCap = max(arr.size, (arr.rawContentPtr.get.size.toDouble / growFactor).ceil)
     arr.setCapacity(newCap)
   }
 }
 
-/// makes sure capacity is at least the given one
+/// Makes sure capacity is at least the given one
 ///
 /// O(given capacity - current capacity) amortized, O(n) worst case // TODO ?
 def ensureCapacity[T](arr: ResizableArray[T], capacity: Int): Unit / Exception[OutOfBounds] = {
@@ -140,62 +140,123 @@ def popRight[T](arr: ResizableArray[T]): T / Exception[OutOfBounds] = {
 }
 
 
-def foreachIndex[T](arr: ResizableArray[T]){ body: (Int, T) => Unit }: Unit = {
+/// Traverse the resizable array `arr`, applying the given action on every element.
+def foreach[T](arr: ResizableArray[T]){ action: T => Unit }: Unit =
   each(0, arr.size) { i =>
-    body(i, arr.rawContentPtr.get.get(i))
+    action(arr.rawContentPtr.get.get(i))
   }
-}
-def foreachIndex[T](arr: ResizableArray[T]){ body: (Int, T) {Label} => Unit }: Unit = {
+
+/// Traverse the resizable array `arr`, applying the given action on every element,
+/// providing a `label` for `break`/`continue`.
+def foreach[T](arr: ResizableArray[T]){ action: (T) {Label} => Unit }: Unit =
   each(0, arr.size) { (i){label} =>
-    body(i, arr.rawContentPtr.get.get(i)){label}
+    action(arr.rawContentPtr.get.get(i)){label}
   }
-}
-def foreach[T](arr: ResizableArray[T]){ body: T => Unit }: Unit = {
+
+/// Traverse the resizable array `arr`, applying the given action on every element and its (zero-based) index.
+def foreachIndex[T](arr: ResizableArray[T]){ action: (Int, T) => Unit }: Unit =
   each(0, arr.size) { i =>
-    body(arr.rawContentPtr.get.get(i))
+    action(i, arr.rawContentPtr.get.get(i))
   }
-}
-def foreach[T](arr: ResizableArray[T]){ body: (T) {Label} => Unit }: Unit = {
+
+/// Traverse the resizable array `arr`, applying the given action on every element and its (zero-based) index,
+/// providing a `label` for `break`/`continue`.
+def foreachIndex[T](arr: ResizableArray[T]){ action: (Int, T) {Label} => Unit }: Unit =
   each(0, arr.size) { (i){label} =>
-    body(arr.rawContentPtr.get.get(i)){label}
+    action(i, arr.rawContentPtr.get.get(i)){label}
   }
-}
-def foreachIndexReversed[T](arr: ResizableArray[T]){ body: (Int, T){Label} => Unit }: Unit = {
+
+/// Traverse the resizable array `arr` in reverse order, applying the given action on every element.
+def foreachReversed[T](arr: ResizableArray[T]){ action: T => Unit }: Unit =
+  var i = arr.size - 1
+  while (i >= 0) {
+    action(arr.rawContentPtr.get.get(i))
+    i = i - 1
+  }
+
+/// Traverse the resizable array `arr` in reverse order, applying the given action on every element,
+/// providing a `label` for `break`/`continue`.
+def foreachReversed[T](arr: ResizableArray[T]){ action: (T) {Label} => Unit }: Unit =
   var i = arr.size - 1
   loop { {l} =>
     if (i < 0) { l.break() }
-    body(i, arr.rawContentPtr.get.get(i)){l}
+    action(arr.rawContentPtr.get.get(i)){l}
     i = i - 1
   }
-}
-def foreachIndexReversed[T](arr: ResizableArray[T]){ body: (Int, T) => Unit }: Unit = {
+
+/// Traverse the resizable array `arr` in reverse order, applying the given action on every element and its (zero-based) index.
+def foreachIndexReversed[T](arr: ResizableArray[T]){ action: (Int, T) => Unit }: Unit =
   var i = arr.size - 1
   while(i >= 0) {
-    body(i, arr.rawContentPtr.get.get(i))
+    action(i, arr.rawContentPtr.get.get(i))
     i = i - 1
   }
-}
-def foreachReversed[T](arr: ResizableArray[T]){ body: (T){Label} => Unit }: Unit = {
+
+/// Traverse the resizable array `arr` in reverse order, applying the given action on every element and its (zero-based) index,
+/// providing a `label` for `break`/`continue`.
+def foreachIndexReversed[T](arr: ResizableArray[T]){ action: (Int, T) {Label} => Unit }: Unit =
   var i = arr.size - 1
   loop { {l} =>
     if (i < 0) { l.break() }
-    body(arr.rawContentPtr.get.get(i)){l}
+    action(i, arr.rawContentPtr.get.get(i)){l}
     i = i - 1
   }
-}
-def foreachReversed[T](arr: ResizableArray[T]){ body: T => Unit }: Unit = {
-  var i = arr.size - 1
-  while (i >= 0) { 
-    body(arr.rawContentPtr.get.get(i))
-    i = i - 1
-  }
-}
 
+
+/// Create a new list from a given resizable array `arr`.
 def toList[T](arr: ResizableArray[T]): List[T] = {
   def go(i: Int, acc: List[T]): List[T] = {
-    if (i < 0) { acc } else {
+    if (i < 0) {
+      acc
+    } else {
       go(i - 1, Cons(arr.rawContentPtr.get.get(i), acc))
     }
   }
+
   go(arr.size - 1, Nil())
+}
+
+
+/// Turns `arr` into a producer of a push stream
+/// by emitting each contained value from 0 to length - 1.
+def each[T](arr: ResizableArray[T]): Unit / emit[T] =
+  each(0, arr.size) { i =>
+    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 = {
+  var i = 0
+  try {
+    reader()
+  } with read[T] {
+    resume {
+      if (i < arr.size) {
+        val v = arr.rawContentPtr.get.get(i)
+        i = i + 1
+        v
+      } else {
+        do stop()
+      }
+    }
+  }
+}
+
+/// Collects elements emitted by a push stream producer `stream` into a new resizable array,
+/// discarding the result of the producer.
+def collect[T] { stream: () => Unit / emit[T] }: ResizableArray[T] =
+  returning::collect[T, Unit]{stream}.second
+
+namespace returning {
+  /// Collects elements emitted by a push stream producer `stream` into a new resizable array,
+  /// returning the result of the producer as well as the collected array.
+  def collect[T, R] { stream: () => R / emit[T] }: (R, ResizableArray[T]) = {
+    val arr = resizableArray()
+    try {
+      (stream(), arr)
+    } with emit[T] { v =>
+      arr.add(v)
+      resume(())
+    }
+  }
 }