@grain/stdlib 0.4.5 → 0.5.1

package/bytes.gr

@@ -12,48 +12,30 @@ import WasmI64 from "runtime/unsafe/wasmi64"
 import WasmF32 from "runtime/unsafe/wasmf32"
 import WasmF64 from "runtime/unsafe/wasmf64"
 import Conv from "runtime/unsafe/conv"
-import {
-  tagSimpleNumber,
-  allocateBytes,
-  allocateString,
-} from "runtime/dataStructures"
+import { allocateBytes, allocateString } from "runtime/dataStructures"
 import Exception from "runtime/exception"
 import Int32 from "int32"
 import { coerceNumberToWasmI32 } from "runtime/numbers"
 
-// hack to avoid incRef on these variables
-@disableGC
-let mut _SIZE_OFFSET = 1n
-@disableGC
-let mut _VALUE_OFFSET = 1n
-@disableGC
-let mut _INT8_BYTE_SIZE = 1n
-@disableGC
-let mut _INT16_BYTE_SIZE = 1n
-@disableGC
-let mut _INT32_BYTE_SIZE = 1n
-@disableGC
-let mut _FLOAT32_BYTE_SIZE = 1n
-@disableGC
-let mut _INT64_BYTE_SIZE = 1n
-@disableGC
-let mut _FLOAT64_BYTE_SIZE = 1n
-
-@disableGC
-let initVals = () => {
-  _SIZE_OFFSET = 4n
-  _VALUE_OFFSET = 8n
-  _INT8_BYTE_SIZE = 1n
-  _INT16_BYTE_SIZE = 2n
-  _INT32_BYTE_SIZE = 4n
-  _FLOAT32_BYTE_SIZE = 4n
-  _INT64_BYTE_SIZE = 8n
-  _FLOAT64_BYTE_SIZE = 8n
-}
-initVals()
+@unsafe
+let _SIZE_OFFSET = 4n
+@unsafe
+let _VALUE_OFFSET = 8n
+@unsafe
+let _INT8_BYTE_SIZE = 1n
+@unsafe
+let _INT16_BYTE_SIZE = 2n
+@unsafe
+let _INT32_BYTE_SIZE = 4n
+@unsafe
+let _FLOAT32_BYTE_SIZE = 4n
+@unsafe
+let _INT64_BYTE_SIZE = 8n
+@unsafe
+let _FLOAT64_BYTE_SIZE = 8n
 
 /** Throws an exception if the index specified is out-of-bounds */
-@disableGC
+@unsafe
 let checkIndexIsInBounds = (i, byteSize, max) => {
   let (+) = WasmI32.add
   let (<) = WasmI32.ltS
@@ -67,7 +49,7 @@ let checkIndexIsInBounds = (i, byteSize, max) => {
 }
 
 /** Gets the size of a Bytes via its ptr */
-@disableGC
+@unsafe
 let getSize = ptr => WasmI32.load(ptr, _SIZE_OFFSET)
 
 /**
@@ -82,13 +64,10 @@ let getSize = ptr => WasmI32.load(ptr, _SIZE_OFFSET)
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec make = (size: Number) => {
+@unsafe
+export let make = (size: Number) => {
   let bytes = allocateBytes(coerceNumberToWasmI32(size))
-  let ret = WasmI32.toGrain(bytes): Bytes
-  Memory.decRef(WasmI32.fromGrain(size))
-  Memory.decRef(WasmI32.fromGrain(make))
-  ret
+  WasmI32.toGrain(bytes): Bytes
 }
 
 /**
@@ -106,17 +85,14 @@ export let empty = make(0)
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec fromString = (string: String) => {
+@unsafe
+export let fromString = (string: String) => {
   let (+) = WasmI32.add
   let src = WasmI32.fromGrain(string)
   let size = getSize(src)
   let dst = allocateBytes(size)
   Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
-  let ret = WasmI32.toGrain(dst): Bytes
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(fromString))
-  ret
+  WasmI32.toGrain(dst): Bytes
 }
 
 /**
@@ -127,17 +103,14 @@ export let rec fromString = (string: String) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec toString = (bytes: Bytes) => {
+@unsafe
+export let toString = (bytes: Bytes) => {
   let (+) = WasmI32.add
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   let dst = allocateString(size)
   Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
-  let ret = WasmI32.toGrain(dst): String
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(toString))
-  ret
+  WasmI32.toGrain(dst): String
 }
 
 /**
@@ -148,13 +121,10 @@ export let rec toString = (bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec length = (bytes: Bytes) => {
+@unsafe
+export let length = (bytes: Bytes) => {
   let b = WasmI32.fromGrain(bytes)
-  let ret = tagSimpleNumber(getSize(b))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(length))
-  ret
+  Conv.wasmI32ToNumber(getSize(b))
 }
 
 /**
@@ -165,17 +135,14 @@ export let rec length = (bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec copy = (b: Bytes) => {
+@unsafe
+export let copy = (b: Bytes) => {
   let (+) = WasmI32.add
   let src = WasmI32.fromGrain(b)
   let size = getSize(src)
   let dst = allocateBytes(size)
   Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
-  let ret = WasmI32.toGrain(dst): Bytes
-  Memory.decRef(WasmI32.fromGrain(b))
-  Memory.decRef(WasmI32.fromGrain(copy))
-  ret
+  WasmI32.toGrain(dst): Bytes
 }
 
 /**
@@ -188,8 +155,8 @@ export let rec copy = (b: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec slice = (start: Number, length: Number, bytes: Bytes) => {
+@unsafe
+export let slice = (start: Number, length: Number, bytes: Bytes) => {
   let (>) = WasmI32.gtS
   let (+) = WasmI32.add
   let src = WasmI32.fromGrain(bytes)
@@ -206,12 +173,7 @@ export let rec slice = (start: Number, length: Number, bytes: Bytes) => {
   let dst = allocateBytes(length)
   let offset = start
   Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET + start, length)
-  let ret = WasmI32.toGrain(dst): Bytes
-  Memory.decRef(WasmI32.fromGrain(iOrig))
-  Memory.decRef(WasmI32.fromGrain(lenOrig))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(slice))
-  ret
+  WasmI32.toGrain(dst): Bytes
 }
 
 /**
@@ -226,8 +188,8 @@ export let rec slice = (start: Number, length: Number, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec resize = (left: Number, right: Number, bytes: Bytes) => {
+@unsafe
+export let resize = (left: Number, right: Number, bytes: Bytes) => {
   let (<) = WasmI32.ltS
   let (>) = WasmI32.gtS
   let (+) = WasmI32.add
@@ -266,12 +228,7 @@ export let rec resize = (left: Number, right: Number, bytes: Bytes) => {
       len
     )
   }
-  let ret = WasmI32.toGrain(dst): Bytes
-  Memory.decRef(WasmI32.fromGrain(leftOrig))
-  Memory.decRef(WasmI32.fromGrain(rightOrig))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(resize))
-  ret
+  WasmI32.toGrain(dst): Bytes
 }
 
 /**
@@ -286,8 +243,8 @@ export let rec resize = (left: Number, right: Number, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec move =
+@unsafe
+export let move =
   (
     srcIndex: Number,
     dstIndex: Number,
@@ -314,19 +271,11 @@ export let rec move =
     throw Exception.InvalidArgument("Invalid destination bytes range")
   }
   let end = srcIndex + length
-  let ret = Memory.copy(
+  Memory.copy(
     dst + _VALUE_OFFSET + dstIndex,
     src + _VALUE_OFFSET + srcIndex,
     length
   )
-
-  Memory.decRef(WasmI32.fromGrain(srcIndexOrig))
-  Memory.decRef(WasmI32.fromGrain(dstIndexOrig))
-  Memory.decRef(WasmI32.fromGrain(lenthOrig))
-  Memory.decRef(WasmI32.fromGrain(src))
-  Memory.decRef(WasmI32.fromGrain(dst))
-  Memory.decRef(WasmI32.fromGrain(move))
-  ret
 }
 
 /**
@@ -354,17 +303,28 @@ export let concat = (bytes1: Bytes, bytes2: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec fill = (value: Int32, bytes: Bytes) => {
+@unsafe
+export let fill = (value: Int32, bytes: Bytes) => {
   let (+) = WasmI32.add
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   let v = Conv.fromInt32(value)
-  let ret = Memory.fill(src + _VALUE_OFFSET, v, size)
-  Memory.decRef(WasmI32.fromGrain(value))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(fill))
-  ret
+  Memory.fill(src + _VALUE_OFFSET, v, size)
+}
+
+/**
+ * Replaces all bytes in a byte sequence with zeroes.
+ *
+ * @param bytes: The byte sequence to clear
+ *
+ * @since v0.5.0
+ */
+@unsafe
+export let clear = (bytes: Bytes) => {
+  let (+) = WasmI32.add
+  let src = WasmI32.fromGrain(bytes)
+  let size = getSize(src)
+  Memory.fill(src + _VALUE_OFFSET, 0n, size)
 }
 
 /**
@@ -380,19 +340,15 @@ export let rec fill = (value: Int32, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec getInt8S = (index: Number, bytes: Bytes) => {
+@unsafe
+export let getInt8S = (index: Number, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
   let n = WasmI32.load8S(ptr + offset, _VALUE_OFFSET)
-  let ret = Conv.toInt32(n)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(getInt8S))
-  ret
+  Conv.toInt32(n)
 }
 
 /**
@@ -404,7 +360,7 @@ export let rec getInt8S = (index: Number, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
+@unsafe
 export let rec getInt8U = (index: Number, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
@@ -412,11 +368,7 @@ export let rec getInt8U = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
   let n = WasmI32.load8U(ptr + offset, _VALUE_OFFSET)
-  let ret = Conv.toInt32(n)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(getInt8U))
-  ret
+  Conv.toInt32(n)
 }
 
 /**
@@ -428,7 +380,7 @@ export let rec getInt8U = (index: Number, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
+@unsafe
 export let rec setInt8 = (index: Number, value: Int32, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
@@ -436,12 +388,7 @@ export let rec setInt8 = (index: Number, value: Int32, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
   let v = Conv.fromInt32(value)
-  let ret = WasmI32.store8(ptr + offset, v, _VALUE_OFFSET)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(value))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(setInt8))
-  ret
+  WasmI32.store8(ptr + offset, v, _VALUE_OFFSET)
 }
 
 /**
@@ -453,19 +400,15 @@ export let rec setInt8 = (index: Number, value: Int32, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec getInt16S = (index: Number, bytes: Bytes) => {
+@unsafe
+export let getInt16S = (index: Number, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
   let n = WasmI32.load16S(ptr + offset, _VALUE_OFFSET)
-  let ret = Conv.toInt32(n)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(getInt16S))
-  ret
+  Conv.toInt32(n)
 }
 
 /**
@@ -477,19 +420,15 @@ export let rec getInt16S = (index: Number, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec getInt16U = (index: Number, bytes: Bytes) => {
+@unsafe
+export let getInt16U = (index: Number, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
   let n = WasmI32.load16U(ptr + offset, _VALUE_OFFSET)
-  let ret = Conv.toInt32(n)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(getInt16U))
-  ret
+  Conv.toInt32(n)
 }
 
 /**
@@ -501,20 +440,15 @@ export let rec getInt16U = (index: Number, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec setInt16 = (index: Number, value: Int32, bytes: Bytes) => {
+@unsafe
+export let setInt16 = (index: Number, value: Int32, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
   let v = Conv.fromInt32(value)
-  let ret = WasmI32.store16(ptr + offset, v, _VALUE_OFFSET)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(value))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(setInt16))
-  ret
+  WasmI32.store16(ptr + offset, v, _VALUE_OFFSET)
 }
 
 /**
@@ -526,19 +460,15 @@ export let rec setInt16 = (index: Number, value: Int32, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec getInt32 = (index: Number, bytes: Bytes) => {
+@unsafe
+export let getInt32 = (index: Number, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let n = WasmI32.load(ptr + offset, _VALUE_OFFSET)
-  let ret = Conv.toInt32(n)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(getInt32))
-  ret
+  Conv.toInt32(n)
 }
 
 /**
@@ -550,20 +480,15 @@ export let rec getInt32 = (index: Number, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec setInt32 = (index: Number, value: Int32, bytes: Bytes) => {
+@unsafe
+export let setInt32 = (index: Number, value: Int32, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let v = Conv.fromInt32(value)
-  let ret = WasmI32.store(ptr + offset, v, _VALUE_OFFSET)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(value))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(setInt32))
-  ret
+  WasmI32.store(ptr + offset, v, _VALUE_OFFSET)
 }
 
 /**
@@ -575,19 +500,15 @@ export let rec setInt32 = (index: Number, value: Int32, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec getFloat32 = (index: Number, bytes: Bytes) => {
+@unsafe
+export let getFloat32 = (index: Number, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let n = WasmF32.load(ptr + offset, _VALUE_OFFSET)
-  let ret = Conv.toFloat32(n)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(getFloat32))
-  ret
+  Conv.toFloat32(n)
 }
 
 /**
@@ -599,20 +520,15 @@ export let rec getFloat32 = (index: Number, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec setFloat32 = (index: Number, value: Float32, bytes: Bytes) => {
+@unsafe
+export let setFloat32 = (index: Number, value: Float32, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let v = Conv.fromFloat32(value)
-  let ret = WasmF32.store(ptr + offset, v, _VALUE_OFFSET)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(value))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(setFloat32))
-  ret
+  WasmF32.store(ptr + offset, v, _VALUE_OFFSET)
 }
 
 /**
@@ -624,19 +540,15 @@ export let rec setFloat32 = (index: Number, value: Float32, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec getInt64 = (index: Number, bytes: Bytes) => {
+@unsafe
+export let getInt64 = (index: Number, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
   let n = WasmI64.load(ptr + offset, _VALUE_OFFSET)
-  let ret = Conv.toInt64(n)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(getInt64))
-  ret
+  Conv.toInt64(n)
 }
 
 /**
@@ -648,20 +560,15 @@ export let rec getInt64 = (index: Number, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec setInt64 = (index: Number, value: Int64, bytes: Bytes) => {
+@unsafe
+export let setInt64 = (index: Number, value: Int64, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
   let v = Conv.fromInt64(value)
-  let ret = WasmI64.store(ptr + offset, v, _VALUE_OFFSET)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(value))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(setInt64))
-  ret
+  WasmI64.store(ptr + offset, v, _VALUE_OFFSET)
 }
 
 /**
@@ -673,19 +580,15 @@ export let rec setInt64 = (index: Number, value: Int64, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
-export let rec getFloat64 = (index: Number, bytes: Bytes) => {
+@unsafe
+export let getFloat64 = (index: Number, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _FLOAT64_BYTE_SIZE, size)
   let n = WasmF64.load(ptr + offset, _VALUE_OFFSET)
-  let ret = Conv.toFloat64(n)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(getFloat64))
-  ret
+  Conv.toFloat64(n)
 }
 
 /**
@@ -697,7 +600,7 @@ export let rec getFloat64 = (index: Number, bytes: Bytes) => {
  *
  * @since v0.3.2
  */
-@disableGC
+@unsafe
 export let rec setFloat64 = (index: Number, value: Float64, bytes: Bytes) => {
   let (+) = WasmI32.add
   let ptr = WasmI32.fromGrain(bytes)
@@ -705,10 +608,5 @@ export let rec setFloat64 = (index: Number, value: Float64, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _FLOAT64_BYTE_SIZE, size)
   let v = Conv.fromFloat64(value)
-  let ret = WasmF64.store(ptr + offset, v, _VALUE_OFFSET)
-  Memory.decRef(WasmI32.fromGrain(index))
-  Memory.decRef(WasmI32.fromGrain(value))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(setFloat64))
-  ret
+  WasmF64.store(ptr + offset, v, _VALUE_OFFSET)
 }

package/bytes.md

@@ -281,6 +281,25 @@ Parameters:
 |`value`|`Int32`|The value replacing each byte|
 |`bytes`|`Bytes`|The byte sequence to update|
 
+### Bytes.**clear**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+clear : Bytes -> Void
+```
+
+Replaces all bytes in a byte sequence with zeroes.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`bytes`|`Bytes`|The byte sequence to clear|
+
 ## Binary operations on integers
 
 Functions for encoding and decoding integers stored in a byte sequence.