@effekt-lang/effekt 0.3.0 → 0.5.0

package/README.md

@@ -11,26 +11,14 @@ aims to be significantly more lightweight in its concepts.
 Also, Effekt comes with no warranty and there are (probably) many bugs -- If this does not discourage you, feel free to
 play with it and give us your feedback :)
 
-## Installation
-
-You need to have Java (>= 11) and Node (>= 12) and npm installed.
-
-The recommended way of installing Effekt is by running:
+## Examples
 
-```
-npm install -g https://github.com/effekt-lang/effekt/releases/latest/download/effekt.tgz
-```
+If you are looking for examples of the Effekt language, we invite you to look at the [casestudies](https://github.com/effekt-lang/effekt/tree/master/examples/casestudies) and the [language tour](https://effekt-lang.org/tour).
 
-Alternatively, you can download the `effekt.tgz` file from [another release](https://github.com/effekt-lang/effekt/releases) and then run
-
-```
-npm install -g effekt.tgz
-```
+## Installation
 
-This will make the `effekt` command globally available. You can start the Effekt REPL by entering:
+Please navigate to the [getting-started guide](https://effekt-lang.org/docs/getting-started#installing-effekt) on our [website](https://effekt-lang.org) for detailed instructions of how to install Effekt.
 
-```
-> effekt
-```
+## Contributing
 
-You can find more information about the Effekt language and how to use it on the website (<https://effekt-lang.org>).
+Thanks for considering to contribute to the Effekt compiler! For setting up your local environment, please check out our [contributing guide](https://effekt-lang.org/contributing.html) on the [website](https://effekt-lang.org).

package/libraries/common/args.effekt

@@ -3,7 +3,6 @@ module args
 extern io def commandLineArgs(): List[String] =
   js { js::commandLineArgs() }
   chez { chez::commandLineArgs() }
-  ml { ml::commandLineArgs() }
   llvm { llvm::commandLineArgs() }
 
 namespace js {
@@ -46,32 +45,6 @@ namespace chez {
   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 """

package/libraries/common/array.effekt

@@ -4,15 +4,11 @@ import effekt
 import exception
 import list
 
-/**
- * A mutable 0-indexed fixed-sized array.
- */
+/// 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.
- */
+/// 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
@@ -21,22 +17,16 @@ extern global def allocate[T](size: Int): Array[T] =
     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
-  }
+/// 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
+}
 
-/**
- * Converts a List `list` to an Array
- */
+/// Converts a List `list` to an Array
 def fromList[T](list: List[T]): Array[T] = {
   val listSize = list.size();
   val arr = allocate(listSize);
@@ -47,58 +37,47 @@ def fromList[T](list: List[T]): Array[T] = {
   return arr;
 }
 
-/**
- * Gets the length of the array in constant time.
- */
+/// 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.
- */
+/// 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
-}
+  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.
- */
+/// 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`
- */
+/// Creates a copy of `arr`
 def copy[T](arr: Array[T]): Array[T] = {
   with on[OutOfBounds].default { <> }; // should not happen
   val len = arr.size;
@@ -107,10 +86,8 @@ def copy[T](arr: Array[T]): Array[T] = {
   newArray
 }
 
-/**
- * Copies `length`-many elements from `from` to `to`
- * starting at `start` (in `from`) and `offset` (in `to`)
- */
+/// 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
@@ -127,26 +104,20 @@ def copy[T](from: Array[T], start: Int, to: Array[T], offset: Int, length: Int):
 
 // Derived operations:
 
-/**
- * Gets the element of the `arr` at given `index` in constant time,
- * throwing an `Exception[OutOfBounds]` unless `0 ≤ index < arr.size`.
- */
+/// 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`.
- */
+/// 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
- */
+/// 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 =>

package/libraries/common/bench.effekt

@@ -1,17 +1,15 @@
 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 =
+type Nanos = Int
+
+/// The current time (since UNIX Epoch) in nanoseconds.
+///
+/// The actual precision varies across the different backends.
+/// - js: Milliseconds
+/// - chez: Microseconds
+extern io def timestamp(): Nanos =
   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)
@@ -27,24 +25,31 @@ 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 =
+// This should not be needed when using NodeJS 16.x or newer.
+extern jsNode """
+  const { performance } = require('node:perf_hooks');
+"""
+
+/// 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(): Nanos =
   js "Math.round(performance.now() * 1000000)"
   default { timestamp() }
 
-/**
- * Runs the block and returns the time in nanoseconds
- */
-def timed { block: => Unit }: Int = {
+type Duration = Int
+
+namespace Duration {
+  def diff(fromNanos: Nanos, toNanos: Nanos): Duration = toNanos - fromNanos
+}
+
+/// Runs the block and returns the time in nanoseconds
+def timed { block: => Unit }: Duration = {
   val before = relativeTimestamp()
   block()
   val after = relativeTimestamp()
-  after - before
+  Duration::diff(before, after)
 }
 
 def measure(warmup: Int, iterations: Int) { block: => Unit }: Unit = {
@@ -58,3 +63,16 @@ def measure(warmup: Int, iterations: Int) { block: => Unit }: Unit = {
   run(warmup, false)
   run(iterations, true)
 }
+
+/// Takes a duration in nanoseconds and formats it in milliseconds with precision of two decimal digits.
+def formatMs(nanos: Nanos): String = {
+  val micros = nanos / 1000000
+  val sub = (nanos.mod(1000000).toDouble / 10000.0).round
+
+  if (sub == 100) {
+    // overflow because of rounding
+    (micros + 1).show ++ ".0ms"
+  } else {
+    micros.show ++ "." ++ sub.show ++ "ms"
+  }
+}

package/libraries/common/buffer.effekt

@@ -9,34 +9,22 @@ import array
 
 record BufferOverflow()
 
-/**
- * Fixed-size ring buffers (queues) where one can write
- * elements to the head and read from the tail.
- */
+/// Fixed-size ring buffers (queues) where one can write
+/// elements to the head and read from the tail.
 interface Buffer[T] {
-  /**
-   * The remaining capacity
-   */
+  /// The remaining capacity
   def capacity(): Int
 
-  /**
-   * Is this buffer full?
-   */
+  /// Is this buffer full?
   def full?(): Bool
 
-  /**
-   * Is this buffer empty?
-   */
+  /// Is this buffer empty?
   def empty?(): Bool
 
-  /**
-   * Read an element from the tail of the buffer
-   */
+  /// Read an element from the tail of the buffer
   def read(): Option[T]
 
-  /**
-   * Write an element to the head of the buffer
-   */
+  /// Write an element to the head of the buffer
   def write(el: T): Unit / Exception[BufferOverflow]
 }
 
@@ -120,4 +108,4 @@ namespace examples {
     println(ringbuffer.read());
     println(ringbuffer.read());
   }
-}
+}

package/libraries/common/bytes.effekt

@@ -1,15 +1,11 @@
 module bytes
 
-/**
- * A memory managed, mutable, fixed-length buffer of 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`.
- */
+/// Allocates new bytes with the given `capacity`, setting its values to `0`.
 extern io def bytes(capacity: Int): Bytes =
   js "(new Uint8Array(${capacity}))"
   llvm """
@@ -55,9 +51,7 @@ extern io def write(b: Bytes, index: Int, value: Byte): Unit =
     ret %Pos zeroinitializer
   """
 
-/**
- * Returns an *aliased* slice of b starting at offset with the given length
- */
+/// 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
@@ -66,9 +60,7 @@ def slice(b: Bytes, offset: Int, length: Int): Bytes = {
 }
 
 
-/**
- * Returns a view into the buffer, with the length truncated to n
- */
+/// Returns a view into the buffer, with the length truncated to n
 def truncated(b: Bytes, n: Int): Bytes =
   b.slice(0, n)
 
@@ -88,9 +80,7 @@ extern pure def toUTF8(b: Bytes): String =
   """
 
 namespace unsafe {
-  /**
-   * Unsafe: offset and length are not checked.
-   */
+  /// 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 """

package/libraries/common/dequeue.effekt

@@ -1,11 +1,11 @@
 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
+/// 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)