@effekt-lang/effekt 0.56.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

@@ -26,20 +26,20 @@ def insert[A](trie: Dictionary[A], key: ByteArray, value: A): Dictionary[A] = {
         case Empty() =>
           val child = go(Empty(), i + 1)
           val children = array(256, Empty())
-          children.unsafeSet(key.unsafeGet(i).toInt, child)
+          children.set(key.get(i).toInt, child)
           Branch(children)
         case Leaf(existing) =>
           val child = go(Empty(), i + 1)
           val children = array(256, Empty())
-          children.unsafeSet(key.unsafeGet(i).toInt, child)
+          children.set(key.get(i).toInt, child)
           Node(existing, children)
         case Branch(children) =>
-          val child = go(children.unsafeGet(key.unsafeGet(i).toInt), i + 1)
-          children.unsafeSet(key.unsafeGet(i).toInt, child)
+          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.unsafeGet(key.unsafeGet(i).toInt), i + 1)
-          children.unsafeSet(key.unsafeGet(i).toInt, child)
+          val child = go(children.get(key.get(i).toInt), i + 1)
+          children.set(key.get(i).toInt, child)
           Node(existing, children)
       }
     } else {
@@ -64,8 +64,8 @@ def lookup[A](trie: Dictionary[A], key: ByteArray): Option[A] = {
       trie match {
         case Empty() => None()
         case Leaf(_) => None()
-        case Branch(children) => go(children.unsafeGet(key.unsafeGet(i).toInt), i + 1)
-        case Node(_, children) => go(children.unsafeGet(key.unsafeGet(i).toInt), i + 1)
+        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 {
@@ -97,12 +97,12 @@ def each[A](trie: Dictionary[A]): Unit / emit[A] =
     case Leaf(value) => do emit(value)
     case Branch(children) =>
       each(0, children.size) { i =>
-        each(children.unsafeGet(i))
+        each(children.get(i))
       }
     case Node(value, children) =>
       do emit(value)
       each(0, children.size) { i =>
-        each(children.unsafeGet(i))
+        each(children.get(i))
       }
   }
 
@@ -110,7 +110,7 @@ def each[A](trie: Dictionary[A]): Unit / emit[A] =
 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.unsafeSet(n - 1 - i, b) }
+    foreachIndex(bytes) { (i, b) => key.set(n - 1 - i, b) }
     key
   }
   def go(trie: Dictionary[A], key: List[Byte], n: Int): Unit =
@@ -119,12 +119,12 @@ def eachTagged[A](trie: Dictionary[A]): Unit / emit[Tagged[A]] = {
       case Leaf(value) => do emit(Tagged(fromBytesReverse(key, n), value))
       case Branch(children) =>
         each(0, children.size) { i =>
-          go(children.unsafeGet(i), Cons(i.toByte, key), n + 1)
+          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.unsafeGet(i), Cons(i.toByte, key), n + 1)
+          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/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/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/ref.effekt

@@ -30,12 +30,12 @@ extern type Ref[T]
 
 /// Allocates a new reference, keeping its value _undefined_.
 /// Prefer using `ref` constructor instead to ensure that the value is defined.
-extern def allocate[T]() at global: Ref[T] =
+extern def unsafeAllocate[T]() at global: Ref[T] =
   js "{ value: undefined }"
   chez "(box #f)"
   llvm """
     ; sizeof Header + sizeof Pos = 32
-    %ref = tail call noalias ptr @malloc(i64 noundef 32)
+    %ref = tail call noalias ptr @calloc(i64 noundef 32, i64 1)
     %refEraser = getelementptr ptr, ptr %ref, i64 1
     %fieldTag = getelementptr ptr, ptr %ref, i64 2
     %fieldData_pointer = getelementptr ptr, ptr %ref, i64 3