@effekt-lang/effekt 0.55.0 → 0.57.0

package/libraries/common/bytearray.effekt

@@ -2,6 +2,7 @@ module bytearray
 
 import effekt
 import stream
+import control
 
 /**
  * A memory managed, mutable, fixed-length array of bytes.
@@ -22,12 +23,12 @@ extern type ByteArray
   // = js "Uint8Array"
   // = chez "bytevector"
 
-/// Allocates a new bytearray with the given `size`, its values are undefined.
+/// Allocates a new bytearray with the given `size`, its values are zero bytes.
 extern def allocate(size: Int) at global: ByteArray =
   js "(new Uint8Array(${size}))"
   llvm """
     %object_size = add i64 ${size}, 16
-    %object_alloc = tail call noalias ptr @malloc(i64 noundef %object_size)
+    %object_alloc = tail call noalias ptr @calloc(i64 %object_size, i64 1)
     store i64 0, ptr %object_alloc, align 8
     %object_data_ptr = getelementptr inbounds i8, ptr %object_alloc, i64 8
     store ptr @bytearray_erase_noop, ptr %object_data_ptr, align 8
@@ -48,9 +49,30 @@ extern def size(arr: ByteArray) at {}: Int =
   chez "(bytevector-length ${arr})"
   vm "bytearray::size(ByteArray)"
 
-extern def unsafeGet(arr: ByteArray, index: Int) at global: Byte =
-  js "(${arr})[${index}]"
+extern js """
+  function bytearray$get(arr, index) {
+    if (index < 0 || index >= arr.length) throw 'Index out of bounds';
+    return arr[index];
+  }
+"""
+
+extern llvm """
+define void @assertInboundsByteArray(i64 %index, %Pos %arr) alwaysinline {
+  %size = extractvalue %Pos %arr, 0
+  %in_bounds = icmp ult i64 %index, %size
+  br i1 %in_bounds, label %ok, label %out
+out:
+  call void @exit(i64 1)
+  unreachable
+ok:
+  ret void
+}
+"""
+
+extern def get(arr: ByteArray, index: Int) at global: Byte =
+  js "bytearray$get(${arr}, ${index})"
   llvm """
+    call void @assertInboundsByteArray(i64 ${index}, %Pos ${arr})
     %arr_ptr = extractvalue %Pos ${arr}, 1
     %arr_data_ptr = getelementptr inbounds i8, ptr %arr_ptr, i64 16
     %element_ptr = getelementptr inbounds i8, ptr %arr_data_ptr, i64 ${index}
@@ -59,11 +81,12 @@ extern def unsafeGet(arr: ByteArray, index: Int) at global: Byte =
     ret i8 %element
   """
   chez "(bytevector-u8-ref ${arr} ${index})"
-  vm "bytearray::unsafeGet(ByteArray, Int)"
+  vm "bytearray::get(ByteArray, Int)"
 
-extern def unsafeSet(arr: ByteArray, index: Int, value: Byte) at global: Unit =
+extern def set(arr: ByteArray, index: Int, value: Byte) at global: Unit =
   js "bytearray$set(${arr}, ${index}, ${value})"
   llvm """
+    call void @assertInboundsByteArray(i64 ${index}, %Pos ${arr})
     %arr_ptr = extractvalue %Pos ${arr}, 1
     %arr_data_ptr = getelementptr inbounds i8, ptr %arr_ptr, i64 16
     %element_ptr = getelementptr inbounds i8, ptr %arr_data_ptr, i64 ${index}
@@ -72,13 +95,13 @@ extern def unsafeSet(arr: ByteArray, index: Int, value: Byte) at global: Unit =
     ret %Pos zeroinitializer
   """
   chez "(bytevector-u8-set! ${arr} ${index} ${value})"
-  vm "bytearray::unsafeSet(ByteArray, Int, Byte)"
+  vm "bytearray::set(ByteArray, Int, Byte)"
 
 /// Creates a new ByteArray of size `size` filled with the value `init`
 def bytearray(size: Int, init: Byte): ByteArray = {
   val arr = allocate(size);
   each(0, size) { i =>
-    unsafeSet(arr, i, init)
+    set(arr, i, init)
   };
   arr
 }
@@ -88,7 +111,7 @@ def resize(source: ByteArray, size: Int): ByteArray = {
   val n = min(source.size, target.size)
   def go(i: Int): ByteArray =
     if (i < n) {
-      target.unsafeSet(i, source.unsafeGet(i))
+      target.set(i, source.get(i))
       go(i + 1)
     } else {
       target
@@ -98,22 +121,22 @@ def resize(source: ByteArray, size: Int): ByteArray = {
 
 def foreach(arr: ByteArray){ action: Byte => Unit }: Unit =
   each(0, arr.size) { i =>
-    action(arr.unsafeGet(i))
+    action(arr.get(i))
   }
 
-def foreach(arr: ByteArray){ action: (Byte) {Control} => Unit }: Unit =
+def foreach(arr: ByteArray){ action: (Byte) {Label} => Unit }: Unit =
   each(0, arr.size) { (i) {label} =>
-    action(arr.unsafeGet(i)) {label}
+    action(arr.get(i)) {label}
   }
 
 def foreachIndex(arr: ByteArray){ action: (Int, Byte) => Unit }: Unit =
   each(0, arr.size) { i =>
-    action(i, arr.unsafeGet(i))
+    action(i, arr.get(i))
   }
 
-def foreachIndex(arr: ByteArray){ action: (Int, Byte) {Control} => Unit }: Unit =
+def foreachIndex(arr: ByteArray){ action: (Int, Byte) {Label} => Unit }: Unit =
   each(0, arr.size) { (i) {label} =>
-    action(i, arr.unsafeGet(i)) {label}
+    action(i, arr.get(i)) {label}
   }
 
 extern def fromString(str: String) at {}: ByteArray =
@@ -214,7 +237,7 @@ def each(bytes: ByteArray): Unit / emit[Byte] = {
   val n = bytes.size
   def go(i: Int): Unit = {
     if (i < n) {
-      do emit(bytes.unsafeGet(i))
+      do emit(bytes.get(i))
       go(i + 1)
     }
   }
@@ -230,7 +253,7 @@ def feed[R](bytes: ByteArray) { reader: () => R / read[Byte] }: R = {
       if (i < bytes.size) {
         val c = i
         i = c + 1
-        bytes.unsafeGet(c)
+        bytes.get(c)
       } else {
         do stop()
       }
@@ -249,7 +272,7 @@ namespace returning {
       (stream(), a.resize(i))
     } with emit[Byte] { (v) =>
       if (i >= a.size) { a = a.resize(2 * a.size) }
-      a.unsafeSet(i, v)
+      a.set(i, v)
       i = i + 1
       resume(())
     }

package/libraries/common/control.effekt

@@ -0,0 +1,27 @@
+module control
+
+import effekt
+
+interface Label {
+  def break(): Unit
+  def continue(): Unit
+}
+
+def loop { f: {Label} => Unit }: Unit = try {
+  def go(): Unit = { f {label}; go() }
+  go()
+} with label: Label {
+  def break() = ()
+  def continue() = loop { f }
+}
+
+/// Calls provided action repeatedly with support for breaking. `start` is inclusive, `end` is not.
+def each(start: Int, end: Int) { action: (Int) {Label} => Unit } = {
+  var i = start;
+  loop { {l} =>
+    if (i < end) { val el = i; i = i + 1; action(el){l} }
+    else { l.break() }
+  }
+}
+
+def repeat(n: Int) { action: () {Label} => Unit } = each(0, n) { (n) {l} => action() {l} }

package/libraries/common/dictionary.effekt

@@ -0,0 +1,133 @@
+module dictionary
+
+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] {
+  Empty()
+  Leaf(value: A)
+  Branch(children: Array[Dictionary[A]])
+  Node(value: A, children: Array[Dictionary[A]])
+}
+
+/// Insert a value with a String key.
+def insert[A](trie: Dictionary[A], key: String, value: A): Dictionary[A] =
+  insert(trie, 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] =
+    if (i < key.size) {
+      trie match {
+        case Empty() =>
+          val child = go(Empty(), i + 1)
+          val children = array(256, Empty())
+          children.set(key.get(i).toInt, child)
+          Branch(children)
+        case Leaf(existing) =>
+          val child = go(Empty(), i + 1)
+          val children = array(256, Empty())
+          children.set(key.get(i).toInt, child)
+          Node(existing, children)
+        case Branch(children) =>
+          val child = go(children.get(key.get(i).toInt), i + 1)
+          children.set(key.get(i).toInt, child)
+          Branch(children)
+        case Node(existing, children) =>
+          val child = go(children.get(key.get(i).toInt), i + 1)
+          children.set(key.get(i).toInt, child)
+          Node(existing, children)
+      }
+    } else {
+      trie match {
+        case Empty() => Leaf(value)
+        case Leaf(_) => Leaf(value)
+        case Node(_, children) => Node(value, children)
+        case Branch(children) => Node(value, children)
+      }
+    }
+  go(trie, 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)
+
+/// 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] =
+    if (i < key.size) {
+      trie match {
+        case Empty() => None()
+        case Leaf(_) => None()
+        case Branch(children) => go(children.get(key.get(i).toInt), i + 1)
+        case Node(_, children) => go(children.get(key.get(i).toInt), i + 1)
+      }
+    } else {
+      trie match {
+        case Empty() => None()
+        case Leaf(value) => Some(value)
+        case Branch(_) => None()
+        case Node(value, _) => Some(value)
+      }
+    }
+  go(trie, 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.
+def collect[A] { stream: () => Unit / emit[Tagged[A]] }: Dictionary[A] = {
+  var trie = Empty()
+  for[Tagged[A]] { stream() } { case Tagged(bytes, value) =>
+    trie = trie.insert(bytes, value)
+  }
+  return trie
+}
+
+/// 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))
+      }
+  }
+
+/// 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 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 =
+    trie match {
+      case Empty() => ()
+      case Leaf(value) => do emit(Tagged(fromBytesReverse(key, n), value))
+      case Branch(children) =>
+        each(0, children.size) { i =>
+          go(children.get(i), Cons(i.toByte, key), n + 1)
+        }
+      case Node(value, children) =>
+        do emit(Tagged(fromBytesReverse(key, n), value))
+        each(0, children.size) { i =>
+          go(children.get(i), Cons(i.toByte, key), n + 1)
+        }
+    }
+  go(trie, Nil(), 0)
+}
+
+

package/libraries/common/effekt.effekt

@@ -732,23 +732,37 @@ type OneOrBoth[A, B] {
 
 // Control Flow
 // ============
-interface Control {
-  def break(): Unit
-  def continue(): Unit
-}
 
-def loop { f: () => Unit }: Unit = {
-  def go(): Unit = { f(); go() }
+/// Repeat `action` forever
+def forever { action: () => Unit }: Nothing = {
+  def go(): Nothing = { action(); go() }
   go()
 }
 
-def loop { f: {Control} => Unit }: Unit = try {
-  def go(): Unit = { f {label}; go() }
-  go()
-} with label: Control {
-  def break() = ()
-  def continue() = loop { f }
-}
+/// Signal that we should stop.
+effect stop(): Nothing
+
+/// When the program stops, then to here.
+def boundary { program: () => Unit / stop }: Unit =
+  try { program() } with stop { () }
+
+/// Repeat `action` until `stop` is thrown.
+def loop { action: () => Unit / stop }: Unit =
+  try {
+    def go(): Unit = { action(); go() }
+    go()
+  } with stop {
+    ()
+  }
+
+/// Repeat `action` until `stop` is thrown, supplying the iteration count.
+def loop { action: Int => Unit / stop }: Unit =
+  try {
+    def go(i: Int): Unit = { action(i); go(i + 1) }
+    go(0)
+  } with stop {
+    ()
+  }
 
 /// Calls provided action repeatedly. `start` is inclusive, `end` is not.
 def each(start: Int, end: Int) { action: (Int) => Unit } = {
@@ -758,19 +772,8 @@ def each(start: Int, end: Int) { action: (Int) => Unit } = {
   loop(start)
 }
 
-/// Calls provided action repeatedly with support for breaking. `start` is inclusive, `end` is not.
-def each(start: Int, end: Int) { action: (Int) {Control} => Unit } = {
-  var i = start;
-  loop { {l} =>
-    if (i < end) { val el = i; i = i + 1; action(el){l} }
-    else { l.break() }
-  }
-}
-
 def repeat(n: Int) { action: () => Unit } = each(0, n) { n => action() }
 
-def repeat(n: Int) { action: () {Control} => Unit } = each(0, n) { (n) {l} => action() {l} }
-
 // NOTE: This is emitted by the close hole code action: do not remove unless you also adjust the code action
 /// Scopes a local computation
 def locally[R] { p: => R } : R = p()

package/libraries/common/heap.effekt

@@ -23,8 +23,8 @@ namespace internal {
     arr.boundsCheck(idx) // idx > parent(idx), parent(parent(idx)) etc
 
     def go(idx: Int): Unit = {
-      if (idx > 0 and (heap.cmp)(arr.unsafeGet(parent(idx)), arr.unsafeGet(idx)) is Greater()) {
-        arr.unsafeSwap(parent(idx), idx)
+      if (idx > 0 and (heap.cmp)(arr.get(parent(idx)), arr.get(idx)) is Greater()) {
+        arr.swap(parent(idx), idx)
         go(parent(idx))
       }
     }
@@ -39,28 +39,28 @@ namespace internal {
     
     def go(idx: Int): Unit = {
       if (right(idx) < arr.size) {
-        val v = arr.unsafeGet(idx)
-        val l = arr.unsafeGet(left(idx))
-        val r = arr.unsafeGet(right(idx))
+        val v = arr.get(idx)
+        val l = arr.get(left(idx))
+        val r = arr.get(right(idx))
         if (l < v && r < v) {
           // swap with the smaller one
           if (l < r) {
-            arr.unsafeSwap(left(idx), idx)
+            arr.swap(left(idx), idx)
             go(left(idx))
           } else {
-            arr.unsafeSwap(right(idx), idx)
+            arr.swap(right(idx), idx)
             go(right(idx))
           }
         } else if (l < v) {
-          arr.unsafeSwap(left(idx), idx)
+          arr.swap(left(idx), idx)
           go(left(idx))
         } else if (r < v) {
-          arr.unsafeSwap(right(idx), idx)
+          arr.swap(right(idx), idx)
           go(right(idx))
         }
       } else if (left(idx) < arr.size) {
-        if (arr.unsafeGet(left(idx)) < arr.unsafeGet(idx)) {
-          arr.unsafeSwap(left(idx), idx)
+        if (arr.get(left(idx)) < arr.get(idx)) {
+          arr.swap(left(idx), idx)
           go(left(idx))
         }
       } // else: we are at the bottom
@@ -79,6 +79,7 @@ def insert[T](heap: Heap[T], value: T): Unit = {
 }
 
 /// find and return (but not remove) the minimal element in this heap
+/// panics when heap is empty
 ///
 /// O(1)
 def findMin[T](heap: Heap[T]): T / Exception[OutOfBounds] = {
@@ -86,13 +87,20 @@ def findMin[T](heap: Heap[T]): T / Exception[OutOfBounds] = {
 }
 
 /// find and remove the minimal element in this heap
+/// panics when heap is empty
 ///
 /// O(log n)
 def deleteMin[T](heap: Heap[T]): T / Exception[OutOfBounds] = {
-  val res = heap.rawContents.get(0)
-  heap.rawContents.unsafeSet(0, heap.rawContents.popRight())
-  internal::sinkDown(heap, 0)
-  res
+  val arr = heap.rawContents
+  val res = arr.get(0)
+  if (arr.size == 1) {
+    arr.popRight()
+    res
+  } else {
+    arr.set(0, arr.popRight())
+    internal::sinkDown(heap, 0)
+    res
+  }
 }
 
 /// Number of elements in the heap

package/libraries/common/io/filesystem.effekt

@@ -102,7 +102,7 @@ def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[I
       push(0, buffer.size)
       offset = 0
     }
-    buffer.unsafeSet(offset, byte)
+    buffer.set(offset, byte)
     offset = offset + 1
     resume(())
   }
@@ -135,7 +135,7 @@ def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IO
         pull()
         offset = 0
       }
-      val byte = buffer.unsafeGet(offset)
+      val byte = buffer.get(offset)
       offset = offset + 1
       return byte
     }

package/libraries/common/json.effekt

@@ -25,12 +25,12 @@ def handleJsonBuilder[R]{b: JsonBuilder}{ body: => R / JsonBuilder }: R = try bo
   def bool(v) = resume(b.bool(v))
   def number(n) = resume(b.number(n))
   def string(s) = resume(b.string(s))
-  def list() = resume { {c} => b.list{c} }
-  def dict() = resume { {c} => b.dict{c} }
+  def list[T]() = resume { {c} => b.list{c} }
+  def dict[T]() = resume { {c} => b.dict{c} }
 }
 /// Make explicitly bound JsonObjectBuilder instance implicit
 def handleJsonObjectBuilder[R]{b: JsonObjectBuilder}{ body: => R / JsonObjectBuilder }: R = try body() with JsonObjectBuilder {
-  def field(k) = resume { {c} => b.field(k){c} }
+  def field[T](k) = resume { {c} => b.field(k){c} }
 }
 
 // --------------------------------------------------------------------------------
@@ -49,8 +49,8 @@ def encodeJsonList[R]{ body: => R / JsonBuilder }: R / emit[String] = {
       def bool(v) = { c(); resume(do bool(v)) }
       def number(n) = { c(); resume(do number(n)) }
       def string(s) = { c(); resume(do string(s)) }
-      def list() = resume { { b } => c(); do list{b} }
-      def dict() = resume { { b } => c(); do dict{b} }
+      def list[T]() = resume { { b } => c(); do list{b} }
+      def dict[T]() = resume { { b } => c(); do dict{b} }
     }
   }
   do emit("]")
@@ -66,7 +66,7 @@ def encodeJsonObject[R]{ body: => R / JsonObjectBuilder }: R / emit[String] = {
   }
   val r = encodeJson {
     try body() with JsonObjectBuilder {
-      def field(k) = resume { {b} => c(k); b() }
+      def field[T](k) = resume { {b} => c(k); b() }
     }
   }
   do emit("}")
@@ -80,8 +80,8 @@ def encodeJson[R]{ body: => R / JsonBuilder }: R / emit[String] = {
       def bool(v) = { resume(do emit( if(v){ "true" } else { "false" } )) }
       def number(n) = { resume(do emit(show(n))) }
       def string(s) = { resume(do emit(escape(s))) }
-      def list() = resume { {b} => encodeJsonList { b() } }
-      def dict() = resume { {b} => encodeJsonObject { b() } }
+      def list[T]() = resume { {b} => encodeJsonList { b() } }
+      def dict[T]() = resume { {b} => encodeJsonObject { b() } }
   }
 }
 
@@ -209,7 +209,7 @@ def decodeJsonList(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} =
 // --------------------------------------------------------------------------------
 /// Ignore the generated calls to JsonObjectBuilder
 def ignoreDict[R](){ body: => R / JsonObjectBuilder }: R = try body() with JsonObjectBuilder {
-  def field(k) = resume { {v} => ignore{v} }
+  def field[T](k) = resume { {v} => ignore{v} }
 }
 
 /// Ignore the generated calls to JsonBuilder
@@ -218,8 +218,8 @@ def ignore[R](){ body: => R / JsonBuilder }: R = try body() with JsonBuilder {
   def bool(b) = resume(())
   def null() = resume(())
   def string(s) = resume(())
-  def list() = resume { {e} => ignore{e} }
-  def dict() = resume { {e} => ignoreDict{e} }
+  def list[T]() = resume { {e} => ignore{e} }
+  def dict[T]() = resume { {e} => ignoreDict{e} }
 }
 
 // --------------------------------------------------------------------------------
@@ -264,12 +264,12 @@ def build[R](){ body: => R / JsonBuilder }: (R, JsonValue) = {
     def bool(b) = { r = Bool(b); resume(()) }
     def null() = { r = Null(); resume(()) }
     def string(s) = { r = String(s); resume(()) }
-    def list() = resume { {els} =>
+    def list[T]() = resume { {els} =>
       val x = buildList {els}
       r = List(x.second)
       x.first
     }
-    def dict() = resume { {fs} =>
+    def dict[T]() = resume { {fs} =>
       val x = buildDict {fs}
       r = Dict(x.second)
       x.first
@@ -283,12 +283,12 @@ def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = list::ret
     def bool(b) = { do emit(Bool(b)); resume(()) }
     def null() = { do emit(Null()); resume(()) }
     def string(s) = { do emit(String(s)); resume(()) }
-    def list() = resume { {els} =>
+    def list[T]() = resume { {els} =>
       val x = buildList {els}
       do emit(List(x.second))
       x.first
     }
-    def dict() = resume { {fs} =>
+    def dict[T]() = resume { {fs} =>
       val x = buildDict {fs}
       do emit(Dict(x.second))
       x.first
@@ -297,7 +297,7 @@ def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = list::ret
 }
 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} =>
+    def field[T](k) = resume { {v} =>
       val x = build{v}
       do emit((k, x.second))
       x.first
@@ -325,7 +325,7 @@ namespace test {
       with scanner[Char]
 
       def k = new JsonObjectBuilder {
-        def field(k){v} = { println(k); ignore{v} }
+        def field[T](k){v} = { println(k); ignore{v} }
       }
       def jsonBuilder[R] {e: => R / JsonBuilder}: R = {
         def d = new JsonBuilder {
@@ -333,8 +333,8 @@ namespace test {
           def bool(b) = ()
           def null() = println("NULL")
           def string(s) = ()
-          def list(){e} = jsonBuilder{e}
-          def dict(){e} = handleJsonObjectBuilder{k}{e}
+          def list[T](){e} = jsonBuilder{e}
+          def dict[T](){e} = handleJsonObjectBuilder{k}{e}
         }
         handleJsonBuilder{d}{e}
       }

package/libraries/common/list.effekt

@@ -2,8 +2,9 @@ module list
 
 import effekt
 import option
-import exception
+import control
 import stream
+import exception
 
 /// Immutable linked list for finite sequences of elements.
 type List[A] {
@@ -123,7 +124,7 @@ def foreach[A](l: List[A]) { f: (A) => Unit } : Unit = l match {
 /// Traverse a list, applying the given action on every element.
 ///
 /// O(N)
-def foreach[A](l: List[A]) { f: (A) {Control} => Unit } : Unit = {
+def foreach[A](l: List[A]) { f: (A) {Label} => Unit } : Unit = {
   var remainder = l
   loop { {label} =>
     remainder match {
@@ -151,7 +152,7 @@ def foreachIndex[A](list: List[A]){ f: (Int, A) => Unit }: Unit = {
 /// Traverse a list, applying the given action on every element and its (zero-based) index.
 ///
 /// O(N)
-def foreachIndex[A](list: List[A]){ f: (Int, A) {Control} => Unit }: Unit = {
+def foreachIndex[A](list: List[A]){ f: (Int, A) {Label} => Unit }: Unit = {
   var remainder = list
   var i = -1
   loop { {label} =>

package/libraries/common/option.effekt

@@ -37,7 +37,7 @@ def foreach[A](self: Option[A]) { f: A => Unit }: Unit = self match {
 }
 
 def value[A](self: Option[A]): A / Exception[MissingValue] = self match {
-  case None() => do raise(MissingValue(), "Trying to get the value of an empty option")
+  case None() => do raise(MissingValue(), "Trying to get the value of an empty option") match {}
   case Some(v) => v
 }
 

package/libraries/common/queue.effekt

@@ -49,7 +49,7 @@ def emptyQueue[T](initialCapacity: Int): Queue[T] at global = {
       val oldSize = capacity.get
       val newSize = capacity.get * 2
       val oldContents = contents.get
-      val newContents = array::allocate[Option[T]](newSize)
+      val newContents = array[Option[T]](newSize, None())
 
       if (head.get < tail.get) {
         // The queue does not wrap around; direct copy is possible.
@@ -93,12 +93,12 @@ def emptyQueue[T](initialCapacity: Int): Queue[T] at global = {
       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))
+      contents.get.set(head.get, Some(el))
     }
 
     def pushBack(el: T) = {
       resizeTo(size.get + 1)
-      contents.get.unsafeSet(tail.get, Some(el))
+      contents.get.set(tail.get, Some(el))
       size.set(size.get + 1)
       tail.set(mod(tail.get + 1, capacity.get))
     }

package/libraries/common/random.effekt

@@ -170,7 +170,7 @@ def main() = {
       val b = randomInt(0, 9)
       val c = randomInt(0, 9)
       println(a.show ++ " " ++ b.show ++ " " ++ c.show)
-      println(a*100 + b*10 + c)
+      println(a * 100 + b * 10 + c)
     }
   }