@effekt-lang/effekt 0.23.0 → 0.25.0

package/libraries/common/buffer.effekt

@@ -3,7 +3,6 @@ module buffer
 import array
 
 // TODO (in Effekt compiler)
-// - [ ] fix allocating into actually global region
 // - [ ] fix exceptions on objects
 // - [X] allow omitting braces after `at` for singleton regions
 
@@ -35,12 +34,12 @@ def emptyBuffer[T](capacity: Int): Buffer[T] at {global} = {
 def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
   // TODO allocate buffer (and array) into a region r.
   val contents = array::allocate[T](initialCapacity)
-  var head in global = 0
-  var tail in global = 0
+  val head = ref(0)
+  val tail = ref(0)
 
   def size(): Int =
-    if (tail >= head) { tail - head }
-    else { initialCapacity - head + tail }
+    if (tail.get >= head.get) { tail.get - head.get }
+    else { initialCapacity - head.get + tail.get }
 
   def capacity(): Int = initialCapacity - size()
 
@@ -51,36 +50,36 @@ def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
     def read() = {
       if (buffer.empty?) None()
       else {
-        val result: T = contents.unsafeGet(head);
-        head = mod(head + 1, initialCapacity)
+        val result: T = contents.unsafeGet(head.get)
+        head.set(mod(head.get + 1, initialCapacity))
         Some(result)
       }
     }
     def write(el: T) = {
       if (buffer.full?) <> // raise(BufferOverflow())
 
-      contents.unsafeSet(tail, el)
-      tail = mod(tail + 1, initialCapacity)
+      contents.unsafeSet(tail.get, el)
+      tail.set(mod(tail.get + 1, initialCapacity))
     }
   }
   buffer
 }
 def refBuffer[T](): Buffer[T] at {global} = {
-  var content: Option[T] in global = None()
+  val content = ref(None())
   new Buffer[T] {
-    def capacity() = if (content.isEmpty) 1 else 0
-    def full?() = content.isDefined
-    def empty?() = isEmpty(content)
+    def capacity() = if (content.get.isEmpty) 1 else 0
+    def full?() = content.get.isDefined
+    def empty?() = isEmpty(content.get)
     def read() = {
-      val res = content
-      content = None()
+      val res = content.get
+      content.set(None())
       res
     }
-    def write(el: T) = content match {
+    def write(el: T) = content.get match {
       case Some(v) =>
         <> // do raise(BufferOverflow(), "Cannot read element from buffer")
       case None() =>
-        content = Some(el)
+        content.set(Some(el))
     }
   }
 }
@@ -88,24 +87,24 @@ def refBuffer[T](): Buffer[T] at {global} = {
 namespace examples {
   def main() = ignore[BufferOverflow] {
     // Buffer with capacity 1
-    def b = emptyBuffer[Int](1);
-    println(b.capacity);
-    println(b.full?);
+    def b = emptyBuffer[Int](1)
+    println(b.capacity)
+    println(b.full?)
 
-    b.write(17);
-    println(b.read());
+    b.write(17)
+    println(b.read())
 
     // buffer with capacity 3
-    def ringbuffer = emptyBuffer[Int](3);
-    ringbuffer.write(1);
-    ringbuffer.write(2);
-    println(ringbuffer.read());
-    ringbuffer.write(3);
-    println(ringbuffer.read());
-    println(ringbuffer.read());
-    ringbuffer.write(4);
-    ringbuffer.write(5);
-    println(ringbuffer.read());
-    println(ringbuffer.read());
+    def ringbuffer = emptyBuffer[Int](3)
+    ringbuffer.write(1)
+    ringbuffer.write(2)
+    println(ringbuffer.read())
+    ringbuffer.write(3)
+    println(ringbuffer.read())
+    println(ringbuffer.read())
+    ringbuffer.write(4)
+    ringbuffer.write(5)
+    println(ringbuffer.read())
+    println(ringbuffer.read())
   }
 }

package/libraries/common/queue.effekt

@@ -25,82 +25,82 @@ def emptyQueue[T](): Queue[T] at {global} =
 
 def emptyQueue[T](initialCapacity: Int): Queue[T] at {global} = {
 
-  var contents in global = array[Option[T]](initialCapacity, None())
-  var head in global = 0
-  var tail in global = 0
-  var size in global = 0
-  var capacity in global = initialCapacity
+  val contents = ref(array[Option[T]](initialCapacity, None()))
+  val head = ref(0)
+  val tail = ref(0)
+  val size = ref(0)
+  val capacity = ref(initialCapacity)
 
   def remove(arr: Array[Option[T]], index: Int): Option[T] = {
-    with on[OutOfBounds].default { None() };
-    val value = arr.get(index);
-    arr.set(index, None());
+    with on[OutOfBounds].default { None() }
+    val value = arr.get(index)
+    arr.set(index, None())
     value
   }
 
   def nonEmpty[T] { p: => Option[T] / Exception[OutOfBounds] }: Option[T] =
-    if (size <= 0) None() else on[OutOfBounds].default { None() } { p() }
+    if (size.get <= 0) None() else on[OutOfBounds].default { None() } { p() }
 
   // Exponential back-off
   def resizeTo(requiredSize: Int): Unit =
-    if (requiredSize <= capacity) () else {
+    if (requiredSize <= capacity.get) () else {
       with on[OutOfBounds].ignore // should not happen
 
-      val oldSize = capacity
-      val newSize = capacity * 2
-      val oldContents = contents
+      val oldSize = capacity.get
+      val newSize = capacity.get * 2
+      val oldContents = contents.get
       val newContents = array::allocate[Option[T]](newSize)
 
-      if (head < tail) {
+      if (head.get < tail.get) {
         // The queue does not wrap around; direct copy is possible.
-        copy(oldContents, head, newContents, 0, size) // changed tail to size
-      } else if (size > 0) {
+        copy(oldContents, head.get, newContents, 0, size.get) // changed tail to size
+      } else if (size.get > 0) {
         // The queue wraps around; copy in two segments.
-        copy(oldContents, head, newContents, 0, oldSize - head) // changed oldSize to oldSize - head
-        copy(oldContents, 0, newContents, oldSize - head, tail) // changed oldSize - head to oldSize - head
+        copy(oldContents, head.get, newContents, 0, oldSize - head.get) // changed oldSize to oldSize - head
+        copy(oldContents, 0, newContents, oldSize - head.get, tail.get) // changed oldSize - head to oldSize - head
       }
 
-      contents = newContents
-      capacity = newSize
-      head = 0
-      tail = oldSize
+      contents.set(newContents)
+      capacity.set(newSize)
+      head.set(0)
+      tail.set(oldSize)
     }
 
   def queue = new Queue[T] {
-    def empty?() = size <= 0
+    def empty?() = size.get <= 0
 
     def popFront() =
       nonEmpty {
-        val result = contents.remove(head)
-        head = mod(head + 1, capacity)
-        size = size - 1
+        val result = contents.get.remove(head.get)
+        head.set(mod(head.get + 1, capacity.get))
+        size.set(size.get - 1)
         result
       }
 
     def popBack() =
       nonEmpty {
-        tail = mod(tail - 1 + capacity, capacity)
-        val result = contents.remove(tail)
-        size = size - 1
+        tail.set(mod(tail.get - 1 + capacity.get, capacity.get))
+        val result = contents.get.remove(tail.get)
+        size.set(size.get - 1)
         result
       }
 
-    def peekFront() = nonEmpty { contents.get(head) }
+    def peekFront() = nonEmpty { contents.get.get(head.get) }
 
-    def peekBack() = nonEmpty { contents.get(tail) }
+    def peekBack() = nonEmpty { contents.get.get(tail.get) }
 
     def pushFront(el: T) = {
-      resizeTo(size + 1);
-      head = mod(head - 1 + capacity, capacity);
-      size = size + 1;
-      contents.unsafeSet(head, Some(el))
+      resizeTo(size.get + 1)
+      head.set(mod(head.get - 1 + capacity.get, capacity.get))
+      size.set(size.get + 1)
+      contents.get.unsafeSet(head.get, Some(el))
     }
 
     def pushBack(el: T) = {
-      resizeTo(size + 1);
-      contents.unsafeSet(tail, Some(el));
-      size = size + 1;
-      tail = mod(tail + 1, capacity)
+      resizeTo(size.get + 1)
+      contents.get.unsafeSet(tail.get, Some(el))
+      size.set(size.get + 1)
+      tail.set(mod(tail.get + 1, capacity.get))
     }
   }
   queue
@@ -109,30 +109,30 @@ def emptyQueue[T](initialCapacity: Int): Queue[T] at {global} = {
 namespace examples {
   def main() = {
     // queue with initial capacity 4
-    def b = emptyQueue[Int](4);
-    println(b.empty?);
-    b.pushFront(1);
-    b.pushBack(2);
-    b.pushFront(3);
-    b.pushBack(4);
+    def b = emptyQueue[Int](4)
+    println(b.empty?)
+    b.pushFront(1)
+    b.pushBack(2)
+    b.pushFront(3)
+    b.pushBack(4)
     // this will cause resizing:
-    b.pushBack(5);
-    b.pushBack(6);
-    b.pushBack(7);
-    b.pushBack(8);
+    b.pushBack(5)
+    b.pushBack(6)
+    b.pushBack(7)
+    b.pushBack(8)
     // and again:
-    b.pushBack(9);
-
-    println(b.empty?);
-    println(b.popFront()); // Some(3)
-    println(b.popFront()); // Some(1)
-    println(b.popFront()); // Some(2)
-    println(b.popFront()); // Some(4)
-    println(b.popFront()); // Some(5)
-    println(b.popFront()); // Some(6)
-    println(b.popFront()); // Some(7)
-    println(b.popFront()); // Some(8)
-    println(b.popFront()); // Some(9)
-    println(b.popFront()); // None()
+    b.pushBack(9)
+
+    println(b.empty?)
+    println(b.popFront()) // Some(3)
+    println(b.popFront()) // Some(1)
+    println(b.popFront()) // Some(2)
+    println(b.popFront()) // Some(4)
+    println(b.popFront()) // Some(5)
+    println(b.popFront()) // Some(6)
+    println(b.popFront()) // Some(7)
+    println(b.popFront()) // Some(8)
+    println(b.popFront()) // Some(9)
+    println(b.popFront()) // None()
   }
 }

package/libraries/common/stream.effekt

@@ -30,6 +30,17 @@ effect stop(): Nothing
 def for[A] { stream: () => Unit / emit[A] } { action: A => Unit }: Unit =
   returning::for[A, Unit]{stream}{action}
 
+/// Runs the stream as a message queue,
+/// handling each of its elements that can produce new elements ("messages"),
+/// until a fixed point is reached.
+def fix[T] { one: T => Unit / emit[T] } { stream: => Unit / emit[T] }: Unit =
+  try {
+    stream()
+  } with emit[T] { value =>
+    fix[T] {one} { one(value) }
+    resume(())
+  }
+
 /// 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] =

package/libraries/common/stringbuffer.effekt

@@ -14,7 +14,7 @@ def stringBuffer[A] { prog: => A / StringBuffer }: A = {
   var pos = 0
 
   def ensureCapacity(sizeToAdd: Int): Unit = {
-    val cap = buffer.size - pos + 1
+    val cap = buffer.size - pos
     if (sizeToAdd <= cap) ()
     else {
       // Double the capacity while ensuring the required capacity

package/libraries/js/effekt_runtime.js

@@ -1,69 +1,79 @@
-
-// Common Runtime
-// --------------
-function Cell(init, region) {
-  const cell = {
-    value: init,
-    backup: function() {
-      const _backup = cell.value;
-      // restore function (has a STRONG reference to `this`)
-      return () => { cell.value = _backup; return cell }
-    }
-  }
-  return cell;
+// Complexity of state:
+//
+//  get: O(1)
+//  set: O(1)
+//  capture: O(1)
+//  restore: O(|write operations since capture|)
+const Mem = null
+
+function Arena() {
+  const s = {
+    root: { value: Mem },
+    generation: 0,
+    fresh: (v) => {
+      const r = {
+        value: v,
+        generation: s.generation,
+        store: s,
+        set: (v) => {
+          const s = r.store
+          const r_gen = r.generation
+          const s_gen = s.generation
+
+          if (r_gen == s_gen) {
+            r.value = v;
+          } else {
+            const root = { value: Mem }
+            // update store
+            s.root.value = { ref: r, value: r.value, generation: r_gen, root: root }
+            s.root = root
+            r.value = v
+            r.generation = s_gen
+          }
+        }
+      };
+      return r
+    },
+    // not implemented
+    newRegion: () => s
+  };
+  return s
 }
 
-const global = {
-  fresh: Cell
+function snapshot(s) {
+  const snap = { store: s, root: s.root, generation: s.generation }
+  s.generation = s.generation + 1
+  return snap
 }
 
-function Arena(_region) {
-  const region = _region;
-  return {
-    fresh: function(init) {
-      const cell = Cell(init);
-      // region keeps track what to backup, but we do not need to backup unreachable cells
-      region.push(cell) // new WeakRef(cell))
-      return cell;
-    },
-    region: _region,
-    newRegion: function() {
-      // a region aggregates weak references
-      const nested = Arena([])
-      // this doesn't work yet, since Arena.backup doesn't return a thunk
-      region.push(nested) //new WeakRef(nested))
-      return nested;
-    },
-    backup: function() {
-      const _backup = []
-      let nextIndex = 0;
-      for (const ref of region) {
-        const cell = ref //.deref()
-        // only backup live cells
-        if (cell) {
-          _backup[nextIndex] = cell.backup()
-          nextIndex++
-        }
-      }
-      function restore() {
-        const region = []
-        let nextIndex = 0;
-        for (const restoreCell of _backup) {
-          region[nextIndex] = restoreCell() // new WeakRef(restoreCell())
-          nextIndex++
-        }
-        return Arena(region)
-      }
-      return restore;
-    }
-  }
+function reroot(n) {
+  if (n.value === Mem) return;
+
+  const diff = n.value
+  const r = diff.ref
+  const v = diff.value
+  const g = diff.generation
+  const n2 = diff.root
+  reroot(n2)
+  n.value = Mem
+  n2.value = { ref: r, value: r.value, generation: r.generation, root: n}
+  r.value = v
+  r.generation = g
 }
 
+function restore(store, snap) {
+  // linear in the number of modifications...
+  reroot(snap.root)
+  store.root = snap.root
+  store.generation = snap.generation + 1
+}
 
+// Common Runtime
+// --------------
 let _prompt = 1;
 
 const TOPLEVEL_K = (x, ks) => { throw { computationIsDone: true, result: x } }
-const TOPLEVEL_KS = { prompt: 0, arena: Arena([]), rest: null }
+const TOPLEVEL_KS = { prompt: 0, arena: Arena(), rest: null }
 
 function THUNK(f) {
   f.thunk = true
@@ -80,9 +90,6 @@ function CAPTURE(body) {
 
 const RETURN = (x, ks) => ks.rest.stack(x, ks.rest)
 
-// const r = ks.arena.newRegion(); body
-// const x = r.alloc(init); body
-
 // HANDLE(ks, ks, (p, ks, k) => { STMT })
 function RESET(prog, ks, k) {
   const prompt = _prompt++;
@@ -90,13 +97,6 @@ function RESET(prog, ks, k) {
   return prog(prompt, { prompt, arena: Arena([]), rest }, RETURN)
 }
 
-function DEALLOC(ks) {
-  const arena = ks.arena
-  if (!!arena) {
-    arena.length = arena.length - 1
-  }
-}
-
 function SHIFT(p, body, ks, k) {
 
   // TODO avoid constructing this object
@@ -104,13 +104,15 @@ function SHIFT(p, body, ks, k) {
   let cont = null
 
   while (!!meta && meta.prompt !== p) {
-    cont = { stack: meta.stack, prompt: meta.prompt, backup: meta.arena.backup(), rest: cont }
+    let store = meta.arena
+    cont = { stack: meta.stack, prompt: meta.prompt, arena: store, backup: snapshot(store), rest: cont }
     meta = meta.rest
   }
   if (!meta) { throw `Prompt not found ${p}` }
 
   // package the prompt itself
-  cont = { stack: meta.stack, prompt: meta.prompt, backup: meta.arena.backup(), rest: cont }
+  let store = meta.arena
+  cont = { stack: meta.stack, prompt: meta.prompt, arena: store, backup: snapshot(store), rest: cont }
   meta = meta.rest
 
   const k1 = meta.stack
@@ -123,7 +125,8 @@ function RESUME(cont, c, ks, k) {
   let meta = { stack: k, prompt: ks.prompt, arena: ks.arena, rest: ks.rest }
   let toRewind = cont
   while (!!toRewind) {
-    meta = { stack: toRewind.stack, prompt: toRewind.prompt, arena: toRewind.backup(), rest: meta }
+    restore(toRewind.arena, toRewind.backup)
+    meta = { stack: toRewind.stack, prompt: toRewind.prompt, arena: toRewind.arena, rest: meta }
     toRewind = toRewind.rest
   }