@effekt-lang/effekt 0.2.2 → 0.3.0

package/bin/effekt.sh

@@ -1,2 +1,2 @@
 #!/bin/bash
-java -jar "$(npm root -g)/effekt/bin/effekt" $@
+java -jar "$(npm root -g)/@effekt-lang/effekt/bin/effekt" $@

package/libraries/chez/common/effekt_primitives.ss

@@ -3,6 +3,7 @@
     [(number? obj) (show-number obj)]
     [(string? obj) obj]
     [(boolean? obj) (if obj "true" "false")]
+    [(char? obj) (show-char obj)]
     ; [(record? obj)
     ;   (let* ([rtd (record-rtd obj)]
     ;          [name (symbol->string (record-type-name rtd))])
@@ -21,6 +22,9 @@
 (define (show-number n)
   (if (integer? n) (number->string (exact n)) (number->string n)))
 
+(define (show-char c)
+  (string c))
+
 ; here we use eval to find the show function defined with the record...
 ; (define (show-record rec)
 ;   (let* ([rtd (record-rtd rec)]
@@ -56,8 +60,8 @@
 
 
 
-(define (println_impl obj)
-  (display (show_impl obj))
+(define (println_impl str)
+  (display str)
   (newline))
 
 (define (equal_impl obj1 obj2)
@@ -79,6 +83,10 @@
 (define (seconds diff)
   (+ (time-second diff) (/ (time-nanosecond diff) 1000000000.0)))
 
+(define (timestamp)
+  (let ([t (current-time)])
+    (+ (* (time-second t) 1000000000) (time-nanosecond t))))
+
 (define (measure block warmup iterations)
   (define (run n)
     (if (<= n 0)

package/libraries/chez/common/immutable/cslist.effekt

@@ -1,25 +1,26 @@
 module immutable/cslist
 
-import immutable/list
+import list
+import array
 
 // a chez scheme cons list
 extern type CSList[A]
 extern pure def cons[A](el: A, rest: CSList[A]): CSList[A] =
-  "(cons ${el} ${rest})"
+  chez "(cons ${el} ${rest})"
 
 extern pure def nil[A](): CSList[A] =
-  "(list)"
+  chez "(list)"
 
-extern pure def isEmpty[A](l: CSList[A]): Boolean =
-  "(null? ${l})"
+extern pure def isEmpty[A](l: CSList[A]): Bool =
+  chez "(null? ${l})"
 
 // unsafe!
 extern pure def head[A](l: CSList[A]): A =
-  "(car ${l})"
+  chez "(car ${l})"
 
 // unsafe!
 extern pure def tail[A](l: CSList[A]): CSList[A] =
-  "(cdr ${l})"
+  chez "(cdr ${l})"
 
 
 def toChez[A](l: List[A]): CSList[A] = l match {
@@ -29,3 +30,8 @@ def toChez[A](l: List[A]): CSList[A] = l match {
 
 def fromChez[A](l: CSList[A]): List[A] =
   if (l.isEmpty) Nil() else Cons(l.head, l.tail.fromChez)
+
+// Old From Chez
+// -------------
+extern pure def toArray[A](l: CSList[A]): Array[A] =
+  chez "(list->vector ${l})"

package/libraries/chez/common/mutable/dict.effekt

@@ -1,30 +1,28 @@
 module mutable/dict
 
-import immutable/option
-
 // https://cisco.github.io/ChezScheme/csug9.5/compat.html#g148
 extern type Dict[K, V]
 
 extern io def emptyDict[K, V](): Dict[K, V] =
-    "(make-eq-hashtable)"
+    chez "(make-eq-hashtable)"
 
 extern io def emptyWeakDict[K, V](): Dict[K, V] =
-    "(make-hash-table #t)"
+    chez "(make-hash-table #t)"
 
 extern io def put[K, V](d: Dict[K, V], key: K, value: V): Unit =
-    "(put-hash-table! ${d} ${key} ${value})"
+    chez "(put-hash-table! ${d} ${key} ${value})"
 
 extern io def get[K, V](d: Dict[K, V], key: K, default: V): V =
-    "(hashtable-ref ${d} ${key} ${default})"
+    chez "(hashtable-ref ${d} ${key} ${default})"
 
 extern io def unsafeGet[K, V](d: Dict[K, V], key: K): V =
-    "(hashtable-ref ${d} ${key} #f)"
+    chez "(hashtable-ref ${d} ${key} #f)"
 
-extern io def contains[K, V](d: Dict[K, V], key: K): Boolean =
-    "(hashtable-contains? ${d} ${key})"
+extern io def contains[K, V](d: Dict[K, V], key: K): Bool =
+    chez "(hashtable-contains? ${d} ${key})"
 
 extern io def remove[K, V](d: Dict[K, V], key: K): Unit =
-    "(remove-hash-table! ${d} ${key})"
+    chez "(remove-hash-table! ${d} ${key})"
 
 def get[K, V](d: Dict[K, V], key: K): Option[V] =
     undefinedToOption(unsafeGet(d, key))

package/libraries/chez/common/text/regex.effekt

@@ -1,17 +1,15 @@
 module text/regex
 
-import immutable/option
 import immutable/cslist
-import mutable/array
 
-extern include "pregexp.scm"
+extern include chez "pregexp.scm"
 
 extern type Regex
 
 record Match(matched: String, index: Int)
 
 extern pure def regex(str: String): Regex =
-  "(pregexp ${str})"
+  chez "(pregexp ${str})"
 
 def exec(reg: Regex, str: String): Option[Match] = {
   val matched = reg.unsafeMatchString(str)
@@ -20,14 +18,14 @@ def exec(reg: Regex, str: String): Option[Match] = {
 }
 
 extern pure def unsafeMatchIndex(reg: Regex, str: String): Int =
-  "(let ([m (pregexp-match-positions ${reg} ${str})]) (if m (car (car m)) #f))"
+  chez "(let ([m (pregexp-match-positions ${reg} ${str})]) (if m (car (car m)) #f))"
 
 // we ignore the captures for now and only return the whole match
 extern pure def unsafeMatchString(reg: Regex, str: String): String =
-  "(let ([m (pregexp-match ${reg} ${str})]) (if m (car m) #f))"
+  chez "(let ([m (pregexp-match ${reg} ${str})]) (if m (car m) #f))"
 
 extern pure def split(reg: Regex, str: String): CSList[String] =
-  "(pregexp-split ${reg} ${str})"
+  chez "(pregexp-split ${reg} ${str})"
 
-def split(str: String, sep: String): Array[String] =
-  sep.regex.split(str).toArray
+// def split(str: String, sep: String): Array[String] =
+//   toArray(split(sep.regex, str))

package/libraries/common/args.effekt

@@ -0,0 +1,95 @@
+module args
+
+extern io def commandLineArgs(): List[String] =
+  js { js::commandLineArgs() }
+  chez { chez::commandLineArgs() }
+  ml { ml::commandLineArgs() }
+  llvm { llvm::commandLineArgs() }
+
+namespace js {
+  extern type Args // = Array[String]
+
+  extern io def nativeArgs(): Args = js "process.argv.slice(1)"
+
+  extern io def argCount(args: Args): Int = js "${args}.length"
+
+  extern io def argument(args: Args, i: Int): String = js "${args}[${i}]"
+
+  def commandLineArgs(): List[String] = {
+    def toList(args: Args, start: Int, acc: List[String]): List[String] =
+      if (start < 1) { acc }
+      else args.toList(start - 1, Cons(args.argument(start), acc))
+
+    val args = nativeArgs()
+    args.toList(args.argCount - 1, Nil())
+  }
+}
+
+namespace chez {
+  extern type Args // = CSList[String]
+
+  extern io def nativeArgs(): Args =
+    chez "(cdr (command-line))"
+
+  extern pure def isEmpty(l: Args): Bool =
+    chez "(null? ${l})"
+
+  extern pure def head(l: Args): String =
+    chez "(car ${l})"
+
+  extern pure def tail(l: Args): Args =
+    chez "(cdr ${l})"
+
+  def toList(l: Args): List[String] =
+    if (l.isEmpty) Nil() else Cons(l.head, l.tail.toList)
+
+  def commandLineArgs(): List[String] = nativeArgs().toList
+}
+
+namespace ml {
+
+  // MLList[String]
+  // we inline these from mllist to not have a dependency
+  extern type Args
+
+  extern io def nativeArgs(): Args =
+    ml "CommandLine.arguments ()"
+
+  extern pure def isEmpty(args: Args): Bool =
+    ml "null ${args}"
+
+  extern io def first(a: Args): String =
+    ml "hd ${a}"
+
+  extern io def rest(a: Args): Args =
+    ml "tl ${a}"
+
+
+  def commandLineArgs(): List[String] = {
+    def toList(args: Args): List[String] =
+      if (args.isEmpty) Nil() else Cons(args.first, args.rest.toList)
+    nativeArgs().toList
+  }
+}
+
+namespace llvm {
+  extern io def argCount(): Int =
+    llvm """
+      %c = call %Int @c_get_argc()
+      ret %Int %c
+    """
+
+  extern io def argument(i: Int): String =
+    llvm """
+      %s = call %Pos @c_get_arg(%Int ${i})
+      ret %Pos %s
+    """
+
+  def commandLineArgs(): List[String] = {
+    def toList(start: Int, acc: List[String]): List[String] =
+      if (start < 1) { acc }
+      else toList(start - 1, Cons(argument(start), acc))
+
+    toList(argCount() - 1, Nil())
+  }
+}

package/libraries/common/array.effekt

@@ -0,0 +1,225 @@
+module array
+
+import effekt
+import exception
+import list
+
+/**
+ * A mutable 0-indexed fixed-sized array.
+ */
+extern type Array[T]
+
+/**
+ * Allocates a new array of size `size`, keeping its values _undefined_.
+ * Prefer using `array` constructor instead to ensure that values are defined.
+ */
+extern global def allocate[T](size: Int): Array[T] =
+  js "(new Array(${size}))"
+  chez "(make-vector ${size})" // creates an array filled with 0s on CS
+  llvm """
+    %z = call %Pos @c_array_new(%Int ${size})
+    ret %Pos %z
+  """
+
+/**
+ * Creates a new Array of size `size` filled with the value `init`
+ */
+extern global def array[T](size: Int, init: T): Array[T] =
+  ml "Array.array (${size}, ${init})"
+  default {
+    val arr = allocate[T](size);
+    each(0, size) { i =>
+      unsafeSet(arr, i, init)
+    };
+    arr
+  }
+
+/**
+ * Converts a List `list` to an Array
+ */
+def fromList[T](list: List[T]): Array[T] = {
+  val listSize = list.size();
+  val arr = allocate(listSize);
+
+  foreachIndex(list) { (i, head) =>
+    arr.unsafeSet(i, head)
+  }
+  return arr;
+}
+
+/**
+ * Gets the length of the array in constant time.
+ */
+extern pure def size[T](arr: Array[T]): Int =
+  js "${arr}.length"
+  chez "(vector-length ${arr})"
+  ml "Array.length ${arr}"
+  llvm """
+    %z = call %Int @c_array_size(%Pos ${arr})
+    ret %Int %z
+  """
+
+/**
+ * Gets the element of the `arr` at given `index` in constant time.
+ * Unchecked Precondition: `index` is in bounds (0 ≤ index < arr.size)
+ *
+ * Prefer using `get` instead.
+ */
+extern global def unsafeGet[T](arr: Array[T], index: Int): T =
+  js "${arr}[${index}]"
+  chez "(vector-ref ${arr} ${index})"
+  ml "Array.sub (${arr}, ${index})"
+  llvm """
+    %z = call %Pos @c_array_get(%Pos ${arr}, %Int ${index})
+    ret %Pos %z
+  """
+
+extern js """
+function array$set(arr, index, value) {
+  arr[index] = value;
+  return $effekt.unit
+}
+"""
+
+ /**
+ * Sets the element of the `arr` at given `index` to `value` in constant time.
+ * Unchecked Precondition: `index` is in bounds (0 ≤ index < arr.size)
+ *
+ * Prefer using `set` instead.
+ */
+extern global def unsafeSet[T](arr: Array[T], index: Int, value: T): Unit =
+  js "array$set(${arr}, ${index}, ${value})"
+  chez "(begin (vector-set! ${arr} ${index} ${value}) #f)"
+  ml "Array.update (${arr}, ${index}, ${value})"
+  llvm """
+    %z = call %Pos @c_array_set(%Pos ${arr}, %Int ${index}, %Pos ${value})
+    ret %Pos %z
+  """
+
+/**
+ * Creates a copy of `arr`
+ */
+def copy[T](arr: Array[T]): Array[T] = {
+  with on[OutOfBounds].default { <> }; // should not happen
+  val len = arr.size;
+  val newArray = allocate[T](len);
+  copy[T](arr, 0, newArray, 0, len);
+  newArray
+}
+
+/**
+ * Copies `length`-many elements from `from` to `to`
+ * starting at `start` (in `from`) and `offset` (in `to`)
+ */
+def copy[T](from: Array[T], start: Int, to: Array[T], offset: Int, length: Int): Unit / Exception[OutOfBounds] = {
+  val startValid  = start >= 0 && start + length <= from.size
+  val offsetValid = offset >= 0 && offset + length <= to.size
+
+  def go(i: Int, j: Int, length: Int): Unit =
+    if (length > 0) {
+      to.unsafeSet(j, from.unsafeGet(i))
+      go(i + 1, j + 1, length - 1)
+    }
+
+  if (startValid && offsetValid) go(start, offset, length)
+  else do raise(OutOfBounds(), "Array index out of bounds, when copying")
+}
+
+// Derived operations:
+
+/**
+ * Gets the element of the `arr` at given `index` in constant time,
+ * throwing an `Exception[OutOfBounds]` unless `0 ≤ index < arr.size`.
+ */
+def get[T](arr: Array[T], index: Int): T / Exception[OutOfBounds] =
+  if (index >= 0 && index < arr.size) arr.unsafeGet(index)
+  else do raise(OutOfBounds(), "Array index out of bounds: " ++ show(index))
+
+/**
+ * Sets the element of the `arr` at given `index` to `value` in constant time,
+ * throwing an `Exception[OutOfBounds]` unless `0 ≤ index < arr.size`.
+ */
+def set[T](arr: Array[T], index: Int, value: T): Unit / Exception[OutOfBounds] =
+  if (index >= 0 && index < arr.size) unsafeSet(arr, index, value)
+  else do raise(OutOfBounds(), "Array index out of bounds: " ++ show(index))
+
+/**
+ * Builds a new Array of size `size` from a computation `index` which gets an index
+ * and returns a value that will be on that position in the resulting array
+ */
+def build[T](size: Int) { index: Int => T }: Array[T] = {
+  val arr = allocate[T](size);
+  each(0, size) { i =>
+    unsafeSet(arr, i, index(i))
+  };
+  arr
+}
+
+// Utility functions:
+
+def toList[T](arr: Array[T]): List[T] = {
+  var i = arr.size - 1;
+  var l = Nil[T]()
+  while (i >= 0) {
+    l = Cons(arr.unsafeGet(i), l)
+    i = i - 1
+  }
+  l
+}
+
+def foreach[T](arr: Array[T]){ action: T => Unit }: Unit =
+  each(0, arr.size) { i =>
+    val x: T = arr.unsafeGet(i)
+    action(x)
+  }
+
+def foreach[T](arr: Array[T]){ action: (T) {Control} => Unit }: Unit =
+  each(0, arr.size) { (i) {label} =>
+    val x: T = arr.unsafeGet(i)
+    action(x) {label}
+  }
+
+def foreachIndex[T](arr: Array[T]){ action: (Int, T) => Unit }: Unit =
+  each(0, arr.size) { i =>
+    val x: T = arr.unsafeGet(i)
+    action(i, x)
+  }
+
+def foreachIndex[T](arr: Array[T]){ action: (Int, T) {Control} => Unit }: Unit =
+  each(0, arr.size) { (i) {label} =>
+    val x: T = arr.unsafeGet(i)
+    action(i, x) {label}
+  }
+
+def sum(list: Array[Int]): Int = {
+  var acc = 0
+  list.foreach { x =>
+    acc = acc + x
+  }
+  acc
+}
+
+// Show Instances
+// --------------
+
+def show[A](arr: Array[A]) { showA: A => String }: String = {
+  var output = "Array("
+  val lastIndex = arr.size - 1
+
+  arr.foreachIndex { (index, a) =>
+    if (index == lastIndex) output = output ++ showA(a)
+    else output = output ++ showA(a) ++ ", "
+  }
+  output = output ++ ")"
+
+  output
+}
+def show(l: Array[Int]): String = show(l) { e => show(e) }
+def show(l: Array[Double]): String = show(l) { e => show(e) }
+def show(l: Array[Bool]): String = show(l) { e => show(e) }
+def show(l: Array[String]): String = show(l) { e => e }
+
+def println(l: Array[Int]): Unit = println(show(l))
+def println(l: Array[Double]): Unit = println(show(l))
+def println(l: Array[Bool]): Unit = println(show(l))
+def println(l: Array[String]): Unit = println(show(l))

package/libraries/common/bench.effekt

@@ -0,0 +1,60 @@
+module bench
+
+/**
+ * The current time (since UNIX Epoch) in nanoseconds.
+ *
+ * The actual precision varies across the different backends.
+ * - js: Milliseconds
+ * - chez: Microseconds
+ * - ml: Microseconds
+ */
+extern io def timestamp(): Int =
+  js "Date.now() * 1000000"
+  chez "(timestamp)"
+  ml "IntInf.toInt (Time.toNanoseconds (Time.now ()))"
+  llvm """
+    %time_ptr = alloca { i64, i64 }
+    call i32 @clock_gettime(i32 0, ptr %time_ptr)
+    %time = load {i64, i64}, ptr %time_ptr
+    %time_seconds = extractvalue {i64, i64} %time, 0
+    %time_nanoseconds = extractvalue {i64, i64} %time, 1
+    %time_seconds_nanoseconds = mul nsw i64 %time_seconds, 1000000000
+    %result = add nsw i64 %time_seconds_nanoseconds, %time_nanoseconds
+    ret %Int %result
+  """
+
+extern llvm """
+  declare i32 @clock_gettime(i32, ptr)
+"""
+
+/**
+ * High-precision timestamp in nanoseconds that should be for measurements.
+ *
+ * This timestamp should only be used for **relative** measurements,
+ * as gives no guarantees on the absolute time (unlike a UNIX timestamp).
+ */
+extern io def relativeTimestamp(): Int =
+  js "Math.round(performance.now() * 1000000)"
+  default { timestamp() }
+
+/**
+ * Runs the block and returns the time in nanoseconds
+ */
+def timed { block: => Unit }: Int = {
+  val before = relativeTimestamp()
+  block()
+  val after = relativeTimestamp()
+  after - before
+}
+
+def measure(warmup: Int, iterations: Int) { block: => Unit }: Unit = {
+  def run(n: Int, report: Bool): Unit = {
+    if (n <= 0) { () } else {
+      val time = timed { block() };
+      if (report) { println(time) } else { () };
+      run(n - 1, report)
+    }
+  }
+  run(warmup, false)
+  run(iterations, true)
+}

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());
+  }
+}