@effekt-lang/effekt 0.66.0 → 0.67.0

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:

package/libraries/common/regex.effekt

@@ -4,7 +4,9 @@ import string
 
 extern include chez "text/pregexp.scm"
 
-extern type Regex
+extern type Regex =
+  js "RegExp"
+  chez "pregexp"
 
 record Match(matched: String, index: Int)
 
@@ -25,9 +27,9 @@ 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"

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)

package/libraries/common/stream.effekt

@@ -7,13 +7,13 @@ import partial
 // Effects
 // -------
 
-/// Describes push streams by emitting values of type `A`.
-effect emit[A](value: A): Unit
+/// The effect for emitting an item of type `A` in a push stream.
+effect emit[A](item: A): Unit
 
-/// Describes pull streams by reading values of type `A`.
+/// The effect for getting the next item of type `A` from a pull stream.
 ///
-/// The producer can decide to `stop` emitting values.
-effect read[A](): A / stop
+/// Uses the `stop` effect to signal the end of the stream.
+effect next[A](): A / stop
 
 
 /// Like `for[A, R]`, but ignores the result of the stream, and consequently
@@ -30,11 +30,11 @@ def for[A] { stream: () => Unit / emit[A] } { action: A => Unit }: Unit =
 def map[A, B] { function: A => B } { stream: () => Unit / emit[A] }: Unit / emit[B] =
   returning::map[A, B, Unit]{function}{stream}
 
-/// Runs the given action whenever the given reader reads an element.
+/// Runs the given action whenever the given driver reads an element.
 ///
-/// e.g. var i = -1; with tap { i = i + 1; i }; reader()
-def tap[A] { action: () => A / stop } { reader: () => Unit / read[A] }: Unit =
-  returning::tap[A, Unit]{action}{reader}
+/// e.g. var i = -1; with tap { i = i + 1; i }; driver()
+def tap[A] { action: () => A / stop } { driver: () => Unit / next[A] }: Unit =
+  returning::tap[A, Unit]{action}{driver}
 
 /// Runs the stream as a message queue,
 /// handling each of its elements that can produce new elements ("messages"),
@@ -42,8 +42,8 @@ def tap[A] { action: () => A / stop } { reader: () => Unit / read[A] }: Unit =
 def fix[T] { one: T => Unit / emit[T] } { stream: => Unit / emit[T] }: Unit =
   try {
     stream()
-  } with emit[T] { value =>
-    fix {one} { one(value) }
+  } with emit[T] { item =>
+    fix {one} { one(item) }
     resume(())
   }
 
@@ -58,7 +58,7 @@ def some[A] { action: () => A / stop }: Unit / { emit[A], fail } = {
 
 
 /// In Effekt lower bounds are inclusive and upper bounds are exclusive
-record Indexed[A](index: Int, value: A)
+record Indexed[A](index: Int, item: A)
 
 def range(lower: Int, upper: Int): Unit / emit[Int] =
   if (lower < upper) {
@@ -116,7 +116,7 @@ def iterate[A](initial: A) { step: A => A }: Unit / emit[A] = {
 /// ```
 def takeWhile[A] { predicate: A => Bool } { stream: () => Unit / emit[A] }: Unit / emit[A] =
   try { stream() } with emit[A] {
-    case value and predicate(value) => do emit(value); resume(())
+    case item and predicate(item) => do emit(item); resume(())
     case _                          => () // end the stream
   }
 
@@ -146,7 +146,7 @@ def product { stream: () => Unit / emit[Int] }: Int =
 /// ```
 def all[A] { cond: A => Bool } { stream: => Unit / emit[A] }: Bool =
   try { stream(); true } with emit[A] {
-    case value and not(cond(value)) => false
+    case item and not(cond(item)) => false
     case _                          => resume(())
   }
 
@@ -169,7 +169,7 @@ def all[A] { cond: A => Bool } { stream: => Unit / emit[A] }: Bool =
 /// ```
 def any[A] { cond: A => Bool } { stream: => Unit / emit[A] }: Bool =
   try { stream(); false } with emit[A] {
-    case value and cond(value) => true
+    case item and cond(item) => true
     case _                     => resume(())
   }
 
@@ -196,8 +196,8 @@ def countIf[A] { shouldCount: A => Bool } { stream: () => Unit / emit[A] }: Int
 def count[A] { stream: () => Unit / emit[A] }: Int =
   countIf[A] { _ => true } {stream}
 
-def source[A] { stream: () => Unit / emit[A] } { reader: () => Unit / read[A] }: Unit =
-  returning::source[A, Unit]{stream}{reader}
+def source[A] { stream: () => Unit / emit[A] } { driver: () => Unit / next[A] }: Unit =
+  returning::source[A, Unit]{stream}{driver}
 
 /// Combines two streams together calling action on pairs in lockstep.
 /// Terminates when either of them terminates.
@@ -206,7 +206,7 @@ def zip[A, B] { stream1: () => Unit / emit[A] } { stream2: () => Unit / emit[B]
   with source[B] { stream2 }
 
   loop {
-    action(do read(), do read())
+    action(do next[A](), do next[B]())
   }
 }
 
@@ -218,15 +218,15 @@ def zipLongest[A, B] { stream1: () => Unit / emit[A] } { stream2: () => Unit / e
 
   loop {
      try {
-      val a = do read[A]()
+      val a = do next[A]()
       try {
-        val b = do read[B]()
+        val b = do next[B]()
         action(Both(a, b))
       } with stop { () =>
         action(This(a))
       }
     } with stop{ () =>
-      val b = do read[B]()
+      val b = do next[B]()
       action(That(b))
     }
   }
@@ -328,8 +328,8 @@ def tee[A]{ cons1: { => Unit / emit[A] } => Unit }{ cons2: { => Unit / emit[A] }
 /// ```
 def first[A] { stream: () => Unit / emit[A] }: A / fail = {
   try {
-    def body(): A = { stream(); do fail() }
-    body()
+    stream()
+    do fail().absurd
   } with emit[A] { a => a }
 }
 
@@ -338,8 +338,8 @@ def first[A] { stream: () => Unit / emit[A] }: A / fail = {
 def nth[A](n: Int){ stream: () => Unit / emit[A] }: A / fail = {
   var m = n
   try {
-    def body(): A = { stream(); do fail() }
-    body()
+    stream()
+    do fail().absurd
   } with emit[A] { a =>
     if (m == 0) {
       return a
@@ -350,6 +350,16 @@ def nth[A](n: Int){ stream: () => Unit / emit[A] }: A / fail = {
   }
 }
 
+// Peeking
+// -------
+
+/// Return the next item without advancing.
+effect peek[A](): A / stop
+
+/// Provide the ability to peek when consuming a stream.
+def peeking[A] { peeker: () => Unit / {next[A], peek[A]} }: Unit / next[A] =
+  returning::peeking[A, Unit]{peeker}
+
 // Counting and padding
 // --------------------
 
@@ -380,25 +390,25 @@ def tracking[A]{ body: => Unit / { emit[A], getPos } }: Unit / emit[A] =
 namespace returning {
 
 /// Canonical handler of push streams that performs `action` for every
-/// value emitted by `stream`.
+/// item emitted by `stream`.
 def for[A, R] { stream: () => R / emit[A] } { action: A => Unit }: R =
   try {
     stream()
-  } with emit[A] { value =>
-    resume(action(value))
+  } with emit[A] { item =>
+    resume(action(item))
   }
 
 def map[A, B, R] { function: A => B } { stream: () => R / emit[A] }: R / emit[B] =
   try {
     stream()
-  } with emit[A] { value =>
-    resume(do emit(function(value)))
+  } with emit[A] { item =>
+    resume(do emit(function(item)))
   }
 
-def tap[A, R] { action: () => A / stop } { reader: () => R / read[A] }: R =
+def tap[A, R] { action: () => A / stop } { driver: () => R / next[A] }: R =
   try {
-    reader()
-  } with read[A] { () =>
+    driver()
+  } with next[A] { () =>
     resume { action() }
   }
 
@@ -460,7 +470,7 @@ def product[R] { stream: () => R / emit[Int] }: (R, Int) = {
   }
 }
 
-def source[A, R] { stream: () => Unit / emit[A] } { reader: () => R / read[A] }: R = {
+def source[A, R] { stream: () => Unit / emit[A] } { driver: () => R / next[A] }: R = {
   var next = box { None() }
   next = box {
     try {
@@ -473,12 +483,42 @@ def source[A, R] { stream: () => Unit / emit[A] } { reader: () => R / read[A] }:
     }
   }
   try {
-    reader()
-  } with read[A] {
+    driver()
+  } with next[A] {
     resume {
       next().getOrElse { do stop() }
     }
   }
 }
 
+/// Provide the ability to peek when consuming a stream.
+def peeking[A, R] { peeker: () => R / {next[A], peek[A]} }: R / next[A] = {
+  def upstream(): A / stop = do next()
+  var last = None()
+  try {
+    peeker()
+  } with peek[A] { () =>
+    resume {
+      last match {
+        case None() =>
+          val t = upstream()
+          last = Some(t)
+          return t
+        case Some(t) =>
+          return t
+      }
+    }
+  } with next[A] {
+    resume {
+      last match {
+        case None() =>
+          upstream()
+        case Some(t) =>
+          last = None()
+          return t
+      }
+    }
+  }
+}
+
 }

package/libraries/common/string.effekt

@@ -237,17 +237,13 @@ extern def unsafeCharAt(str: String, n: Int) at {}: Char =
 // Streaming
 // ---------
 
-def feed[R](string: String) { reader: () => R / read[Char] } =
-  feed(string.fromString) {
-    decodeUTF8 {
-      reader()
-    }
-  }
+def feed[R](string: String) { driver: () => R / next[Char] } =
+  feed(string.fromString) { decodeUTF8 { driver() } }
 
 def each(string: String): Unit / emit[Char] =
   feed(string) {
     loop {
-      do emit(do read())
+      do emit(do next())
     }
   }
 

package/libraries/llvm/io.c

@@ -576,61 +576,6 @@ void c_yield(Stack stack) {
     c_timer_start(0, stack);
 }
 
-// Signals
-// --------
-
-typedef enum { INITIAL, NOTIFIED } signal_state_t;
-
-typedef struct {
-    uint64_t rc;
-    void* eraser;
-    signal_state_t state;
-    struct Pos value;
-    Stack stack;
-} Signal;
-
-void c_signal_erase(void *envPtr) {
-    // envPtr points to a Signal _after_ the eraser, so let's adjust it to point to the beginning.
-    Signal *signal = (Signal*) (envPtr - offsetof(Signal, state));
-    erasePositive(signal->value);
-    if (signal->stack != NULL) { eraseStack(signal->stack); }
-}
-
-struct Pos c_signal_make() {
-    Signal* f = (Signal*)malloc(sizeof(Signal));
-
-    f->rc = 0;
-    f->eraser = c_signal_erase;
-    f->state = INITIAL;
-    f->value = (struct Pos) { .tag = 0, .obj = NULL, };
-    f->stack = NULL;
-
-    return (struct Pos) { .tag = 0, .obj = f, };
-}
-
-void c_signal_notify(struct Pos signal, struct Pos value, Stack stack) {
-    Signal* f = (Signal*)signal.obj;
-    switch (f->state) {
-        case INITIAL: {
-            f->state = NOTIFIED;
-            f->value = value;
-            f->stack = stack;
-            erasePositive(signal);
-            break;
-        }
-        case NOTIFIED: {
-            struct Pos other_value = f->value;
-            f->value = (struct Pos) { .tag = 0, .obj = NULL, };
-            Stack other_stack = f->stack;
-            f->stack = NULL;
-            erasePositive(signal);
-            resume_Pos(other_stack, value);
-            resume_Pos(stack, other_value);
-            break;
-        }
-    }
-}
-
 // Subprocesses
 // ------------