@effekt-lang/effekt 0.21.0 → 0.23.0

package/libraries/common/array.effekt

@@ -3,6 +3,7 @@ module array
 import effekt
 import exception
 import list
+import option
 
 /// A mutable 0-indexed fixed-sized array.
 extern type Array[T]
@@ -18,12 +19,17 @@ extern global def allocate[T](size: Int): Array[T] =
   """
   vm "array::allocate(Int)"
 
+/// Fills a given array in-place.
+def fill[T](arr: Array[T], filler: T): Unit = {
+  arr.foreachIndex { (idx, _) =>
+    arr.unsafeSet(idx, filler)
+  }
+}
+
 /// Creates a new Array of size `size` filled with the value `init`
 def array[T](size: Int, init: T): Array[T] = {
   val arr = allocate[T](size);
-  each(0, size) { i =>
-    unsafeSet(arr, i, init)
-  };
+  arr.fill(init)
   arr
 }
 
@@ -81,8 +87,6 @@ extern global def unsafeSet[T](arr: Array[T], index: Int, value: T): Unit =
   """
   vm "array::unsafeSet[T](Array[T], Int, T)"
 
-
-
 // Derived operations:
 
 /// Gets the element of the `arr` at given `index` in constant time,
@@ -107,6 +111,9 @@ def build[T](size: Int) { index: Int => T }: Array[T] = {
   arr
 }
 
+/// Resizes an array to a given size.
+///
+/// O(N + M)
 def resize[T](source: Array[T], size: Int): Array[T] = {
   val target = allocate(size)
   val n = min(source.size, target.size)
@@ -147,6 +154,27 @@ def copy[T](from: Array[T], start: Int, to: Array[T], offset: Int, length: Int):
 
 // Utility functions:
 
+/// Swap the value at index i with that at index j.
+/// Warning: undefined behaviour if the indices are out bound.
+/// 
+/// O(1)
+def unsafeSwap[A](arr: Array[A], i: Int, j: Int): Unit = {
+  val tmp = arr.unsafeGet(i)
+  arr.unsafeSet(i, arr.unsafeGet(j))
+  arr.unsafeSet(j, tmp)
+}
+
+/// Swap the value at index i with that at index j.
+/// 
+/// O(1)
+def swap[A](arr: Array[A], i: Int, j: Int): Unit / Exception[OutOfBounds] = {
+  if (i < 0 || i >= arr.size || j < 0 || j >= arr.size) do raise(OutOfBounds(), "Index out of bounds")
+  arr.unsafeSwap(i, j)
+}
+
+/// Converts the given array into a list.
+/// 
+/// O(N)
 def toList[T](arr: Array[T]): List[T] = {
   var i = arr.size - 1;
   var l = Nil[T]()
@@ -157,34 +185,380 @@ def toList[T](arr: Array[T]): List[T] = {
   l
 }
 
+/// Traverse an array, applying the given action on every element.
+///
+/// O(N)
 def foreach[T](arr: Array[T]){ action: T => Unit }: Unit =
   each(0, arr.size) { i =>
     action(arr.unsafeGet(i))
   }
 
+/// Traverse an array, applying the given action on every element.
+///
+/// O(N)
 def foreach[T](arr: Array[T]){ action: (T) {Control} => Unit }: Unit =
   each(0, arr.size) { (i) {label} =>
     action(arr.unsafeGet(i)) {label}
   }
 
+/// Traverse an array, applying the given action on every element and its (zero-based) index.
+///
+/// O(N)
 def foreachIndex[T](arr: Array[T]){ action: (Int, T) => Unit }: Unit =
   each(0, arr.size) { i =>
     action(i, arr.unsafeGet(i))
   }
 
+/// Traverse an array, applying the given action on every element and its (zero-based) index.
+///
+/// O(N)
 def foreachIndex[T](arr: Array[T]){ action: (Int, T) {Control} => Unit }: Unit =
   each(0, arr.size) { (i) {label} =>
     action(i, arr.unsafeGet(i)) {label}
   }
 
-def sum(list: Array[Int]): Int = {
+/// Sum the elements of the array.
+/// 
+/// O(N)
+def sum(arr: Array[Int]): Int = {
   var acc = 0
-  list.foreach { x =>
+  arr.foreach { x =>
     acc = acc + x
   }
   acc
 }
 
+/// Checks whether two given arrays are equal with respect to an equalty funciton defined on their element.
+/// 
+/// O(N)
+def equals[A](this: Array[A], other: Array[A]) { eq: (A, A) => Bool }: Bool = {
+  if (this.size != other.size) false
+  else {
+    var res = true
+    this.foreachIndex { (idx, elem) {label} =>
+      if (not(eq(elem, other.unsafeGet(idx)))) {
+        res = false
+        label.break()
+      }
+    }
+    res
+  }
+}
+
+/// Map a function `f` over the elements in a given array.
+/// Modifies the array in-place.
+///
+/// O(N)
+def map[A](arr: Array[A]) { f: A => A }: Unit = {
+  arr.foreachIndex { (idx, elem) =>
+    arr.unsafeSet(idx, f(arr.unsafeGet(idx)))
+  }
+}
+
+/// Map a function over elements.
+/// Allocates a new array of the same size.
+///
+/// O(N)
+def mapped[A, B](arr: Array[A]) { f: A => B }: Array[B] = {
+  val res = allocate(arr.size)
+  arr.foreachIndex { (idx, elem) =>
+    res.unsafeSet(idx, f(arr.unsafeGet(idx)))
+  }
+  res
+}
+
+/// Reverses an array in-place.
+/// 
+/// O(N)
+def reverse[A](arr: Array[A]): Unit = {
+  val size = arr.size()
+  val mid = size / 2
+
+  // Swap elements from start and end, moving towards the middle
+  each(0, mid) { i =>
+    val temp = arr.unsafeGet(i)
+    val j = size - 1 - i
+    val other = arr.unsafeGet(j)
+    arr.unsafeSet(i, other)
+    arr.unsafeSet(j, temp)
+  }
+}
+/// Creates a new array with elements in reverse order.
+/// 
+/// O(N)
+def reversed[A](arr: Array[A]): Array[A] = {
+  val size = arr.size()
+  val result = allocate[A](size)
+  
+  // Copy elements in reverse order to new array
+  each(0, size) { i =>
+    val value = arr.unsafeGet(i)
+    result.unsafeSet(size - 1 - i, value)
+  }
+  result
+}
+
+/// Fold an array using `f`, starting from the left given a starting value.
+///
+/// O(N)
+def foldLeft[A, B](arr: Array[A], init: B) { f: (B, A) => B }: B = {
+  var acc = init;
+  arr.foreach { x => acc = f(acc, x) };
+  acc
+}
+
+/// Fold an array using `f`, starting from the right given a starting value.
+///
+/// O(N)
+def foldRight[A, B](arr: Array[A], init: B) { f: (A, B) => B }: B = {
+  var acc = init;
+  arr.reversed.foreach { x => acc = f(x, acc) };
+  acc
+}
+
+/// Filters a given array with respect to a given predicate such that a
+/// new array containing all the elements for which the predicate
+/// holds is allocated.
+/// 
+/// O(N)
+def filtered[A](arr: Array[A]) { shouldKeep: A => Bool }: Array[A] = {
+  val res = arr.copy()
+  var idx = 0
+  arr.foreach { x =>
+    if (shouldKeep(x)) {
+      res.unsafeSet(idx, x)
+      idx = idx + 1
+    }
+  }
+  res.resize(idx)
+}
+
+/// Check if predicate is true for all elements.
+///
+/// O(N)
+def all[A](arr: Array[A]) { predicate: A => Bool }: Bool = {
+  var result = true
+  arr.foreach { (x) {label} =>
+    if (not(predicate(x))) {
+      result = false
+      label.break()
+    }
+  }
+  result
+}
+
+/// Check if predicate is true for at least one element.
+///
+/// O(N)
+def any[A](arr: Array[A]) { predicate: A => Bool }: Bool = {
+  not(arr.all { x => not(predicate(x)) })
+}
+
+/// Count elements satisfying the predicate.
+///
+/// O(N)
+def count[A](arr: Array[A]) { predicate: A => Bool }: Int = {
+  var count = 0
+  arr.foreach { x =>
+    if (predicate(x)) count = count + 1
+  }
+  count
+}
+
+/// Take first n elements.
+/// Returns a new array.
+///
+/// O(N)
+def take[A](arr: Array[A], n: Int): Array[A] = {
+  val len = min(max(0, n), arr.size)
+  val result = allocate[A](len)
+  each(0, len) { i => 
+    result.unsafeSet(i, arr.unsafeGet(i))
+  }
+  result
+}
+
+// Drop first n elements.
+/// Returns a new array.
+/// 
+/// O(N)
+def drop[A](arr: Array[A], n: Int): Array[A] = {
+  val start = min(max(0, n), arr.size)
+  val len = arr.size - start
+  val result = allocate[A](len)
+  each(0, len) { i =>
+    result.unsafeSet(i, arr.unsafeGet(i + start))
+  }
+  result
+}
+
+/// Return a slice from start (inclusive) to end (exclusive).
+/// Returns a new array.
+///
+/// O(N)
+def sliced[A](arr: Array[A], start: Int, end: Int): Array[A] = {
+  val validStart = min(max(0, start), arr.size)
+  val validEnd = min(max(validStart, end), arr.size)
+  val len = validEnd - validStart
+  val result = allocate[A](len)
+  each(0, len) { i =>
+    result.unsafeSet(i, arr.unsafeGet(i + validStart))
+  }
+  result
+}
+
+/// Zip two arrays into an array of pairs.
+/// Length is minimum of input lengths.
+///
+/// O(min(N, M))
+def zipped[A, B](this: Array[A], other: Array[B]): Array[(A, B)] = {
+  val len = min(this.size, other.size)
+  val result = allocate[(A, B)](len)
+  each(0, len) { i =>
+    result.unsafeSet(i, (this.unsafeGet(i), other.unsafeGet(i)))
+  }
+  result
+}
+
+/// Combine two arrays using given function.
+/// Length is minimum of input lengths.
+///
+/// O(min(N, M))
+def zippedWith[A, B, C](this: Array[A], other: Array[B]) { f: (A, B) => C }: Array[C] = {
+  val len = min(this.size, other.size)
+  val result = allocate[C](len)
+  each(0, len) { i =>
+    result.unsafeSet(i, f(this.unsafeGet(i), other.unsafeGet(i)))
+  }
+  result
+}
+
+/// Produce a pair of arrays from an array of pairs.
+/// Allocates two new arrays as a result.
+///
+/// O(N)
+def unzipped[A, B](arr: Array[(A, B)]): (Array[A], Array[B]) = {
+  val arr1 = allocate(arr.size)
+  val arr2 = allocate(arr.size)
+  arr.foreachIndex { (idx, tpl) =>
+    val (x, y) = tpl
+    arr1.unsafeSet(idx, x)
+    arr2.unsafeSet(idx, y)
+  }
+  (arr1, arr2)
+}
+
+/// Partition a given array into two arrays.
+/// The left array contains the elements that satsify the predicate,
+/// the right array contains the elements that do not.
+///
+/// O(N)
+def partioned[A](arr: Array[A]) { pred: A => Bool }: (Array[A], Array[A]) = {
+  val tcases = arr.copy()
+  val fcases = arr.copy()
+  var tidx = 0
+  var fidx = 0
+  arr.foreach { x =>
+    if (pred(x)) {
+      tcases.unsafeSet(tidx, x)
+      tidx = tidx + 1
+    } else {
+      fcases.unsafeSet(fidx, x)
+      fidx = fidx + 1
+    }
+  }
+  (tcases.resize(tidx), fcases.resize(fidx))
+}
+
+/// Get the _first_ index of the last occurance of `elem`, if there is any.
+/// 
+/// O(N)
+def indexOf[A](arr: Array[A], toFind: A) { eq: (A, A) => Bool }: Option[Int] = {
+  var found = None[Int]()
+  arr.foreachIndex { (idx, elem) {label} =>
+    if (eq(elem, toFind) && found.isEmpty) {
+      found = Some(idx)
+      label.break()
+    }
+  }
+  found
+}
+
+/// Get the _last_ index of the last occurance of `elem`, if there is any.
+/// 
+/// O(N)
+def lastIndexOf[A](arr: Array[A], toFind: A) { eq: (A, A) => Bool }: Option[Int] = {
+  var lastFound = None[Int]()
+  arr.foreachIndex { (idx, elem) =>
+    if (eq(elem, toFind)) {
+      lastFound = Some(idx)
+    }
+  }
+  lastFound
+}
+
+/// Perform binary search to find the index of a given element.
+/// 
+/// O(log N)
+def binarySearch[A](arr: Array[A], toFind: A) { ord: (A, A) => Ordering }: Option[Int] = {
+  def binarySearch(lowerIdx: Int, upperIdx: Int): Option[Int] = {
+    if (lowerIdx > upperIdx) None()
+    else {
+      val mid = lowerIdx + (upperIdx - lowerIdx) / 2
+      val current = arr.unsafeGet(mid)
+      ord(current, toFind) match {
+        case Less() => binarySearch(mid + 1, upperIdx)
+        case Greater() => binarySearch(lowerIdx, mid - 1)
+        case Equal() => Some(mid)
+      }
+    }
+  }
+  binarySearch(0, arr.size - 1)
+}
+
+/// Sort an array in-place using provided comparison function.
+/// Note: sort is unstable since it uses QuickSort (unlike list::sortBy)
+///
+/// O(N log N) average case
+def sort[A](arr: Array[A]) { ord: (A, A) => Ordering }: Unit = {
+  def partition(low: Int, high: Int): Int = {
+    val pivot = arr.unsafeGet(high)
+    var i = low - 1
+    
+    each(low, high) { j =>
+      ord(arr.unsafeGet(j), pivot) match {
+        case Less() =>
+          i = i + 1
+          unsafeSwap(arr, i, j)
+        case _ => ()
+      }
+    }
+    unsafeSwap(arr, i + 1, high)
+    i + 1
+  }
+  
+  def quickSort(low: Int, high: Int): Unit = {
+    if (low < high) {
+      val par = partition(low, high)
+      quickSort(low, par - 1)
+      quickSort(par + 1, high)
+    }
+  }
+  
+  quickSort(0, arr.size - 1)
+}
+
+/// Sort an array using provided comparison function.
+/// A newly allocated sorted array is returned as result, i.e., the sorting is not in-place.
+/// Note: sort is unstable since it uses QuickSort (unlike list::sortBy)
+///
+/// O(N log N) average case
+def sorted[A](arr: Array[A]) { ord: (A, A) => Ordering }: Array[A] = {
+  val res = arr.copy()
+  res.sort { ord }
+  res
+}
+
 // Show Instances
 // --------------
 

package/libraries/common/bytearray.effekt

@@ -41,6 +41,15 @@ extern global def unsafeSet(arr: ByteArray, index: Int, value: Byte): Unit =
   """
   chez "(bytevector-u8-set! ${arr} ${index} ${value})"
 
+/// 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)
+  };
+  arr
+}
+
 def resize(source: ByteArray, size: Int): ByteArray = {
   val target = allocate(size)
   val n = min(source.size, target.size)

package/libraries/common/exception.effekt

@@ -50,7 +50,7 @@ def wrongFormat(msg: String): Nothing / Exception[WrongFormat] =
 /**
  * A fatal runtime error that cannot be caught
  */
-extern io def panic[R](msg: String): R =
+extern io def panic(msg: String): Nothing =
   js "(function() { throw ${msg} })()"
   chez "(raise ${msg})"
   llvm """

package/libraries/common/io/filesystem.effekt

@@ -109,6 +109,10 @@ def close(file: File): Unit / Exception[IOError] = {
   internal::checkResult(internal::close(file)); ()
 }
 
+def mkdir(path: String): Unit / Exception[IOError] = {
+  internal::checkResult(internal::mkdir(path)); ()
+}
+
 namespace internal {
 
   extern js """
@@ -149,6 +153,12 @@ namespace internal {
         if (err) { callback(err.errno) } else { callback(0) }
       })
     }
+
+    function mkdir(path, callback) {
+      fs.mkdir(path, (err) => {
+        if (err) { callback(err.errno) } else { callback(0) }
+      })
+    }
   """
 
   extern llvm """
@@ -158,6 +168,7 @@ namespace internal {
     declare void @c_fs_read(%Int, %Pos, %Int, %Int, %Int, %Stack)
     declare void @c_fs_write(%Int, %Pos, %Int, %Int, %Int, %Stack)
     declare void @c_fs_close(%Int, %Stack)
+    declare void @c_fs_mkdir(%Pos, %Stack)
   """
 
   extern async def openForReading(path: String): Int =
@@ -204,6 +215,13 @@ namespace internal {
       ret void
     """
 
+  extern async def mkdir(path: String): Int =
+    jsNode "$effekt.capture(callback => mkdir(${path}, callback))"
+    llvm """
+      call void @c_fs_mkdir(%Pos ${path}, %Stack %stack)
+      ret void
+    """
+
   def checkResult(result: Int): Int / Exception[IOError] =
     if (result < 0) {
       val ioError = fromNumber(internal::errorNumber(result));

package/libraries/common/resizable_array.effekt

@@ -29,7 +29,7 @@ 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] = {
-  if (index < 0 && index >= arr.size) {
+  if (index < 0 || index >= arr.size) {
     do raise(OutOfBounds(), "Array index out of bounds: " ++ show(index))
   }
 }

package/libraries/common/stream.effekt

@@ -282,7 +282,10 @@ def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[I
     push(0, offset)
     return r
   } with emit[Byte] { (byte) =>
-    if (offset >= buffer.size) { push(0, buffer.size) }
+    if (offset >= buffer.size) {
+      push(0, buffer.size)
+      offset = 0
+    }
     buffer.unsafeSet(offset, byte)
     offset = offset + 1
     resume(())
@@ -304,7 +307,6 @@ def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IO
       case 0 =>
         do stop()
       case n =>
-        offset = 0
         length = n
     }
   }
@@ -313,7 +315,10 @@ def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IO
     reader()
   } with read[Byte] {
     resume {
-      if (offset >= length) { pull() }
+      if (offset >= length) {
+        pull()
+        offset = 0
+      }
       val byte = buffer.unsafeGet(offset)
       offset = offset + 1
       return byte

package/libraries/llvm/file.c

@@ -0,0 +1 @@
+

package/libraries/llvm/io.c

@@ -71,7 +71,7 @@ void c_fs_open(String path, int flags, Stack stack) {
     uv_fs_t* request = malloc(sizeof(uv_fs_t));
     request->data = stack;
 
-    int result = uv_fs_open(uv_default_loop(), request, path_str, flags, 0666, c_resume_int_fs);
+    int result = uv_fs_open(uv_default_loop(), request, path_str, flags, 0777, c_resume_int_fs);
 
     if (result < 0) {
         uv_fs_req_cleanup(request);
@@ -79,7 +79,7 @@ void c_fs_open(String path, int flags, Stack stack) {
         resume_Int(stack, result);
     }
 
-    // We must free the string either way, since libuv copies it into the request
+    // Free the string since libuv copies it into the request
     free(path_str);
 
     return;
@@ -147,6 +147,29 @@ void c_fs_close(Int file, Stack stack) {
     }
 }
 
+void c_fs_mkdir(String path, Stack stack) {
+
+    // Convert the Effekt String to a null-terminated string
+    char* path_str = c_bytearray_into_nullterminated_string(path);
+    erasePositive((struct Pos) path);
+
+    uv_fs_t* request = malloc(sizeof(uv_fs_t));
+    request->data = stack;
+
+    // Perform the mkdir operation
+    int result = uv_fs_mkdir(uv_default_loop(), request, path_str, 0777, c_resume_int_fs);
+
+    if (result < 0) {
+        uv_fs_req_cleanup(request);
+        free(request);
+        resume_Int(stack, result);
+    }
+
+    // Free the string since libuv copies it into the request
+    free(path_str);
+
+    return;
+}
 
 /**
  * Maps the libuv error code to a stable (platform independent) numeric value.