@effekt-lang/effekt 0.19.0 → 0.20.0

package/libraries/common/effekt.effekt

@@ -736,6 +736,28 @@ 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} }
 
+
+// Splices
+// =======
+//
+// The Effekt compiler translates the string interpolation
+//
+//     "foo ${42} bar ${43}"
+//
+// to the following stream of `literal`s and `splice[Int]`s:
+//
+//     do literal("foo "); do splice(42); do literal(" bar "); do splice(43)
+//
+// The stream is wrapped into a handler function, which defaults to `stringbuffer::s`
+//
+//    s { ... }
+//
+// but can be specified by prefixing the string interpolation `custom"..."`.
+
+effect literal(s: String): Unit
+effect splice[A](x: A): Unit
+
+
 namespace internal {
   namespace boxing {
     // For boxing polymorphic values

package/libraries/common/heap.effekt

@@ -0,0 +1,103 @@
+module heap
+import resizable_array
+
+/// Resizable 2-ary min-heap, backed by a resizable array
+/// `cmp` defines the ordering of elements
+record Heap[T](rawContents: ResizableArray[T], cmp: (T, T) => Ordering at {})
+
+/// Make a new Heap with the given comparison operation
+def heap[T](cmp: (T,T) => Ordering at {}) = 
+  Heap[T](resizableArray(), cmp)
+
+/// Make a new Heap with the given comparison operation and initial capacity
+def heap[T](cmp: (T,T) => Ordering at {}, capacity: Int) = 
+  Heap[T](resizableArray(capacity), cmp)
+
+namespace internal {
+  def left(idx: Int) = 2 * idx + 1
+  def right(idx: Int) = 2 * idx + 2
+  def parent(idx: Int) = (idx - 1) / 2
+
+  def bubbleUp[A](heap: Heap[A], idx: Int) = {
+    val arr = heap.rawContents
+    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)
+        go(parent(idx))
+      }
+    }
+    go(idx)
+  }
+  def sinkDown[A](heap: Heap[A], idx: Int) = {
+    val arr = heap.rawContents
+
+    def infixLt(x: A, y: A) = {
+      if ((heap.cmp)(x,y) is Less()) { true } else { false }
+    }
+    
+    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))
+        if (l < v && r < v) {
+          // swap with the smaller one
+          if (l < r) {
+            arr.unsafeSwap(left(idx), idx)
+            go(left(idx))
+          } else {
+            arr.unsafeSwap(right(idx), idx)
+            go(right(idx))
+          }
+        } else if (l < v) {
+          arr.unsafeSwap(left(idx), idx)
+          go(left(idx))
+        } else if (r < v) {
+          arr.unsafeSwap(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)
+          go(left(idx))
+        }
+      } // else: we are at the bottom
+    }
+    go(idx)
+  }
+}
+
+/// Insert value into heap
+///
+/// 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)
+}
+
+/// find and return (but not remove) the minimal element in this heap
+///
+/// O(1)
+def findMin[T](heap: Heap[T]): T / Exception[OutOfBounds] = {
+  heap.rawContents.get(0)
+}
+
+/// find and remove the minimal element in this heap
+///
+/// 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
+}
+
+/// Number of elements in the heap
+///
+/// O(1)
+def size[T](heap: Heap[T]): Int = {
+  heap.rawContents.size
+}

package/libraries/common/io/filesystem.effekt

@@ -6,35 +6,13 @@ import io
 import io/error
 
 
-/// Represents the file opening modes with their respective flags
-/// Backends rely on the order of these
-type Mode {
-  // Most common modes
-  ReadOnly()            // 'r'  exception if does not exist
-  WriteOnly()           // 'w'  created if does not exist, truncated if exists
-  AppendOnly()          // 'a'  created if does not exist
-
-  // Other modes
-  ReadWrite()           // 'w+' created if does not exist, truncated if exists
-  ReadAppend()          // 'a+' created if does not exist
-  AppendExclusive()     // 'ax' created if does not exist, fails if exists
-  ReadAppendExclusive() // 'ax+' created if does not exist, fails if exists
-  AppendSync()          // 'as' created if does not exist, append in synchronous mode
-  ReadAppendSync()      // 'as+' created if does not exist, append in synchronous mode
-  ReadSync()            // 'rs' exception if does not exist, read in synchronous mode
-  ReadWriteSync()       // 'rs+' exception if does not exist, read/write in synchronous mode
-  WriteExclusive()      // 'wx' created if does not exist, truncated if exists, fails if exists
-  ReadWriteExclusive()  // 'wx+' created if does not exist, truncated if exists, fails if exists
-}
-
-
 /// A file descriptor. Should not be inspected.
 type File = Int
 
 
 /// Reads a file at given path as utf8 encoded string.
 def readFile(path: String): String / Exception[IOError] = {
-  val file = open(path, ReadOnly());
+  val file = openForReading(path);
   with on[IOError].finalize { close(file) }
 
   val chunkSize = 1048576 // 1MB
@@ -59,7 +37,7 @@ def readFile(path: String): String / Exception[IOError] = {
 
 /// Writes the (utf8 encoded) string `contents` into the specified file.
 def writeFile(path: String, contents: String): Unit / Exception[IOError] = {
-  val file = open(path, WriteOnly());
+  val file = openForWriting(path);
   with on[IOError].finalize { close(file) }
 
   val chunkSize = 1048576 // 1MB
@@ -75,6 +53,23 @@ def writeFile(path: String, contents: String): Unit / Exception[IOError] = {
   go()
 }
 
+/// Appends the (utf8 encoded) string `contents` to the specified file.
+def appendFile(path: String, contents: String): Unit / Exception[IOError] = {
+  val file = openForAppending(path);
+  with on[IOError].finalize { close(file) }
+
+  val chunkSize = 1048576 // 1MB
+  val buffer = contents.fromString
+  var offset = 0;
+
+  def go(): Unit = {
+    val n = write(file, buffer, offset, min(buffer.size - offset, chunkSize), -1)
+    offset = offset + n
+    if (offset < buffer.size) { go() }
+  }
+
+  go()
+}
 
 /// An abstract interface applications can program against.
 ///
@@ -95,8 +90,14 @@ def filesystem[R] { program: => R / Files }: R / Exception[IOError] = // TODO mo
   }
 
 
-def open(path: String, mode: Mode): File / Exception[IOError] =
-  internal::checkResult(internal::open(path, mode))
+def openForReading(path: String): File / Exception[IOError] =
+  internal::checkResult(internal::openForReading(path))
+
+def openForWriting(path: String): File / Exception[IOError] =
+  internal::checkResult(internal::openForWriting(path))
+
+def openForAppending(path: String): File / Exception[IOError] =
+  internal::checkResult(internal::openForAppending(path))
 
 def read(file: File, buffer: ByteArray, offset: Int, size: Int, position: Int): Int / Exception[IOError] =
   internal::checkResult(internal::read(file, buffer, offset, size, position))
@@ -111,40 +112,6 @@ def close(file: File): Unit / Exception[IOError] = {
 namespace internal {
 
   extern js """
-    function modeName(mode) {
-      switch (mode.__tag) {
-      case 0: // ReadOnly()
-        return 'r';
-      case 1: // WriteOnly()
-        return 'w';
-      case 2: // AppendOnly()
-        return 'a';
-      case 3: // ReadWrite()
-        return 'w+';
-      case 4: // ReadAppend()
-        return 'a+';
-      case 5: // AppendExclusive()
-        return 'ax';
-      case 6: // ReadAppendExclusive()
-        return 'ax+';
-      case 7: // AppendSync()
-        return 'as';
-      case 8: // ReadAppendSync()
-        return 'as+';
-      case 9: // ReadSync()
-        return 'rs';
-      case 10: // ReadWriteSync()
-        return 'rs+';
-      case 11: // WriteExclusive()
-        return 'wx';
-      case 12: // ReadWriteExclusive()
-        return 'wx+';
-      default:
-        // Invalid tag value
-        return null;
-      }
-    }
-
     /**
      * Nodejs file operations expect buffers, but we represent buffers as typed arrays.
      * This function converts between the two without copying.
@@ -157,8 +124,8 @@ namespace internal {
   extern jsNode """
     const fs = require("fs");
 
-    function open(path, mode, callback) {
-      fs.open(path, modeName(mode), (err, file) => {
+    function open(path, flags, callback) {
+      fs.open(path, flags, (err, file) => {
         if (err) { callback(err.errno) } else { callback(file) }
       })
     }
@@ -185,16 +152,32 @@ namespace internal {
   """
 
   extern llvm """
-    declare void @c_fs_open(%Pos, %Pos, %Stack)
+    declare void @c_fs_open_reading(%Pos, %Stack)
+    declare void @c_fs_open_writing(%Pos, %Stack)
+    declare void @c_fs_open_appending(%Pos, %Stack)
     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)
   """
 
-  extern async def open(path: String, mode: Mode): Int =
-    jsNode "$effekt.capture(callback => open(${path}, ${mode}, callback))"
+  extern async def openForReading(path: String): Int =
+    jsNode "$effekt.capture(callback => open(${path}, 'r', callback))"
+    llvm """
+      call void @c_fs_open_reading(%Pos ${path}, %Stack %stack)
+      ret void
+    """
+
+  extern async def openForWriting(path: String): Int =
+    jsNode "$effekt.capture(callback => open(${path}, 'w', callback))"
+    llvm """
+      call void @c_fs_open_writing(%Pos ${path}, %Stack %stack)
+      ret void
+    """
+
+  extern async def openForAppending(path: String): Int =
+    jsNode "$effekt.capture(callback => open(${path}, 'a', callback))"
     llvm """
-      call void @c_fs_open(%Pos ${path}, %Pos ${mode}, %Stack %stack)
+      call void @c_fs_open_appending(%Pos ${path}, %Stack %stack)
       ret void
     """
 

package/libraries/common/resizable_array.effekt

@@ -0,0 +1,235 @@
+module resizable_array
+
+import ref
+import array
+
+record ResizableArray[T](rawSizePtr: Ref[Int], rawContentPtr: Ref[Array[T]])
+
+// These numbers should be optimized based on benchmarking
+// According to https://en.wikipedia.org/wiki/Dynamic_array most use 1.5 or 2
+
+/// Factor by which to grow the capacity when it becomes too small
+val growFactor = 1.5
+/// shrink array when size / capacity falls below this threshold
+/// should be < 1/growFactor
+val shrinkThreshold = 0.4
+
+/// Number of elements in the dynamic array
+///
+/// O(1)
+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)))
+}
+
+/// Allocate 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] = {
+  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)
+}
+
+/// set the element at position index in the array
+///
+/// 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)
+}
+
+/// swap the elements at the given positions in the array
+///
+/// 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)
+  }
+}
+
+/// Change the resizable array to have exactly the given capacity.
+/// This only changes the size of the backing array, not the `size`.
+///
+/// O(n)
+def setCapacity[T](arr: ResizableArray[T], capacity: Int): Unit / Exception[OutOfBounds] = {
+  if (arr.size > capacity) {
+    do raise(OutOfBounds(), "Cannot change capacity of ResizableArray to " ++ capacity.show ++ " below size " ++ arr.size.show)
+  }
+  arr.unsafeSetCapacity(capacity)
+}
+
+/// If the shrinkThreshold is reached, shrink by growFactor, otherwise do nothing
+///
+/// O(n)
+def maybeShrink[T](arr: ResizableArray[T]): Unit = {
+  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)
+  }
+}
+
+/// 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 / Exception[OutOfBounds] = {
+  if (arr.rawContentPtr.get.size < capacity) {
+    val curCapd: Double = arr.rawContentPtr.get.size.toDouble
+    val minGrowCapacity: Int = (curCapd * growFactor + 1.0).toInt
+    val newCapacity = max(capacity, minGrowCapacity)
+    arr.setCapacity(newCapacity)
+  }
+}
+
+/// Set the value at given position, resizing if necessary
+/// 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 / Exception[OutOfBounds] = {
+  if (index < 0) {
+    do raise(OutOfBounds(), "Negative index " ++ index.show)
+  }
+  if (index < arr.size) {
+    arr.rawContentPtr.get.unsafeSet(index, value)
+  }
+  ensureCapacity(arr, index + 1)
+  arr.rawContentPtr.get.unsafeSet(index, value)
+  arr.rawSizePtr.set(index + 1)
+}
+
+/// Add a new element at the end of the resizable array.
+/// Return the index of the new element
+///
+/// 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
+}
+
+/// Remove and return the rightmost element in the resizable array.
+///
+/// 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)
+  arr.maybeShrink()
+  r
+}
+
+
+def foreachIndex[T](arr: ResizableArray[T]){ body: (Int, T) => Unit }: Unit = {
+  each(0, arr.size) { i =>
+    body(i, arr.rawContentPtr.get.unsafeGet(i))
+  }
+}
+def foreachIndex[T](arr: ResizableArray[T]){ body: (Int, T) {Control} => Unit }: Unit = {
+  each(0, arr.size) { (i){label} =>
+    body(i, arr.rawContentPtr.get.unsafeGet(i)){label}
+  }
+}
+def foreach[T](arr: ResizableArray[T]){ body: T => Unit }: Unit = {
+  each(0, arr.size) { i =>
+    body(arr.rawContentPtr.get.unsafeGet(i))
+  }
+}
+def foreach[T](arr: ResizableArray[T]){ body: (T) {Control} => Unit }: Unit = {
+  each(0, arr.size) { (i){label} =>
+    body(arr.rawContentPtr.get.unsafeGet(i)){label}
+  }
+}
+def foreachIndexReversed[T](arr: ResizableArray[T]){ body: (Int, T){Control} => Unit }: Unit = {
+  var i = arr.size - 1
+  loop { {l} =>
+    if (i < 0) { l.break() }
+    body(i, arr.rawContentPtr.get.unsafeGet(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))
+    i = i - 1
+  }
+}
+def foreachReversed[T](arr: ResizableArray[T]){ body: (T){Control} => Unit }: Unit = {
+  var i = arr.size - 1
+  loop { {l} =>
+    if (i < 0) { l.break() }
+    body(arr.rawContentPtr.get.unsafeGet(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))
+    i = i - 1
+  }
+}
+
+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(arr.size - 1, Nil())
+}

package/libraries/common/stream.effekt

@@ -263,7 +263,7 @@ def zip[A, B] { stream1: () => Unit / emit[A] } { stream2: () => Unit / emit[B]
 
 def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[IOError] = {
 
-  val file = open(path, WriteOnly());
+  val file = openForWriting(path);
   with on[IOError].finalize { close(file) }
 
   val chunkSize = 1048576 // 1MB
@@ -291,7 +291,7 @@ def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[I
 
 def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IOError] = {
 
-  val file = open(path, ReadOnly());
+  val file = openForReading(path);
   with on[IOError].finalize { close(file) }
 
   val chunkSize = 1048576 // 1MB

package/libraries/common/stringbuffer.effekt

@@ -0,0 +1,65 @@
+module stringbuffer
+
+import bytearray
+
+interface StringBuffer {
+  def write(str: String): Unit
+  def flush(): String
+}
+
+def stringBuffer[A] { prog: => A / StringBuffer }: A = {
+  val initialCapacity = 128
+  var buffer = bytearray::allocate(initialCapacity)
+  // next free index to write to
+  var pos = 0
+
+  def ensureCapacity(sizeToAdd: Int): Unit = {
+    val cap = buffer.size - pos + 1
+    if (sizeToAdd <= cap) ()
+    else {
+      // Double the capacity while ensuring the required capacity
+      val newSize = max(buffer.size * 2, buffer.size + sizeToAdd)
+      buffer = buffer.resize(newSize)
+    }
+  }
+
+  try { prog() }
+  with StringBuffer {
+    def write(str) = {
+      val bytes = fromString(str)
+      ensureCapacity(bytes.size)
+      bytes.foreach { b =>
+        buffer.unsafeSet(pos, b)
+        pos = pos + 1
+      }
+      resume(())
+    }
+    def flush() = {
+      // resize buffer to strip trailing zeros that otherwise would be converted into 0x00 characters
+      val str = bytearray::resize(buffer, pos).toString()
+      // after flushing, the stringbuffer should be empty again
+      buffer = bytearray::allocate(initialCapacity)
+      resume(str)
+    }
+  }
+}
+
+/// Handler for string interpolation using a string buffer
+def s { prog: () => Unit / { literal, splice[String] } }: String =
+  stringBuffer {
+    try { prog(); do flush() }
+    with splice[String] { x => resume(do write(x)) }
+    with literal { s => resume(do write(s)) }
+  }
+
+namespace examples {
+  def main() = {
+    with stringBuffer
+    do write("hello")
+    do write(", world")
+    // prints `hello, world`
+    println(do flush())
+    // prints the empty string
+    println(do flush())
+  }
+}