@grain/stdlib 0.5.12 → 0.6.0

package/runtime/equal.gr

@@ -1,24 +1,19 @@
-/* grainc-flags --no-pervasives */
-
-import WasmI32, {
-  eq as (==),
-  ne as (!=),
-  and as (&),
-  xor as (^),
-  add as (+),
-  sub as (-),
-  mul as (*),
-  ltS as (<),
-  remS as (%),
-  shl as (<<),
-} from "runtime/unsafe/wasmi32"
-import WasmI64 from "runtime/unsafe/wasmi64"
-import Tags from "runtime/unsafe/tags"
-import { isNumber, numberEqual } from "runtime/numbers"
-
-primitive (!): Bool -> Bool = "@not"
-primitive (||): (Bool, Bool) -> Bool = "@or"
-primitive (&&): (Bool, Bool) -> Bool = "@and"
+@noPervasives
+module Equal
+
+from "runtime/unsafe/memory" include Memory
+from "runtime/unsafe/wasmi32" include WasmI32
+use WasmI32.{ (==), (!=), (&), (^), (+), (-), (*), (<), remS as (%), (<<) }
+from "runtime/unsafe/wasmi64" include WasmI64
+from "runtime/unsafe/wasmf32" include WasmF32
+from "runtime/unsafe/tags" include Tags
+from "runtime/numbers" include Numbers
+use Numbers.{ isNumber, numberEqual }
+
+primitive (!) = "@not"
+primitive (||) = "@or"
+primitive (&&) = "@and"
+primitive ignore = "@ignore"
 
 @unsafe
 let cycleMarker = 0x80000000n
@@ -121,9 +116,7 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
         result
       }
     },
-    t when (
-      t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG
-    ) => {
+    t when t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG => {
       let xlength = WasmI32.load(xptr, 4n)
       let ylength = WasmI32.load(yptr, 4n)
 
@@ -131,30 +124,7 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
       if (xlength != ylength) {
         false
       } else {
-        let extra = xlength % 8n
-        let first = xlength - extra
-        let mut result = true
-        for (let mut i = 0n; i < first; i += 8n) {
-          if (
-            WasmI64.ne(WasmI64.load(xptr + i, 8n), WasmI64.load(yptr + i, 8n))
-          ) {
-            result = false
-            break
-          }
-        }
-        if (result) {
-          for (let mut i = 0n; i < extra; i += 1n) {
-            if (
-              WasmI32.load8U(xptr + first + i, 8n) !=
-              WasmI32.load8U(yptr + first + i, 8n)
-            ) {
-              result = false
-              break
-            }
-          }
-        }
-
-        result
+        Memory.compare(xptr + 8n, yptr + 8n, xlength) == 0n
       }
     },
     t when t == Tags._GRAIN_TUPLE_HEAP_TAG => {
@@ -184,13 +154,25 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
         result
       }
     },
+    t when t == Tags._GRAIN_UINT32_HEAP_TAG || t == Tags._GRAIN_INT32_HEAP_TAG => {
+      let xval = WasmI32.load(xptr, 4n)
+      let yval = WasmI32.load(yptr, 4n)
+      xval == yval
+    },
+    // Float32 is handled by equalHelp directly
+    t when t == Tags._GRAIN_UINT64_HEAP_TAG => {
+      use WasmI64.{ (==) }
+      let xval = WasmI64.load(xptr, 8n)
+      let yval = WasmI64.load(yptr, 8n)
+      xval == yval
+    },
     _ => {
       // No other implementation
       xptr == yptr
     },
   }
-},
-equalHelp = (x, y) => {
+}
+and equalHelp = (x, y) => {
   if (
     (x & Tags._GRAIN_GENERIC_TAG_MASK) != 0n &&
     (y & Tags._GRAIN_GENERIC_TAG_MASK) != 0n
@@ -200,6 +182,12 @@ equalHelp = (x, y) => {
   } else if (isNumber(x)) {
     // Numbers have special equality rules, e.g. NaN != NaN
     numberEqual(x, y)
+  } else if (WasmI32.load(x, 0n) == Tags._GRAIN_FLOAT32_HEAP_TAG) {
+    // Short circuit for Float32 to correctly handle NaN != NaN
+    let xval = WasmF32.load(x, 4n)
+    let yval = WasmF32.load(y, 4n)
+    use WasmF32.{ (==) }
+    xval == yval
   } else {
     // Handle all other heap allocated things
     // Can short circuit if pointers are the same
@@ -207,7 +195,20 @@ equalHelp = (x, y) => {
   }
 }
 
+/**
+ * Check that two values are equal. This checks for structural equality,
+ * so it also works for comparing things like tuples and lists.
+ *
+ * @param value1: The first operand
+ * @param value2: The second operand
+ * @returns `true` if the values are structurally equal or `false` otherwise
+ *
+ * @since v0.1.0
+ */
 @unsafe
-export let equal = (x: a, y: a) => {
-  equalHelp(WasmI32.fromGrain(x), WasmI32.fromGrain(y))
+provide let equal = (value1: a, value2: a) => {
+  let value = equalHelp(WasmI32.fromGrain(value1), WasmI32.fromGrain(value2))
+  ignore(value1)
+  ignore(value2)
+  value
 }

package/runtime/equal.md

@@ -1,6 +1,35 @@
+---
+title: Equal
+---
+
+## Values
+
+Functions and constants included in the Equal module.
+
 ### Equal.**equal**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.1.0</code></summary>
+No other changes yet.
+</details>
+
 ```grain
-equal : (a, a) -> Bool
+equal : (value1: a, value2: a) => Bool
 ```
 
+Check that two values are equal. This checks for structural equality,
+so it also works for comparing things like tuples and lists.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`value1`|`a`|The first operand|
+|`value2`|`a`|The second operand|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Bool`|`true` if the values are structurally equal or `false` otherwise|
+

package/runtime/exception.gr

@@ -1,35 +1,26 @@
-/* grainc-flags --compilation-mode=runtime */
+@runtimeMode
+module Exception
 
-import WasmI32, { eq as (==), add as (+) } from "runtime/unsafe/wasmi32"
+from "runtime/unsafe/wasmi32" include WasmI32
+use WasmI32.{ (==), (+), (-) }
 
-import foreign wasm fd_write: (
-  WasmI32,
-  WasmI32,
-  WasmI32,
-  WasmI32,
-) -> WasmI32 from "wasi_snapshot_preview1"
+foreign wasm fd_write:
+  (WasmI32, WasmI32, WasmI32, WasmI32) => WasmI32 from "wasi_snapshot_preview1"
 
-primitive unreachable: () -> a = "@unreachable"
+primitive unreachable = "@unreachable"
 
-enum Option<a> {
-  Some(a),
-  None,
-}
-
-export let mut printers = 0n
+provide let mut printers = 0n
 
 // These functions are dangerous because they leak runtime memory and perform
 // no GC operations. As such, they should only be called by this module and/or
 // modules that understand these restrictions, namely Pervasives.
 
-export let dangerouslyRegisterBasePrinter = f => {
+provide let dangerouslyRegisterBasePrinter = f => {
   let mut current = printers
   while (true) {
     // There will be at least one printer registered by the time this is called
-    let (_, next) = WasmI32.toGrain(current): (
-      Exception -> Option<String>,
-      WasmI32
-    )
+    let (_, next) = WasmI32.toGrain(current):
+      (Exception => Option<String>, WasmI32)
     if (next == 0n) {
       // Using a tuple in runtime mode is typically disallowed as there is no way
       // to reclaim the memory, but this function is only called once
@@ -44,36 +35,38 @@ export let dangerouslyRegisterBasePrinter = f => {
   void
 }
 
-export let dangerouslyRegisterPrinter = f => {
+provide let dangerouslyRegisterPrinter = f => {
   printers = WasmI32.fromGrain((f, printers))
   // We don't decRef the closure or arguments here to avoid a cyclic dep. on Memory.
   // This is fine, as this function is only called seldomly.
   void
 }
 
+// avoid cirular dependency on gc
+let incRef = v => {
+  let ptr = WasmI32.fromGrain(v) - 8n
+  WasmI32.store(ptr, WasmI32.load(ptr, 0n) + 1n, 0n)
+  v
+}
+
 let _GENERIC_EXCEPTION_NAME = "GrainException"
 
 let exceptionToString = (e: Exception) => {
   let mut result = _GENERIC_EXCEPTION_NAME
   let mut current = printers
   while (true) {
-    if (current == 0n) {
-      break
-    }
-    let (printer, next) = WasmI32.toGrain(current): (
-      Exception -> Option<String>,
-      WasmI32
-    )
-    match (printer(e)) {
-      Some(str) => {
-        result = str
-        break
+    if (current == 0n) return result
+    let (printer, next) = WasmI32.toGrain(current):
+      (Exception => Option<String>, WasmI32)
+    // as GC is not available, manually increment the references
+    match (incRef(printer)(incRef(e))) {
+      Some(str) => return str,
+      None => {
+        current = next
       },
-      None => void,
     }
-    current = next
   }
-  result
+  return result
 }
 
 // HACK: Allocate static buffer for printing (40 bytes)
@@ -81,7 +74,7 @@ let exceptionToString = (e: Exception) => {
 // the runtime heap, but this is the only module that needs to do it
 let iov = WasmI32.fromGrain([> 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n])
 
-export let panic = (msg: String) => {
+provide let panic = (msg: String) => {
   let ptr = WasmI32.fromGrain(msg)
   let written = iov + 32n
   let lf = iov + 36n
@@ -94,18 +87,16 @@ export let panic = (msg: String) => {
   unreachable()
 }
 
-export let panicWithException = (e: Exception) => {
+provide let panicWithException = (e: Exception) => {
   panic(exceptionToString(e))
 }
 
-export exception IndexOutOfBounds
-export exception IndexNonInteger
-export exception DivisionByZero
-export exception ModuloByZero
-export exception Overflow
-export exception NumberNotIntlike
-export exception NumberNotRational
-export exception MatchFailure
+provide exception DivisionByZero
+provide exception ModuloByZero
+provide exception Overflow
+provide exception NumberNotIntlike
+provide exception NumberNotRational
+provide exception MatchFailure
 /*
  * `assert <condition>` is essentially syntactic sugar for:
  * `if (!<condition>) throw AssertionError(<message>)`
@@ -114,8 +105,8 @@ export exception MatchFailure
  * this file to construct the error, but constructing a string in this module is impractical as we
  * don't have access to memory allocation since malloc.gr depends on this module.
  */
-export exception AssertionError(String)
-export exception InvalidArgument(String)
+
+provide exception InvalidArgument(String)
 
 let runtimeErrorPrinter = e => {
   match (e) {

package/runtime/exception.md

@@ -1,8 +1,10 @@
-### Exception.**Option**
+---
+title: Exception
+---
 
-```grain
-type Option<a>
-```
+## Values
+
+Functions and constants included in the Exception module.
 
 ### Exception.**printers**
 
@@ -13,24 +15,24 @@ printers : WasmI32
 ### Exception.**dangerouslyRegisterBasePrinter**
 
 ```grain
-dangerouslyRegisterBasePrinter : a -> Void
+dangerouslyRegisterBasePrinter : (f: a) => Void
 ```
 
 ### Exception.**dangerouslyRegisterPrinter**
 
 ```grain
-dangerouslyRegisterPrinter : a -> Void
+dangerouslyRegisterPrinter : (f: a) => Void
 ```
 
 ### Exception.**panic**
 
 ```grain
-panic : String -> a
+panic : (msg: String) => a
 ```
 
 ### Exception.**panicWithException**
 
 ```grain
-panicWithException : Exception -> a
+panicWithException : (e: Exception) => a
 ```
 

package/runtime/gc.gr

@@ -1,4 +1,5 @@
-/* grainc-flags --compilation-mode=runtime */
+@runtimeMode
+module GC
 
 /* Notes:
  *
@@ -18,131 +19,28 @@
  *   userPtr : The pointer returned (and referenced by) to the Grain runtime
  */
 
-import Malloc from "runtime/malloc"
-import Tags from "runtime/unsafe/tags"
-import WasmI32, {
-  add as (+),
-  sub as (-),
-  mul as (*),
-  and as (&),
-  eq as (==),
-} from "runtime/unsafe/wasmi32"
+from "runtime/malloc" include Malloc
+from "runtime/unsafe/tags" include Tags
+from "runtime/unsafe/wasmi32" include WasmI32
+use WasmI32.{ (+), (-), (*), (&), (==), (!=) }
 
 // Using foreigns directly here to avoid cyclic dependency
-import foreign wasm fd_write: (
-  WasmI32,
-  WasmI32,
-  WasmI32,
-  WasmI32,
-) -> WasmI32 from "wasi_snapshot_preview1"
+foreign wasm fd_write:
+  (WasmI32, WasmI32, WasmI32, WasmI32) => WasmI32 from "wasi_snapshot_preview1"
 
-primitive (&&): (Bool, Bool) -> Bool = "@and"
-primitive (||): (Bool, Bool) -> Bool = "@or"
-primitive throw: Exception -> a = "@throw"
-primitive ignore: a -> Void = "@ignore"
-primitive box: a -> Box<a> = "@box"
-primitive unbox: Box<a> -> a = "@unbox"
+primitive (&&) = "@and"
+primitive (||) = "@or"
+primitive throw = "@throw"
+primitive ignore = "@ignore"
+primitive box = "@box"
+primitive unbox = "@unbox"
 
 exception DecRefError
 
-let decimalCount32Dummy = (n: WasmI32) => 0n
-let utoa32BufferedDummy = (a: WasmI32, b: WasmI32, c: WasmI32) => void
-
-// When these boxes are backpatched, the reference count of each function will
-// fall to zero which would cause them to be freed. We can't free anything that
-// got allocated in runtime mode (since that memory space is not managed by the
-// GC, so here we prevent that by manually setting a higher refcount.
-WasmI32.store(WasmI32.fromGrain(decimalCount32Dummy) - 8n, 2n, 0n)
-WasmI32.store(WasmI32.fromGrain(utoa32BufferedDummy) - 8n, 2n, 0n)
-
-export let decimalCount32 = box(decimalCount32Dummy)
-export let utoa32Buffered = box(utoa32BufferedDummy)
-
 let mut _DEBUG = false
 
 let _HEADER_SIZE = 8n
 
-/*
-//Debugging functions:
-import foreign wasm fd_sync : (WasmI32) -> WasmI32 from "wasi_snapshot_preview1"
-
-// incRef debug messages: "decRef: 0xNNNNNN (prev count: nn)\n"
-let _INCREF_DEBUG_STR_1 = "incRef: 0x"
-let _INCREF_DEBUG_STR_2 = " (prev count: "
-let _INCREF_DEBUG_STR_3 = "; tag: "
-let _INCREF_DEBUG_STR_4 = ")\n"
-
-// decRef debug messages: "decRef: 0xNNNNNN (prev count: nn)\n"
-let _DECREF_DEBUG_STR_1 = "decRef: 0x"
-let _DECREF_DEBUG_STR_2 = " (prev count: "
-let _DECREF_DEBUG_STR_3 = "; ignoreZeros: true)\n"
-let _DECREF_DEBUG_STR_4 = "; ignoreZeros: false)\n"
-
-let logIncRef = (userPtr: WasmI32, refCount: WasmI32) => {
-  let ptrDecimals = WasmI32.shrU(31n - WasmI32.clz(userPtr), 2n) + 1n
-  let ptrStr = Malloc.malloc(ptrDecimals)
-  unbox(utoa32Buffered)(ptrStr, userPtr, 16n)
-  let refCountDecimals = unbox(decimalCount32)(refCount)
-  let refCountStr = Malloc.malloc(refCountDecimals)
-  unbox(utoa32Buffered)(refCountStr, refCount, 10n)
-  let tag = WasmI32.load(userPtr, 0n)
-  let tagDecimals = unbox(decimalCount32)(tag)
-  let tagStr = Malloc.malloc(tagDecimals)
-  unbox(utoa32Buffered)(tagStr, tag, 10n)
-  let iov = Malloc.malloc((8n * 5n) + 4n)
-  let written = iov + (8n * 7n)
-  WasmI32.store(iov, WasmI32.fromGrain(_INCREF_DEBUG_STR_1) + 8n, 0n)
-  WasmI32.store(iov, WasmI32.load(WasmI32.fromGrain(_INCREF_DEBUG_STR_1), 4n), 4n)
-  WasmI32.store(iov, ptrStr, 8n)
-  WasmI32.store(iov, ptrDecimals, 12n)
-  WasmI32.store(iov, WasmI32.fromGrain(_INCREF_DEBUG_STR_2) + 8n, 16n)
-  WasmI32.store(iov, WasmI32.load(WasmI32.fromGrain(_INCREF_DEBUG_STR_2), 4n), 20n)
-  WasmI32.store(iov, refCountStr, 24n)
-  WasmI32.store(iov, refCountDecimals, 28n)
-  WasmI32.store(iov, WasmI32.fromGrain(_INCREF_DEBUG_STR_3) + 8n, 32n)
-  WasmI32.store(iov, WasmI32.load(WasmI32.fromGrain(_INCREF_DEBUG_STR_3), 4n), 36n)
-  WasmI32.store(iov, tagStr, 40n)
-  WasmI32.store(iov, tagDecimals, 44n)
-  WasmI32.store(iov, WasmI32.fromGrain(_INCREF_DEBUG_STR_4) + 8n, 48n)
-  WasmI32.store(iov, WasmI32.load(WasmI32.fromGrain(_INCREF_DEBUG_STR_4), 4n), 52n)
-  fd_write(1n, iov, 7n, written)
-  fd_sync(1n)
-  Malloc.free(ptrStr)
-  Malloc.free(refCountStr)
-}
-
-let logDecRef = (userPtr: WasmI32, refCount: WasmI32, ignoreZeros) => {
-  let ptrDecimals = WasmI32.shrU(31n - WasmI32.clz(userPtr), 2n) + 1n
-  let ptrStr = Malloc.malloc(ptrDecimals)
-  unbox(utoa32Buffered)(ptrStr, userPtr, 16n)
-  let refCountDecimals = unbox(decimalCount32)(refCount)
-  let refCountStr = Malloc.malloc(refCountDecimals)
-  unbox(utoa32Buffered)(refCountStr, refCount, 10n)
-  let iov = Malloc.malloc((8n * 5n) + 4n)
-  let written = iov + (8n * 5n)
-  WasmI32.store(iov, WasmI32.fromGrain(_DECREF_DEBUG_STR_1) + 8n, 0n)
-  WasmI32.store(iov, WasmI32.load(WasmI32.fromGrain(_DECREF_DEBUG_STR_1), 4n), 4n)
-  WasmI32.store(iov, ptrStr, 8n)
-  WasmI32.store(iov, ptrDecimals, 12n)
-  WasmI32.store(iov, WasmI32.fromGrain(_DECREF_DEBUG_STR_2) + 8n, 16n)
-  WasmI32.store(iov, WasmI32.load(WasmI32.fromGrain(_DECREF_DEBUG_STR_2), 4n), 20n)
-  WasmI32.store(iov, refCountStr, 24n)
-  WasmI32.store(iov, refCountDecimals, 28n)
-  if (ignoreZeros) {
-    WasmI32.store(iov, WasmI32.fromGrain(_DECREF_DEBUG_STR_3) + 8n, 32n)
-    WasmI32.store(iov, WasmI32.load(WasmI32.fromGrain(_DECREF_DEBUG_STR_3), 4n), 36n)
-  } else {
-    WasmI32.store(iov, WasmI32.fromGrain(_DECREF_DEBUG_STR_4) + 8n, 32n)
-    WasmI32.store(iov, WasmI32.load(WasmI32.fromGrain(_DECREF_DEBUG_STR_4), 4n), 36n)
-  }
-  fd_write(1n, iov, 5n, written)
-  fd_sync(1n)
-  Malloc.free(ptrStr)
-  Malloc.free(refCountStr)
-}
-
-*/
-
 let getRefCount = (userPtr: WasmI32) => {
   WasmI32.load(userPtr - _HEADER_SIZE, 0n)
 }
@@ -151,7 +49,7 @@ let setRefCount = (userPtr: WasmI32, count: WasmI32) => {
   WasmI32.store(userPtr - _HEADER_SIZE, count, 0n)
 }
 
-export let malloc = (size: WasmI32) => {
+provide let malloc = (size: WasmI32) => {
   // Add space for header
   let rawPtr = Malloc.malloc(size + _HEADER_SIZE)
 
@@ -163,16 +61,13 @@ export let malloc = (size: WasmI32) => {
   rawPtr + _HEADER_SIZE
 }
 
-export let free = (userPtr: WasmI32) => {
+provide let free = (userPtr: WasmI32) => {
   // Free the raw pointer
   Malloc.free(userPtr - _HEADER_SIZE)
 }
 
-export let incRef = (userPtr: WasmI32) => {
-  if (
-    WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) &&
-    WasmI32.ne(userPtr, 0n)
-  ) {
+provide let incRef = (userPtr: WasmI32) => {
+  if (WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) && userPtr != 0n) {
     // if (_DEBUG) {
     //   logIncRef(userPtr, getRefCount(userPtr))
     //   void;
@@ -183,10 +78,7 @@ export let incRef = (userPtr: WasmI32) => {
 }
 
 let rec decRef = (userPtr: WasmI32, ignoreZeros: Bool) => {
-  if (
-    WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) &&
-    WasmI32.ne(userPtr, 0n)
-  ) {
+  if (WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) && userPtr != 0n) {
     let refCount = getRefCount(userPtr)
     // if (_DEBUG) {
     //   logDecRef(userPtr, refCount, ignoreZeros)
@@ -213,8 +105,8 @@ let rec decRef = (userPtr: WasmI32, ignoreZeros: Bool) => {
   } else {
     userPtr
   }
-},
-decRefChildren = (userPtr: WasmI32) => {
+}
+and decRefChildren = (userPtr: WasmI32) => {
   match (WasmI32.load(userPtr, 0n)) {
     t when t == Tags._GRAIN_BOXED_NUM_HEAP_TAG => {
       let tag = WasmI32.load(userPtr, 4n)
@@ -238,9 +130,7 @@ decRefChildren = (userPtr: WasmI32) => {
         ignore(decRef(WasmI32.load(userPtr + i, 16n), false))
       }
     },
-    t when (
-      t == Tags._GRAIN_ARRAY_HEAP_TAG || t == Tags._GRAIN_TUPLE_HEAP_TAG
-    ) => {
+    t when t == Tags._GRAIN_ARRAY_HEAP_TAG || t == Tags._GRAIN_TUPLE_HEAP_TAG => {
       let arity = WasmI32.load(userPtr, 4n)
       let maxOffset = arity * 4n
       for (let mut i = 0n; WasmI32.ltU(i, maxOffset); i += 4n) {
@@ -261,23 +151,4 @@ decRefChildren = (userPtr: WasmI32) => {
   }
 }
 
-export let decRef = userPtr => decRef(userPtr, false)
-
-// For debugging:
-
-// export let getRefCount = (value) => {
-//   let userPtr = WasmI32.fromGrain(value)
-//   let ret = if (WasmI32.eqz(userPtr & Tags._GRAIN_GENERIC_TAG_MASK) && WasmI32.ne(userPtr, 0n)) {
-//     WasmI32.toGrain((getRefCount(userPtr) * 2n) + 1n) : Number
-//   } else {
-//     0
-//   }
-//   decRef(userPtr)
-//   ret
-// }
-
-// export let rec setDebug = (enabled: Bool) => {
-//   _DEBUG = enabled
-//   decRef(WasmI32.fromGrain(setDebug))
-//   void
-// }
+provide let decRef = userPtr => decRef(userPtr, false)

package/runtime/gc.md

@@ -1,36 +1,32 @@
-### Gc.**decimalCount32**
+---
+title: GC
+---
 
-```grain
-decimalCount32 : Box<WasmI32 -> WasmI32>
-```
-
-### Gc.**utoa32Buffered**
+## Values
 
-```grain
-utoa32Buffered : Box<(WasmI32, WasmI32, WasmI32) -> Void>
-```
+Functions and constants included in the GC module.
 
-### Gc.**malloc**
+### GC.**malloc**
 
 ```grain
-malloc : WasmI32 -> WasmI32
+malloc : (size: WasmI32) => WasmI32
 ```
 
-### Gc.**free**
+### GC.**free**
 
 ```grain
-free : WasmI32 -> Void
+free : (userPtr: WasmI32) => Void
 ```
 
-### Gc.**incRef**
+### GC.**incRef**
 
 ```grain
-incRef : WasmI32 -> WasmI32
+incRef : (userPtr: WasmI32) => WasmI32
 ```
 
-### Gc.**decRef**
+### GC.**decRef**
 
 ```grain
-decRef : WasmI32 -> WasmI32
+decRef : (userPtr: WasmI32) => WasmI32
 ```