@effekt-lang/effekt 0.66.0 → 0.68.0

package/libraries/common/effekt.effekt

@@ -46,7 +46,6 @@ extern def print(value: String): Unit =
     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})"
@@ -55,7 +54,6 @@ extern def println(value: String): Unit =
     call void @c_io_println(%Pos ${value})
     ret %Pos zeroinitializer ; Unit
   """
-  vm "effekt::println(String)"
 
 extern jsNode """
 $effekt.readln = function readln$impl(callback) {
@@ -83,6 +81,7 @@ def println(value: Unit): Unit = println(value.show)
 def println(value: Double): Unit = println(value.show)
 def println(value: Bool): Unit = println(value.show)
 def println(value: Byte): Unit = println(value.show)
+def println(value: Char): Unit = println(value.show)
 
 extern def showBuiltin(value: Int) at {}: String =
   js "'' + ${value}"
@@ -91,7 +90,6 @@ extern def showBuiltin(value: Int) at {}: String =
     %z = call %Pos @c_bytearray_show_Int(%Int ${value})
     ret %Pos %z
   """
-  vm "effekt::show(Int)"
 
 extern def showBuiltin(value: Double) at {}: String =
   js "'' + ${value}"
@@ -100,7 +98,6 @@ extern def showBuiltin(value: Double) at {}: String =
     %z = call %Pos @c_bytearray_show_Double(%Double ${value})
     ret %Pos %z
   """
-  vm "effekt::show(Double)"
 
 extern def showBuiltin(value: Char) at {}: String =
   js "String.fromCodePoint(${value})"
@@ -109,7 +106,6 @@ extern def showBuiltin(value: Char) at {}: String =
     %z = call %Pos @c_bytearray_show_Char(%Int ${value})
     ret %Pos %z
   """
-  vm "effekt::show(Char)"
 
 extern def showBuiltin(value: Byte) at {}: String =
   js "'0x' + ${value}.toString(16).toUpperCase().padStart(2, '0')"
@@ -118,11 +114,9 @@ extern def showBuiltin(value: Byte) at {}: String =
     %z = call %Pos @c_bytearray_show_Byte(%Byte ${value})
     ret %Pos %z
   """
-  vm "effekt::show(Byte)"
 
 extern def inspect[R](value: R) at io: Unit =
   default { println(show(value)) }
-  vm "effekt::inspect(Any)"
 
 /// A fatal runtime error that cannot be caught
 extern def panic(msg: String) at io: Nothing =
@@ -135,8 +129,8 @@ extern def panic(msg: String) at io: Nothing =
   """
 
 extern def show[R](value: R) at {}: String =
-  js "$effekt.show(${value})"
-  chez "(show_impl ${value})"
+  js "undefined"
+  chez "(void)"
   llvm "ret %Pos poison"
 
 extern def genericShow[R](value: R) at {}: String =
@@ -152,7 +146,6 @@ extern def infixPlusPlus(s1: String, s2: String) at {}: String =
     %spz = call %Pos @c_bytearray_concatenate(%Pos ${s1}, %Pos ${s2})
     ret %Pos %spz
   """
-  vm "effekt::infixPlusPlus(String, String)"
 
 extern def length(str: String) at {}: Int =
   js "${str}.length"
@@ -161,7 +154,6 @@ extern def length(str: String) at {}: Int =
     %x = call %Int @c_bytearray_size(%Pos ${str})
     ret %Int %x
   """
-  vm "effekt::length(String)"
 
 extern def unsafeSubstring(str: String, from: Int, to: Int) at {}: String =
   js "${str}.substring(${from}, ${to})"
@@ -170,7 +162,6 @@ extern def unsafeSubstring(str: String, from: Int, to: Int) at {}: String =
     %x = call %Pos @c_bytearray_substring(%Pos ${str}, i64 ${from}, i64 ${to})
     ret %Pos %x
   """
-  vm "effekt::substring(String, Int, Int)"
 
 
 // Side effecting ops
@@ -183,7 +174,6 @@ extern def random() at io: Double =
     %r = call double @c_io_random()
     ret double %r
   """
-  vm "effekt::random()"
 
 // References and state
 // ====================
@@ -252,7 +242,6 @@ extern def infixEq(x: Int, y: Int) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixEq(Int, Int)"
 
 extern def infixNeq(x: Int, y: Int) at {}: Bool =
   js "${x} !== ${y}"
@@ -263,7 +252,6 @@ extern def infixNeq(x: Int, y: Int) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixNeq(Int, Int)"
 
 extern def infixEq(x: Char, y: Char) at {}: Bool =
   js "${x} === ${y}"
@@ -274,7 +262,6 @@ extern def infixEq(x: Char, y: Char) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixEq(Char, Char)"
 
 extern def infixNeq(x: Char, y: Char) at {}: Bool =
   js "${x} !== ${y}"
@@ -293,7 +280,6 @@ extern def infixEq(x: String, y: String) at {}: Bool =
     %res = call %Pos @c_bytearray_equal(%Pos ${x}, %Pos ${y})
     ret %Pos %res
   """
-  vm "effekt::infixEq(String, String)"
 
 def infixNeq(x: String, y: String): Bool = not(x == y)
 
@@ -308,7 +294,6 @@ extern def infixEq(x: Bool, y: Bool) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixEq(Bool, Bool)"
 
 extern def infixNeq(x: Bool, y: Bool) at {}: Bool =
   js "${x} !== ${y}"
@@ -331,7 +316,6 @@ extern def infixEq(x: Byte, y: Byte) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixEq(Byte, Byte)"
 
 extern def infixNeq(x: Byte, y: Byte) at {}: Bool =
   js "${x} !== ${y}"
@@ -342,7 +326,6 @@ extern def infixNeq(x: Byte, y: Byte) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixNeq(Byte, Byte)"
 
 // Math ops
 // ========
@@ -350,85 +333,71 @@ extern def infixPlus(x: Int, y: Int) at {}: Int =
   js "(${x} + ${y})"
   chez "(+ ${x} ${y})"
   llvm "%z = add  %Int ${x}, ${y} ret %Int %z"
-  vm "effekt::infixPlus(Int, Int)"
 
 extern def infixStar(x: Int, y: Int) at {}: Int =
   js "(${x} * ${y})"
   chez "(* ${x} ${y})"
   llvm "%z = mul  %Int ${x}, ${y} ret %Int %z"
-  vm "effekt::infixStar(Int, Int)"
 
 extern def infixSlash(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::infixSlash(Int, Int)"
 
 extern def infixMinus(x: Int, y: Int) at {}: Int =
   js "(${x} - ${y})"
   chez "(- ${x} ${y})"
   llvm "%z = sub  %Int ${x}, ${y} ret %Int %z"
-  vm "effekt::infixMinus(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 def infixPlus(x: Double, y: Double) at {}: Double =
   js "(${x} + ${y})"
   chez "(+ ${x} ${y})"
   llvm "%z = fadd %Double ${x}, ${y} ret %Double %z"
-  vm "effekt::infixPlus(Double, Double)"
 
 extern def infixStar(x: Double, y: Double) at {}: Double =
   js "(${x} * ${y})"
   chez "(* ${x} ${y})"
   llvm "%z = fmul %Double ${x}, ${y} ret %Double %z"
-  vm "effekt::infixStar(Double, Double)"
 
 extern def infixMinus(x: Double, y: Double) at {}: Double =
   js "(${x} - ${y})"
   chez "(- ${x} ${y})"
   llvm "%z = fsub %Double ${x}, ${y} ret %Double %z"
-  vm "effekt::infixMinus(Double, Double)"
 
 extern def infixSlash(x: Double, y: Double) at {}: Double =
   js "(${x} / ${y})"
   chez "(fl/ ${x} ${y})"
   llvm "%z = fdiv %Double ${x}, ${y} ret %Double %z"
-  vm "effekt::infixSlash(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 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 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 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 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"
-  vm "effekt::sqrt(Double)"
 
 def square(x: Double): Double = x * x
 
@@ -447,7 +416,6 @@ def abs(n: 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 def log1p(x: Double) at {}: Double =
@@ -458,7 +426,6 @@ extern def log1p(x: Double) at {}: Double =
 extern def exp(x: Double) at {}: Double =
   js "Math.exp(${x})"
   chez "(exp ${x})"
-  vm "effekt::exp(Double)"
   llvm "%z = call %Double @llvm.exp.f64(double ${x}) ret %Double %z"
 
 def pow(base: Double, exponent: Int): Double = {
@@ -477,14 +444,12 @@ def pow(base: Double, exponent: Int): 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 def _pi() at {}: Double =
   js "Math.PI"
   chez "(* 4 (atan 1))"
-  vm "effekt::pi()"
   llvm "ret double 3.14159265358979323846264338327950288419716939937510582097494459"
 
 val PI: Double = _pi()
@@ -493,13 +458,11 @@ 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 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 def round(d: Double) at {}: Int =
@@ -509,7 +472,6 @@ extern def round(d: Double) at {}: Int =
     %i = call %Double @llvm.round.f64(double ${d})
     %z = fptosi double %i to %Int ret %Int %z
   """
-  vm "effekt::round(Double)"
 
 def round(d: Double, digits: Int): Double = {
   val factor = pow(10.0, digits)
@@ -554,7 +516,6 @@ extern def infixLt(x: Int, y: Int) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixLt(Int, Int)"
 
 extern def infixLte(x: Int, y: Int) at {}: Bool =
   js "(${x} <= ${y})"
@@ -565,7 +526,6 @@ extern def infixLte(x: Int, y: Int) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixLte(Int, Int)"
 
 extern def infixGt(x: Int, y: Int) at {}: Bool =
   js "(${x} > ${y})"
@@ -576,7 +536,6 @@ extern def infixGt(x: Int, y: Int) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixGt(Int, Int)"
 
 extern def infixGte(x: Int, y: Int) at {}: Bool =
   js "(${x} >= ${y})"
@@ -587,17 +546,14 @@ extern def infixGte(x: Int, y: Int) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixGte(Int, Int)"
 
 extern def infixEq(x: Double, y: Double) at {}: Bool =
   js "${x} === ${y}"
   chez "(= ${x} ${y})"
-  vm "effekt::infixEq(Double, Double)"
 
 extern def infixNeq(x: Double, y: Double) at {}: Bool =
   js "${x} !== ${y}"
   chez "(not (= ${x} ${y}))"
-  vm "effekt::infixNeq(Double, Double)"
 
 extern def infixLt(x: Double, y: Double) at {}: Bool =
   js "(${x} < ${y})"
@@ -608,12 +564,10 @@ extern def infixLt(x: Double, y: Double) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixLt(Double, Double)"
 
 extern def infixLte(x: Double, y: Double) at {}: Bool =
   js "(${x} <= ${y})"
   chez "(<= ${x} ${y})"
-  vm "effekt::infixLte(Double, Double)"
 
 extern def infixGt(x: Double, y: Double) at {}: Bool =
   js "(${x} > ${y})"
@@ -624,12 +578,10 @@ extern def infixGt(x: Double, y: Double) at {}: Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
-  vm "effekt::infixGt(Double, Double)"
 
 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 def infixLt(x: String, y: String) at {}: Bool =
@@ -660,7 +612,6 @@ extern def not(b: Bool) at {}: Bool =
     %adt_q = insertvalue %Pos zeroinitializer, i64 %q, 0
     ret %Pos %adt_q
   """
-  vm "effekt::not(Bool)"
 
 def infixBarBar { first: => Bool } { second: => Bool }: Bool =
   if (first()) true else second()
@@ -677,38 +628,32 @@ 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 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 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 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 def bitwiseXor(x: Int, y: Int) at {}: Int =
   js "(${x} ^ ${y})"
   chez "(logxor ${x} ${y})"
   llvm "%z = xor %Int ${x}, ${y} ret %Int %z"
-  vm "effekt::bitwiseXor(Int, Int)"
 
 extern def bitwiseNot(x: Int) at {}: Int =
   js "(~${x})"
   chez "(lognot ${x})"
   llvm "%z = xor %Int ${x}, -1 ret %Int %z"
-  vm "effekt::bitwiseNot(Int)"
 
 
 // Byte operations
@@ -721,7 +666,6 @@ extern def toByte(n: Int) at {}: Byte =
 extern def toInt(n: Byte) at {}: Int =
   js "${n}"
   llvm "%z = zext %Byte ${n} to %Int ret %Int %z"
-  vm "effekt::toInt(Byte)"
   chez "${n}"
 
 
@@ -738,14 +682,21 @@ extern def toInt(n: Byte) at {}: Int =
 extern def undefined[A]() at {}: A =
   js "undefined"
   chez "#f"
-  vm "effekt::undefined()"
 
 /// Is an FFI value undefined?
 extern def isUndefined[A](value: A) at {}: Bool =
   js "(${value} === undefined || ${value} === null)"
   chez "(eq? ${value} #f)"
-  vm "effekt::isUndefined[A](A)"
 
+// Ascription
+// ==========
+
+/// Ascribe a type, for example `f().as[Int]`.
+def as[A](x: A): A = x
+
+/// Witness absurdity, for example `f().absurd`.
+/// Very often the type argument is inferred.
+def absurd[A](x: Nothing): A = x match {}
 
 // Tuples
 // ======
@@ -832,4 +783,10 @@ effect write(s: String): Unit
 
 effect splice[A](x: A): Unit
 
+// Source positions
+// ================
+//
+// When adding an implicit value argument ?sourcePosition of this type, will have the information
+// of the call site unless passed explicitly.
 
+record SourcePosition(file: String, startLine: Int, startColumn: Int, endLine: Int, endColumn: Int)

package/libraries/common/io/channel.effekt

@@ -33,7 +33,7 @@ def send[A, B](sender: Sender[A, B], value: A): B = {
   sender.set(rest)
   // TODO avoid yield
   yield()
-  this.unsafeFire(value)
+  this.fire(value)
 }
 
 /// Receives a value from a channel and blocks until a sender arrives.
@@ -51,7 +51,7 @@ def receive[A, B](receiver: Receiver[A, B], value: B): A = {
   receiver.set(rest)
   // TODO avoid yield
   yield()
-  this.unsafeWait(value)
+  this.wait(value)
 }
 
 // TODO streaming

package/libraries/common/io/console.effekt

@@ -26,7 +26,8 @@ namespace js {
     const readline = require('node:readline');
   """
 
-  extern type JSConsole
+  extern type JSConsole =
+    js "readline.createInterface return type"
 
   extern def newConsole() at io: JSConsole =
     jsNode """readline.createInterface({

package/libraries/common/io/filesystem.effekt

@@ -74,8 +74,8 @@ def appendFile(path: String, contents: String): Unit / Exception[IOError] = {
 def writeFileUTF8[R](path: String) { stream: () => R / emit[Char] }: R / Exception[IOError] =
   writeFile(path) { encodeUTF8 { stream() } }
 
-def readFileUTF8[R](path: String) { reader: () => R / read[Char] }: R / Exception[IOError] =
-  readFile(path) { decodeUTF8 { reader() } }
+def readFileUTF8[R](path: String) { driver: () => R / next[Char] }: R / Exception[IOError] =
+  readFile(path) { decodeUTF8 { driver() } }
 
 def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[IOError] = {
 
@@ -108,7 +108,7 @@ def writeFile[R](path: String) { stream: () => R / emit[Byte] }: R / Exception[I
   }
 }
 
-def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IOError] = {
+def readFile[R](path: String) { driver: () => R / next[Byte] }: R / Exception[IOError] = {
 
   val file = openForReading(path);
   with on[IOError].finalize { close(file) }
@@ -128,8 +128,8 @@ def readFile[R](path: String) { reader: () => R / read[Byte] }: R / Exception[IO
   }
 
   try {
-    reader()
-  } with read[Byte] {
+    driver()
+  } with next[Byte] {
     resume {
       if (offset >= length) {
         pull()

package/libraries/common/io/network.effekt

@@ -42,13 +42,13 @@ def listen(listener: Listener, handler: Connection => Unit at {io, async, global
 def shutdown(listener: Listener): Unit =
   internal::shutdown(listener)
 
-def streaming[R](connection: Connection) { program: () => R / {read[ByteArray], emit[ByteArray]} }: R / Exception[IOError] =
+def streaming[R](connection: Connection) { program: () => R / {next[ByteArray], emit[ByteArray]} }: R / Exception[IOError] =
   try {
     program()
   } with emit[ByteArray] { bytes =>
     write(connection, bytes, 0, bytes.size)
     resume(())
-  } with read[ByteArray] { () =>
+  } with next[ByteArray] { () =>
     val bytes = bytearray::allocate(4096)
     read(connection, bytes, 0, bytes.size) match {
       case r and r == bytes.size => resume { return bytes }

package/libraries/common/io/promise.effekt

@@ -37,7 +37,7 @@ def await[T](promise: Promise[T]): T =
       val signal = signal()
       promise.set(Pending(Cons(signal, signals)))
       // TODO perhaps yield to avoid stack overflow
-      signal.unsafeWait(())
+      signal.wait(())
   }
 
 /// Resolves the given promise, unblocking all awaiting tasks.
@@ -48,6 +48,6 @@ def resolve[T](promise: Promise[T], value: T): Unit =
     case Pending(signals) =>
       promise.set(Resolved(value))
       // TODO perhaps yield to avoid stack overflow
-      signals.reverse.foreach { signal => unsafeFire(signal, value) }
+      signals.reverse.foreach { signal => fire(signal, value) }
   }
 

package/libraries/common/io/signal.effekt

@@ -5,32 +5,29 @@ module io/signal
 
 /// Must be fired exactly once with an A receiving a B,
 /// and must be waited for exactly once with a B receiving an A.
-extern type Signal[A, B]
+extern type Signal[A, B] =
+  js "{ state: int, value, stack }"
+  llvm "%Pos"
 
-extern def signal[A, B]() at global: Signal[A, B] =
-  js "signal$make()"
-  llvm """
-    %signal = call %Pos @c_signal_make()
-    ret %Pos %signal
-  """
+extern llvm """
+%Signal = type { %Header, i64, ptr, %Pos }
 
-extern def unsafeFire[A, B](signal: Signal[A, B], value: A) at async: B =
-  js "$effekt.capture(callback => signal$notify(${signal}, ${value}, callback))"
-  llvm """
-    call void @c_signal_notify(%Pos ${signal}, %Pos ${value}, %Stack %stack)
+define void @signal_erase(ptr %envPtr) {
+    %base = getelementptr %Header, ptr %envPtr, i64 -1
+    %statePtr = getelementptr %Signal, ptr %base, i64 0, i32 1
+    %stackPtr = getelementptr %Signal, ptr %base, i64 0, i32 2
+    %valuePtr = getelementptr %Signal, ptr %base, i64 0, i32 3
+    %state = load i64, ptr %statePtr
+    switch i64 %state, label %none [i64 0, label %free i64 1, label %free i64 2, label %free]
+  free:
+    %stack = load %Stack, ptr %stackPtr
+    %value = load %Pos, ptr %valuePtr
+    call void @erasePositive(%Pos %value)
+    call void @eraseStack(%Stack %stack)
     ret void
-  """
-
-extern def unsafeWait[A, B](signal: Signal[A, B], value: B) at async: A =
-  js "$effekt.capture(callback => signal$notify(${signal}, ${value}, callback))"
-  llvm """
-    call void @c_signal_notify(%Pos ${signal}, %Pos ${value}, %Stack %stack)
+  none:
     ret void
-  """
-
-extern llvm """
-  declare %Pos @c_signal_make()
-  declare void @c_signal_notify(%Pos, %Pos, %Stack)
+}
 """
 
 extern js """
@@ -53,3 +50,70 @@ extern js """
     }
   }
 """
+
+extern def signal[A, B]() at global: Signal[A, B] =
+  js "signal$make()"
+  llvm """
+    %base = call ptr @calloc(i64 1, i64 48)
+    %eraserPtr = getelementptr %Signal, ptr %base, i64 0, i32 0, i32 1
+    store ptr @signal_erase, ptr %eraserPtr
+    %result = insertvalue %Pos { i64 0, ptr poison }, ptr %base, 1
+    ret %Pos %result
+  """
+
+extern def fire[A, B](signal: Signal[A, B], value: A) at async: B =
+  js "$effekt.capture(callback => signal$notify(${signal}, ${value}, callback))"
+  llvm """
+    %base = extractvalue %Pos ${signal}, 1
+    %statePtr = getelementptr %Signal, ptr %base, i64 0, i32 1
+    %stackPtr = getelementptr %Signal, ptr %base, i64 0, i32 2
+    %valuePtr = getelementptr %Signal, ptr %base, i64 0, i32 3
+    %state = load i64, ptr %statePtr
+    switch i64 %state, label %panic [i64 0, label %init i64 1, label %fire]
+  init:
+    store i64 2, ptr %statePtr
+    store %Stack %stack, ptr %stackPtr
+    store %Pos ${value}, ptr %valuePtr
+    call void @erasePositive(%Pos ${signal})
+    ret void
+  fire:
+    %otherStack = load %Stack, ptr %stackPtr
+    %otherValue = load %Pos, ptr %valuePtr
+    store i64 3, ptr %statePtr
+    call void @erasePositive(%Pos ${signal})
+    call void @resume_Pos(%Stack %otherStack, %Pos ${value})
+    call void @resume_Pos(%Stack %stack, %Pos %otherValue)
+    ret void
+  panic:
+    call void @exit(i64 1)
+    ret void
+  """
+
+extern def wait[A, B](signal: Signal[A, B], value: B) at async: A =
+  js "$effekt.capture(callback => signal$notify(${signal}, ${value}, callback))"
+  llvm """
+    %base = extractvalue %Pos ${signal}, 1
+    %statePtr = getelementptr %Signal, ptr %base, i64 0, i32 1
+    %stackPtr = getelementptr %Signal, ptr %base, i64 0, i32 2
+    %valuePtr = getelementptr %Signal, ptr %base, i64 0, i32 3
+    %state = load i64, ptr %statePtr
+    switch i64 %state, label %panic [i64 0, label %init i64 2, label %wait]
+  init:
+    store i64 1, ptr %statePtr
+    store %Stack %stack, ptr %stackPtr
+    store %Pos ${value}, ptr %valuePtr
+    call void @erasePositive(%Pos ${signal})
+    ret void
+  wait:
+    %otherStack = load %Stack, ptr %stackPtr
+    %otherValue = load %Pos, ptr %valuePtr
+    store i64 3, ptr %statePtr
+    call void @erasePositive(%Pos ${signal})
+    call void @resume_Pos(%Stack %otherStack, %Pos ${value})
+    call void @resume_Pos(%Stack %stack, %Pos %otherValue)
+    ret void
+  panic:
+    call void @exit(i64 1)
+    ret void
+  """
+