@effekt-lang/effekt 0.46.0 → 0.48.0

package/libraries/common/effekt.effekt

@@ -60,7 +60,7 @@ $effekt.readln = function readln$impl(callback) {
 }
 """
 
-extern async def readln(): String =
+extern def readln() at async: String =
   jsNode "$effekt.capture(callback => $effekt.readln(callback))"
   llvm """
     %result = call %Pos @c_io_readln()
@@ -74,7 +74,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 pure def show(value: Int): String =
+extern def show(value: Int) at {}: String =
   js "'' + ${value}"
   chez "(show-number ${value})"
   llvm """
@@ -85,7 +85,7 @@ extern pure def show(value: Int): String =
 
 def show(value: Unit): String = "()"
 
-extern pure def show(value: Double): String =
+extern def show(value: Double) at {}: String =
   js "'' + ${value}"
   chez "(show-number ${value})"
   llvm """
@@ -100,7 +100,7 @@ def show(value: String): String =
 def show(value: Bool): String =
   if (value) "true" else "false"
 
-extern pure def show(value: Char): String =
+extern def show(value: Char) at {}: String =
   js "String.fromCodePoint(${value})"
   chez "(string (integer->char ${value}))"
   llvm """
@@ -109,7 +109,7 @@ extern pure def show(value: Char): String =
   """
   vm "effekt::show(Char)"
 
-extern pure def show(value: Byte): String =
+extern def show(value: Byte) at {}: String =
   js "'' + ${value}"
   chez "(string ${value})"
   llvm """
@@ -118,11 +118,11 @@ extern pure def show(value: Byte): String =
   """
   vm "effekt::show(Byte)"
 
-extern pure def genericShow[R](value: R): String =
+extern def genericShow[R](value: R) at {}: String =
   js "$effekt.show(${value})"
   chez "(show_impl ${value})"
 
-extern io def inspect[R](value: R): Unit =
+extern def inspect[R](value: R) at io: Unit =
   js { println(genericShow(value)) }
   chez { println(genericShow(value)) }
   vm "effekt::inspect(Any)"
@@ -130,7 +130,7 @@ extern io def inspect[R](value: R): Unit =
 
 // Strings
 // =======
-extern pure def infixConcat(s1: String, s2: String): String =
+extern def infixConcat(s1: String, s2: String) at {}: String =
   js "${s1} + ${s2}"
   chez "(string-append ${s1} ${s2})"
   llvm """
@@ -139,7 +139,7 @@ extern pure def infixConcat(s1: String, s2: String): String =
   """
   vm "effekt::infixConcat(String, String)"
 
-extern pure def length(str: String): Int =
+extern def length(str: String) at {}: Int =
   js "${str}.length"
   chez "(string-length ${str})"
   llvm """
@@ -148,7 +148,7 @@ extern pure def length(str: String): Int =
   """
   vm "effekt::length(String)"
 
-extern pure def unsafeSubstring(str: String, from: Int, to: Int): String =
+extern def unsafeSubstring(str: String, from: Int, to: Int) at {}: String =
   js "${str}.substring(${from}, ${to})"
   chez "(substring ${str} ${from} ${to})" // potentially raises: "Exception in substring: ..."
   llvm """
@@ -161,7 +161,7 @@ extern pure def unsafeSubstring(str: String, from: Int, to: Int): String =
 // Side effecting ops
 // ==================
 
-extern io def random(): Double =
+extern def random() at io: Double =
   js "Math.random()"
   chez "(random 1.0)"
   vm "effekt::random()"
@@ -170,8 +170,8 @@ extern io def random(): Double =
 // ====================
 // the following type is defined in builtins.scala
 // interface Ref[T] { def get(): T; def put(t: T): Unit }
-// extern io def freshIn[T](t: T) {r: Region}: Ref[T] at {r} = js "r.fresh(${t})"
-// extern io def freshGlobal[T](t: T): Ref[T] at {global} = js "$effekt.fresh(${t})"
+// extern io def freshIn[T](t: T) {r: Region}: Ref[T] at r = js "r.fresh(${t})"
+// extern io def freshGlobal[T](t: T): Ref[T] at global = js "$effekt.fresh(${t})"
 
 
 // Equality
@@ -193,7 +193,7 @@ def compareInt(n: Int, m: Int) =
   else if (n < m) Less()
   else Greater()
 
-extern pure def genericCompareImpl[R](x: R, y: R): Int =
+extern def genericCompareImpl[R](x: R, y: R) at {}: Int =
   js "$effekt.compare(${x}, ${y})"
 
 /// Compares two values of the same type, returning an `Ordering`.
@@ -222,7 +222,7 @@ def println(o: Ordering): Unit = println(o.show)
 // ==============
 
 /// Structural equality: Not available in the LLVM backend
-extern pure def equals[R](x: R, y: R): Bool =
+extern def equals[R](x: R, y: R) at {}: Bool =
   js "$effekt.equals(${x}, ${y})"
   chez "(equal_impl ${x} ${y})"
 
@@ -230,10 +230,10 @@ def differsFrom[R](x: R, y: R): Bool =
   not(equals(x, y))
 
 // TODO fix this in the pattern matching compiler
-extern pure def infixEq(x: Unit, y: Unit): Bool =
+extern def infixEq(x: Unit, y: Unit) at {}: Bool =
   default { true }
 
-extern pure def infixEq(x: Int, y: Int): Bool =
+extern def infixEq(x: Int, y: Int) at {}: Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"
   llvm """
@@ -244,7 +244,7 @@ extern pure def infixEq(x: Int, y: Int): Bool =
   """
   vm "effekt::infixEq(Int, Int)"
 
-extern pure def infixNeq(x: Int, y: Int): Bool =
+extern def infixNeq(x: Int, y: Int) at {}: Bool =
   js "${x} !== ${y}"
   chez "(not (equal? ${x} ${y}))"
   llvm """
@@ -255,7 +255,7 @@ extern pure def infixNeq(x: Int, y: Int): Bool =
   """
   vm "effekt::infixNeq(Int, Int)"
 
-extern pure def infixEq(x: Char, y: Char): Bool =
+extern def infixEq(x: Char, y: Char) at {}: Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"
   llvm """
@@ -266,7 +266,7 @@ extern pure def infixEq(x: Char, y: Char): Bool =
   """
   vm "effekt::infixEq(Char, Char)"
 
-extern pure def infixNeq(x: Char, y: Char): Bool =
+extern def infixNeq(x: Char, y: Char) at {}: Bool =
   js "${x} !== ${y}"
   chez "(not (equal? ${x} ${y}))"
   llvm """
@@ -276,7 +276,7 @@ extern pure def infixNeq(x: Char, y: Char): Bool =
     ret %Pos %adt_boolean
   """
 
-extern pure def infixEq(x: String, y: String): Bool =
+extern def infixEq(x: String, y: String) at {}: Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"
   llvm """
@@ -287,7 +287,7 @@ extern pure def infixEq(x: String, y: String): Bool =
 
 def infixNeq(x: String, y: String): Bool = not(x == y)
 
-extern pure def infixEq(x: Bool, y: Bool): Bool =
+extern def infixEq(x: Bool, y: Bool) at {}: Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"
   llvm """
@@ -300,7 +300,7 @@ extern pure def infixEq(x: Bool, y: Bool): Bool =
   """
   vm "effekt::infixEq(Bool, Bool)"
 
-extern pure def infixNeq(x: Bool, y: Bool): Bool =
+extern def infixNeq(x: Bool, y: Bool) at {}: Bool =
   js "${x} !== ${y}"
   chez "(not (equal? ${x} ${y}))"
   llvm """
@@ -315,85 +315,85 @@ extern pure def infixNeq(x: Bool, y: Bool): Bool =
 
 // Math ops
 // ========
-extern pure def infixAdd(x: Int, y: Int): Int =
+extern def infixAdd(x: Int, y: Int) at {}: Int =
   js "(${x} + ${y})"
   chez "(+ ${x} ${y})"
   llvm "%z = add  %Int ${x}, ${y} ret %Int %z"
   vm "effekt::infixAdd(Int, Int)"
 
-extern pure def infixMul(x: Int, y: Int): Int =
+extern def infixMul(x: Int, y: Int) at {}: Int =
   js "(${x} * ${y})"
   chez "(* ${x} ${y})"
   llvm "%z = mul  %Int ${x}, ${y} ret %Int %z"
   vm "effekt::infixMul(Int, Int)"
 
-extern pure def infixDiv(x: Int, y: Int): Int =
+extern def infixDiv(x: Int, y: Int) at {}: Int =
   js "Math.floor(${x} / ${y})"
   chez "(floor (/ ${x} ${y}))"
   llvm "%z = sdiv %Int ${x}, ${y} ret %Int %z"
   vm "effekt::infixDiv(Int, Int)"
 
-extern pure def infixSub(x: Int, y: Int): Int =
+extern def infixSub(x: Int, y: Int) at {}: Int =
   js "(${x} - ${y})"
   chez "(- ${x} ${y})"
   llvm "%z = sub  %Int ${x}, ${y} ret %Int %z"
   vm "effekt::infixSub(Int, Int)"
 
-extern pure def mod(x: Int, y: Int): Int =
+extern def mod(x: Int, y: Int) at {}: Int =
   js "(${x} % ${y})"
   chez "(modulo ${x} ${y})"
   llvm "%z = srem %Int ${x}, ${y} ret %Int %z"
   vm "effekt::mod(Int, Int)"
 
-extern pure def infixAdd(x: Double, y: Double): Double =
+extern def infixAdd(x: Double, y: Double) at {}: Double =
   js "(${x} + ${y})"
   chez "(+ ${x} ${y})"
   llvm "%z = fadd %Double ${x}, ${y} ret %Double %z"
   vm "effekt::infixAdd(Double, Double)"
 
-extern pure def infixMul(x: Double, y: Double): Double =
+extern def infixMul(x: Double, y: Double) at {}: Double =
   js "(${x} * ${y})"
   chez "(* ${x} ${y})"
   llvm "%z = fmul %Double ${x}, ${y} ret %Double %z"
   vm "effekt::infixMul(Double, Double)"
 
-extern pure def infixSub(x: Double, y: Double): Double =
+extern def infixSub(x: Double, y: Double) at {}: Double =
   js "(${x} - ${y})"
   chez "(- ${x} ${y})"
   llvm "%z = fsub %Double ${x}, ${y} ret %Double %z"
   vm "effekt::infixSub(Double, Double)"
 
-extern pure def infixDiv(x: Double, y: Double): Double =
+extern def infixDiv(x: Double, y: Double) at {}: Double =
   js "(${x} / ${y})"
   chez "(fl/ ${x} ${y})"
   llvm "%z = fdiv %Double ${x}, ${y} ret %Double %z"
   vm "effekt::infixDiv(Double, Double)"
 
-extern pure def cos(x: Double): Double =
+extern def cos(x: Double) at {}: Double =
   js "Math.cos(${x})"
   chez "(cos ${x})"
   vm "effekt::cos(Double)"
   llvm "%z = call %Double @llvm.cos.f64(double ${x}) ret %Double %z"
 
-extern pure def sin(x: Double): Double =
+extern def sin(x: Double) at {}: Double =
   js "Math.sin(${x})"
   chez "(sin ${x})"
   vm "effekt::sin(Double)"
   llvm "%z = call %Double @llvm.sin.f64(double ${x}) ret %Double %z"
 
-extern pure def atan(x: Double): Double =
+extern def atan(x: Double) at {}: Double =
   js "Math.atan(${x})"
   chez "(atan ${x})"
   vm "effekt::atan(Double)"
   llvm "%z = call %Double @atan(double ${x}) ret %Double %z"
 
-extern pure def tan(x: Double): Double =
+extern def tan(x: Double) at {}: Double =
   js "Math.tan(${x})"
   chez "(tan ${x})"
   vm "effekt::tan(Double)"
   llvm "%z = call %Double @tan(double ${x}) ret %Double %z"
 
-extern pure def sqrt(x: Double): Double =
+extern def sqrt(x: Double) at {}: Double =
   js "Math.sqrt(${x})"
   chez "(sqrt ${x})"
   llvm "%z = call %Double @llvm.sqrt.f64(double ${x}) ret %Double %z"
@@ -404,24 +404,27 @@ def square(x: Double): Double = x * x
 def neg(n: Double): Double =
   0.0 - n
 
+def min(n: Double, m: Double): Double =
+  if (n < m) n else m
+
 def max(n: Double, m: Double): Double =
   if (n > m) n else m
 
 def abs(n: Double): Double =
   max(n, neg(n))
 
-extern pure def log(x: Double): Double =
+extern def log(x: Double) at {}: Double =
   js "Math.log(${x})"
   chez "(log ${x})"
   vm "effekt::log(Double)"
   llvm "%z = call %Double @llvm.log.f64(double ${x}) ret %Double %z"
 
-extern pure def log1p(x: Double): Double =
+extern def log1p(x: Double) at {}: Double =
   js "Math.log1p(${x})"
   chez "(log (+ ${x} 1))"
   llvm "%z = call %Double @log1p(double ${x}) ret %Double %z"
 
-extern pure def exp(x: Double): Double =
+extern def exp(x: Double) at {}: Double =
   js "Math.exp(${x})"
   chez "(exp ${x})"
   vm "effekt::exp(Double)"
@@ -440,14 +443,14 @@ def pow(base: Double, exponent: Int): Double = {
   }
 }
 
-extern pure def pow(base: Double, exponent: Double): Double =
+extern def pow(base: Double, exponent: Double) at {}: Double =
   js "Math.pow(${base}, ${exponent})"
   chez "(expt ${base} ${exponent})"
   vm "effekt::pow(Double, Double)"
   llvm "%z = call %Double @llvm.pow.f64(double ${base}, double ${exponent}) ret %Double %z"
 
 // since we do not have "extern val", yet
-extern pure def _pi(): Double =
+extern def _pi() at {}: Double =
   js "Math.PI"
   chez "(* 4 (atan 1))"
   vm "effekt::pi()"
@@ -455,20 +458,20 @@ extern pure def _pi(): Double =
 
 val PI: Double = _pi()
 
-extern pure def toInt(d: Double): Int =
+extern def toInt(d: Double) at {}: Int =
   js "Math.trunc(${d})"
   chez "(flonum->fixnum ${d})"
   llvm "%z = fptosi double ${d} to %Int ret %Int %z"
   vm "effekt::toInt(Double)"
 
-extern pure def toDouble(d: Int): Double =
+extern def toDouble(d: Int) at {}: Double =
   js "${d}"
   chez "(fixnum->flonum ${d})"
   llvm "%z = sitofp i64 ${d} to double ret double %z"
   vm "effekt::toDouble(Int)"
 
 
-extern pure def round(d: Double): Int =
+extern def round(d: Double) at {}: Int =
   js "Math.round(${d})"
   chez "(flonum->fixnum (round ${d}))"
   llvm """
@@ -482,7 +485,7 @@ def round(d: Double, digits: Int): Double = {
   round(d * factor).toDouble / factor
 }
 
-extern pure def floor(d: Double): Int =
+extern def floor(d: Double) at {}: Int =
   js "Math.floor(${d})"
   chez "(flonum->fixnum (floor ${d}))"
   llvm """
@@ -490,7 +493,7 @@ extern pure def floor(d: Double): Int =
     %z = fptosi double %i to %Int ret %Int %z
   """
 
-extern pure def ceil(d: Double): Int =
+extern def ceil(d: Double) at {}: Int =
   js "Math.ceil(${d})"
   chez "(flonum->fixnum (ceiling ${d}))"
   llvm """
@@ -511,7 +514,7 @@ def abs(n: Int): Int =
     max(n, neg(n))
 
 
-extern pure def infixLt(x: Int, y: Int): Bool =
+extern def infixLt(x: Int, y: Int) at {}: Bool =
   js "(${x} < ${y})"
   chez "(< ${x} ${y})"
   llvm """
@@ -522,7 +525,7 @@ extern pure def infixLt(x: Int, y: Int): Bool =
   """
   vm "effekt::infixLt(Int, Int)"
 
-extern pure def infixLte(x: Int, y: Int): Bool =
+extern def infixLte(x: Int, y: Int) at {}: Bool =
   js "(${x} <= ${y})"
   chez "(<= ${x} ${y})"
   llvm """
@@ -533,7 +536,7 @@ extern pure def infixLte(x: Int, y: Int): Bool =
   """
   vm "effekt::infixLte(Int, Int)"
 
-extern pure def infixGt(x: Int, y: Int): Bool =
+extern def infixGt(x: Int, y: Int) at {}: Bool =
   js "(${x} > ${y})"
   chez "(> ${x} ${y})"
   llvm """
@@ -544,7 +547,7 @@ extern pure def infixGt(x: Int, y: Int): Bool =
   """
   vm "effekt::infixGt(Int, Int)"
 
-extern pure def infixGte(x: Int, y: Int): Bool =
+extern def infixGte(x: Int, y: Int) at {}: Bool =
   js "(${x} >= ${y})"
   chez "(>= ${x} ${y})"
   llvm """
@@ -555,17 +558,17 @@ extern pure def infixGte(x: Int, y: Int): Bool =
   """
   vm "effekt::infixGte(Int, Int)"
 
-extern pure def infixEq(x: Double, y: Double): Bool =
+extern def infixEq(x: Double, y: Double) at {}: Bool =
   js "${x} === ${y}"
   chez "(= ${x} ${y})"
   vm "effekt::infixEq(Double, Double)"
 
-extern pure def infixNeq(x: Double, y: Double): Bool =
+extern def infixNeq(x: Double, y: Double) at {}: Bool =
   js "${x} !== ${y}"
   chez "(not (= ${x} ${y}))"
   vm "effekt::infixNeq(Double, Double)"
 
-extern pure def infixLt(x: Double, y: Double): Bool =
+extern def infixLt(x: Double, y: Double) at {}: Bool =
   js "(${x} < ${y})"
   chez "(< ${x} ${y})"
   llvm """
@@ -576,12 +579,12 @@ extern pure def infixLt(x: Double, y: Double): Bool =
   """
   vm "effekt::infixLt(Double, Double)"
 
-extern pure def infixLte(x: Double, y: Double): Bool =
+extern def infixLte(x: Double, y: Double) at {}: Bool =
   js "(${x} <= ${y})"
   chez "(<= ${x} ${y})"
   vm "effekt::infixLte(Double, Double)"
 
-extern pure def infixGt(x: Double, y: Double): Bool =
+extern def infixGt(x: Double, y: Double) at {}: Bool =
   js "(${x} > ${y})"
   chez "(> ${x} ${y})"
   llvm """
@@ -592,32 +595,32 @@ extern pure def infixGt(x: Double, y: Double): Bool =
   """
   vm "effekt::infixGt(Double, Double)"
 
-extern pure def infixGte(x: Double, y: Double): Bool =
+extern def infixGte(x: Double, y: Double) at {}: Bool =
   js "(${x} >= ${y})"
   chez "(>= ${x} ${y})"
   vm "effekt::infixGte(Double, Double)"
 
 // TODO do we really need those? if yes, move to string.effekt
-extern pure def infixLt(x: String, y: String): Bool =
+extern def infixLt(x: String, y: String) at {}: Bool =
   js "(${x} < ${y})"
   chez "(string<? ${x} ${y})"
 
-extern pure def infixLte(x: String, y: String): Bool =
+extern def infixLte(x: String, y: String) at {}: Bool =
   js "(${x} <= ${y})"
   chez "(string<=? ${x} ${y})"
 
-extern pure def infixGt(x: String, y: String): Bool =
+extern def infixGt(x: String, y: String) at {}: Bool =
   js "(${x} > ${y})"
   chez "(string>? ${x} ${y})"
 
-extern pure def infixGte(x: String, y: String): Bool =
+extern def infixGte(x: String, y: String) at {}: Bool =
   js "(${x} >= ${y})"
   chez "(string>=? ${x} ${y})"
 
 
 // Boolean operations
 // ==================
-extern pure def not(b: Bool): Bool =
+extern def not(b: Bool) at {}: Bool =
   js "!${b}"
   chez "(not ${b})"
   llvm """
@@ -639,32 +642,32 @@ def infixAnd { first: => Bool } { second: => Bool }: Bool =
 // ==================
 
 /// Arithmetic left shift
-extern pure def bitwiseShl(x: Int, y: Int): Int =
+extern def bitwiseShl(x: Int, y: Int) at {}: Int =
   js "(${x} << ${y})"
   chez "(ash ${x} ${y})"
   llvm "%z = shl %Int ${x}, ${y} ret %Int %z"
   vm "effekt::bitwiseShl(Int, Int)"
 
 /// Arithmetic right shift
-extern pure def bitwiseShr(x: Int, y: Int): Int =
+extern def bitwiseShr(x: Int, y: Int) at {}: Int =
   js "(${x} >> ${y})"
   chez "(ash ${x} (- ${y}))"
   llvm "%z = ashr %Int ${x}, ${y} ret %Int %z"
   vm "effekt::bitwiseShr(Int, Int)"
 
-extern pure def bitwiseAnd(x: Int, y: Int): Int =
+extern def bitwiseAnd(x: Int, y: Int) at {}: Int =
   js "(${x} & ${y})"
   chez "(logand ${x} ${y})"
   llvm "%z = and %Int ${x}, ${y} ret %Int %z"
   vm "effekt::bitwiseAnd(Int, Int)"
 
-extern pure def bitwiseOr(x: Int, y: Int): Int =
+extern def bitwiseOr(x: Int, y: Int) at {}: Int =
   js "(${x} | ${y})"
   chez "(logior ${x} ${y})"
   llvm "%z = or %Int ${x}, ${y} ret %Int %z"
   vm "effekt::bitwiseOr(Int, Int)"
 
-extern pure def bitwiseXor(x: Int, y: Int): Int =
+extern def bitwiseXor(x: Int, y: Int) at {}: Int =
   js "(${x} ^ ${y})"
   chez "(logxor ${x} ${y})"
   llvm "%z = xor %Int ${x}, ${y} ret %Int %z"
@@ -673,12 +676,12 @@ extern pure def bitwiseXor(x: Int, y: Int): Int =
 
 // Byte operations
 // ===============
-extern pure def toByte(n: Int): Byte =
+extern def toByte(n: Int) at {}: Byte =
   js "${n}"
   llvm "%z = trunc %Int ${n} to %Byte ret %Byte %z"
   chez "${n}"
 
-extern pure def toInt(n: Byte): Int =
+extern def toInt(n: Byte) at {}: Int =
   js "${n}"
   llvm "%z = zext %Byte ${n} to %Int ret %Int %z"
   vm "effekt::toInt(Byte)"
@@ -695,13 +698,13 @@ extern pure def toInt(n: Byte): Int =
 //   llvm: null?
 
 /// The value used by the FFI to represent undefined values
-extern pure def undefined[A](): A =
+extern def undefined[A]() at {}: A =
   js "undefined"
   chez "#f"
   vm "effekt::undefined()"
 
 /// Is an FFI value undefined?
-extern pure def isUndefined[A](value: A): Bool =
+extern def isUndefined[A](value: A) at {}: Bool =
   js "(${value} === undefined || ${value} === null)"
   chez "(eq? ${value} #f)"
   vm "effekt::isUndefined[A](A)"

package/libraries/common/exception.effekt

@@ -50,7 +50,7 @@ def wrongFormat(msg: String): Nothing / Exception[WrongFormat] =
 /**
  * A fatal runtime error that cannot be caught
  */
-extern io def panic(msg: String): Nothing =
+extern def panic(msg: String) at io: Nothing =
   js "(function() { throw ${msg} })()"
   chez "(raise ${msg})"
   llvm """

package/libraries/common/io/console.effekt

@@ -28,18 +28,18 @@ namespace js {
 
   extern type JSConsole
 
-  extern io def newConsole(): JSConsole =
+  extern def newConsole() at io: JSConsole =
     jsNode """readline.createInterface({
         input: process.stdin,
         output: process.stdout,
       })"""
 
-  extern io def close(console: JSConsole): Unit =
+  extern def close(console: JSConsole) at io: Unit =
     jsNode "${console}.close()"
 
-  extern async def readLine(console: JSConsole): String =
+  extern def readLine(console: JSConsole) at async: String =
     jsNode "$effekt.capture(k => ${console}.once('line', k))"
-  extern io def writeLine(console: JSConsole, message: String): Unit =
+  extern def writeLine(console: JSConsole, message: String) at io: Unit =
     jsNode "${console}.output.write(${message} + '\\n')"
 }
 

package/libraries/common/io/error.effekt

@@ -456,7 +456,7 @@ namespace internal {
     }
   """
 
-  extern pure def errorNumber(errno: Int): Int =
+  extern def errorNumber(errno: Int) at {}: Int =
     jsNode "errorNumber(${errno})"
     llvm """
       %z = call %Int @c_error_number(%Int ${errno})
@@ -464,3 +464,14 @@ namespace internal {
     """
 
 }
+
+namespace internal {
+  def checkResult(result: Int): Int / Exception[IOError] =
+    if (result < 0) {
+      val ioError = fromNumber(internal::errorNumber(result));
+      do raise[IOError](ioError, message(ioError))
+    } else {
+      result
+    }
+}
+