@effekt-lang/effekt 0.18.0 → 0.19.0

package/libraries/common/buffer.effekt

@@ -34,7 +34,7 @@ def emptyBuffer[T](capacity: Int): Buffer[T] at {global} = {
 }
 def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
   // TODO allocate buffer (and array) into a region r.
-  val contents = emptyArray[T](initialCapacity)
+  val contents = array::allocate[T](initialCapacity)
   var head in global = 0
   var tail in global = 0
 
@@ -51,7 +51,7 @@ def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
     def read() = {
       if (buffer.empty?) None()
       else {
-        val result: T = contents.remove(head).getOrElse { <> };
+        val result: T = contents.unsafeGet(head);
         head = mod(head + 1, initialCapacity)
         Some(result)
       }
@@ -59,7 +59,7 @@ def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
     def write(el: T) = {
       if (buffer.full?) <> // raise(BufferOverflow())
 
-      contents.put(tail, el)
+      contents.unsafeSet(tail, el)
       tail = mod(tail + 1, initialCapacity)
     }
   }

package/libraries/common/bytearray.effekt

@@ -6,7 +6,7 @@ module bytearray
 extern type ByteArray
   // = llvm "%Pos"
   // = js "Uint8Array"
-
+  // = chez "bytevector"
 
 /// Allocates a new bytearray with the given `size`, its values are undefined.
 extern global def allocate(size: Int): ByteArray =
@@ -15,6 +15,7 @@ extern global def allocate(size: Int): ByteArray =
     %arr = call %Pos @c_bytearray_new(%Int ${size})
     ret %Pos %arr
   """
+  chez "(make-bytevector ${size})"
 
 extern pure def size(arr: ByteArray): Int =
   js "${arr}.length"
@@ -22,6 +23,7 @@ extern pure def size(arr: ByteArray): Int =
     %size = call %Int @c_bytearray_size(%Pos ${arr})
     ret %Int %size
   """
+  chez "(bytevector-length ${arr})"
 
 extern global def unsafeGet(arr: ByteArray, index: Int): Byte =
   js "(${arr})[${index}]"
@@ -29,6 +31,7 @@ extern global def unsafeGet(arr: ByteArray, index: Int): Byte =
     %byte = call %Byte @c_bytearray_get(%Pos ${arr}, %Int ${index})
     ret %Byte %byte
   """
+  chez "(bytevector-u8-ref ${arr} ${index})"
 
 extern global def unsafeSet(arr: ByteArray, index: Int, value: Byte): Unit =
   js "bytearray$set(${arr}, ${index}, ${value})"
@@ -36,6 +39,7 @@ extern global def unsafeSet(arr: ByteArray, index: Int, value: Byte): Unit =
     %z = call %Pos @c_bytearray_set(%Pos ${arr}, %Int ${index}, %Byte ${value})
     ret %Pos %z
   """
+  chez "(bytevector-u8-set! ${arr} ${index} ${value})"
 
 def resize(source: ByteArray, size: Int): ByteArray = {
   val target = allocate(size)
@@ -75,6 +79,7 @@ extern pure def fromString(str: String): ByteArray =
   llvm """
     ret %Pos ${str}
   """
+  chez "(string->utf8 ${str})"
 
 extern pure def toString(arr: ByteArray): String =
   js "(new TextDecoder('utf-8').decode(${arr}))"
@@ -82,10 +87,68 @@ extern pure def toString(arr: ByteArray): String =
   llvm """
     ret %Pos ${arr}
   """
+  chez "(utf8->string ${arr})"
 
 extern js """
   function bytearray$set(bytes, index, value) {
     bytes[index] = value;
     return $effekt.unit;
   }
+
+  function bytearray$compare(arr1, arr2) {
+    const len = Math.min(arr1.length, arr2.length);
+
+    for (let i = 0; i < len; i++) {
+      if (arr1[i] !== arr2[i]) {
+        return arr1[i] < arr2[i] ? -1 : 1;
+      }
+    }
+
+    if (arr1.length !== arr2.length) {
+      return arr1.length < arr2.length ? -1 : 1;
+    } else {
+      return 0;
+    }
+  }
+"""
+
+extern chez """
+  (define (bytearray$compare b1 b2)
+    (let ([len1 (bytevector-length b1)]
+          [len2 (bytevector-length b2)]
+          [minlen (min (bytevector-length b1) (bytevector-length b2))])
+      (let loop ([i 0])
+        (cond
+          [(= i minlen)
+          (cond [(< len1 len2) -1]
+                [(> len1 len2) 1]
+                [else 0])]
+          [(< (bytevector-u8-ref b1 i) (bytevector-u8-ref b2 i)) -1]
+          [(> (bytevector-u8-ref b1 i) (bytevector-u8-ref b2 i)) 1]
+          [else (loop (+ i 1))]))))
 """
+
+extern pure def compareByteArrayImpl(b1: ByteArray, b2: ByteArray): Int =
+  js "bytearray$compare(${b1}, ${b2})"
+  llvm """
+    %x = call %Int @c_bytearray_compare(%Pos ${b1}, %Pos ${b2})
+    ret %Int %x
+  """
+  chez "(bytearray$compare ${b1} ${b2})"
+
+def compareByteArray(b1: ByteArray, b2: ByteArray): Ordering = {
+  val ret = compareByteArrayImpl(b1, b2)
+  if (ret == 0) {
+    Equal()
+  } else if (ret < 0) {
+    Less()
+  } else { // ret > 0
+    Greater()
+  }
+}
+
+def compareStringBytes(left: String, right: String): Ordering = {
+  val l = left.fromString
+  val r = right.fromString
+  compareByteArray(l, r)
+}

package/libraries/common/effekt.effekt

@@ -90,6 +90,7 @@ extern pure def show(value: Char): String =
 
 extern pure def show(value: Byte): String =
   js "'' + ${value}"
+  chez "(string ${value})"
   llvm """
     %z = call %Pos @c_bytearray_show_Byte(i8 ${value})
     ret %Pos %z
@@ -166,17 +167,24 @@ type Ordering {
   Greater()
 }
 
+def compareInt(n: Int, m: Int) =
+  if (n == m) Equal()
+  else if (n < m) Less()
+  else Greater()
+
 extern pure def genericCompareImpl[R](x: R, y: R): Int =
   js "$effekt.compare(${x}, ${y})"
 
 /// Compares two values of the same type, returning an `Ordering`.
 /// Only available on the JavaScript backend.
 def genericCompare[R](x: R, y: R): Ordering = {
-  genericCompareImpl(x, y) match {
-    case -1 => Less()
-    case 0 => Equal()
-    case 1 => Greater()
-    case _ => <{ "Impossible: JS comparison returned invalid value!" }>
+  val ret = genericCompareImpl(x, y)
+  if (ret == 0) {
+    Equal()
+  } else if (ret < 0) {
+    Less()
+  } else { // ret > 0
+    Greater()
   }
 }
 
@@ -390,7 +398,7 @@ extern pure def log(x: Double): Double =
 extern pure def log1p(x: Double): Double =
   js "Math.log1p(${x})"
   chez "(log (+ ${x} 1))"
-  llvm "%z = call %Double @log1p(double ${x}) ret %Double %z" 
+  llvm "%z = call %Double @log1p(double ${x}) ret %Double %z"
 
 extern pure def exp(x: Double): Double =
   js "Math.exp(${x})"
@@ -571,19 +579,19 @@ extern pure def infixGte(x: Double, y: Double): Bool =
 // TODO do we really need those? if yes, move to string.effekt
 extern pure def infixLt(x: String, y: String): Bool =
   js "(${x} < ${y})"
-  chez "(< ${x} ${y})"
+  chez "(string<? ${x} ${y})"
 
 extern pure def infixLte(x: String, y: String): Bool =
   js "(${x} <= ${y})"
-  chez "(<= ${x} ${y})"
+  chez "(string<=? ${x} ${y})"
 
 extern pure def infixGt(x: String, y: String): Bool =
   js "(${x} > ${y})"
-  chez "(> ${x} ${y})"
+  chez "(string>? ${x} ${y})"
 
 extern pure def infixGte(x: String, y: String): Bool =
   js "(${x} >= ${y})"
-  chez "(>= ${x} ${y})"
+  chez "(string>=? ${x} ${y})"
 
 
 // Boolean operations
@@ -647,10 +655,13 @@ extern pure def bitwiseXor(x: Int, y: Int): Int =
 extern pure def toByte(n: Int): Byte =
   js "${n}"
   llvm "%z = trunc %Int ${n} to %Byte ret %Byte %z"
+  chez "${n}"
 
 extern pure def toInt(n: Byte): Int =
   js "${n}"
   llvm "%z = zext %Byte ${n} to %Int ret %Int %z"
+  vm "effekt::toInt(Byte)"
+  chez "${n}"
 
 
 // Undefined and Null
@@ -666,11 +677,13 @@ extern pure def toInt(n: Byte): Int =
 extern pure def undefined[A](): A =
   js "undefined"
   chez "#f"
+  vm "effekt::undefined()"
 
 /// Is an FFI value undefined?
 extern pure def isUndefined[A](value: A): Bool =
   js "(${value} === undefined || ${value} === null)"
   chez "(eq? ${value} #f)"
+  vm "effekt::isUndefined[A](A)"
 
 
 // Tuples

package/libraries/common/io/network.effekt

@@ -57,14 +57,17 @@ def server(host: String, port: Int, handler: () => Unit / Socket at {io, async,
 
 namespace examples {
   def helloWorldApp(): Unit / Socket = {
-    val request = do receive();
+    val request = do receive().toString;
 
-    println("Received a request: " ++ request.toUTF8)
+    println("Received a request: " ++ request)
 
-    if (request.toUTF8.startsWith("GET /")) {
-      do send(fromUTF8("HTTP/1.1 200 OK\r\n\r\nHello from Effekt!"))
+    def respond(s: String): Unit / Socket =
+      do send(s.fromString)
+
+    if (request.startsWith("GET /")) {
+      respond("HTTP/1.1 200 OK\r\n\r\nHello from Effekt!")
     } else {
-      do send("HTTP/1.1 400 Bad Request\r\n\r\n".fromUTF8)
+      respond("HTTP/1.1 400 Bad Request\r\n\r\n")
     }
     do end()
   }

package/libraries/common/json.effekt

@@ -62,7 +62,7 @@ def encodeJsonObject[R]{ body: => R / JsonObjectBuilder }: R / emit[String] = {
   do emit("{")
   def c(k: String) = {
     if (not(first)) { do emit(",") }
-    do emit(escape(k)); do emit(":") 
+    do emit(escape(k)); do emit(":")
     first = false
   }
   val r = encodeJson {
@@ -76,7 +76,7 @@ def encodeJsonObject[R]{ body: => R / JsonObjectBuilder }: R / emit[String] = {
 /// Main entry point for encoding json.
 /// Emits individual tokens of the resulting json.
 def encodeJson[R]{ body: => R / JsonBuilder }: R / emit[String] = {
-  try body() with JsonBuilder { 
+  try body() with JsonBuilder {
       def null() = { resume(do emit("null")) }
       def bool(v) = { resume(do emit( if(v){ "true" } else { "false" } )) }
       def number(n) = { resume(do emit(show(n))) }
@@ -112,7 +112,7 @@ def readDouble(): Double / Scan[Char] = {
     if (optionally { readIf('.') }) {
       var b = 0.1
       var r = pre.toDouble
-      while (optionally[Int] { readDigit() } is Some(d)) {
+      while (returning::optionally[Int] { readDigit() } is Some(d)) {
         r = r + b * d.toDouble
         b = b * 0.1
       }
@@ -126,14 +126,14 @@ def readDouble(): Double / Scan[Char] = {
 
 def expectString(string: String): Unit / { Scan[Char], Exception[WrongFormat] } =
   for[Char] { string.each } { char =>
-    expect[Unit]("Expected " ++ string) { readIf(char) }
+    expect("Expected " ++ string) { readIf(char) }
   }
 
 /// Read and unescape a string in ""
 def readQuotedString(): Unit / { Scan[Char], emit[Char], Exception[WrongFormat] } = {
   try {
     skipWhitespace()
-    expect[Unit]("Expected \"") { readIf('"') }
+    expect("Expected \"") { readIf('"') }
     while(read[Char]() is c and c != '"') {
       c match {
         case '\\' => read[Char]() match {
@@ -191,7 +191,7 @@ def decodeJsonObject(): Unit / {Scan[Char], JsonObjectBuilder, Exception[WrongFo
   }
   do skip[Char]()
 }
-def decodeJsonList(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} = { 
+def decodeJsonList(): Unit / {Scan[Char], JsonBuilder, Exception[WrongFormat]} = {
   var first = true
   expectString("[")
   with boundary
@@ -278,7 +278,7 @@ def build[R](){ body: => R / JsonBuilder }: (R, JsonValue) = {
   }
   (x, r)
 }
-def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = collectList[JsonValue, R] {
+def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = returning::collectList[JsonValue, R] {
   try body() with JsonBuilder {
     def number(n) = { do emit(Number(n)); resume(()) }
     def bool(b) = { do emit(Bool(b)); resume(()) }
@@ -296,7 +296,7 @@ def buildList[R](){ body: => R / JsonBuilder }: (R, List[JsonValue]) = collectLi
     }
   }
 }
-def buildDict[R](){ body: => R / JsonObjectBuilder }: (R, List[(String, JsonValue)]) = collectList[(String, JsonValue), R] {
+def buildDict[R](){ body: => R / JsonObjectBuilder }: (R, List[(String, JsonValue)]) = returning::collectList[(String, JsonValue), R] {
   try body() with JsonObjectBuilder {
     def field(k) = resume { {v} =>
       val x = build{v}
@@ -315,10 +315,12 @@ namespace test {
 
     // Read quoted string
     feed("\"\ta\n\ra\"") {
-      with scanner[Char, Unit]
+      with scanner[Char]
       println(collectString { readQuotedString() })
     }
 
+    println("")
+
     // Parse example
     feed("""{ "a": null, "b": [true,false,false,true], "f": 12.532   }"""){
       with scanner[Char]
@@ -336,8 +338,10 @@ namespace test {
       }
       handleJsonBuilder{d}{ decodeJson() }
     }
-    try{
-  
+
+    println("")
+
+    try {
       // Encode example
       encodeJson {
         do dict{
@@ -352,13 +356,15 @@ namespace test {
           }
         }
       }
-  
+
+      println("")
+
       // format with intermediate value
-      val j = feed("""{ 
-                  "a": null, 
-                  "b": [true, false, false, true], "f": 12.532   
+      val j = feed[JsonValue]("""{
+                  "a": null,
+                  "b": [true, false, false, true], "f": 12.532
                 } """){
-        with scanner[Char, JsonValue]
+        with returning::scanner[Char, JsonValue]
         build {
           decodeJson()
         }.second
@@ -366,18 +372,20 @@ namespace test {
       encodeJson{
         unbuild(j)
       }
-      
+
+      println("")
+
       // format (minify) example
       encodeJson{
-        feed("""{ 
-                  "a": null, 
-                  "b": [true, false, false, true], "f": 12.532   
+        feed("""{
+                  "a": null,
+                  "b": [true, false, false, true], "f": 12.532
                 } """){
-          with scanner[Char, Unit]
+          with scanner[Char]
           decodeJson()
         }
       }
-  
+
     } with emit[String] { e =>
       resume(println(e))
     }