@effekt-lang/effekt 0.2.1 → 0.2.2

package/libraries/llvm/effekt.effekt

@@ -0,0 +1,243 @@
+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/forward-declare-c.ll

@@ -0,0 +1,24 @@
+; forward-declared from primitives.c
+
+declare i64 @c_get_argc()
+declare %Pos @c_get_arg(i64)
+
+declare void @c_io_println_Boolean(%Pos)
+declare void @c_io_println_Int(%Int)
+declare void @c_io_println_Double(%Double)
+declare void @c_io_println_String(%Pos)
+
+declare %Pos @c_buffer_construct(i64, i8*)
+declare void @c_buffer_refcount_increment(%Pos)
+declare void @c_buffer_refcount_decrement(%Pos)
+declare %Pos @c_buffer_concatenate(%Pos, %Pos)
+
+declare void @hole()
+
+declare %Pos @c_buffer_eq(%Pos, %Pos)
+declare %Pos @c_buffer_substring(%Pos, i64, i64)
+declare i64 @c_buffer_length(%Pos)
+declare i64 @c_buffer_toInt(%Pos)
+declare %Pos @c_buffer_show_Int(%Pos)
+declare %Pos @c_buffer_show_Double(%Pos)
+declare %Int @c_buffer_index(%Pos)

package/libraries/llvm/hole.c

@@ -0,0 +1,11 @@
+#ifndef EFFEKT_HOLE_C
+#define EFFEKT_HOLE_C
+
+#include <stdio.h>
+
+void hole() {
+    fprintf(stderr, "PANIC: Reached a hole in the program\n");
+    exit(1);
+}
+
+#endif