@effekt-lang/effekt 0.2.1 → 0.3.0

package/libraries/common/buffer.effekt

@@ -0,0 +1,123 @@
+module buffer
+
+import array
+
+// TODO (in Effekt compiler)
+// - [ ] fix allocating into actually global region
+// - [ ] fix exceptions on objects
+// - [X] allow omitting braces after `at` for singleton regions
+
+record BufferOverflow()
+
+/**
+ * Fixed-size ring buffers (queues) where one can write
+ * elements to the head and read from the tail.
+ */
+interface Buffer[T] {
+  /**
+   * The remaining capacity
+   */
+  def capacity(): Int
+
+  /**
+   * Is this buffer full?
+   */
+  def full?(): Bool
+
+  /**
+   * Is this buffer empty?
+   */
+  def empty?(): Bool
+
+  /**
+   * Read an element from the tail of the buffer
+   */
+  def read(): Option[T]
+
+  /**
+   * Write an element to the head of the buffer
+   */
+  def write(el: T): Unit / Exception[BufferOverflow]
+}
+
+def emptyBuffer[T](capacity: Int): Buffer[T] at {global} = {
+  if (capacity == 1) refBuffer()
+  else arrayBuffer(capacity)
+}
+def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
+  // TODO allocate buffer (and array) into a region r.
+  val contents = emptyArray[T](initialCapacity)
+  var head in global = 0
+  var tail in global = 0
+
+  def size(): Int =
+    if (tail >= head) { tail - head }
+    else { initialCapacity - head + tail }
+
+  def capacity(): Int = initialCapacity - size()
+
+  def buffer = new Buffer[T] {
+    def capacity() = capacity()
+    def full?() = capacity() <= 0
+    def empty?() = size() <= 0
+    def read() = {
+      if (buffer.empty?) None()
+      else {
+        val result: T = contents.remove(head).getOrElse { <> };
+        head = mod(head + 1, initialCapacity)
+        Some(result)
+      }
+    }
+    def write(el: T) = {
+      if (buffer.full?) <> // raise(BufferOverflow())
+
+      contents.put(tail, el)
+      tail = mod(tail + 1, initialCapacity)
+    }
+  }
+  buffer
+}
+def refBuffer[T](): Buffer[T] at {global} = {
+  var content: Option[T] in global = None()
+  new Buffer[T] {
+    def capacity() = if (content.isEmpty) 1 else 0
+    def full?() = content.isDefined
+    def empty?() = isEmpty(content)
+    def read() = {
+      val res = content
+      content = None()
+      res
+    }
+    def write(el: T) = content match {
+      case Some(v) =>
+        <> // do raise(BufferOverflow(), "Cannot read element from buffer")
+      case None() =>
+        content = Some(el)
+    }
+  }
+}
+
+namespace examples {
+  def main() = ignore[BufferOverflow] {
+    // Buffer with capacity 1
+    def b = emptyBuffer[Int](1);
+    println(b.capacity);
+    println(b.full?);
+
+    b.write(17);
+    println(b.read());
+
+    // buffer with capacity 3
+    def ringbuffer = emptyBuffer[Int](3);
+    ringbuffer.write(1);
+    ringbuffer.write(2);
+    println(ringbuffer.read());
+    ringbuffer.write(3);
+    println(ringbuffer.read());
+    println(ringbuffer.read());
+    ringbuffer.write(4);
+    ringbuffer.write(5);
+    println(ringbuffer.read());
+    println(ringbuffer.read());
+  }
+}

package/libraries/common/bytes.effekt

@@ -0,0 +1,125 @@
+module bytes
+
+/**
+ * A memory managed, mutable, fixed-length buffer of bytes.
+ */
+extern type Bytes
+  // = llvm "%Pos"
+  // = js "Uint8Array"
+
+/**
+ * Allocates new bytes with the given `capacity`, setting its values to `0`.
+ */
+extern io def bytes(capacity: Int): Bytes =
+  js "(new Uint8Array(${capacity}))"
+  llvm """
+    %buf = call %Pos @c_buffer_construct_uninitialized(i64 ${capacity})
+    ret %Pos %buf
+  """
+
+def copy(b: Bytes): Bytes = {
+  val len = b.size
+  val clone = bytes(len)
+  copy(b, clone, 0, 0, len)
+  clone
+}
+
+extern io def copy(from: Bytes, to: Bytes, startFrom: Int, startTo: Int, length: Int): Unit =
+  js "bytes$copy(${from}, ${to}, ${startFrom}, ${startTo}, ${length})"
+  llvm """
+    call void @c_buffer_copy(%Pos ${from}, %Pos ${to}, i64 ${startFrom}, i64 ${startTo}, i64 ${length})
+    ; return Unit
+    ret %Pos zeroinitializer
+  """
+
+extern pure def size(b: Bytes): Int =
+  js "${b}.length"
+  llvm """
+    %size = call i64 @c_buffer_length(%Pos ${b})
+    ret i64 %size
+  """
+
+extern io def read(b: Bytes, index: Int): Byte =
+  js "(${b})[${index}]"
+  llvm """
+    %byte = call i8 @c_buffer_index(%Pos ${b}, i64 ${index})
+    ret i8 %byte
+  """
+
+// TODO should return the number of bytes written.
+extern io def write(b: Bytes, index: Int, value: Byte): Unit =
+  js "bytes$set(${b}, ${index}, ${value})"
+  llvm """
+    call void @c_buffer_set(%Pos ${b}, i64 ${index}, i8 ${value})
+    ; return Unit
+    ret %Pos zeroinitializer
+  """
+
+/**
+ * Returns an *aliased* slice of b starting at offset with the given length
+ */
+def slice(b: Bytes, offset: Int, length: Int): Bytes = {
+  def validOffset() = offset >= 0 && offset < b.size
+  def validLength() = length >= 0 && (offset + length) <= b.size
+  if (validOffset() && validLength()) unsafe::slice(b, offset, length)
+  else panic("Invalid slice of bytes (size: " ++ b.size.show ++ ", offset: " ++ offset.show ++ ", length: " ++ length.show ++ ")")
+}
+
+
+/**
+ * Returns a view into the buffer, with the length truncated to n
+ */
+def truncated(b: Bytes, n: Int): Bytes =
+  b.slice(0, n)
+
+extern pure def fromUTF8(s: String): Bytes =
+  js "(new TextEncoder().encode(${s}))"
+  llvm """
+    %copy = call %Pos @c_buffer_clone(%Pos ${s})
+    ret %Pos %copy
+  """
+
+extern pure def toUTF8(b: Bytes): String =
+  js "(new TextDecoder('utf-8').decode(${b}))"
+  // assuming the buffer is already in UTF-8
+  llvm """
+    %copy = call %Pos @c_buffer_clone(%Pos ${b})
+    ret %Pos %copy
+  """
+
+namespace unsafe {
+  /**
+   * Unsafe: offset and length are not checked.
+   */
+  extern io def slice(b: Bytes, offset: Int, length: Int): Bytes =
+    js "new Uint8Array(${b}.buffer, ${offset}, ${length})"
+    llvm """
+      %buf = call %Pos @c_buffer_slice(%Pos ${b}, i64 ${offset}, i64 ${length})
+      ret %Pos %buf
+    """
+
+}
+
+
+extern js """
+  function bytes$set(bytes, index, value) {
+    bytes[index] = value;
+    return $effekt.unit;
+  }
+
+  function bytes$clone(original) {
+    let copy = new Uint8Array(original.length);
+    copy.set(original);
+    return copy;
+  }
+
+  function bytes$copy(from, to, startFrom, startTo, length) {
+    // Check bounds
+    if (startFrom + length > from.length || startTo + length > to.length) {
+        throw new RangeError('Index out of bounds');
+    }
+
+    // Create a subarray of 'from' and set it into 'to'
+    to.set(from.subarray(startFrom, startFrom + length), startTo);
+}
+"""

package/libraries/common/dequeue.effekt

@@ -0,0 +1,92 @@
+module dequeue
+
+
+// An implementation of a functional dequeue, using Okasaki's
+// bankers dequeue implementation.
+//
+// Translation from the Haskell implementation:
+//   https://hackage.haskell.org/package/dequeue-0.1.12/docs/src/Data-Dequeue.html#Dequeue
+record Dequeue[R](front: List[R], frontSize: Int, rear: List[R], rearSize: Int)
+
+def emptyQueue[R](): Dequeue[R] = Dequeue(Nil(), 0, Nil(), 0)
+
+def isEmpty[R](dq: Dequeue[R]): Bool = dq match {
+    case Dequeue(f, fs, r, rs) => (fs == 0) && (rs == 0)
+}
+
+def size[R](dq: Dequeue[R]): Int = dq match {
+    case Dequeue(f, fs, r, rs) => fs + rs
+}
+
+def first[R](dq: Dequeue[R]): Option[R] = dq match {
+    case Dequeue(f, fs, r, rs) =>
+      if ((fs == 0) && (rs == 1)) { r.headOption }
+      else { f.headOption }
+}
+
+def last[R](dq: Dequeue[R]): Option[R] = dq match {
+    case Dequeue(f, fs, r, rs) =>
+      if ((fs == 1) && (rs == 0)) { f.headOption }
+      else { r.headOption }
+}
+
+def check[R](dq: Dequeue[R]): Dequeue[R] = dq match {
+    case Dequeue(f, fs, r, rs) =>
+        val c = 4;
+        val size1 = (fs + rs) / 2;
+        val size2 = (fs + rs) - size1;
+
+        if (fs > c * rs + 1) {
+            val front = f.take(size1);
+            val rear = r.append(f.drop(size1).reverse);
+            Dequeue(front, size1, rear, size2)
+        } else if (rs > c * fs + 1) {
+            val front = f.append(r.drop(size1).reverse);
+            val rear = r.take(size1);
+            Dequeue(front, size2, rear, size1)
+        } else {
+            dq
+        }
+}
+
+def pushFront[R](dq: Dequeue[R], el: R): Dequeue[R] = dq match {
+    case Dequeue(f, fs, r, rs) => Dequeue(Cons(el, f), fs + 1, r, rs).check
+}
+
+def popFront[R](dq: Dequeue[R]): Option[(R, Dequeue[R])] = dq match {
+    case Dequeue(Nil(), fs, Cons(x, Nil()), rs) =>
+        Some((x, emptyQueue()))
+    case Dequeue(Nil(), fs, r, rs) =>
+        None()
+    case Dequeue(Cons(x, rest), fs, r, rs) =>
+        Some((x, Dequeue(rest, fs - 1, r, rs).check))
+}
+
+def pushBack[R](dq: Dequeue[R], el: R): Dequeue[R] = dq match {
+    case Dequeue(f, fs, r, rs) => Dequeue(f, fs, Cons(el, r), rs + 1).check
+}
+
+def popBack[R](dq: Dequeue[R]): Option[(R, Dequeue[R])] = dq match {
+    case Dequeue(Cons(x, Nil()), fs, Nil(), rs) =>
+        Some((x, emptyQueue()))
+    case Dequeue(f, fs, Nil(), rs) =>
+        None()
+    case Dequeue(f, fs, Cons(x, rest), rs) =>
+        Some((x, Dequeue(f, fs, rest, rs - 1).check))
+}
+
+
+def show[A](d: Dequeue[A]) { showA: A => String }: String = {
+  val Dequeue(front, frontSize, rear, rearSize) = d;
+  "Dequeue(" ++ show(front){showA} ++ ", " ++ show(frontSize) ++ ", " ++
+      show(rear){showA} ++ ", " ++ show(rearSize) ++ ")"
+}
+def show(l: Dequeue[Int]): String = show(l) { e => show(e) }
+def show(l: Dequeue[Double]): String = show(l) { e => show(e) }
+def show(l: Dequeue[Bool]): String = show(l) { e => show(e) }
+def show(l: Dequeue[String]): String = show(l) { e => e }
+
+def println(l: Dequeue[Int]): Unit = println(show(l))
+def println(l: Dequeue[Double]): Unit = println(show(l))
+def println(l: Dequeue[Bool]): Unit = println(show(l))
+def println(l: Dequeue[String]): Unit = println(show(l))