Our of bounds exceptions for resizable arrays

Author: phischu

examples/stdlib/heap/heap.effekt

@@ -4,6 +4,7 @@ import test
 def main() = {
   suite("HeapTests", false) {
     test("simple heap sort on integers") {
+      with on[OutOfBounds].default { assertTrue(false); <> };
       val h = heap[Int](box { (x: Int, y: Int) =>
         if (x < y) {
           Less()

examples/stdlib/resizable_array/resizable_array.check

@@ -1,6 +1,6 @@
 ResizableArrayTests
 ✓ usage as stack
 
- 1 pass
+ 2 pass
  0 fail
- 1 tests total
+ 2 tests total

examples/stdlib/resizable_array/resizable_array.effekt

@@ -4,6 +4,7 @@ import test
 def main() = {
   suite("ResizableArrayTests", false) {
     test("usage as stack") {
+      with on[OutOfBounds].default { assertTrue(false, "out of bounds") }
       val a = resizableArray()
       a.add(1)
       a.add(1)
@@ -26,6 +27,19 @@ def main() = {
       assert(a.popRight(), 1)
       assert(a.popRight(), 1)
     }
+    test("out of bounds check") {
+      def checkOutOfBounds(arr: ResizableArray[Int], index: Int) = {
+        with on[OutOfBounds].default { () }
+        arr.get(index)
+        assertTrue(false, "not out of bounds")
+      }
+      with on[OutOfBounds].default { assertTrue(false, "out of bounds") }
+      val a = resizableArray()
+      a.checkOutOfBounds(-1)
+      a.add(1)
+      a.add(2)
+      a.checkOutOfBounds(2)
+    }
   };
   ()
 }

libraries/common/heap.effekt

@@ -73,6 +73,7 @@ namespace internal {
 ///
 /// O(log n) worst case if capacity suffices, O(1) average
 def insert[T](heap: Heap[T], value: T): Unit = {
+  with on[OutOfBounds].panic();
   val idx = heap.rawContents.add(value)
   internal::bubbleUp(heap, idx)
 }
@@ -81,15 +82,15 @@ def insert[T](heap: Heap[T], value: T): Unit = {
 /// panics when heap is empty
 ///
 /// O(1)
-def findMin[T](heap: Heap[T]): T = {
+def findMin[T](heap: Heap[T]): T / Exception[OutOfBounds] = {
   heap.rawContents.get(0)
 }
 
 /// find and remove the minimal element in this heap
 /// panics when heap is empty
 ///
 /// O(log n)
-def deleteMin[T](heap: Heap[T]): T = {
+def deleteMin[T](heap: Heap[T]): T / Exception[OutOfBounds] = {
   val arr = heap.rawContents
   val res = arr.get(0)
   if (arr.size == 1) {

libraries/common/resizable_array.effekt

@@ -24,37 +24,37 @@ def resizableArray[T](capacity: Int): ResizableArray[T] = {
   ResizableArray(ref(0), ref(unsafeAllocate(capacity)))
 }
 
-/// Aallocatellocate a new, empty dynamic array
+/// Aallocate a new, empty dynamic array
 def resizableArray[T](): ResizableArray[T] = resizableArray(8)
 
-/// Panics if index is not a valid index into arr
-def boundsCheck[T](arr: ResizableArray[T], index: Int): Unit = {
+
+/// Throw an OutOfBounds exception if index is not a valid index into arr
+def boundsCheck[T](arr: ResizableArray[T], index: Int): Unit / Exception[OutOfBounds] =
   if (index < 0 || index >= arr.size) {
-    panic("Array index out of bounds")
+    do raise(OutOfBounds(), "Array index out of bounds: " ++ show(index))
   }
-}
 
 
 /// get the element at position index in the array
 ///
 /// O(1)
-def get[T](arr: ResizableArray[T], index: Int): T = {
+def get[T](arr: ResizableArray[T], index: Int): T / Exception[OutOfBounds] = {
   arr.boundsCheck(index);
   arr.rawContentPtr.get.get(index)
 }
 
 /// set the element at position index in the array
 ///
 /// O(1)
-def set[T](arr: ResizableArray[T], index: Int, value: T): Unit = {
+def set[T](arr: ResizableArray[T], index: Int, value: T): Unit / Exception[OutOfBounds] = {
   arr.boundsCheck(index);
   arr.rawContentPtr.get.set(index, value)
 }
 
 /// swap the elements at the given positions in the array
 ///
 /// O(1)
-def swap[T](arr: ResizableArray[T], index1: Int, index2: Int): Unit = {
+def swap[T](arr: ResizableArray[T], index1: Int, index2: Int): Unit / Exception[OutOfBounds] = {
   arr.boundsCheck(max(index1, index2))
   val raw = arr.rawContentPtr.get
   val tmp = raw.get(index1)
@@ -66,9 +66,9 @@ def swap[T](arr: ResizableArray[T], index1: Int, index2: Int): Unit = {
 /// This only changes the size of the backing array, not the `size`.
 ///
 /// O(n)
-def setCapacity[T](arr: ResizableArray[T], capacity: Int): Unit = {
+def setCapacity[T](arr: ResizableArray[T], capacity: Int): Unit / Exception[OutOfBounds] = {
   if (arr.size > capacity) {
-    panic("Cannot change capacity of ResizableArray.")
+    do raise(OutOfBounds(), "Cannot change capacity of ResizableArray to " ++ capacity.show ++ " below size " ++ arr.size.show)
   }
   val oldRaw = arr.rawContentPtr.get
   if (oldRaw.size != capacity) { 
@@ -81,7 +81,7 @@ def setCapacity[T](arr: ResizableArray[T], capacity: Int): Unit = {
 /// 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.setCapacity(newCap)
@@ -91,7 +91,7 @@ def maybeShrink[T](arr: ResizableArray[T]): Unit = {
 /// makes sure capacity is at least the given one
 ///
 /// O(given capacity - current capacity) amortized, O(n) worst case // TODO ?
-def ensureCapacity[T](arr: ResizableArray[T], capacity: Int): Unit = {
+def ensureCapacity[T](arr: ResizableArray[T], capacity: Int): Unit / Exception[OutOfBounds] = {
   if (arr.rawContentPtr.get.size < capacity) {
     val curCapd: Double = arr.rawContentPtr.get.size.toDouble
     val minGrowCapacity: Int = (curCapd * growFactor + 1.0).toInt
@@ -104,7 +104,13 @@ def ensureCapacity[T](arr: ResizableArray[T], capacity: Int): Unit = {
 /// Note: New elements might be uninitialized!!!
 ///
 /// O(max(1,index - n)) amortized, O(n) worst case if index > capacity
-def setResizing[T](arr: ResizableArray[T], index: Int, value: T): Unit = {
+def setResizing[T](arr: ResizableArray[T], index: Int, value: T): Unit / Exception[OutOfBounds] = {
+  if (index < 0) {
+    do raise(OutOfBounds(), "Negative index " ++ index.show)
+  }
+  if (index < arr.size) {
+    arr.rawContentPtr.get.set(index, value)
+  }
   ensureCapacity(arr, index + 1)
   arr.rawContentPtr.get.set(index, value)
   if (index >= arr.size) arr.rawSizePtr.set(index + 1)
@@ -115,6 +121,7 @@ def setResizing[T](arr: ResizableArray[T], index: Int, value: T): Unit = {
 ///
 /// O(1) amortized, O(n) worst case
 def add[T](arr: ResizableArray[T], value: T): Int = {
+  with on[OutOfBounds].panic();
   val idx = arr.size
   arr.setResizing(idx, value)
   idx
@@ -123,7 +130,7 @@ def add[T](arr: ResizableArray[T], value: T): Int = {
 /// Remove and return the rightmost element in the resizable array.
 ///
 /// O(1) amortized, O(n) worst case
-def popRight[T](arr: ResizableArray[T]): T = {
+def popRight[T](arr: ResizableArray[T]): T / Exception[OutOfBounds] = {
   val last = arr.size - 1
   arr.boundsCheck(last)
   val r = arr.rawContentPtr.get.get(last)
@@ -187,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.get(i), acc))
+      go(i - 1, Cons(arr.rawContentPtr.get.get(i), acc))
     }
   }
   go(arr.size - 1, Nil())