@effekt-lang/effekt 0.2.2 → 0.3.0

package/libraries/js/io/args.effekt

@@ -1,9 +0,0 @@
-module io/args
-
-import effekt
-import immutable/list
-import mutable/array
-
-extern io def nativeArgs(): Array[String] = "process.argv.slice(2)"
-
-def commandLineArgs(): List[String] = nativeArgs().toList

package/libraries/js/io/async.effekt

@@ -1,28 +0,0 @@
-module io/async
-
-extern include "async.js"
-
-extern type Promise[T]
-
-interface AsyncIO {
-  def read(path: String): Promise[String]
-  def await[T](p: Promise[T]): T
-}
-
-def asyncIO[R](p: () => R / AsyncIO at {io}): R = try {
-  p()
-} with AsyncIO {
-  def read(path) = resume(readPromise(path))
-  def await[T](p) = awaitPromise(p, resume)
-}
-
-def block[T](p: Promise[T]) = do await(p)
-
-extern io def readPromise(path: String): Promise[String] =
-  "fsPromises.readFile(${path}, 'utf8')"
-
-extern io def awaitPromise[T, R](p: Promise[T], cont: T => R at {io}): R =
-  "${p}.then(res => (${cont})(res).run())"
-
-extern io def fork(process: () => Unit at {io}): Unit =
-  "setTimeout(() => (${process})().run(), 0)"

package/libraries/js/io/async.js

@@ -1,2 +0,0 @@
-const fs = require("fs")
-const fsPromises = fs.promises;

package/libraries/js/io/file.effekt

@@ -1,50 +0,0 @@
-module io/file
-
-effect IOException[A](msg: String): A
-
-extern include "file_include.js"
-
-extern type FileDescriptor
-
-extern type Buffer
-
-type Result[A] {
-  Error(msg: String);
-  Success(a: A)
-}
-
-extern type Promise[T]
-
-extern io def readPromise(path: String): Promise[String] =
-  "$effekt.delayed(() => fsPromises.readFile(${path}, 'utf8'))"
-
-def await[T](p: Promise[T]): T / { IOException } =
-  try { awaitImpl(p){exc} } with exc : IOException[A] {
-    msg => do IOException(msg)
-  }
-
-extern io def awaitImpl[T](p: Promise[T]){exc: IOException}: T =
-  "$effekt.callcc(k => ${p}.then(res => k($effekt.pure(res)), err => k(${box { (msg: String) => do IOException[T](msg) }}(err.message)))).then(c => c)"
-
-def open(path: String, mode: String): FileDescriptor / { IOException } =
-  try { openImpl(path, mode){exc} } with exc : IOException[A] {
-    msg => do IOException(msg)
-  }
-
-extern io def openImpl(path: String, mode: String){exc: IOException}: FileDescriptor =
-  "$effekt.delayed(() => { try { return $effekt.pure(fs.openSync(${path}, ${mode})); } catch (err) { return ${box { (msg: String) => do IOException[FileDescriptor](msg) }}(err.message); }}).then(c => c)"
-
-extern io def close(fd: FileDescriptor): Unit =
-  "$effekt.delayed(() => fs.closeSync(${fd}))"
-
-// uses the asynchronous API of node
-extern io def readFile(path: String): Result[String] =
-  "$effekt.callcc(k => fs.readFile(${path}, 'utf8', (err, data) => k(err ? ${box Error}(err.message) : ${box Success}(data))))"
-
-def read(path: String): String / { IOException } =
-  getResult(readFile(path))
-
-def getResult[R](r: Result[R]): R / { IOException } = r match {
-  case Error(msg) => do IOException(msg)
-  case Success(r) => r
-}

package/libraries/js/io/file_include.js

@@ -1,13 +0,0 @@
-const fs = require("fs")
-const fsPromises = fs.promises;
-
-function readAsyncHelper(path, f) {
-    return $effekt.callcc(k => {
-        fs.readFile(path, 'utf8', (err, data) => {
-            // change f, so it returns true
-            const comp = f(err ? Error(err.message) : Success(data)).then(x => $effekt.pure(true))
-            k(comp); // restore the stack, since `f` might use effects
-        });
-        return k($effekt.pure(false))
-    }).then(x => x).then(abort => abort ? $effekt.callcc(k => $effekt.pure(null)) : $effekt.pure(null))
-}

package/libraries/js/mutable/array.effekt

@@ -1,98 +0,0 @@
-module mutable/array
-
-import immutable/option
-import immutable/list
-
-// A mutable 0-based indexed array, backed by a JavaScript array.
-extern type Array[T]
-
-def emptyArray[T](): Array[T] = emptyArray(0)
-
-// Creates a new Array of size `size` filled with the value `default`
-def fill[T](size: Int, default: T): Array[T] = {
-  val arr = emptyArray[T](size)
-  each(0, arr.size()) { i =>
-    put(arr, i, default)
-  }
-  return arr;
-}
-
-// 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 = emptyArray[T](size)
-  each(0, arr.size()) { i =>
-    put(arr, i, index(i))
-  }
-  return arr
-}
-
-// Converts a List `list` to an Array
-def fromList[T](list: List[T]): Array[T] = {
-  val listSize = list.size();
-  val arr = emptyArray(listSize);
-
-  foreachIndex(list) { (i, head) =>
-    put(arr, i, head)
-  }
-  return arr;
-}
-
-extern pure def emptyArray[T](initialSize: Int): Array[T] =
-  "(new Array(${initialSize}))"
-
-def get[T](arr: Array[T], index: Int): Option[T] =
-  arr.unsafeGet(index).undefinedToOption
-
-extern pure def size[T](arr: Array[T]): Int =
-  "${arr}.length"
-
-extern io def unsafeGet[T](arr: Array[T], index: Int): T =
-  "${arr}[${index}]"
-
-extern """
-function put(arr, index, value) {
-  arr[index] = value;
-  return $effekt.unit
-}
-"""
-
-extern io def put[T](arr: Array[T], index: Int, value: T): Unit =
-  "put(${arr}, ${index}, ${value})"
-
-extern pure def copy[T](arr: Array[T]): Array[T] =
-  "[...${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(unsafeGet(arr, i), l)
-    i = i - 1
-  }
-  l
-}
-
-def foreach[T](arr: Array[T]){ action: T => Unit / Control }: Unit = {
-  each(0, arr.size) { i =>
-    val x: T = arr.unsafeGet(i)
-    action(x)
-  }
-}
-
-def foreachIndex[T](arr: Array[T]){ action: (Int, T) => Unit / Control }: Unit = {
-  each(0, arr.size) { i =>
-    val x: T = arr.unsafeGet(i)
-    action(i, x)
-  }
-}
-
-def sum(list: Array[Int]): Int = {
-  var acc = 0
-  list.foreach { x =>
-    acc = acc + x
-  }
-  acc
-}

package/libraries/js/mutable/heap.effekt

@@ -1,32 +0,0 @@
-module mutable/heap
-
-extern """
-var heap$data = {};
-var heap$pointer = 0;
-
-function heap$fresh(init) {
-    const ref = heap$pointer++;
-    heap$data[ref] = init;
-    return ref
-}
-
-function heap$put(ref, value) {
-    heap$data[ref] = value;
-    return null
-}
-
-function get$impl(ref) {
-    return heap$data[ref];
-}
-"""
-
-extern type HeapRef[T]
-
-extern io def fresh[T](init: T): HeapRef[T] =
-    "heap$fresh(${init})"
-
-extern io def put[T](ref: HeapRef[T], value: T): Unit =
-    "heap$put(${ref}, ${value})"
-
-extern io def get[T](ref: HeapRef[T]): T =
-    "heap$data[${ref}]"

package/libraries/js/test.effekt

@@ -1,59 +0,0 @@
-import text/string
-
-interface Assertion {
-  def assert(condition: Boolean, msg: String): Unit
-}
-
-def assertTrue(condition: Boolean, msg: String) =
-  do assert(condition, msg)
-
-def assertTrue(condition: Boolean) =
-  do assert(condition, "Assertion failed")
-
-def assertFalse(condition: Boolean, msg: String) =
-  do assert(not(condition), msg)
-
-def assertFalse(condition: Boolean) =
-  do assert(not(condition), "Assertion failed")
-
-def assertEqual[A](obtained: A, expected: A, msg: String) =
-  do assert(obtained == expected, msg)
-
-def assertEqual[A](obtained: A, expected: A) =
-  do assert(obtained == expected, "Obtained: " ++ obtained.show ++ "\n but expected:" ++ expected.show)
-
-interface Test {
-  def success(name: String): Unit
-  def failure(name: String, msg: String): Unit
-}
-
-def test(name: String) { body: => Unit / Assertion } =
-  try { body(); do success(name) } with Assertion {
-    def assert(condition, msg) = if (condition) resume(()) else do failure(name, msg)
-  }
-
-def suite(name: String) { body: => Unit / Test }: Boolean = {
-  println("Running suite: " ++ name);
-  var failed = 0
-  var passed = 0
-
-  try { body() } with Test {
-    def success(name) = {
-      passed = passed + 1
-      println(ANSI_GREEN ++ "+ " ++ name ++ "" ++ ANSI_RESET);
-      resume(())
-    }
-    def failure(name, msg) = {
-      failed = failed + 1
-      println(ANSI_RED ++ "- (FAIL) " ++ name ++ "\n    " ++ msg ++ ANSI_RESET);
-      resume(())
-    }
-  }
-  if (failed > 0) {
-    println(ANSI_RED ++ "Some tests failed (" ++ passed.show ++ " passed, " ++ failed.show ++ " failed)" ++ ANSI_RESET)
-    false
-  } else {
-    println(ANSI_GREEN ++ "All tests passed (" ++ passed.show ++ " passed)" ++ ANSI_RESET)
-    true
-  }
-}

package/libraries/js/text/string.effekt

@@ -1,64 +0,0 @@
-module text/string
-
-import immutable/option
-import mutable/array
-
-def charAt(str: String, index: Int): Option[String] =
-    str.unsafeCharAt(index).undefinedToOption
-
-extern pure def length(str: String): Int =
-  "${str}.length"
-
-extern pure def repeat(str: String, n: Int): String =
-  "${str}.repeat(${n})"
-
-extern pure def unsafeSubstring(str: String, from: Int, to: Int): String =
-  "${str}.substring(${from}, ${to})"
-
-def substring(str: String, from: Int, to: Int): String =
-  if (from >= to) { "" }
-  else {
-    str.unsafeSubstring(from, to)
-  }
-
-def substring(str: String, from: Int): String =
-  str.unsafeSubstring(from, str.length)
-
-extern pure def split(str: String, sep: String): Array[String] =
-  "${str}.split(${sep})"
-
-extern pure def trim(str: String): String =
-  "${str}.trim()"
-
-def toInt(str: String): Option[Int] =
-  str.unsafeToInt.undefinedToOption
-
-extern pure def unsafeCharAt(str: String, n: Int): String =
-  "${str}[${n}]"
-
-extern pure def unsafeToInt(str: String): Int =
-  "(Number.isNaN(parseInt(${str})) ? undefined : parseInt(${str}))"
-
-def indexOf(str: String, sub: String): Option[Int] = {
-  val index = str.unsafeIndexOf(sub)
-  if (index < 0) { None() } else { Some(index) }
-}
-
-def lastIndexOf(str: String, sub: String): Option[Int] = {
-  val index = str.unsafeLastIndexOf(sub)
-  if (index < 0) { None() } else { Some(index) }
-}
-
-extern pure def unsafeIndexOf(str: String, sub: String): Int = "${str}.indexOf(${sub})"
-extern pure def unsafeLastIndexOf(str: String, sub: String): Int = "${str}.lastIndexOf(${sub})"
-
-extern pure def startsWith(str: String, prefix: String): Boolean =
-  "${str}.startsWith(${prefix})"
-
-extern pure def endsWith(str: String, suffix: String): Boolean =
-  "${str}.endsWith(${suffix})"
-
-// ANSI escape codes
-val ANSI_GREEN = "\u001b[32m"
-val ANSI_RED = "\u001b[31m"
-val ANSI_RESET = "\u001b[0m"

package/libraries/llvm/effekt.effekt

@@ -1,243 +0,0 @@
-module effekt
-
-extern include "rts.ll"
-extern include "forward-declare-c.ll"
-
-// Effekt-closed stdlib facilities
-
-def min(n: Int, m: Int): Int =
-    if (n < m) n else m
-
-def max(n: Int, m: Int): Int =
-    if (n > m) n else m
-
-def neg(n: Int): Int =
-    0 - n
-
-def abs(n: Int): Int =
-    max(n, neg(n))
-
-
-// i/o
-
-extern io def println(n: Int): Unit = """
-    call void @c_io_println_Int(%Int %n)
-    ret %Pos zeroinitializer ; Unit
-"""
-
-extern io def println(b: Boolean): Unit = """
-    call void @c_io_println_Boolean(%Pos %b)
-    ret %Pos zeroinitializer ; Unit
-"""
-
-extern io def println(x: Double): Unit = """
-    call void @c_io_println_Double(%Double %x)
-    ret %Pos zeroinitializer ; Unit
-"""
-
-extern io def println(str: String): Unit = """
-    call void @c_io_println_String(%Pos %str)
-    call void @c_buffer_refcount_decrement(%Pos %str)
-    ret %Pos zeroinitializer ; Unit
-"""
-
-def println(u: Unit): Unit = println("unit")
-
-// strings
-
-extern pure def infixEq(x: String, y: String): Boolean = """
-    %res = call %Pos @c_buffer_eq(%Pos %x, %Pos %y)
-    call void @c_buffer_refcount_decrement(%Pos %x)
-    call void @c_buffer_refcount_decrement(%Pos %y)
-    ret %Pos %res
-"""
-def infixNeq(x: String, y: String): Boolean = not(x == y)
-
-extern pure def infixConcat(s: String, z: String): String = """
-    %spz = call %Pos @c_buffer_concatenate(%Pos %s, %Pos %z)
-    call void @c_buffer_refcount_decrement(%Pos %s)
-    call void @c_buffer_refcount_decrement(%Pos %z)
-    ret %Pos %spz
-"""
-
-// integer arithmetic
-
-extern pure def infixAdd(x: Int, y: Int): Int = "%z = add  %Int ${x}, ${y} ret %Int %z"
-extern pure def infixSub(x: Int, y: Int): Int = "%z = sub  %Int ${x}, ${y} ret %Int %z"
-extern pure def infixMul(x: Int, y: Int): Int = "%z = mul  %Int ${x}, ${y} ret %Int %z"
-extern pure def infixDiv(x: Int, y: Int): Int = "%z = sdiv %Int ${x}, ${y} ret %Int %z"
-
-extern pure def mod     (x: Int, y: Int): Int = "%z = srem %Int ${x}, ${y} ret %Int %z"
-
-
-// floating-point arithmetic
-
-extern pure def infixAdd(x: Double, y: Double): Double = "%z = fadd %Double ${x}, ${y} ret %Double %z"
-extern pure def infixSub(x: Double, y: Double): Double = "%z = fsub %Double ${x}, ${y} ret %Double %z"
-extern pure def infixMul(x: Double, y: Double): Double = "%z = fmul %Double ${x}, ${y} ret %Double %z"
-extern pure def infixDiv(x: Double, y: Double): Double = "%z = fdiv %Double ${x}, ${y} ret %Double %z"
-
-
-// ordering on signed integers
-
-extern pure def infixEq(x: Int, y: Int): Boolean = """
-    %z = icmp eq %Int %x, %y
-    %fat_z = zext i1 %z to i64
-    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
-    ret %Pos %adt_boolean
-"""
-
-extern pure def infixNeq(x: Int, y: Int): Boolean = """
-    %z = icmp ne %Int %x, %y
-    %fat_z = zext i1 %z to i64
-    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
-    ret %Pos %adt_boolean
-"""
-
-extern pure def infixLt(x: Int, y: Int): Boolean = """
-    %z = icmp slt %Int %x, %y
-    %fat_z = zext i1 %z to i64
-    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
-    ret %Pos %adt_boolean
-"""
-
-extern pure def infixLte(x: Int, y: Int): Boolean = """
-    %z = icmp sle %Int %x, %y
-    %fat_z = zext i1 %z to i64
-    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
-    ret %Pos %adt_boolean
-"""
-
-extern pure def infixGt(x: Int, y: Int): Boolean = """
-    %z = icmp sgt %Int %x, %y
-    %fat_z = zext i1 %z to i64
-    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
-    ret %Pos %adt_boolean
-"""
-
-extern pure def infixGte(x: Int, y: Int): Boolean = """
-    %z = icmp sge %Int %x, %y
-    %fat_z = zext i1 %z to i64
-    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
-    ret %Pos %adt_boolean
-"""
-
-
-// boolean algebra
-
-extern pure def infixEq(x: Boolean, y: Boolean): Boolean = """
-    %slim_x = extractvalue %Pos %x, 0
-    %slim_y = extractvalue %Pos %y, 0
-    %slim_z = icmp eq i64 %slim_x, %slim_y
-    %fat_z = zext i1 %slim_z to i64
-    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
-    ret %Pos %adt_boolean
-"""
-
-extern pure def infixNeq(x: Boolean, y: Boolean): Boolean = """
-    %slim_x = extractvalue %Pos %x, 0
-    %slim_y = extractvalue %Pos %y, 0
-    %slim_z = icmp ne i64 %slim_x, %slim_y
-    %fat_z = zext i1 %slim_z to i64
-    %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
-    ret %Pos %adt_boolean
-"""
-
-extern pure def not(adt_p: Boolean): Boolean = """
-    %p = extractvalue %Pos %adt_p, 0
-    %q = xor i64 1, %p
-    %adt_q = insertvalue %Pos zeroinitializer, i64 %q, 0
-    ret %Pos %adt_q
-"""
-
-extern pure def infixOr(adt_p: Boolean, adt_q: Boolean): Boolean = """
-    %p = extractvalue %Pos %adt_p, 0
-    %q = extractvalue %Pos %adt_q, 0
-    %r = or i64 %p, %q
-    %adt_r = insertvalue %Pos zeroinitializer, i64 %r, 0
-    ret %Pos %adt_r
-"""
-
-extern pure def infixAnd(adt_p: Boolean, adt_q: Boolean): Boolean = """
-    %p = extractvalue %Pos %adt_p, 0
-    %q = extractvalue %Pos %adt_q, 0
-    %r = and i64 %p, %q
-    %adt_r = insertvalue %Pos zeroinitializer, i64 %r, 0
-    ret %Pos %adt_r
-"""
-
-// show
-extern pure def show(i: Int): String = """
-   %z = call %Pos @c_buffer_show_Int(%Int %i)
-   ret %Pos %z
- """
-extern pure def show(x: Double): String = """
-   %z = call %Pos @c_buffer_show_Double(%Double %x)
-   ret %Pos %z
- """
-def show(b: Boolean): String = {
-    if(b) { "true" } else { "false" }
-}
-def show(u: Unit): String = { "unit" }
-
-// For boxing polymorphic values
-record BoxedUnit(unboxUnit: Unit)
-record BoxedInt(unboxInt: Int)
-record BoxedBoolean(unboxBoolean: Boolean)
-record BoxedDouble(unboxDouble: Double)
-record BoxedString(unboxString: String)
-
-// Pairs
-// =====
-record Tuple2[A, B](first: A, second: B)
-record Tuple3[A, B, C](first: A, second: B, third: C)
-record Tuple4[A, B, C, D](first: A, second: B, third: C, fourth: D)
-record Tuple5[A, B, C, D, E](first: A, second: B, third: C, fourth: D, fifth: E)
-record Tuple6[A, B, C, D, E, F](first: A, second: B, third: C, fourth: D, fifth: E, sixth: F)
-
-// Exceptions
-// ==========
-interface Exception[E] {
-  def raise(exception: E, msg: String): Nothing
-}
-record RuntimeError()
-
-def raise[A](msg: String): A / Exception[RuntimeError] = do raise(RuntimeError(), msg) match {}
-def raise[A, E](exception: E, msg: String): A / Exception[E] = do raise(exception, msg) match {}
-
-// reports exceptions of (static) type E to the console
-def report[E] { prog: => Unit / Exception[E] }: Unit =
-  try { prog() } with Exception[E] { def raise(exception: E, msg: String) = println(msg) }
-
-// ignores exceptions of (static) type E
-// TODO this should be called "ignore" but that name currently clashes with internal pattern matching names on $effekt
-def ignoring[E] { prog: => Unit / Exception[E] }: Unit =
-  try { prog() } with Exception[E] { def raise(exception: E, msg: String) = () }
-
-// Control Flow
-// ============
-interface Control {
-  def break(): Unit
-  def continue(): Unit
-}
-
-def loop { f: () => Unit / Control }: Unit = try {
-  def go(): Unit = { f(); go() }
-  go()
-} with Control {
-  def break() = ()
-  def continue() = loop { f }
-}
-
-/**
- * Calls provided action repeatedly. `start` is inclusive, `end` is not.
- */
-def each(start: Int, end: Int) { action: (Int) => Unit / Control } = {
-  var i = start;
-  loop {
-    if (i < end) { val el = i; i = i + 1; action(el) }
-    else { do break() }
-  }
-}
-
-def repeat(n: Int) { action: () => Unit / Control } = each(0, n) { n => action() }

package/libraries/llvm/immutable/option.effekt

@@ -1,53 +0,0 @@
-module immutable/option
-
-import effekt
-
-type Option[A] {
-  None();
-  Some(value: A)
-}
-
-def isDefined[A](self: Option[A]): Boolean = self match {
-  case None()  => false
-  case Some(v) => true
-}
-
-def isEmpty[A](self: Option[A]): Boolean =
-  self.isDefined.not
-
-def orElse[A](self: Option[A]) { that: => Option[A] }: Option[A] = self match {
-  case None()  => that()
-  case Some(v) => Some(v)
-}
-
-def getOrElse[A](self: Option[A]) { that: => A }: A = self match {
-  case None() => that()
-  case Some(v) => v
-}
-
-def map[A, B](self: Option[A]) { f: A => B }: Option[B] = self match {
-  case None()  => None()
-  case Some(v) => Some(f(v))
-}
-
-def foreach[A](self: Option[A]) { f: A => Unit }: Unit = self match {
-  case None()  => ()
-  case Some(v) => f(v)
-}
-
-// =========================================
-// `show` / `println` overloads for options:
-// =========================================
-
-// for now define some common cases; TODO better solution
-def showOption[A](o: Option[A]){ showA: A => String }: String = o match {
-  case None() => "None()"
-  case Some(v) => "Some(" ++ showA(v) ++ ")"
-}
-def show(o: Option[Int]): String = showOption(o){ e => show(e) }
-def show(o: Option[Double]): String = showOption(o){ e => show(e) }
-def show(o: Option[Boolean]): String = showOption(o){ e => show(e) }
-
-def println(o: Option[Int]): Unit = println(show(o))
-def println(o: Option[Double]): Unit = println(show(o))
-def println(o: Option[Boolean]): Unit = println(show(o))

package/libraries/llvm/immutable/result.effekt

@@ -1,29 +0,0 @@
-import immutable/option
-
-// Results
-// =======
-// The "reification" of the Exception[E] effect.
-type Result[A, E] {
-  Error(exception: E, msg: String);
-  Success(a: A)
-}
-
-def result[A, E] { f: () => A / Exception[E] }: Result[A, E] = try {
-  Success(f())
-} with Exception[E] {
-  def raise(exc, msg) = Error(exc, msg)
-}
-
-/**
- * Extracts the value of a result, if available
- * Monadic "reflection"
- */
-def value[A, E](r: Result[A, E]): A / Exception[E] = r match {
-  case Success(a) => a
-  case Error(exc, msg) => do raise(exc, msg)
-}
-
-def toOption[A, E](r: Result[A, E]): Option[A] = r match {
-  case Success(a) => Some(a)
-  case Error(exc, msg) => None()
-}