@effekt-lang/effekt 0.18.0 → 0.20.0

package/libraries/common/buffer.effekt

@@ -34,7 +34,7 @@ def emptyBuffer[T](capacity: Int): Buffer[T] at {global} = {
 }
 def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
   // TODO allocate buffer (and array) into a region r.
-  val contents = emptyArray[T](initialCapacity)
+  val contents = array::allocate[T](initialCapacity)
   var head in global = 0
   var tail in global = 0
 
@@ -51,7 +51,7 @@ def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
     def read() = {
       if (buffer.empty?) None()
       else {
-        val result: T = contents.remove(head).getOrElse { <> };
+        val result: T = contents.unsafeGet(head);
         head = mod(head + 1, initialCapacity)
         Some(result)
       }
@@ -59,7 +59,7 @@ def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
     def write(el: T) = {
       if (buffer.full?) <> // raise(BufferOverflow())
 
-      contents.put(tail, el)
+      contents.unsafeSet(tail, el)
       tail = mod(tail + 1, initialCapacity)
     }
   }

package/libraries/common/bytearray.effekt

@@ -6,7 +6,7 @@ module bytearray
 extern type ByteArray
   // = llvm "%Pos"
   // = js "Uint8Array"
-
+  // = chez "bytevector"
 
 /// Allocates a new bytearray with the given `size`, its values are undefined.
 extern global def allocate(size: Int): ByteArray =
@@ -15,6 +15,7 @@ extern global def allocate(size: Int): ByteArray =
     %arr = call %Pos @c_bytearray_new(%Int ${size})
     ret %Pos %arr
   """
+  chez "(make-bytevector ${size})"
 
 extern pure def size(arr: ByteArray): Int =
   js "${arr}.length"
@@ -22,6 +23,7 @@ extern pure def size(arr: ByteArray): Int =
     %size = call %Int @c_bytearray_size(%Pos ${arr})
     ret %Int %size
   """
+  chez "(bytevector-length ${arr})"
 
 extern global def unsafeGet(arr: ByteArray, index: Int): Byte =
   js "(${arr})[${index}]"
@@ -29,6 +31,7 @@ extern global def unsafeGet(arr: ByteArray, index: Int): Byte =
     %byte = call %Byte @c_bytearray_get(%Pos ${arr}, %Int ${index})
     ret %Byte %byte
   """
+  chez "(bytevector-u8-ref ${arr} ${index})"
 
 extern global def unsafeSet(arr: ByteArray, index: Int, value: Byte): Unit =
   js "bytearray$set(${arr}, ${index}, ${value})"
@@ -36,6 +39,7 @@ extern global def unsafeSet(arr: ByteArray, index: Int, value: Byte): Unit =
     %z = call %Pos @c_bytearray_set(%Pos ${arr}, %Int ${index}, %Byte ${value})
     ret %Pos %z
   """
+  chez "(bytevector-u8-set! ${arr} ${index} ${value})"
 
 def resize(source: ByteArray, size: Int): ByteArray = {
   val target = allocate(size)
@@ -75,6 +79,7 @@ extern pure def fromString(str: String): ByteArray =
   llvm """
     ret %Pos ${str}
   """
+  chez "(string->utf8 ${str})"
 
 extern pure def toString(arr: ByteArray): String =
   js "(new TextDecoder('utf-8').decode(${arr}))"
@@ -82,10 +87,68 @@ extern pure def toString(arr: ByteArray): String =
   llvm """
     ret %Pos ${arr}
   """
+  chez "(utf8->string ${arr})"
 
 extern js """
   function bytearray$set(bytes, index, value) {
     bytes[index] = value;
     return $effekt.unit;
   }
+
+  function bytearray$compare(arr1, arr2) {
+    const len = Math.min(arr1.length, arr2.length);
+
+    for (let i = 0; i < len; i++) {
+      if (arr1[i] !== arr2[i]) {
+        return arr1[i] < arr2[i] ? -1 : 1;
+      }
+    }
+
+    if (arr1.length !== arr2.length) {
+      return arr1.length < arr2.length ? -1 : 1;
+    } else {
+      return 0;
+    }
+  }
+"""
+
+extern chez """
+  (define (bytearray$compare b1 b2)
+    (let ([len1 (bytevector-length b1)]
+          [len2 (bytevector-length b2)]
+          [minlen (min (bytevector-length b1) (bytevector-length b2))])
+      (let loop ([i 0])
+        (cond
+          [(= i minlen)
+          (cond [(< len1 len2) -1]
+                [(> len1 len2) 1]
+                [else 0])]
+          [(< (bytevector-u8-ref b1 i) (bytevector-u8-ref b2 i)) -1]
+          [(> (bytevector-u8-ref b1 i) (bytevector-u8-ref b2 i)) 1]
+          [else (loop (+ i 1))]))))
 """
+
+extern pure def compareByteArrayImpl(b1: ByteArray, b2: ByteArray): Int =
+  js "bytearray$compare(${b1}, ${b2})"
+  llvm """
+    %x = call %Int @c_bytearray_compare(%Pos ${b1}, %Pos ${b2})
+    ret %Int %x
+  """
+  chez "(bytearray$compare ${b1} ${b2})"
+
+def compareByteArray(b1: ByteArray, b2: ByteArray): Ordering = {
+  val ret = compareByteArrayImpl(b1, b2)
+  if (ret == 0) {
+    Equal()
+  } else if (ret < 0) {
+    Less()
+  } else { // ret > 0
+    Greater()
+  }
+}
+
+def compareStringBytes(left: String, right: String): Ordering = {
+  val l = left.fromString
+  val r = right.fromString
+  compareByteArray(l, r)
+}

package/libraries/common/effekt.effekt

@@ -90,6 +90,7 @@ extern pure def show(value: Char): String =
 
 extern pure def show(value: Byte): String =
   js "'' + ${value}"
+  chez "(string ${value})"
   llvm """
     %z = call %Pos @c_bytearray_show_Byte(i8 ${value})
     ret %Pos %z
@@ -166,17 +167,24 @@ type Ordering {
   Greater()
 }
 
+def compareInt(n: Int, m: Int) =
+  if (n == m) Equal()
+  else if (n < m) Less()
+  else Greater()
+
 extern pure def genericCompareImpl[R](x: R, y: R): Int =
   js "$effekt.compare(${x}, ${y})"
 
 /// Compares two values of the same type, returning an `Ordering`.
 /// Only available on the JavaScript backend.
 def genericCompare[R](x: R, y: R): Ordering = {
-  genericCompareImpl(x, y) match {
-    case -1 => Less()
-    case 0 => Equal()
-    case 1 => Greater()
-    case _ => <{ "Impossible: JS comparison returned invalid value!" }>
+  val ret = genericCompareImpl(x, y)
+  if (ret == 0) {
+    Equal()
+  } else if (ret < 0) {
+    Less()
+  } else { // ret > 0
+    Greater()
   }
 }
 
@@ -390,7 +398,7 @@ extern pure def log(x: Double): Double =
 extern pure def log1p(x: Double): Double =
   js "Math.log1p(${x})"
   chez "(log (+ ${x} 1))"
-  llvm "%z = call %Double @log1p(double ${x}) ret %Double %z" 
+  llvm "%z = call %Double @log1p(double ${x}) ret %Double %z"
 
 extern pure def exp(x: Double): Double =
   js "Math.exp(${x})"
@@ -571,19 +579,19 @@ extern pure def infixGte(x: Double, y: Double): Bool =
 // TODO do we really need those? if yes, move to string.effekt
 extern pure def infixLt(x: String, y: String): Bool =
   js "(${x} < ${y})"
-  chez "(< ${x} ${y})"
+  chez "(string<? ${x} ${y})"
 
 extern pure def infixLte(x: String, y: String): Bool =
   js "(${x} <= ${y})"
-  chez "(<= ${x} ${y})"
+  chez "(string<=? ${x} ${y})"
 
 extern pure def infixGt(x: String, y: String): Bool =
   js "(${x} > ${y})"
-  chez "(> ${x} ${y})"
+  chez "(string>? ${x} ${y})"
 
 extern pure def infixGte(x: String, y: String): Bool =
   js "(${x} >= ${y})"
-  chez "(>= ${x} ${y})"
+  chez "(string>=? ${x} ${y})"
 
 
 // Boolean operations
@@ -647,10 +655,13 @@ extern pure def bitwiseXor(x: Int, y: Int): Int =
 extern pure def toByte(n: Int): Byte =
   js "${n}"
   llvm "%z = trunc %Int ${n} to %Byte ret %Byte %z"
+  chez "${n}"
 
 extern pure def toInt(n: Byte): Int =
   js "${n}"
   llvm "%z = zext %Byte ${n} to %Int ret %Int %z"
+  vm "effekt::toInt(Byte)"
+  chez "${n}"
 
 
 // Undefined and Null
@@ -666,11 +677,13 @@ extern pure def toInt(n: Byte): Int =
 extern pure def undefined[A](): A =
   js "undefined"
   chez "#f"
+  vm "effekt::undefined()"
 
 /// Is an FFI value undefined?
 extern pure def isUndefined[A](value: A): Bool =
   js "(${value} === undefined || ${value} === null)"
   chez "(eq? ${value} #f)"
+  vm "effekt::isUndefined[A](A)"
 
 
 // Tuples
@@ -723,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/io/network.effekt

@@ -57,14 +57,17 @@ def server(host: String, port: Int, handler: () => Unit / Socket at {io, async,
 
 namespace examples {
   def helloWorldApp(): Unit / Socket = {
-    val request = do receive();
+    val request = do receive().toString;
 
-    println("Received a request: " ++ request.toUTF8)
+    println("Received a request: " ++ request)
 
-    if (request.toUTF8.startsWith("GET /")) {
-      do send(fromUTF8("HTTP/1.1 200 OK\r\n\r\nHello from Effekt!"))
+    def respond(s: String): Unit / Socket =
+      do send(s.fromString)
+
+    if (request.startsWith("GET /")) {
+      respond("HTTP/1.1 200 OK\r\n\r\nHello from Effekt!")
     } else {
-      do send("HTTP/1.1 400 Bad Request\r\n\r\n".fromUTF8)
+      respond("HTTP/1.1 400 Bad Request\r\n\r\n")
     }
     do end()
   }