@effekt-lang/effekt 0.29.0 → 0.31.0

package/libraries/common/char.effekt

@@ -1,7 +1,10 @@
 /// Warning: This library currently only works with ASCII characters, **not** unicode!
 module char
 
+import effekt
 import exception
+import option
+import result
 
 
 /// Checks if the given character is an ASCII whitespace
@@ -15,56 +18,51 @@ def isWhitespace(c: Char): Bool = c match {
   case _      => false
 }
 
-/// Gets the value of a given ASCII digit in base 10
-def digitValue(char: Char): Option[Int] =
-  // TODO use fail
+/// Gets the value of a given ASCII digit in base 10,
+/// throwing an exception on wrong format
+def digitValue(char: Char): Int / Exception[WrongFormat] =
   if (char >= '0' && char <= '9') {
-    Some(char.toInt - '0'.toInt)
+    char.toInt - '0'.toInt
   } else {
-    None()
+    wrongFormat("Not a valid digit: '" ++ char.toString ++ "' in base 10")
   }
 
-/// Gets the value of a given ASCII digit in base 16
-def hexDigitValue(char: Char): Option[Int] =
-  // TODO use fail
+/// Gets the value of a given ASCII digit in base 16,
+/// throwing an exception on wrong format
+def hexDigitValue(char: Char): Int / Exception[WrongFormat] =
   char match {
-    case char and char >= '0' && char <= '9' => Some(char.toInt - '0'.toInt)
-    case char and char >= 'A' && char <= 'F' => Some((char.toInt - 'A'.toInt) + 10)
-    case char and char >= 'a' && char <= 'f' => Some((char.toInt - 'a'.toInt) + 10)
-    case _ => None()
+    case char and char >= '0' && char <= '9' => char.toInt - '0'.toInt
+    case char and char >= 'A' && char <= 'F' => (char.toInt - 'A'.toInt) + 10
+    case char and char >= 'a' && char <= 'f' => (char.toInt - 'a'.toInt) + 10
+    case _ => wrongFormat("Not a valid digit: '" ++ char.toString ++ "' in base 16")
   }
 
-/// Gets the value of a given ASCII digit in the given base up to 36
-def digitValue(char: Char, base: Int): Option[Int] = {
-  // TODO use fail
-  val perhapsDigit = char match {
-      case char and char >= '0' && char <= '9' => Some(char.toInt - '0'.toInt)
-      case char and char >= 'A' && char <= 'Z' => Some((char.toInt - 'A'.toInt) + 10)
-      case char and char >= 'a' && char <= 'z' => Some((char.toInt - 'a'.toInt) + 10)
-      case _ => None()
-    }
-  perhapsDigit match {
-    case Some(digit) =>
-      if (digit < base) {
-        Some(digit)
-      } else {
-        None()
-      }
-    case None() => None()
+/// Gets the value of a given ASCII digit in the given base up to 36,
+/// throwing an exception on wrong format
+def digitValue(char: Char, base: Int): Int / Exception[WrongFormat] = {
+  val digit = char match {
+    case char and char >= '0' && char <= '9' => char.toInt - '0'.toInt
+    case char and char >= 'A' && char <= 'Z' => (char.toInt - 'A'.toInt) + 10
+    case char and char >= 'a' && char <= 'z' => (char.toInt - 'a'.toInt) + 10
+    case _ => wrongFormat("Not a valid digit: '" ++ char.toString ++ "'")
   }
+  if (digit >= base) {
+    wrongFormat("Digit '" ++ digit.show ++ "' is too big for base " ++ base.show)
+  }
+  digit
 }
 
 /// Checks if the given character is an ASCII digit in base 10
-/// Use `digitValue(c: Char)` to get the numeric value out.
-def isDigit(char: Char): Bool = digitValue(char).isDefined
+/// Prefer using `digitValue(c: Char)` to get the numeric value out.
+def isDigit(char: Char): Bool = result[Int, WrongFormat] { digitValue(char) }.isSuccess
 
 /// Checks if the given character is an ASCII digit in base 16
-/// Use `hexDigitValue(c: Char)` to get the numeric value out.
-def isHexDigit(char: Char): Bool = hexDigitValue(char).isDefined
+/// Prefer using `hexDigitValue(c: Char)` to get the numeric value out.
+def isHexDigit(char: Char): Bool = result[Int, WrongFormat] { hexDigitValue(char)}.isSuccess
 
 /// Checks if the given character is an ASCII digit in base 10
-/// Use `digitValue(c: Char)` to get the numeric value out.
-def isDigit(char: Char, base: Int): Bool = digitValue(char, base).isDefined
+/// Prefer using `digitValue(c: Char, base: Int)` to get the numeric value out.
+def isDigit(char: Char, base: Int): Bool = result[Int, WrongFormat] { digitValue(char, base) }.isSuccess
 
 /// Checks if a given character is a 7-bit ASCII character
 def isASCII(c: Char): Bool = { c.toInt < 128 }
@@ -80,3 +78,100 @@ def isAlphanumeric(c: Char): Bool = isDigit(c) || isLower(c) || isUpper(c)
 
 /// Checks if a given character is an ASCII alphabetic character
 def isAlphabetic(c: Char): Bool = isLower(c) || isUpper(c)
+
+// Characters
+// ----------
+//
+//   JS: Int (Unicode codepoints)
+//   Chez: ?
+//   LLVM: i64 representing utf-8 (varying length 1-4 bytes)
+
+extern pure def toString(ch: Char): String =
+  js "String.fromCodePoint(${ch})"
+  chez "(string (integer->char ${ch}))"
+  llvm """
+    %z = call %Pos @c_bytearray_show_Char(%Int ${ch})
+    ret %Pos %z
+  """
+
+// Since we currently represent Char by integers in all backends, we could reuse comparison
+extern pure def toInt(ch: Char): Int =
+  js "${ch}"
+  chez "${ch}"
+  llvm "ret %Int ${ch}"
+  vm "string::toInt(Char)"
+
+extern pure def toChar(codepoint: Int): Char =
+  js "${codepoint}"
+  chez "${codepoint}"
+  llvm "ret %Int ${codepoint}"
+  vm "string::toChar(Int)"
+
+
+extern pure def infixLt(x: Char, y: Char): Bool =
+  js "(${x} < ${y})"
+  chez "(< ${x} ${y})"
+  llvm """
+    %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
+  """
+  vm "string::infixLt(Char, Char)"
+
+extern pure def infixLte(x: Char, y: Char): Bool =
+  js "(${x} <= ${y})"
+  chez "(<= ${x} ${y})"
+  llvm """
+    %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
+  """
+  vm "string::infixLte(Char, Char)"
+
+extern pure def infixGt(x: Char, y: Char): Bool =
+  js "(${x} > ${y})"
+  chez "(> ${x} ${y})"
+  llvm """
+    %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
+  """
+  vm "string::infixGt(Char, Char)"
+
+extern pure def infixGte(x: Char, y: Char): Bool =
+  js "(${x} >= ${y})"
+  chez "(>= ${x} ${y})"
+  llvm """
+    %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
+  """
+  vm "string::infixGte(Char, Char)"
+
+
+/**
+ * Determines the number of bytes needed by a codepoint
+ *
+ * Also see: https://en.wikipedia.org/wiki/UTF-8
+ */
+def utf8ByteCount(codepoint: Char): Int = codepoint match {
+  case c and c >= \u0000  and c <= \u007F   => 1
+  case c and c >= \u0080  and c <= \u07FF   => 2
+  case c and c >= \u0800  and c <= \uFFFF   => 3
+  case c and c >= \u10000 and c <= \u10FFFF => 4
+  case c => panic("Not a valid code point")
+}
+
+def utf16UnitCount(codepoint: Char): Int = codepoint match {
+  case c and c >= \u0000  and c <= \uFFFF   => 1
+  case c and c >= \u10000 and c <= \u10FFFF => 4
+  case c => panic("Not a valid code point")
+}
+
+extern pure def charWidth(c: Char): Int =
+  // JavaScript strings are UTF-16 where every unicode character after 0xffff takes two units
+  js "(${c} > 0xffff) ? 2 : 1"

package/libraries/common/effekt.effekt

@@ -42,11 +42,32 @@ extern def println(value: String): Unit =
   js "$effekt.println(${value})"
   chez "(println_impl ${value})"
   llvm """
-    call void @c_io_println_String(%Pos ${value})
+    call void @c_io_println(%Pos ${value})
     ret %Pos zeroinitializer ; Unit
   """
   vm "effekt::println(String)"
 
+extern jsNode """
+$effekt.readln = function readln$impl(callback) {
+  const readline = require('node:readline').createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  readline.question('', (answer) => {
+    readline.close();
+    callback(answer);
+  });
+}
+"""
+
+extern async def readln(): String =
+  jsNode "$effekt.capture(callback => $effekt.readln(callback))"
+  llvm """
+    %result = call %Pos @c_io_readln()
+    tail call void @resume_Pos(%Stack %stack, %Pos %result)
+    ret void
+  """
+
 def println(value: Int): Unit = println(value.show)
 def println(value: Unit): Unit = println(value.show)
 def println(value: Double): Unit = println(value.show)
@@ -736,6 +757,9 @@ def repeat(n: Int) { action: () => Unit } = each(0, n) { n => action() }
 
 def repeat(n: Int) { action: () {Control} => Unit } = each(0, n) { (n) {l} => action() {l} }
 
+// NOTE: This is emitted by the close hole code action: do not remove unless you also adjust the code action
+/// Scopes a local computation
+def locally[R] { p: => R } : R = p()
 
 // Splices
 // =======

package/libraries/common/exception.effekt

@@ -54,7 +54,7 @@ extern io def panic(msg: String): Nothing =
   js "(function() { throw ${msg} })()"
   chez "(raise ${msg})"
   llvm """
-    call void @c_io_println_String(%Pos ${msg})
+    call void @c_io_println(%Pos ${msg})
     call void @exit(i32 1)
     ret %Pos zeroinitializer ; Unit
   """

package/libraries/common/json.effekt

@@ -1,6 +1,5 @@
 module json
 
-import char
 import scanner
 import stream
 
@@ -390,4 +389,4 @@ namespace test {
       resume(println(e))
     }
   }
-}
+}

package/libraries/common/result.effekt

@@ -35,3 +35,9 @@ def toOption[A, E](r: Result[A, E]): Option[A] = r match {
   case Success(a) => Some(a)
   case Error(exc, msg) => None()
 }
+
+def isError[A, E](r: Result[A, E]): Bool =
+  if (r is Error(_, _)) true else false
+
+def isSuccess[A, E](r: Result[A, E]): Bool =
+  if (r is Success(_)) true else false

package/libraries/common/scanner.effekt

@@ -1,6 +1,5 @@
 module scanner
 
-import char
 import stream
 
 interface Scan[A] {
@@ -49,6 +48,15 @@ def readSome[A, B] { convert: A => Option[B] }: B / { Scan[A], stop } =
     do stop()
   }
 
+/// like `readSome`, but for functions `A => B / Exception[WrongFormat]` such as `char::digitValue`
+def tryRead[A, B] { convert: A => B / Exception[WrongFormat] }: B / { Scan[A], stop } = {
+  with on[WrongFormat].default { do stop() }
+
+  val t = convert(do peek())
+  do skip[A]()
+  return t
+}
+
 /// Reads until the predicate does not hold for the next token.
 /// Emits the tokens read.
 def readWhile[A] { predicate: A => Bool }: Unit / { Scan[A], emit[A] } =
@@ -78,7 +86,7 @@ def readString(string: String): Unit / { Scan[Char], stop } =
 
 /// Check that the next character is a digit in base 10, and if so read and return it.
 def readDigit(): Int / { Scan[Char], stop } =
-  readSome[Char, Int]{ char => digitValue(char) }
+  tryRead[Char, Int]{ char => digitValue(char) }
 
 /// Read a positive decimal number.
 def readDecimal(): Int / Scan[Char] = {
@@ -91,7 +99,7 @@ def readDecimal(): Int / Scan[Char] = {
 
 /// Check that the next character is a digit in base 16, and if so read and return it.
 def readHexDigit(): Int / { Scan[Char], stop } =
-  readSome[Char, Int]{ char => hexDigitValue(char) }
+  tryRead[Char, Int]{ char => hexDigitValue(char) }
 
 /// Read a hexadecimal number.
 def readHexadecimal(): Int / Scan[Char] = {

package/libraries/common/stream.effekt

@@ -173,10 +173,23 @@ def replicate[A](number: Int) { action: () => A }: Unit / emit[A] =
     replicate(number - 1) {action}
   }
 
+/// Creates an infinite iterated stream given by an `initial` seed and a `step` function:
+/// iterate(a){f} ~> a, f(a), f(f(a)), f(f(f(a))), ...
+def iterate[A](initial: A) { step: A => A }: Unit / emit[A] = {
+  var current = initial
+  while (true) {
+    do emit(current)
+    current = step(current)
+  }
+}
 
-def sum { stream : () => Unit / emit[Int] }: Int =
+
+def sum { stream: () => Unit / emit[Int] }: Int =
   returning::sum[Unit]{stream}.second
 
+def product { stream: () => Unit / emit[Int] }: Int =
+  returning::product[Unit]{stream}.second
+
 def collectList[A] { stream: () => Unit / emit[A] }: List[A] =
   returning::collectList[A, Unit]{stream}.second
 
@@ -409,6 +422,88 @@ def each(string: String): Unit / emit[Char] =
 def collectString { stream: () => Unit / emit[Char] }: String =
   returning::collectString[Unit]{stream}.second
 
+namespace internal {
+  effect snapshot(): Unit
+}
+
+/// Use cons to handle prod, but also emit to the outside.
+/// The outside controls iteration, i.e., if cons aborts, the rest of prod will still be emitted.
+/// 
+/// Starts by executing cons. Will stop cons during execution if the outside stops consuming.
+/// 
+/// Example, printing all values consumed by the outside:
+///
+///     with teeing{ {s} => for{s}{ e => println(e) } }
+///     prod() // some producer
+///
+/// Laws-ish (hopefully):
+/// - hnd{ prd() } === hnd{ teeing{t}{ prd() } } for all hnd and t that calls its argument at most once (and has no other captures)
+def teeing[A]{ cons: { => Unit / emit[A] } => Unit }{ prod: => Unit / emit[A] }: Unit / emit[A] = region r {
+  var consDone = false
+  var k in r = box { prod() } // what still needs to run of prod after cons exits
+  try {
+    cons{
+      try {
+        prod()
+        k = box { () }
+      } with emit[A] { v =>
+        do internal::snapshot() // remember that we need to continue here if cons aborts
+        if(not(consDone)) do emit(v)
+        outer.emit(v)
+        resume(())
+      }
+      if(consDone) do stop() // cons already exited, so skip continuing there
+    } // end cons
+    consDone = true
+  }
+  with stop { () => () }
+  with outer: emit[A]{ v => resume(do emit(v)) }
+  with internal::snapshot{ () =>
+    k = box { resume(()) }
+    resume(())
+  }
+  k()
+}
+
+/// Binds a `teeing`-like function in the body, stopping the inner producer once all consumers in tees are done consuming.
+/// 
+/// Example of use, equivalent to `tee[A]{cns1}{cns2}{prd}`:
+/// 
+///     manyTee[A] { {tee} =>
+///       with tee{cns1}
+///       with tee{cns2}
+///       prd()
+///     }
+///
+def manyTee[A]{ body: { { { => Unit / emit[A] } => Unit }{ => Unit / emit[A] } => Unit / emit[A] } => Unit / emit[A] }: Unit = {
+  var running = 0
+  try {
+    body{ {hnd}{prod} =>
+      running = running + 1
+      teeing[A]{ {b} => hnd{b}; running = running - 1 }{prod}
+    }
+  } with emit[A] { _ =>
+    if(running > 0) resume(())
+  }
+}
+
+/// Streams prod to both cons1 and cons2. Stops once both cons1 and cons2 stopped.
+/// Only runs prod once, resuming at most once at each emit.
+///
+///     var sumRes = 0
+///     var productRes = 0
+///     tee{ s => sumRes = sum{s} }{ s => productRes = product{s} }{ range(0, 10) }
+///     assertEquals(sum{ range(0, 10) }, sumRes)
+///     assertEquals(product{ range(0, 10) }, productRes)
+///
+def tee[A]{ cons1: { => Unit / emit[A] } => Unit }{ cons2: { => Unit / emit[A] } => Unit }{ prod: => Unit / emit[A] }: Unit = {
+  manyTee[A]{ {tee} =>
+    with tee{cons1}
+    with tee{cons2}
+    prod()
+  }
+}
+
 namespace returning {
 
 /// Canonical handler of push streams that performs `action` for every
@@ -461,7 +556,7 @@ def limit[A, R](number: Int) { stream: () => R / emit[A] }: R / { emit[A], stop
   }
 }
 
-def sum[R] { stream : () => R / emit[Int] }: (R, Int) = {
+def sum[R] { stream: () => R / emit[Int] }: (R, Int) = {
   var s = 0;
   try {
     (stream(), s)
@@ -471,6 +566,16 @@ def sum[R] { stream : () => R / emit[Int] }: (R, Int) = {
   }
 }
 
+def product[R] { stream: () => R / emit[Int] }: (R, Int) = {
+  var s = 1;
+  try {
+    (stream(), s)
+  } with emit[Int] { v =>
+    s = s * v;
+    resume(())
+  }
+}
+
 def collectList[A, R] { stream: () => R / emit[A] }: (R, List[A]) =
   try {
     (stream(), Nil())

package/libraries/common/string.effekt

@@ -5,6 +5,7 @@ import option
 import list
 import exception
 import result
+import char
 
 // TODO
 // - [ ] handle unicode codepoints (that can span two indices) correctly
@@ -61,12 +62,22 @@ def endsWith(str: String, suffix: String): Bool =
 /// TODO use a more efficient way of appending strings like a buffer
 def repeat(str: String, n: Int): String = {
   def go(n: Int, result: String): String = {
-    if (n == 0) result
+    if (n <= 0) result
     else go(n - 1, result ++ str)
   }
   go(n, "")
 }
 
+/// Left-pad the given string with spaces
+def padLeft(str: String, n: Int): String = {
+  " ".repeat(n - str.length) ++ str
+}
+
+/// Right-pad the given string with spaces
+def padRight(str: String, n: Int): String = {
+  str ++ " ".repeat(n - str.length)
+}
+
 // TODO use .split() in JS
 def split(str: String, sep: String): List[String] = {
   val strLength = str.length
@@ -113,20 +124,18 @@ def toBool(s: String): Bool / Exception[WrongFormat] = s match {
 
 // TODO optimize (right now this will be horribly slow (compared to the native JS version)
 def toInt(str: String): Int / Exception[WrongFormat] = {
-
-  val zero = '0'.toInt
-
   def go(index: Int, acc: Int): Int = {
-    result[Char, OutOfBounds] { str.charAt(index) } match {
-      case Success(c) and c >= '0' and c <= '9' =>
-        go(index + 1, 10 * acc + (c.toInt - zero))
-      case Success(c) => wrongFormat("Not a valid number: '" ++ str ++ "'")
-      // wrong index means we are done parsing
-      case Error(_, _) => acc
-    }
+    // wrong index means we're done parsing
+    with on[OutOfBounds].default { () => acc };
+
+    val c = str.charAt(index)
+    val d = char::digitValue(c)
+    go(index + 1, 10 * acc + d)
   }
 
-  with default[OutOfBounds, Int] { wrongFormat("Empty string is not a valid number") };
+  with on[OutOfBounds].default {
+    wrongFormat("Empty string is not a valid number")
+  }
 
   str.charAt(0) match {
     case '-' => 0 - go(1, 0)
@@ -136,38 +145,22 @@ def toInt(str: String): Int / Exception[WrongFormat] = {
 
 // TODO optimize (right now this will be horribly slow (compared to the native JS version)
 def toInt(str: String, base: Int): Int / Exception[WrongFormat] = {
-
-  if( base > 36 || base < 1 ) {
+  if (base > 36 || base < 1) {
     wrongFormat("Invalid base: " ++ base.show)
   }
 
-  val zero = '0'.toInt
-  val l_a = 'a'.toInt
-  val u_a = 'A'.toInt
-
-  def parseDigit(c: Char): Option[Int] = {
-    if( c >= '0' and c <= '9' and c.toInt - zero < base ) {
-      Some(c.toInt - zero)
-    } else if( c >= 'a' and c <= 'z' and c.toInt - l_a < base - 10 ) {
-      Some(c.toInt - l_a + 10)
-    } else if( c >= 'A' and c <= 'Z' and c.toInt - u_a < base - 10) {
-      Some(c.toInt - u_a + 10)
-    } else {
-      None()
-    }
-  }
-
   def go(index: Int, acc: Int): Int = {
-    result[Char, OutOfBounds] { str.charAt(index) } match {
-      case Success(c) and parseDigit(c) is Some(d) =>
-        go(index + 1, base * acc + d)
-      case Success(c) => wrongFormat("Not a valid number: '" ++ str ++ "'")
-      // wrong index means we are done parsing
-      case Error(_, _) => acc
-    }
+    // wrong index means we're done parsing
+    with on[OutOfBounds].default { () => acc };
+
+    val c = str.charAt(index)
+    val d = char::digitValue(c, base)
+    go(index + 1, base * acc + d)
   }
 
-  with default[OutOfBounds, Int] { wrongFormat("Empty string is not a valid number") };
+  with on[OutOfBounds].default {
+    wrongFormat("Empty string is not a valid number")
+  }
 
   str.charAt(0) match {
     case '-' => 0 - go(1, 0)
@@ -222,104 +215,6 @@ def lastIndexOf(str: String, sub: String, from: Int): Option[Int] = {
 // extern pure def unsafeIndexOf(str: String, sub: String): Int =
 //   js "${str}.indexOf(${sub})"
 
-
-// Characters
-// ----------
-//
-//   JS: Int (Unicode codepoints)
-//   Chez: ?
-//   LLVM: i64 representing utf-8 (varying length 1-4 bytes)
-
-extern pure def toString(ch: Char): String =
-  js "String.fromCodePoint(${ch})"
-  chez "(string (integer->char ${ch}))"
-  llvm """
-    %z = call %Pos @c_bytearray_show_Char(%Int ${ch})
-    ret %Pos %z
-  """
-
-// Since we currently represent Char by integers in all backends, we could reuse comparison
-extern pure def toInt(ch: Char): Int =
-  js "${ch}"
-  chez "${ch}"
-  llvm "ret %Int ${ch}"
-  vm "string::toInt(Char)"
-
-extern pure def toChar(codepoint: Int): Char =
-  js "${codepoint}"
-  chez "${codepoint}"
-  llvm "ret %Int ${codepoint}"
-  vm "string::toChar(Int)"
-
-
-extern pure def infixLt(x: Char, y: Char): Bool =
-  js "(${x} < ${y})"
-  chez "(< ${x} ${y})"
-  llvm """
-    %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
-  """
-  vm "string::infixLt(Char, Char)"
-
-extern pure def infixLte(x: Char, y: Char): Bool =
-  js "(${x} <= ${y})"
-  chez "(<= ${x} ${y})"
-  llvm """
-    %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
-  """
-  vm "string::infixLte(Char, Char)"
-
-extern pure def infixGt(x: Char, y: Char): Bool =
-  js "(${x} > ${y})"
-  chez "(> ${x} ${y})"
-  llvm """
-    %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
-  """
-  vm "string::infixGt(Char, Char)"
-
-extern pure def infixGte(x: Char, y: Char): Bool =
-  js "(${x} >= ${y})"
-  chez "(>= ${x} ${y})"
-  llvm """
-    %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
-  """
-  vm "string::infixGte(Char, Char)"
-
-
-/**
- * Determines the number of bytes needed by a codepoint
- *
- * Also see: https://en.wikipedia.org/wiki/UTF-8
- */
-def utf8ByteCount(codepoint: Char): Int = codepoint match {
-  case c and c >= \u0000  and c <= \u007F   => 1
-  case c and c >= \u0080  and c <= \u07FF   => 2
-  case c and c >= \u0800  and c <= \uFFFF   => 3
-  case c and c >= \u10000 and c <= \u10FFFF => 4
-  case c => panic("Not a valid code point")
-}
-
-def utf16UnitCount(codepoint: Char): Int = codepoint match {
-  case c and c >= \u0000  and c <= \uFFFF   => 1
-  case c and c >= \u10000 and c <= \u10FFFF => 4
-  case c => panic("Not a valid code point")
-}
-
-extern pure def charWidth(c: Char): Int =
-  // JavaScript strings are UTF-16 where every unicode character after 0xffff takes two units
-  js "(${c} > 0xffff) ? 2 : 1"
-
 def charAt(str: String, index: Int): Char / Exception[OutOfBounds] =
   if (index < 0 || index >= length(str))
     do raise(OutOfBounds(), "Index out of bounds: " ++ show(index) ++ " in string: '" ++ str ++ "'")

package/libraries/js/effekt_builtins.js

@@ -58,4 +58,4 @@ $effekt.unit = { __unit: true }
 
 $effekt.emptyMatch = function() { throw "empty match" }
 
-$effekt.hole = function() { throw "not implemented, yet" }
+$effekt.hole = function() { throw "not implemented, yet" }