@effekt-lang/effekt 0.15.0 → 0.17.0

package/libraries/common/args.effekt

@@ -4,6 +4,7 @@ extern io def commandLineArgs(): List[String] =
   js { js::commandLineArgs() }
   chez { chez::commandLineArgs() }
   llvm { llvm::commandLineArgs() }
+  vm { Nil() }
 
 namespace js {
   extern type Args // = Array[String]

package/libraries/common/array.effekt

@@ -16,6 +16,7 @@ extern global def allocate[T](size: Int): Array[T] =
     %z = call %Pos @c_array_new(%Int ${size})
     ret %Pos %z
   """
+  vm "array::allocate(Int)"
 
 /// Creates a new Array of size `size` filled with the value `init`
 def array[T](size: Int, init: T): Array[T] = {
@@ -45,6 +46,7 @@ extern pure def size[T](arr: Array[T]): Int =
     %z = call %Int @c_array_size(%Pos ${arr})
     ret %Int %z
   """
+  vm "array::size[T](Array[T])"
 
 /// Gets the element of the `arr` at given `index` in constant time.
 /// Unchecked Precondition: `index` is in bounds (0 ≤ index < arr.size)
@@ -57,6 +59,7 @@ extern global def unsafeGet[T](arr: Array[T], index: Int): T =
     %z = call %Pos @c_array_get(%Pos ${arr}, %Int ${index})
     ret %Pos %z
   """
+  vm "array::unsafeGet[T](Array[T], Int)"
 
 extern js """
   function array$set(arr, index, value) {
@@ -76,6 +79,7 @@ extern global def unsafeSet[T](arr: Array[T], index: Int, value: T): Unit =
     %z = call %Pos @c_array_set(%Pos ${arr}, %Int ${index}, %Pos ${value})
     ret %Pos %z
   """
+  vm "array::unsafeSet[T](Array[T], Int, T)"
 
 
 

package/libraries/common/effekt.effekt

@@ -45,6 +45,7 @@ extern def println(value: String): Unit =
     call void @c_io_println_String(%Pos ${value})
     ret %Pos zeroinitializer ; Unit
   """
+  vm "effekt::println(String)"
 
 def println(value: Int): Unit = println(value.show)
 def println(value: Unit): Unit = println(value.show)
@@ -59,6 +60,7 @@ extern pure def show(value: Int): String =
     %z = call %Pos @c_bytearray_show_Int(%Int ${value})
     ret %Pos %z
   """
+  vm "effekt::show(Int)"
 
 def show(value: Unit): String = "()"
 
@@ -69,6 +71,7 @@ extern pure def show(value: Double): String =
     %z = call %Pos @c_bytearray_show_Double(%Double ${value})
     ret %Pos %z
   """
+  vm "effekt::show(Double)"
 
 def show(value: String): String =
   value
@@ -83,6 +86,7 @@ extern pure def show(value: Char): String =
     %z = call %Pos @c_bytearray_show_Char(%Int ${value})
     ret %Pos %z
   """
+  vm "effekt::show(Char)"
 
 extern pure def show(value: Byte): String =
   js "'' + ${value}"
@@ -90,6 +94,7 @@ extern pure def show(value: Byte): String =
     %z = call %Pos @c_bytearray_show_Byte(i8 ${value})
     ret %Pos %z
   """
+  vm "effekt::show(Byte)"
 
 extern pure def genericShow[R](value: R): String =
   js "$effekt.show(${value})"
@@ -98,6 +103,7 @@ extern pure def genericShow[R](value: R): String =
 extern io def inspect[R](value: R): Unit =
   js { println(genericShow(value)) }
   chez { println(genericShow(value)) }
+  vm "effekt::inspect(Any)"
 
 
 // Strings
@@ -109,15 +115,16 @@ extern pure def infixConcat(s1: String, s2: String): String =
     %spz = call %Pos @c_bytearray_concatenate(%Pos ${s1}, %Pos ${s2})
     ret %Pos %spz
   """
+  vm "effekt::infixConcat(String, String)"
 
 extern pure def length(str: String): Int =
   js "${str}.length"
   chez "(string-length ${str})"
   llvm """
     %x = call %Int @c_bytearray_size(%Pos ${str})
-    call void @erasePositive(%Pos ${str})
     ret %Int %x
   """
+  vm "effekt::length(String)"
 
 extern pure def unsafeSubstring(str: String, from: Int, to: Int): String =
   js "${str}.substring(${from}, ${to})"
@@ -126,6 +133,7 @@ extern pure def unsafeSubstring(str: String, from: Int, to: Int): 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
@@ -134,6 +142,7 @@ extern pure def unsafeSubstring(str: String, from: Int, to: Int): String =
 extern io def random(): Double =
   js "Math.random()"
   chez "(random 1.0)"
+  vm "effekt::random()"
 
 // References and state
 // ====================
@@ -193,8 +202,7 @@ def differsFrom[R](x: R, y: R): Bool =
 
 // TODO fix this in the pattern matching compiler
 extern pure def infixEq(x: Unit, y: Unit): Bool =
-  js "true"
-  chez "#t"
+  default { true }
 
 extern pure def infixEq(x: Int, y: Int): Bool =
   js "${x} === ${y}"
@@ -205,6 +213,7 @@ extern pure def infixEq(x: Int, y: Int): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "effekt::infixEq(Int, Int)"
 
 extern pure def infixNeq(x: Int, y: Int): Bool =
   js "${x} !== ${y}"
@@ -215,6 +224,7 @@ extern pure def infixNeq(x: Int, y: Int): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "effekt::infixNeq(Int, Int)"
 
 extern pure def infixEq(x: Char, y: Char): Bool =
   js "${x} === ${y}"
@@ -225,6 +235,7 @@ extern pure def infixEq(x: Char, y: Char): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "effekt::infixEq(Char, Char)"
 
 extern pure def infixNeq(x: Char, y: Char): Bool =
   js "${x} !== ${y}"
@@ -243,6 +254,7 @@ extern pure def infixEq(x: String, y: String): 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)
 
@@ -257,6 +269,7 @@ extern pure def infixEq(x: Bool, y: Bool): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "effekt::infixEq(Bool, Bool)"
 
 extern pure def infixNeq(x: Bool, y: Bool): Bool =
   js "${x} !== ${y}"
@@ -277,67 +290,81 @@ extern pure def infixAdd(x: Int, y: Int): 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 =
   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 =
   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 =
   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 =
   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 =
   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 =
   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 =
   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 =
   js "(${x} / ${y})"
   chez "(/ ${x} ${y})"
   llvm "%z = fdiv %Double ${x}, ${y} ret %Double %z"
+  vm "effekt::infixDiv(Double, Double)"
 
 extern pure def cos(x: Double): Double =
   js "Math.cos(${x})"
   chez "(cos ${x})"
+  vm "effekt::cos(Double)"
 
 extern pure def sin(x: Double): Double =
   js "Math.sin(${x})"
   chez "(sin ${x})"
+  vm "effekt::sin(Double)"
 
 extern pure def atan(x: Double): Double =
   js "Math.atan(${x})"
   chez "(atan ${x})"
+  vm "effekt::atan(Double)"
 
 extern pure def tan(x: Double): Double =
   js "Math.tan(${x})"
   chez "(tan ${x})"
+  vm "effekt::tan(Double)"
 
 extern pure def sqrt(x: Double): 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
 
@@ -353,6 +380,7 @@ def abs(n: Double): Double =
 extern pure def log(x: Double): Double =
   js "Math.log(${x})"
   chez "(log ${x})"
+  vm "effekt::log(Double)"
 
 extern pure def log1p(x: Double): Double =
   js "Math.log1p(${x})"
@@ -361,6 +389,7 @@ extern pure def log1p(x: Double): Double =
 extern pure def exp(x: Double): Double =
   js "Math.exp(${x})"
   chez "(exp ${x})"
+  vm "effekt::exp(Double)"
 
 def pow(base: Double, exponent: Int): Double = {
   def loop(base: Double, exponent: Int, acc: Double): Double = {
@@ -378,11 +407,13 @@ def pow(base: Double, exponent: Int): Double = {
 extern pure def pow(base: Double, exponent: Double): Double =
   js "Math.pow(${base}, ${exponent})"
   chez "(expt ${base} ${exponent})"
+  vm "effekt::pow(Double, Double)"
 
 // since we do not have "extern val", yet
 extern pure def _pi(): Double =
   js "Math.PI"
   chez "(* 4 (atan 1))"
+  vm "effekt::pi()"
 
 val PI: Double = _pi()
 
@@ -390,11 +421,14 @@ extern pure def toInt(d: Double): 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 =
   js "${d}"
   chez "${d}"
   llvm "%z = sitofp i64 ${d} to double ret double %z"
+  vm "effekt::toDouble(Int)"
+
 
 extern pure def round(d: Double): Int =
   js "Math.round(${d})"
@@ -403,6 +437,7 @@ extern pure def round(d: Double): 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)
@@ -447,6 +482,7 @@ extern pure def infixLt(x: Int, y: Int): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "effekt::infixLt(Int, Int)"
 
 extern pure def infixLte(x: Int, y: Int): Bool =
   js "(${x} <= ${y})"
@@ -457,6 +493,7 @@ extern pure def infixLte(x: Int, y: Int): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "effekt::infixLte(Int, Int)"
 
 extern pure def infixGt(x: Int, y: Int): Bool =
   js "(${x} > ${y})"
@@ -467,6 +504,7 @@ extern pure def infixGt(x: Int, y: Int): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "effekt::infixGt(Int, Int)"
 
 extern pure def infixGte(x: Int, y: Int): Bool =
   js "(${x} >= ${y})"
@@ -477,14 +515,17 @@ extern pure def infixGte(x: Int, y: Int): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "effekt::infixGte(Int, Int)"
 
 extern pure def infixEq(x: Double, y: Double): Bool =
   js "${x} === ${y}"
   chez "(= ${x} ${y})"
+  vm "effekt::infixEq(Double, Double)"
 
 extern pure def infixNeq(x: Double, y: Double): Bool =
   js "${x} !== ${y}"
   chez "(not (= ${x} ${y}))"
+  vm "effekt::infixNeq(Double, Double)"
 
 extern pure def infixLt(x: Double, y: Double): Bool =
   js "(${x} < ${y})"
@@ -495,10 +536,12 @@ extern pure def infixLt(x: Double, y: Double): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "effekt::infixLt(Double, Double)"
 
 extern pure def infixLte(x: Double, y: Double): Bool =
   js "(${x} <= ${y})"
   chez "(<= ${x} ${y})"
+  vm "effekt::infixLte(Double, Double)"
 
 extern pure def infixGt(x: Double, y: Double): Bool =
   js "(${x} > ${y})"
@@ -509,10 +552,12 @@ extern pure def infixGt(x: Double, y: Double): Bool =
     %adt_boolean = insertvalue %Pos zeroinitializer, i64 %fat_z, 0
     ret %Pos %adt_boolean
   """
+  vm "effekt::infixGt(Double, Double)"
 
 extern pure def infixGte(x: Double, y: Double): 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 =
@@ -543,6 +588,7 @@ extern pure def not(b: Bool): Bool =
     %adt_q = insertvalue %Pos zeroinitializer, i64 %q, 0
     ret %Pos %adt_q
   """
+  vm "effekt::not(Bool)"
 
 def infixOr { first: => Bool } { second: => Bool }: Bool =
   if (first()) true else second()
@@ -559,27 +605,32 @@ extern pure def bitwiseShl(x: Int, y: Int): 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 =
   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 =
   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 =
   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 =
   js "(${x} ^ ${y})"
   chez "(logxor ${x} ${y})"
   llvm "%z = xor %Int ${x}, ${y} ret %Int %z"
+  vm "effekt::bitwiseXor(Int, Int)"
 
 
 // Byte operations

package/libraries/common/io/filesystem.effekt

@@ -198,6 +198,7 @@ namespace internal {
       ret void
     """
 
+  /// The buffer must be kept alive by using it after the call
   extern async def read(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int): Int =
     jsNode "$effekt.capture(callback => read(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """
@@ -205,6 +206,7 @@ namespace internal {
       ret void
     """
 
+  /// The buffer must be kept alive by using it after the call
   extern async def write(file: Int, buffer: ByteArray, offset: Int, size: Int, position: Int): Int =
     jsNode "$effekt.capture(callback => write(${file}, ${buffer}, ${offset}, ${size}, ${position}, callback))"
     llvm """

package/libraries/common/io.effekt

@@ -16,7 +16,8 @@ extern async def spawn(task: Task[Unit]): Unit =
   js "$effekt.capture(k => { setTimeout(() => k($effekt.unit), 0); return $effekt.run(${task}) })"
   llvm """
     call void @c_yield(%Stack %stack)
-    call void @run(%Neg ${task})
+    %unboxed = call ccc %Neg @unbox(%Pos ${task})
+    call void @run(%Neg %unboxed)
     ret void
   """
 

package/libraries/common/ref.effekt

@@ -30,6 +30,7 @@ extern global def ref[T](init: T): Ref[T] =
     %z = call %Pos @c_ref_fresh(%Pos ${init})
     ret %Pos %z
   """
+  vm "ref::ref[T](T)"
 
 /// Gets the referenced element of the `ref` in constant time.
 extern global def get[T](ref: Ref[T]): T =
@@ -39,6 +40,7 @@ extern global def get[T](ref: Ref[T]): T =
     %z = call %Pos @c_ref_get(%Pos ${ref})
     ret %Pos %z
   """
+  vm "ref::get[T](Ref[T])"
 
 /// Sets the referenced element of the `ref` to `value` in constant time.
 extern global def set[T](ref: Ref[T], value: T): Unit =
@@ -48,3 +50,4 @@ extern global def set[T](ref: Ref[T], value: T): Unit =
     %z = call %Pos @c_ref_set(%Pos ${ref}, %Pos ${value})
     ret %Pos %z
   """
+  vm "ref::set[T](Ref[T], T)"

package/libraries/llvm/array.c

@@ -32,13 +32,16 @@ struct Pos c_array_new(const Int size) {
 
 Int c_array_size(const struct Pos arr) {
   uint64_t *sizePtr = arr.obj + sizeof(struct Header);
-  return *sizePtr;
+  uint64_t size = *sizePtr;
+  erasePositive(arr);
+  return size;
 }
 
 struct Pos c_array_get(const struct Pos arr, const Int index) {
   struct Pos *dataPtr = arr.obj + sizeof(struct Header) + sizeof(uint64_t);
   struct Pos element = dataPtr[index];
   sharePositive(element);
+  erasePositive(arr);
   return element;
 }
 
@@ -47,6 +50,7 @@ struct Pos c_array_set(const struct Pos arr, const Int index, const struct Pos v
   struct Pos element = dataPtr[index];
   erasePositive(element);
   dataPtr[index] = value;
+  erasePositive(arr);
   return Unit;
 }
 

package/libraries/llvm/bytearray.c

@@ -29,30 +29,34 @@ struct Pos c_bytearray_new(const Int size) {
 }
 
 Int c_bytearray_size(const struct Pos arr) {
+  erasePositive(arr);
   return arr.tag;
 }
 
-uint8_t* c_bytearray_data(const struct Pos arr) {
-  return arr.obj + sizeof(struct Header);
-}
-
 Byte c_bytearray_get(const struct Pos arr, const Int index) {
   Byte *dataPtr = arr.obj + sizeof(struct Header);
   Byte element = dataPtr[index];
+  erasePositive(arr);
   return element;
 }
 
 struct Pos c_bytearray_set(const struct Pos arr, const Int index, const Byte value) {
   Byte *dataPtr = arr.obj + sizeof(struct Header);
   dataPtr[index] = value;
+  erasePositive(arr);
   return Unit;
 }
 
+// Internal Operations
+
+uint8_t* c_bytearray_data(const struct Pos arr) {
+    uint8_t *data = arr.obj + sizeof(struct Header);
+    return data;
+}
+
 struct Pos c_bytearray_construct(const uint64_t n, const uint8_t *data) {
     struct Pos arr = c_bytearray_new(n);
-
     memcpy(c_bytearray_data(arr), data, n);
-
     return arr;
 }
 
@@ -66,7 +70,7 @@ struct Pos c_bytearray_from_nullterminated_string(const char *data) {
 }
 
 char* c_bytearray_into_nullterminated_string(const struct Pos arr) {
-    uint64_t size = c_bytearray_size(arr);
+    uint64_t size = arr.tag;
 
     char* result = (char*)malloc(size + 1);
 
@@ -125,12 +129,14 @@ struct Pos c_bytearray_show_Double(const Double x) {
 
 // TODO do this in Effekt
 struct Pos c_bytearray_concatenate(const struct Pos left, const struct Pos right) {
-    const struct Pos concatenated = c_bytearray_new(c_bytearray_size(left) + c_bytearray_size(right));
-    for (int64_t j = 0; j < c_bytearray_size(concatenated); ++j)
+    uint64_t left_size = left.tag;
+    uint64_t right_size = right.tag;
+    const struct Pos concatenated = c_bytearray_new(left_size + right_size);
+    for (uint64_t j = 0; j < concatenated.tag; ++j)
         c_bytearray_data(concatenated)[j]
-            = j < c_bytearray_size(left)
+            = j < left_size
             ? c_bytearray_data(left)[j]
-            : c_bytearray_data(right)[j - c_bytearray_size(left)];
+            : c_bytearray_data(right)[j - left_size];
 
     erasePositive(left);
     erasePositive(right);
@@ -139,8 +145,8 @@ struct Pos c_bytearray_concatenate(const struct Pos left, const struct Pos right
 
 // TODO do this in Effekt
 struct Pos c_bytearray_equal(const struct Pos left, const struct Pos right) {
-    uint64_t left_size = c_bytearray_size(left);
-    uint64_t right_size = c_bytearray_size(right);
+    uint64_t left_size = left.tag;
+    uint64_t right_size = right.tag;
     if (left_size != right_size) {
         erasePositive(left);
         erasePositive(right);
@@ -161,7 +167,7 @@ struct Pos c_bytearray_equal(const struct Pos left, const struct Pos right) {
 // TODO deprecate
 struct Pos c_bytearray_substring(const struct Pos str, uint64_t start, uint64_t end) {
     const struct Pos substr = c_bytearray_new(end - start);
-    for (int64_t j = 0; j < c_bytearray_size(substr); ++j) {
+    for (uint64_t j = 0; j < substr.tag; ++j) {
         c_bytearray_data(substr)[j] = c_bytearray_data(str)[start+j];
     }
     erasePositive(str);
@@ -174,27 +180,27 @@ uint32_t c_bytearray_character_at(const struct Pos str, const uint64_t index) {
     uint8_t first_byte = bytes[index];
     uint32_t character = 0;
 
-    uint32_t length = c_bytearray_size(str);
+    uint32_t size = str.tag;
 
     if (first_byte < 0x80) {
         // Single-byte character (0xxxxxxx)
         character = first_byte;
     } else if ((first_byte & 0xE0) == 0xC0) {
         // Two-byte character (110xxxxx 10xxxxxx)
-        if (index + 1 < length) {
+        if (index + 1 < size) {
             character = ((first_byte & 0x1F) << 6) |
                         (bytes[index + 1] & 0x3F);
         }
     } else if ((first_byte & 0xF0) == 0xE0) {
         // Three-byte character (1110xxxx 10xxxxxx 10xxxxxx)
-        if (index + 2 < length) {
+        if (index + 2 < size) {
             character = ((first_byte & 0x0F) << 12) |
                         ((bytes[index + 1] & 0x3F) << 6) |
                         (bytes[index + 2] & 0x3F);
         }
     } else if ((first_byte & 0xF8) == 0xF0) {
         // Four-byte character (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
-        if (index + 3 < length) {
+        if (index + 3 < size) {
             character = ((first_byte & 0x07) << 18) |
                         ((bytes[index + 1] & 0x3F) << 12) |
                         ((bytes[index + 2] & 0x3F) << 6) |

package/libraries/llvm/io.c

@@ -20,7 +20,7 @@ void c_io_println_Double(const Double x) {
 }
 
 void c_io_println_String(String text) {
-    for (int64_t j = 0; j < c_bytearray_size(text); ++j)
+    for (uint64_t j = 0; j < text.tag; ++j)
         putchar(c_bytearray_data(text)[j]);
     erasePositive(text);
     putchar('\n');
@@ -126,8 +126,8 @@ void c_fs_open(String path, struct Pos mode, Stack stack) {
 void c_fs_read(Int file, struct Pos buffer, Int offset, Int size, Int position, Stack stack) {
 
     uv_buf_t buf = uv_buf_init((char*)(c_bytearray_data(buffer) + offset), size);
-    // erasePositive(buffer);
-    // TODO we should erase the buffer but abort if this was the last reference
+    erasePositive(buffer);
+    // TODO panic if this was the last reference
 
     uv_fs_t* request = malloc(sizeof(uv_fs_t));
     request->data = stack;
@@ -144,8 +144,8 @@ void c_fs_read(Int file, struct Pos buffer, Int offset, Int size, Int position,
 void c_fs_write(Int file, struct Pos buffer, Int offset, Int size, Int position, Stack stack) {
 
     uv_buf_t buf = uv_buf_init((char*)(c_bytearray_data(buffer) + offset), size);
-    // erasePositive(buffer);
-    // TODO we should erase the buffer but abort if this was the last reference
+    erasePositive(buffer);
+    // TODO panic if this was the last reference
 
     uv_fs_t* request = malloc(sizeof(uv_fs_t));
     request->data = stack;

package/libraries/llvm/main.c

@@ -9,7 +9,6 @@
 
 #define DEBUG_REFCOUNT (false)
 
-#include "sanity.c"
 #include "types.c"
 #include "bytearray.c"
 #include "io.c"

package/libraries/llvm/ref.c

@@ -31,6 +31,7 @@ struct Pos c_ref_get(const struct Pos ref) {
   struct Pos *fieldPtr = ref.obj + sizeof(struct Header);
   struct Pos element = *fieldPtr;
   sharePositive(element);
+  erasePositive(ref);
   return element;
 }
 
@@ -39,6 +40,7 @@ struct Pos c_ref_set(const struct Pos ref, const struct Pos value) {
   struct Pos element = *fieldPtr;
   erasePositive(element);
   *fieldPtr = value;
+  erasePositive(ref);
   return Unit;
 }
 

package/libraries/llvm/rts.ll

@@ -114,6 +114,26 @@ declare void @exit(i64)
 declare void @llvm.assume(i1)
 
 
+; Boxing (externs functions, hence ccc)
+define ccc %Pos @box(%Neg %input) {
+    %vtable = extractvalue %Neg %input, 0
+    %heap_obj = extractvalue %Neg %input, 1
+    %vtable_as_int = ptrtoint ptr %vtable to i64
+    %pos_result = insertvalue %Pos undef, i64 %vtable_as_int, 0
+    %pos_result_with_heap = insertvalue %Pos %pos_result, ptr %heap_obj, 1
+    ret %Pos %pos_result_with_heap
+}
+
+define ccc %Neg @unbox(%Pos %input) {
+    %tag = extractvalue %Pos %input, 0
+    %heap_obj = extractvalue %Pos %input, 1
+    %vtable = inttoptr i64 %tag to ptr
+    %neg_result = insertvalue %Neg undef, ptr %vtable, 0
+    %neg_result_with_heap = insertvalue %Neg %neg_result, ptr %heap_obj, 1
+    ret %Neg %neg_result_with_heap
+}
+
+
 ; Prompts
 
 define private %Prompt @currentPrompt(%Stack %stack) {