@effekt-lang/effekt 0.55.0 → 0.57.0

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

package/libraries/common/resizable_array.effekt

@@ -21,42 +21,26 @@ 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] = {
-  ResizableArray(ref(0), ref(allocate(capacity)))
+  ResizableArray(ref(0), ref(unsafeAllocate(capacity)))
 }
 
-/// Allocate a new, empty dynamic array
+/// Aallocate a new, empty dynamic array
 def resizableArray[T](): ResizableArray[T] = resizableArray(8)
 
+
 /// Throw an OutOfBounds exception if index is not a valid index into arr
-def boundsCheck[T](arr: ResizableArray[T], index: Int): Unit / Exception[OutOfBounds] = {
+def boundsCheck[T](arr: ResizableArray[T], index: Int): Unit / Exception[OutOfBounds] =
   if (index < 0 || index >= arr.size) {
     do raise(OutOfBounds(), "Array index out of bounds: " ++ show(index))
   }
-}
 
-/// get the element at position index in the array
-///
-/// precondition: index is a valid index into the array
-///
-/// O(1)
-def unsafeGet[T](arr: ResizableArray[T], index: Int): T = {
-  arr.rawContentPtr.get.unsafeGet(index)
-}
+
 /// get the element at position index in the array
 ///
 /// O(1)
 def get[T](arr: ResizableArray[T], index: Int): T / Exception[OutOfBounds] = {
   arr.boundsCheck(index);
-  arr.unsafeGet(index)
-}
-
-/// set the element at position index in the array
-///
-/// precondition: index is a valid index into the array
-///
-/// O(1)
-def unsafeSet[T](arr: ResizableArray[T], index: Int, value: T): Unit = {
-  arr.rawContentPtr.get.unsafeSet(index, value)
+  arr.rawContentPtr.get.get(index)
 }
 
 /// set the element at position index in the array
@@ -64,19 +48,7 @@ def unsafeSet[T](arr: ResizableArray[T], index: Int, value: T): Unit = {
 /// O(1)
 def set[T](arr: ResizableArray[T], index: Int, value: T): Unit / Exception[OutOfBounds] = {
   arr.boundsCheck(index);
-  arr.unsafeSet(index, value)
-}
-
-/// swap the elements at the given positions in the array
-///
-/// precondition: both are valid indices into the array
-///
-/// O(1)
-def unsafeSwap[T](arr: ResizableArray[T], index1: Int, index2: Int): Unit = {
-  val raw = arr.rawContentPtr.get
-  val tmp = raw.unsafeGet(index1)
-  raw.unsafeSet(index1, raw.unsafeGet(index2))
-  raw.unsafeSet(index2, tmp)
+  arr.rawContentPtr.get.set(index, value)
 }
 
 /// swap the elements at the given positions in the array
@@ -84,22 +56,10 @@ def unsafeSwap[T](arr: ResizableArray[T], index1: Int, index2: Int): Unit = {
 /// O(1)
 def swap[T](arr: ResizableArray[T], index1: Int, index2: Int): Unit / Exception[OutOfBounds] = {
   arr.boundsCheck(max(index1, index2))
-  arr.unsafeSwap(index1, index2)
-}
-
-/// Change the dynamic to have exactly the given capacity
-///
-/// precondition: given capacity is at least the size of the array
-///
-/// O(n)
-def unsafeSetCapacity[T](arr: ResizableArray[T], capacity: Int): Unit = {
-  with on[OutOfBounds].panic
-  val oldRaw = arr.rawContentPtr.get
-  if (oldRaw.size != capacity) { 
-    val newRaw = array::allocate(capacity)
-    oldRaw.copy(0, newRaw, 0, arr.size)
-    arr.rawContentPtr.set(newRaw)
-  }
+  val raw = arr.rawContentPtr.get
+  val tmp = raw.get(index1)
+  raw.set(index1, raw.get(index2))
+  raw.set(index2, tmp)
 }
 
 /// Change the resizable array to have exactly the given capacity.
@@ -110,16 +70,21 @@ def setCapacity[T](arr: ResizableArray[T], capacity: Int): Unit / Exception[OutO
   if (arr.size > capacity) {
     do raise(OutOfBounds(), "Cannot change capacity of ResizableArray to " ++ capacity.show ++ " below size " ++ arr.size.show)
   }
-  arr.unsafeSetCapacity(capacity)
+  val oldRaw = arr.rawContentPtr.get
+  if (oldRaw.size != capacity) { 
+    val newRaw = array::unsafeAllocate(capacity)
+    oldRaw.copy(0, newRaw, 0, arr.size)
+    arr.rawContentPtr.set(newRaw)
+  }
 }
 
 /// If the shrinkThreshold is reached, shrink by growFactor, otherwise do nothing
 ///
 /// O(n)
-def maybeShrink[T](arr: ResizableArray[T]): Unit = {
+def maybeShrink[T](arr: ResizableArray[T]): Unit / Exception[OutOfBounds] = {
   if(arr.size.toDouble < arr.rawContentPtr.get.size.toDouble * shrinkThreshold) {
     val newCap = max(arr.size, (arr.rawContentPtr.get.size.toDouble / growFactor).ceil)
-    arr.unsafeSetCapacity(newCap)
+    arr.setCapacity(newCap)
   }
 }
 
@@ -144,11 +109,11 @@ def setResizing[T](arr: ResizableArray[T], index: Int, value: T): Unit / Excepti
     do raise(OutOfBounds(), "Negative index " ++ index.show)
   }
   if (index < arr.size) {
-    arr.rawContentPtr.get.unsafeSet(index, value)
+    arr.rawContentPtr.get.set(index, value)
   }
   ensureCapacity(arr, index + 1)
-  arr.rawContentPtr.get.unsafeSet(index, value)
-  arr.rawSizePtr.set(index + 1)
+  arr.rawContentPtr.get.set(index, value)
+  if (index >= arr.size) arr.rawSizePtr.set(index + 1)
 }
 
 /// Add a new element at the end of the resizable array.
@@ -166,9 +131,10 @@ def add[T](arr: ResizableArray[T], value: T): Int = {
 ///
 /// O(1) amortized, O(n) worst case
 def popRight[T](arr: ResizableArray[T]): T / Exception[OutOfBounds] = {
-  arr.boundsCheck(arr.size - 1)
-  arr.rawSizePtr.set(arr.size - 1)
-  val r = arr.unsafeGet(arr.size)
+  val last = arr.size - 1
+  arr.boundsCheck(last)
+  val r = arr.rawContentPtr.get.get(last)
+  arr.rawSizePtr.set(last)
   arr.maybeShrink()
   r
 }
@@ -176,51 +142,51 @@ def popRight[T](arr: ResizableArray[T]): T / Exception[OutOfBounds] = {
 
 def foreachIndex[T](arr: ResizableArray[T]){ body: (Int, T) => Unit }: Unit = {
   each(0, arr.size) { i =>
-    body(i, arr.rawContentPtr.get.unsafeGet(i))
+    body(i, arr.rawContentPtr.get.get(i))
   }
 }
-def foreachIndex[T](arr: ResizableArray[T]){ body: (Int, T) {Control} => Unit }: Unit = {
+def foreachIndex[T](arr: ResizableArray[T]){ body: (Int, T) {Label} => Unit }: Unit = {
   each(0, arr.size) { (i){label} =>
-    body(i, arr.rawContentPtr.get.unsafeGet(i)){label}
+    body(i, arr.rawContentPtr.get.get(i)){label}
   }
 }
 def foreach[T](arr: ResizableArray[T]){ body: T => Unit }: Unit = {
   each(0, arr.size) { i =>
-    body(arr.rawContentPtr.get.unsafeGet(i))
+    body(arr.rawContentPtr.get.get(i))
   }
 }
-def foreach[T](arr: ResizableArray[T]){ body: (T) {Control} => Unit }: Unit = {
+def foreach[T](arr: ResizableArray[T]){ body: (T) {Label} => Unit }: Unit = {
   each(0, arr.size) { (i){label} =>
-    body(arr.rawContentPtr.get.unsafeGet(i)){label}
+    body(arr.rawContentPtr.get.get(i)){label}
   }
 }
-def foreachIndexReversed[T](arr: ResizableArray[T]){ body: (Int, T){Control} => Unit }: Unit = {
+def foreachIndexReversed[T](arr: ResizableArray[T]){ body: (Int, T){Label} => Unit }: Unit = {
   var i = arr.size - 1
   loop { {l} =>
     if (i < 0) { l.break() }
-    body(i, arr.rawContentPtr.get.unsafeGet(i)){l}
+    body(i, arr.rawContentPtr.get.get(i)){l}
     i = i - 1
   }
 }
 def foreachIndexReversed[T](arr: ResizableArray[T]){ body: (Int, T) => Unit }: Unit = {
   var i = arr.size - 1
   while(i >= 0) {
-    body(i, arr.rawContentPtr.get.unsafeGet(i))
+    body(i, arr.rawContentPtr.get.get(i))
     i = i - 1
   }
 }
-def foreachReversed[T](arr: ResizableArray[T]){ body: (T){Control} => Unit }: Unit = {
+def foreachReversed[T](arr: ResizableArray[T]){ body: (T){Label} => Unit }: Unit = {
   var i = arr.size - 1
   loop { {l} =>
     if (i < 0) { l.break() }
-    body(arr.rawContentPtr.get.unsafeGet(i)){l}
+    body(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.unsafeGet(i))
+    body(arr.rawContentPtr.get.get(i))
     i = i - 1
   }
 }
@@ -228,7 +194,7 @@ def foreachReversed[T](arr: ResizableArray[T]){ body: T => Unit }: Unit = {
 def toList[T](arr: ResizableArray[T]): List[T] = {
   def go(i: Int, acc: List[T]): List[T] = {
     if (i < 0) { acc } else {
-      go(i - 1, Cons(arr.unsafeGet(i), acc))
+      go(i - 1, Cons(arr.rawContentPtr.get.get(i), acc))
     }
   }
   go(arr.size - 1, Nil())

package/libraries/common/seq.effekt

@@ -579,14 +579,14 @@ def each[A](seq: Seq[A]) { consume: (A) => Unit }: Unit = {
   }
 }
 
-def each[A](seq: Seq[A]) { f: (A) {Control} => Unit }: Unit = try {
+def each[A](seq: Seq[A]) { f: (A) {Label} => Unit }: Unit = try {
   seq.each { (el) =>
-    try { f(el) {inner} } with inner: Control {
+    try { f(el) {inner} } with inner: Label {
       def break() = outer.break()
       def continue() = ()
     }
   }
-} with outer: Control {
+} with outer: Label {
   def break() = ()
   def continue() = ()
 }
@@ -627,14 +627,14 @@ def eachReverse[A](seq: Seq[A]) { consume: A => Unit }: Unit = {
   }
 }
 
-def eachReverse[A](seq: Seq[A]) { f: (A) {Control} => Unit }: Unit = try {
+def eachReverse[A](seq: Seq[A]) { f: (A) {Label} => Unit }: Unit = try {
   seq.eachReverse { (el) =>
-    try { f(el) {inner} } with inner: Control {
+    try { f(el) {inner} } with inner: Label {
       def break() = outer.break()
       def continue() = ()
     }
   }
-} with outer: Control {
+} with outer: Label {
   def break() = ()
   def continue() = ()
 }
@@ -854,7 +854,7 @@ def map[A, B](seq: Seq[A]) { f: A => B }: Seq[B] = {
   result
 }
 
-def map[A, B](seq: Seq[A]) { f: (A) {Control} => B }: Seq[B] = {
+def map[A, B](seq: Seq[A]) { f: (A) {Label} => B }: Seq[B] = {
   var result: Seq[B] = Empty()
   seq.each { (a) {label} => result = result.consRight(f(a) {label}) }
   result

package/libraries/common/stream.effekt

@@ -15,8 +15,6 @@ effect emit[A](value: A): Unit
 /// The producer can decide to `stop` emitting values.
 effect read[A](): A / stop
 
-/// Signal from a producer to a consumer that there are no further values.
-effect stop(): Nothing
 
 /// Like `for[A, R]`, but ignores the result of the stream, and consequently
 /// works for any type. Use this to annotate the type of stream elements
@@ -50,25 +48,8 @@ def fix[T] { one: T => Unit / emit[T] } { stream: => Unit / emit[T] }: Unit =
   }
 
 
-def boundary { program: () => Unit / stop }: Unit = {
-  returning::boundary[Unit]{program}
-  ()
-}
-
-/// Run `program` forever until `stop` is thrown.
-def exhaustively { program: () => Unit / stop }: Unit =
-  try {
-    def go(): Unit = {
-      program()
-      go()
-    }
-    go()
-  } with stop {
-    ()
-  }
-
 def many[A] { action: () => A / stop }: Unit / emit[A] =
-  exhaustively { do emit(action()) }
+  loop { do emit(action()) }
 
 def some[A] { action: () => A / stop }: Unit / { emit[A], stop } = {
   do emit(action())
@@ -230,7 +211,7 @@ def zip[A, B] { stream1: () => Unit / emit[A] } { stream2: () => Unit / emit[B]
   with source[A] { stream1 }
   with source[B] { stream2 }
 
-  exhaustively {
+  loop {
     action(do read(), do read())
   }
 }
@@ -241,7 +222,7 @@ def zipLongest[A, B] { stream1: () => Unit / emit[A] } { stream2: () => Unit / e
   with source[A] { stream1 }
   with source[B] { stream2 }
 
-  exhaustively {
+  loop {
      try {
       val a = do read[A]()
       try {

package/libraries/common/string.effekt

@@ -245,7 +245,7 @@ def feed[R](string: String) { reader: () => R / read[Char] } =
 
 def each(string: String): Unit / emit[Char] =
   feed(string) {
-    exhaustively {
+    loop {
       do emit(do read())
     }
   }

package/libraries/common/stringbuffer.effekt

@@ -30,7 +30,7 @@ def stringBuffer[A] { prog: => A / StringBuffer }: A = {
       val bytes = fromString(str)
       ensureCapacity(bytes.size)
       bytes.foreach { b =>
-        buffer.unsafeSet(pos, b)
+        buffer.set(pos, b)
         pos = pos + 1
       }
       resume(())

package/libraries/common/union_find.effekt

@@ -15,9 +15,9 @@ namespace internal {
   def parent(u: UnionFind, s: Int): Int / Exception[MissingValue] = {
     with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ s.show) }
     val c = u.rawElements.get(s)
-    if (c < 0) { 
-      do raise(MissingValue(), "Root node " ++ s.show ++ " has no parent.") 
-    } else { 
+    if (c < 0) {
+      do raise(MissingValue(), "Root node " ++ s.show ++ " has no parent.")
+    } else {
       c
     }
   }
@@ -31,11 +31,11 @@ namespace internal {
     }
   }
   def setParent(u: UnionFind, child: Int, parent: Int) = {
-    with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ child.show) }
+    with default[OutOfBounds, Unit] { do raise(MissingValue(), "No node " ++ child.show) }
     u.rawElements.set(child, parent)
   }
   def setRank(u: UnionFind, root: Int, rank: Int) = {
-    with on[OutOfBounds].default { do raise(MissingValue(), "No node " ++ root.show) }
+    with default[OutOfBounds, Unit] { do raise(MissingValue(), "No node " ++ root.show) }
     u.rawElements.set(root, -1 * rank - 1)
   }
 }
@@ -66,7 +66,7 @@ def find(u: UnionFind, s: Int): Int / Exception[MissingValue] = {
   }
   val root = goFind(s)
 
-  def goCompress(s: Int): Unit = { 
+  def goCompress(s: Int): Unit = {
     if (not(u.internal::isRoot(s))) {
       val p = u.internal::parent(s)
       u.internal::setParent(s, root)
@@ -82,7 +82,7 @@ def find(u: UnionFind, s: Int): Int / Exception[MissingValue] = {
 ///
 /// O(1)
 def unionRoots(u: UnionFind, x: Int, y: Int): Int / Exception[MissingValue] = {
-  if(not(u.internal::isRoot(x) && u.internal::isRoot(y))) { 
+  if(not(u.internal::isRoot(x) && u.internal::isRoot(y))) {
     panic("unionRoots should only be called on representatives")
   }
 

package/libraries/js/effekt_builtins.js

@@ -56,6 +56,6 @@ $effekt.println = function println$impl(str) {
 
 $effekt.unit = { __unit: true }
 
-$effekt.emptyMatch = function() { throw "empty match" }
+$effekt.unreachable = function() { throw "should not be reachable!" }
 
 $effekt.hole = function(pos) { throw pos + " not implemented yet" }

package/libraries/llvm/forward-declare-c.ll

@@ -7,8 +7,8 @@ declare void @c_io_println(%Pos)
 declare %Pos @c_io_readln()
 declare %Double @c_io_random()
 
-declare void @hole(i8*)
-declare void @duplicated_prompt()
+declare void @hole(i8*) cold
+declare void @duplicated_prompt() cold
 
 declare %Pos @c_ref_fresh(%Pos)
 declare %Pos @c_ref_get(%Pos)

package/libraries/llvm/io.c

@@ -143,8 +143,8 @@ void c_fs_read(Int file, struct Pos buffer, Int offset, Int size, Int position,
     if (result < 0) {
         uv_fs_req_cleanup(request);
         free(request);
+        free(read_closure);
         resume_Int(stack, result);
-	free(read_closure);
     }
 }
 
@@ -166,8 +166,8 @@ void c_fs_write(Int file, struct Pos buffer, Int offset, Int size, Int position,
     if (result < 0) {
         uv_fs_req_cleanup(request);
         free(request);
+        free(write_closure);
         resume_Int(stack, result);
-	free(write_closure);
     }
 }
 

package/libraries/llvm/panic.c

@@ -7,11 +7,13 @@
 // this should _morally_ be using `stderr`, but we don't tee it in tests
 // see PR #823 & issue #815 for context
 
+__attribute__((cold))
 void hole(const char* message) {
     printf("PANIC: %s not implemented yet\n", message);
     exit(1);
 }
 
+__attribute__((cold))
 void duplicated_prompt() {
     printf("PANIC: Continuation invoked itself\n");
     exit(1);

package/libraries/llvm/rts.ll

@@ -97,6 +97,7 @@
 declare ptr @malloc(i64)
 declare void @free(ptr)
 declare ptr @realloc(ptr, i64)
+declare noalias ptr @calloc(i64, i64)
 declare void @memcpy(ptr, ptr, i64)
 declare i64 @llvm.ctlz.i64 (i64 , i1)
 declare i64 @llvm.fshr.i64(i64, i64, i64)
@@ -407,7 +408,7 @@ define private void @invalidate(%Stack %stack, %Stack %end) {
 
 error:
     call void @duplicated_prompt()
-    ret void
+    unreachable
 
 check:
     %isEnd = icmp eq %Stack %next, %end
@@ -690,15 +691,13 @@ define private %Stack @withEmptyStack() {
     ret %Stack %stack
 }
 
-define void @resume_Int(%Stack %stack, %Int %argument) {
-    %stackPointer = call ccc %StackPointer @stackDeallocate(%Stack %stack, i64 24)
-    %returnAddressPointer = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 0, i32 0
-    %returnAddress = load %ReturnAddress, ptr %returnAddressPointer, !alias.scope !12, !noalias !22
-    tail call tailcc void %returnAddress(%Int %argument, %Stack %stack)
+define ccc void @resume_Int(%Stack %stack, %Int %integer) {
+    %argument = call ccc %Pos @coerceIntPos(%Int %integer)
+    call ccc void @resume_Pos(%Stack %stack, %Pos %argument)
     ret void
 }
 
-define void @resume_Pos(%Stack %stack, %Pos %argument) {
+define ccc void @resume_Pos(%Stack %stack, %Pos %argument) {
     %stackPointer = call ccc %StackPointer @stackDeallocate(%Stack %stack, i64 24)
     %returnAddressPointer = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 0, i32 0
     %returnAddress = load %ReturnAddress, ptr %returnAddressPointer, !alias.scope !12, !noalias !22
@@ -706,56 +705,36 @@ define void @resume_Pos(%Stack %stack, %Pos %argument) {
     ret void
 }
 
-define void @run(%Pos %boxed) {
-    ; unbox
-    %f = call %Neg @coercePosNeg(%Pos %boxed)
+define ccc void @run(%Pos %boxed) {
 
-    ; fresh stack
+    %function = call %Neg @coercePosNeg(%Pos %boxed)
     %stack = call %Stack @withEmptyStack()
 
-    ; prepare call
-    %arrayPointer = extractvalue %Neg %f, 0
-    %object = extractvalue %Neg %f, 1
+    %arrayPointer = extractvalue %Neg %function, 0
+    %object = extractvalue %Neg %function, 1
     %functionPointerPointer = getelementptr ptr, ptr %arrayPointer, i64 0
     %functionPointer = load ptr, ptr %functionPointerPointer, !alias.scope !15, !noalias !25
 
-    ; call
     tail call tailcc %Pos %functionPointer(%Object %object, %Stack %stack)
     ret void
 }
 
-define void @run_Int(%Pos %boxed, i64 %argument) {
-    ; unbox
-    %f = call %Neg @coercePosNeg(%Pos %boxed)
-
-    ; fresh stack
-    %stack = call %Stack @withEmptyStack()
-
-    ; prepare call
-    %arrayPointer = extractvalue %Neg %f, 0
-    %object = extractvalue %Neg %f, 1
-    %functionPointerPointer = getelementptr ptr, ptr %arrayPointer, i64 0
-    %functionPointer = load ptr, ptr %functionPointerPointer, !alias.scope !15, !noalias !25
-
-    ; call
-    tail call tailcc %Pos %functionPointer(%Object %object, i64 %argument, %Stack %stack)
+define ccc void @run_Int(%Pos %boxed, %Int %integer) {
+    %argument = call ccc %Pos @coerceIntPos(%Int %integer)
+    call ccc %Pos @run_Pos(%Pos %boxed, %Pos %argument)
     ret void
 }
 
-define void @run_Pos(%Pos %boxed, %Pos %argument) {
-    ; unbox
-    %f = call %Neg @coercePosNeg(%Pos %boxed)
+define ccc void @run_Pos(%Pos %boxed, %Pos %argument) {
 
-    ; fresh stack
+    %function = call ccc %Neg @coercePosNeg(%Pos %boxed)
     %stack = call %Stack @withEmptyStack()
 
-    ; prepare call
-    %arrayPointer = extractvalue %Neg %f, 0
-    %object = extractvalue %Neg %f, 1
+    %arrayPointer = extractvalue %Neg %function, 0
+    %object = extractvalue %Neg %function, 1
     %functionPointerPointer = getelementptr ptr, ptr %arrayPointer, i64 0
     %functionPointer = load ptr, ptr %functionPointerPointer, !alias.scope !15, !noalias !25
 
-    ; call
     tail call tailcc %Pos %functionPointer(%Object %object, %Pos %argument, %Stack %stack)
     ret void
 }