@effekt-lang/effekt 0.60.0 → 0.62.0

package/libraries/chez/common/effekt_primitives.ss

@@ -60,6 +60,8 @@
      out))
 
 
+(define (print_impl str)
+  (display str))
 
 (define (println_impl str)
   (display str)
@@ -140,4 +142,4 @@
   (raise
     (condition
       (make-error)
-      (make-message-condition ("should not be reachable!")))))
+      (make-message-condition ("should not be reachable!")))))

package/libraries/common/array.effekt

@@ -624,7 +624,9 @@ def sorted[A](arr: Array[A]) { ord: (A, A) => Ordering }: Array[A] = {
 // Show Instances
 // --------------
 
-def show[A](arr: Array[A]) { showA: A => String }: String = {
+// TODO: These can eventually be replaced if we ever figure out monomorphization on extern types
+
+def showBuiltin[A](arr: Array[A]) { showA: A => String }: String = {
   var output = "Array("
   val lastIndex = arr.size - 1
 
@@ -636,16 +638,16 @@ def show[A](arr: Array[A]) { showA: A => String }: String = {
 
   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))
+def showBuiltin(l: Array[Int]): String = showBuiltin(l) { e => show(e) }
+def showBuiltin(l: Array[Double]): String = showBuiltin(l) { e => show(e) }
+def showBuiltin(l: Array[Bool]): String = showBuiltin(l) { e => show(e) }
+def showBuiltin(l: Array[String]): String = showBuiltin(l) { e => e }
 
+def println(l: Array[Int]): Unit = println(showBuiltin(l))
+def println(l: Array[Double]): Unit = println(showBuiltin(l))
+def println(l: Array[Bool]): Unit = println(showBuiltin(l))
+def println(l: Array[String]): Unit = println(showBuiltin(l))
 
 // Streaming
 // ---------

package/libraries/common/dequeue.effekt

@@ -75,18 +75,10 @@ def popBack[R](dq: Dequeue[R]): Option[(R, Dequeue[R])] = dq match {
         Some((x, Dequeue(f, fs, rest, rs - 1).check))
 }
 
+// TODO: Replace when monomorphization is merged
 
-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))
+def println(l: Dequeue[String]): Unit = println(show(l))

package/libraries/common/effekt.effekt

@@ -38,6 +38,16 @@ namespace llvm {
 // Showing and debugging
 // =====================
 
+extern def print(value: String): Unit =
+  jsWeb "$effekt.println(${value})"
+  jsNode "$effekt.print(${value})"
+  chez "(print_impl ${value})"
+  llvm """
+    call void @c_io_print(%Pos ${value})
+    ret %Pos zeroinitializer ; Unit
+  """
+  vm "effekt::print(String)"
+
 extern def println(value: String): Unit =
   js "$effekt.println(${value})"
   chez "(println_impl ${value})"
@@ -74,7 +84,7 @@ def println(value: Double): Unit = println(value.show)
 def println(value: Bool): Unit = println(value.show)
 def println(value: Byte): Unit = println(value.show)
 
-extern def show(value: Int) at {}: String =
+extern def showBuiltin(value: Int) at {}: String =
   js "'' + ${value}"
   chez "(show-number ${value})"
   llvm """
@@ -83,9 +93,7 @@ extern def show(value: Int) at {}: String =
   """
   vm "effekt::show(Int)"
 
-def show(value: Unit): String = "()"
-
-extern def show(value: Double) at {}: String =
+extern def showBuiltin(value: Double) at {}: String =
   js "'' + ${value}"
   chez "(show-number ${value})"
   llvm """
@@ -94,13 +102,7 @@ extern def show(value: Double) at {}: String =
   """
   vm "effekt::show(Double)"
 
-def show(value: String): String =
-  value
-
-def show(value: Bool): String =
-  if (value) "true" else "false"
-
-extern def show(value: Char) at {}: String =
+extern def showBuiltin(value: Char) at {}: String =
   js "String.fromCodePoint(${value})"
   chez "(string (integer->char ${value}))"
   llvm """
@@ -109,22 +111,17 @@ extern def show(value: Char) at {}: String =
   """
   vm "effekt::show(Char)"
 
-extern def show(value: Byte) at {}: String =
-  js "'' + ${value}"
-  chez "(string ${value})"
+extern def showBuiltin(value: Byte) at {}: String =
+  js "'0x' + ${value}.toString(16).toUpperCase().padStart(2, '0')"
+  chez "(format #f \"0x~2,'0X\" ${value})"
   llvm """
-    %z = call %Pos @c_bytearray_show_Byte(i8 ${value})
+    %z = call %Pos @c_bytearray_show_Byte(%Byte ${value})
     ret %Pos %z
   """
   vm "effekt::show(Byte)"
 
-extern def genericShow[R](value: R) at {}: String =
-  js "$effekt.show(${value})"
-  chez "(show_impl ${value})"
-
 extern def inspect[R](value: R) at io: Unit =
-  js { println(genericShow(value)) }
-  chez { println(genericShow(value)) }
+  default { println(show(value)) }
   vm "effekt::inspect(Any)"
 
 /// A fatal runtime error that cannot be caught
@@ -137,6 +134,10 @@ extern def panic(msg: String) at io: Nothing =
     ret %Pos zeroinitializer ; Unit
   """
 
+extern def show[R](value: R) at {}: String =
+  js "$effekt.show(${value})"
+  chez "(show_impl ${value})"
+  llvm "ret %Pos poison"
 
 // Strings
 // =======
@@ -223,12 +224,6 @@ def genericCompare[R](x: R, y: R): Ordering = {
   }
 }
 
-def show(o: Ordering): String = o match {
-  case Less() => "Less()"
-  case Equal() => "Equal()"
-  case Greater() => "Greater()"
-}
-
 def println(o: Ordering): Unit = println(o.show)
 
 
@@ -795,9 +790,9 @@ def locally[R] { p: => R } : R = p()
 //
 //     "foo ${42} bar ${43}"
 //
-// to the following stream of `literal`s and `splice[Int]`s:
+// to the following stream of `write`s and `splice[Int]`s:
 //
-//     do literal("foo "); do splice(42); do literal(" bar "); do splice(43)
+//     do write("foo "); do splice(42); do write(" bar "); do splice(43)
 //
 // The stream is wrapped into a handler function, which defaults to `stringbuffer::s`
 //
@@ -805,7 +800,8 @@ def locally[R] { p: => R } : R = p()
 //
 // but can be specified by prefixing the string interpolation `custom"..."`.
 
-effect literal(s: String): Unit
+effect write(s: String): Unit
+
 effect splice[A](x: A): Unit
 
 

package/libraries/common/list.effekt

@@ -74,6 +74,16 @@ def tail[A](l: List[A]): List[A] / Exception[MissingValue] = l match {
   case Cons(a, rest) => rest
 }
 
+/// Return all elements of a given list except the last element.
+/// Throws a `MissingValue` exception if it's empty.
+///
+/// O(n)
+def init[A](l: List[A]): List[A] / Exception[MissingValue] = l match {
+  case Nil() => do raise(MissingValue(), "Trying to get the beginning of an empty list")
+  case Cons(a, Nil()) => Nil()
+  case Cons(a, as) => Cons(a, as.init)
+}
+
 /// Return the first element of a given list.
 /// Returns `None()` if it's empty.
 ///
@@ -914,24 +924,15 @@ def isSortedBy[A](list: List[A]) { lessOrEqual: (A, A) => Bool }: Bool = {
 // Show Instances
 // --------------
 
-def show[A](l: List[A]) { showA: A => String }: String = {
-  def go(l: List[A]): String = l match {
-    case Nil() => "Nil()"
-    case Cons(x, xs) => "Cons(" ++ showA(x) ++ ", " ++ go(xs) ++ ")"
-  }
-  go(l)
-}
-def show(l: List[Int]): String = show(l) { e => show(e) }
-def show(l: List[Double]): String = show(l) { e => show(e) }
-def show(l: List[Bool]): String = show(l) { e => show(e) }
-def show(l: List[String]): String = show(l) { e => e }
+// TODO: Get rid of these after monomorphization is merged
+
 
 def println(l: List[Int]): Unit = println(show(l))
 def println(l: List[Double]): Unit = println(show(l))
+def println(l: List[Char]): Unit = println(show(l))
 def println(l: List[Bool]): Unit = println(show(l))
 def println(l: List[String]): Unit = println(show(l))
 
-
 // Streaming
 // ---------
 

package/libraries/common/map.effekt

@@ -969,7 +969,7 @@ namespace internal {
       t match {
         case Tip() => ""
         case Bin(_, k, v, l, r) =>
-          val pair = k.genericShow ++ " → " ++ v.genericShow
+          val pair = k.show ++ " → " ++ v.show
           val currentLine = prefix ++ (if (isTail) "└── " else "├── ") ++ pair ++ "\n"
 
           val newPrefix = prefix ++ (if (isTail) "    " else "│   ")

package/libraries/common/option.effekt

@@ -59,14 +59,7 @@ def undefinedToOption[A](value: A): Option[A] =
 // Show Instances
 // --------------
 
-def show[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 = show(o) { e => show(e) }
-def show(o: Option[Double]): String = show(o) { e => show(e) }
-def show(o: Option[Bool]): String = show(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[Bool]): Unit = println(show(o))
+def println(o: Option[Bool]): Unit = println(show(o))

package/libraries/common/partial.effekt

@@ -46,3 +46,19 @@ def suchThat[A](value: A){ predicate: A => Bool }: Option[A] =
 
 def getOrFail[A](option: Option[A]): A / fail =
   option.getOrElse { do fail() }
+
+namespace returning {
+
+def exhaustively[R](init: R) { program: () => R / fail }: R =
+  var res = init
+  try {
+    def go(): R = {
+      res = program()
+      go()
+    }
+    go()
+  } with fail {
+    res
+  }
+
+}

package/libraries/common/random.effekt

@@ -51,7 +51,7 @@ def minstd(seed: Int): Unit / emit[Byte] = {
 ///
 /// Implementation is similar to `stream::source`, specialized for bytes and the `random` effect.
 def minstd(seed: Int) { randomnessReader: () => Unit / random }: Unit = {
-  var next = box { 255.toByte } // sentinel value
+  var next = box { 0xFF } // sentinel value
   next = box {
     try {
       minstd(seed)

package/libraries/common/stream.effekt

@@ -192,6 +192,10 @@ def countIf[A] { shouldCount: A => Bool } { stream: () => Unit / emit[A] }: Int
   count
 }
 
+/// Count the number of emitted values.
+def count[A] { stream: () => Unit / emit[A] }: Int =
+  countIf[A] { _ => true } {stream}
+
 def source[A] { stream: () => Unit / emit[A] } { reader: () => Unit / read[A] }: Unit =
   returning::source[A, Unit]{stream}{reader}
 

package/libraries/common/stringbuffer.effekt

@@ -3,60 +3,58 @@ module stringbuffer
 import effekt
 import bytearray
 
-interface StringBuffer {
-  def write(str: String): Unit
-  def flush(): String
-}
+effect flush(): String
+
+def stringBuffer { program: () => Unit / write }: String =
+  flushableStringBuffer { program(); do flush() }
 
-def stringBuffer[A] { prog: => A / StringBuffer }: A = {
+def flushableStringBuffer[A] { program: () => A / { write, flush } }: A = {
   val initialCapacity = 128
   var buffer = bytearray::allocate(initialCapacity)
   // next free index to write to
-  var pos = 0
+  var position = 0
 
-  def ensureCapacity(sizeToAdd: Int): Unit = {
-    val cap = buffer.size - pos
-    if (sizeToAdd <= cap) ()
+  def ensureCapacity(required: Int): Unit = {
+    val capacity = buffer.size - position
+    if (required <= capacity) ()
     else {
       // Double the capacity while ensuring the required capacity
-      val newSize = max(buffer.size * 2, buffer.size + sizeToAdd)
+      val newSize = max(buffer.size * 2, buffer.size + required)
       buffer = buffer.resize(newSize)
     }
   }
 
-  try { prog() }
-  with StringBuffer {
-    def write(str) = {
-      val bytes = fromString(str)
-      ensureCapacity(bytes.size)
-      bytes.foreach { b =>
-        buffer.set(pos, b)
-        pos = pos + 1
-      }
-      resume(())
-    }
-    def flush() = {
-      // resize (& copy) buffer to strip trailing zeros that otherwise would be converted into 0x00 characters
-      val str = bytearray::resize(buffer, pos).toString()
-      // NOTE: Keep the `buffer` as-is (no wipe, no realloc),
-      //       just reset the `pos` in case we want to use it again.
-      pos = 0
-      resume(str)
+  try {
+    program()
+  } with write { string =>
+    val bytes = fromString(string)
+    ensureCapacity(bytes.size)
+    bytes.foreach { b =>
+      buffer.set(position, b)
+      position = position + 1
     }
+    resume(())
+  } with flush {
+    val string = buffer.resize(position).toString()
+    position = 0
+    resume(string)
   }
 }
 
+def splicing[T] { writer: T => Unit } { program: () => Unit / splice[T] }: Unit =
+  try { program() } with splice[T] { t => resume(writer(t)) }
+
+
 /// Handler for string interpolation using a string buffer
-def s { prog: () => Unit / { literal, splice[String] } }: String =
+def s { program: () => Unit / { write, splice[String] } }: String =
   stringBuffer {
-    try { prog(); do flush() }
+    try { program() }
     with splice[String] { x => resume(do write(x)) }
-    with literal { s => resume(do write(s)) }
   }
 
 namespace examples {
   def main() = {
-    with stringBuffer
+    with flushableStringBuffer
 
     do write("hello")
     do write(", world")

package/libraries/common/test.effekt

@@ -46,7 +46,7 @@ def assertEqual[A](obtained: A, expected: A, msg: String): Unit / Assertion =
   assertEqual(obtained, expected, msg) { (x, y) => x.equals(y) }
 
 def assertEqual[A](obtained: A, expected: A): Unit / { Assertion, Formatted } =
-  assertEqual(obtained, expected) { (x, y) => x.equals(y) } { x => x.genericShow }
+  assertEqual(obtained, expected) { (x, y) => x.equals(y) } { x => x.show }
 
 def assertEqual[A](obtained: A, expected: A, msg: String) { equals: (A, A) => Bool }: Unit / Assertion =
   do assert(equals(obtained, expected), msg)
@@ -56,6 +56,17 @@ def assertEqual[A](obtained: A, expected: A) { equals: (A, A) => Bool } { show:
   // NOTE:                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   //             Here's an accidental capture! Can we prevent this somehow nicely?
 
+def assertNotThrown[E](ex: on[E]) { body: => Unit / Exception[E] }: Unit / Assertion =
+  ex.default { do assert(false, "Unexpected Exception") } {body}
+
+def assertNoThrow[E] { body: => Unit / Exception[E] }: Unit / Assertion =
+  on[E].default{ do assert(false, "Unexpected Exception") } {body}
+
+def assertThrown[E](ex: on[E]) { body: => Unit / Exception[E] }: Unit / Assertion =
+  do assert(ex.default { true } { body(); false }, "Expected Exception, but exited normally")
+
+def assertThrows[E] { body: => Unit / Exception[E] }: Unit / Assertion =
+  do assert(on[E].default { true } { body(); false }, "Expected Exception, but exited normally")
 
 interface Test {
   def success(name: String, duration: Int): Unit

package/libraries/js/effekt_builtins.js

@@ -54,6 +54,10 @@ $effekt.println = function println$impl(str) {
   console.log(str); return $effekt.unit;
 }
 
+$effekt.print = function println$impl(str) {
+  process.stdout.write(str); return $effekt.unit;
+}
+
 $effekt.unit = { __unit: true }
 
 $effekt.unreachable = function() { throw "should not be reachable!" }

package/libraries/llvm/bytearray.c

@@ -2,6 +2,8 @@
 #define EFFEKT_BYTEARRAY_C
 
 #include <string.h> // For memcopy
+#include <stdint.h>
+#include <inttypes.h>
 
 /** We represent bytearrays like positive types.
  *
@@ -115,8 +117,8 @@ struct Pos c_bytearray_show_Char(const uint64_t n) {
 
 // TODO do this in Effekt
 struct Pos c_bytearray_show_Byte(const Byte n) {
-    char str[4];  // Byte values range from 0 to 255, 3 characters + null terminator
-    snprintf(str, sizeof(str), "%" PRIu8, n);
+    char str[5]; // |"0x" ++ <2 hex digits> ++ '\0'| = 5
+    snprintf(str, sizeof str, "0x%02" PRIX8, (uint8_t)n);
     return c_bytearray_from_nullterminated_string(str);
 }
 

package/libraries/llvm/forward-declare-c.ll

@@ -3,6 +3,7 @@
 declare i64 @c_get_argc()
 declare %Pos @c_get_arg(i64)
 
+declare void @c_io_print(%Pos)
 declare void @c_io_println(%Pos)
 declare %Pos @c_io_readln()
 declare %Double @c_io_random()

package/libraries/llvm/io.c

@@ -7,11 +7,15 @@
 // Println and Readln and Random
 // -----------------------------
 
-void c_io_println(String text) {
+void c_io_print(String text) {
     for (uint64_t j = 0; j < text.tag; ++j) {
         putchar(c_bytearray_data(text)[j]);
     };
     erasePositive(text);
+}
+
+void c_io_println(String text) {
+    c_io_print(text);
     putchar('\n');
 }