@grain/stdlib 0.5.13 → 0.6.1

package/bytes.gr

@@ -1,21 +1,38 @@
 /**
- * @module Bytes: Utilities for working with byte sequences.
+ * Utilities for working with byte sequences.
  *
- * @example import Bytes from "bytes"
+ * @example from "bytes" include Bytes
+ *
+ * @example b"\x00"
+ * @example Bytes.make(1)
  *
  * @since v0.3.2
  */
-
-import Memory from "runtime/unsafe/memory"
-import WasmI32 from "runtime/unsafe/wasmi32"
-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 { allocateBytes, allocateString } from "runtime/dataStructures"
-import Exception from "runtime/exception"
-import Int32 from "int32"
-import { coerceNumberToWasmI32 } from "runtime/numbers"
+module Bytes
+
+from "runtime/unsafe/memory" include Memory
+from "runtime/unsafe/wasmi32" include WasmI32
+from "runtime/unsafe/wasmi64" include WasmI64
+from "runtime/unsafe/wasmf32" include WasmF32
+from "runtime/unsafe/wasmf64" include WasmF64
+from "runtime/unsafe/conv" include Conv
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{
+  tagInt8,
+  tagUint8,
+  tagInt16,
+  tagUint16,
+  untagInt8,
+  untagUint8,
+  untagInt16,
+  untagUint16,
+  allocateBytes,
+  allocateString,
+}
+from "runtime/exception" include Exception
+from "int32" include Int32
+from "runtime/numbers" include Numbers
+use Numbers.{ coerceNumberToWasmI32 }
 
 @unsafe
 let _SIZE_OFFSET = 4n
@@ -37,14 +54,12 @@ let _FLOAT64_BYTE_SIZE = 8n
 /** Throws an exception if the index specified is out-of-bounds */
 @unsafe
 let checkIndexIsInBounds = (i, byteSize, max) => {
-  let (+) = WasmI32.add
-  let (<) = WasmI32.ltS
-  let (>) = WasmI32.gtS
+  use WasmI32.{ (+), (<), (>) }
   if (i < 0n) {
-    throw Exception.IndexOutOfBounds
+    throw IndexOutOfBounds
   }
   if (i + byteSize > max) {
-    throw Exception.IndexOutOfBounds
+    throw IndexOutOfBounds
   }
 }
 
@@ -52,30 +67,34 @@ let checkIndexIsInBounds = (i, byteSize, max) => {
 @unsafe
 let getSize = ptr => WasmI32.load(ptr, _SIZE_OFFSET)
 
-/**
- * @section Values: Functions for working with the Bytes data type.
- */
-
 /**
  * Creates a new byte sequence of the input size.
  *
  * @param size: The number of bytes to store
  * @returns The new byte sequence
  *
+ * @example Bytes.make(0) == b"""
+ * @example Bytes.make(1) == b"\x00"
+ *
  * @since v0.3.2
  */
 @unsafe
-export let make = (size: Number) => {
-  let bytes = allocateBytes(coerceNumberToWasmI32(size))
+provide let make = (size: Number) => {
+  use WasmI32.{ (+) }
+  let size = coerceNumberToWasmI32(size)
+  let bytes = allocateBytes(size)
+  Memory.fill(bytes + 8n, 0n, size)
   WasmI32.toGrain(bytes): Bytes
 }
 
 /**
  * An empty byte sequence.
  *
+ * @example Bytes.empty == b""
+ *
  * @since v0.3.2
  */
-export let empty = make(0)
+provide let empty = make(0)
 
 /**
  * Creates a new byte sequence from the input string.
@@ -83,11 +102,13 @@ export let empty = make(0)
  * @param string: The string to copy into a byte sequence
  * @returns The new byte sequence
  *
+ * @example Bytes.fromString("\x00\x00") == b"\x00\x00"
+ *
  * @since v0.3.2
  */
 @unsafe
-export let fromString = (string: String) => {
-  let (+) = WasmI32.add
+provide let fromString = (string: String) => {
+  use WasmI32.{ (+) }
   let src = WasmI32.fromGrain(string)
   let size = getSize(src)
   let dst = allocateBytes(size)
@@ -101,11 +122,14 @@ export let fromString = (string: String) => {
  * @param bytes: The source byte sequence
  * @returns The string representation of the bytes
  *
+ * @example Bytes.toString(b"\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64") == "Hello World"
+ * @example Bytes.toString(b"Hello World") == "Hello World"
+ *
  * @since v0.3.2
  */
 @unsafe
-export let toString = (bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let toString = (bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   let dst = allocateString(size)
@@ -119,10 +143,13 @@ export let toString = (bytes: Bytes) => {
  * @param bytes: The byte sequence to inspect
  * @returns The number of bytes
  *
+ * @example Bytes.length(b"") == 0
+ * @example Bytes.length(b"\x48") == 1
+ *
  * @since v0.3.2
  */
 @unsafe
-export let length = (bytes: Bytes) => {
+provide let length = (bytes: Bytes) => {
   let b = WasmI32.fromGrain(bytes)
   Conv.wasmI32ToNumber(getSize(b))
 }
@@ -133,12 +160,14 @@ export let length = (bytes: Bytes) => {
  * @param bytes: The byte sequence to copy
  * @returns The new byte sequence
  *
+ * @example Bytes.copy(b"\x48") == b"\x48"
+ *
  * @since v0.3.2
  */
 @unsafe
-export let copy = (b: Bytes) => {
-  let (+) = WasmI32.add
-  let src = WasmI32.fromGrain(b)
+provide let copy = (bytes: Bytes) => {
+  use WasmI32.{ (+) }
+  let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   let dst = allocateBytes(size)
   Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
@@ -155,12 +184,16 @@ export let copy = (b: Bytes) => {
  *
  * @throws InvalidArgument(String): When `start + length` is greater than the bytes size
  *
+ * @example
+ * assert Bytes.toString(
+ *   Bytes.slice(0, 5, b"\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64")
+ * ) == "Hello"
+ *
  * @since v0.3.2
  */
 @unsafe
-export let slice = (start: Number, length: Number, bytes: Bytes) => {
-  let (>) = WasmI32.gtS
-  let (+) = WasmI32.add
+provide let slice = (start: Number, length: Number, bytes: Bytes) => {
+  use WasmI32.{ (+), (>) }
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   let iOrig = start
@@ -169,7 +202,7 @@ export let slice = (start: Number, length: Number, bytes: Bytes) => {
   let length = coerceNumberToWasmI32(length)
   if (start + length > size) {
     throw Exception.InvalidArgument(
-      "The given index and length do not specify a valid range of bytes"
+      "The given index and length do not specify a valid range of bytes",
     )
   }
   let dst = allocateBytes(length)
@@ -190,15 +223,13 @@ export let slice = (start: Number, length: Number, bytes: Bytes) => {
  *
  * @throws InvalidArgument(String): When the new size is negative
  *
+ * @example Bytes.length(Bytes.resize(0, 3, b"")) == 3
+ *
  * @since v0.3.2
  */
 @unsafe
-export let resize = (left: Number, right: Number, bytes: Bytes) => {
-  let (<) = WasmI32.ltS
-  let (>) = WasmI32.gtS
-  let (+) = WasmI32.add
-  let (-) = WasmI32.sub
-  let (*) = WasmI32.mul
+provide let resize = (left: Number, right: Number, bytes: Bytes) => {
+  use WasmI32.{ (+), (-), (*), (<), (>) }
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   let leftOrig = left
@@ -241,26 +272,29 @@ export let resize = (left: Number, right: Number, bytes: Bytes) => {
  *
  * @param srcIndex: The starting index to copy bytes from
  * @param dstIndex: The starting index to copy bytes into
- * @param length: The amount of bytes to copy from the source buffer
+ * @param length: The amount of bytes to copy from the source byte sequence
  * @param src: The source byte sequence
  * @param dst: The destination byte sequence
  *
  * @throws InvalidArgument(String): When `srcIndex + length` is greater than the `src` bytes size
  * @throws InvalidArgument(String): When the `dstIndex + length` is greater than the `dst` bytes size
  *
+ * @example
+ * let bytes = Bytes.make(5)
+ * Bytes.move(0, 0, 5, b"\x48\x64\x6c\x6f\x20\x57\x6f\x72\x6c\x64", bytes)
+ * assert Bytes.toString(bytes) == "Hello"
+ *
  * @since v0.3.2
  */
 @unsafe
-export let move =
-  (
-    srcIndex: Number,
-    dstIndex: Number,
-    length: Number,
-    src: Bytes,
-    dst: Bytes,
-  ) => {
-  let (>) = WasmI32.gtS
-  let (+) = WasmI32.add
+provide let move = (
+  srcIndex: Number,
+  dstIndex: Number,
+  length: Number,
+  src: Bytes,
+  dst: Bytes,
+) => {
+  use WasmI32.{ (+), (>) }
   let srcIndexOrig = srcIndex
   let dstIndexOrig = dstIndex
   let lenthOrig = length
@@ -292,9 +326,14 @@ export let move =
  * @param bytes2: The ending byte sequence
  * @returns The new byte sequence
  *
+ * @example
+ * let helloBytes = Bytes.fromString("Hello ")
+ * let worldBytes = Bytes.fromString("World")
+ * assert Bytes.toString(Bytes.concat(helloBytes, worldBytes)) == "Hello World"
+ *
  * @since v0.3.2
  */
-export let concat = (bytes1: Bytes, bytes2: Bytes) => {
+provide let concat = (bytes1: Bytes, bytes2: Bytes) => {
   let len1 = length(bytes1)
   let len2 = length(bytes2)
   let ret = resize(0, len2, bytes1)
@@ -308,14 +347,20 @@ export let concat = (bytes1: Bytes, bytes2: Bytes) => {
  * @param value: The value replacing each byte
  * @param bytes: The byte sequence to update
  *
+ * @example
+ * let bytes = Bytes.make(5)
+ * Bytes.fill(1us, bytes)
+ * assert bytes == b"\x01\x01\x01\x01\x01"
+ *
  * @since v0.3.2
+ * @history v0.6.0: `value` argument type changed to `Uint8`
  */
 @unsafe
-export let fill = (value: Int32, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let fill = (value: Uint8, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
-  let v = Conv.fromInt32(value)
+  let v = untagUint8(value)
   Memory.fill(src + _VALUE_OFFSET, v, size)
 }
 
@@ -324,41 +369,78 @@ export let fill = (value: Int32, bytes: Bytes) => {
  *
  * @param bytes: The byte sequence to clear
  *
+ * @example
+ * let bytes = Bytes.make(5)
+ * Bytes.fill(1us, bytes)
+ * Bytes.clear(bytes)
+ * assert bytes == b"\x00\x00\x00\x00\x00"
+ *
  * @since v0.5.0
  */
 @unsafe
-export let clear = (bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let clear = (bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   Memory.fill(src + _VALUE_OFFSET, 0n, size)
 }
 
-/**
- * @section Binary operations on integers: Functions for encoding and decoding integers stored in a byte sequence.
- */
-
 /**
  * Gets a signed 8-bit integer starting at the given byte index.
  *
  * @param index: The byte index to access
  * @param bytes: The byte sequence to access
- * @returns A 32-bit integer representing a signed 8-bit integer that starts at the given index
+ * @returns A signed 8-bit integer that starts at the given index
  *
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 1` is greater than the bytes size
  *
- * @since v0.3.2
+ * @example
+ * let bytes = Bytes.make(1)
+ * Bytes.setInt8(0, 1s, bytes)
+ * assert Bytes.getInt8(0, bytes) == 1s
+ *
+ * @since v0.6.0
+ * @history v0.3.2: Originally called `getInt8S`, returning an `Int32`
  */
 @unsafe
-export let getInt8S = (index: Number, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let getInt8 = (index: Number, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   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)
-  Conv.toInt32(n)
+  tagInt8(n)
+}
+
+/**
+ * Sets a signed 8-bit integer starting at the given byte index.
+ *
+ * @param index: The byte index to update
+ * @param value: The value to set
+ * @param bytes: The byte sequence to mutate
+ *
+ * @throws IndexOutOfBounds: When `index` is negative
+ * @throws IndexOutOfBounds: When `index + 1` is greater than the bytes size
+ *
+ * @example
+ * let bytes = Bytes.make(1)
+ * Bytes.setInt8(0, 2s, bytes)
+ * assert Bytes.getInt8(0, bytes) == 2s
+ *
+ * @since v0.3.2
+ * @history v0.6.0: `value` argument type changed to `Int8`
+ */
+@unsafe
+provide let setInt8 = (index: Number, value: Int8, bytes: Bytes) => {
+  use WasmI32.{ (+) }
+  let ptr = WasmI32.fromGrain(bytes)
+  let size = getSize(ptr)
+  let offset = coerceNumberToWasmI32(index)
+  checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
+  let v = untagInt8(value)
+  WasmI32.store8(ptr + offset, v, _VALUE_OFFSET)
 }
 
 /**
@@ -366,26 +448,32 @@ export let getInt8S = (index: Number, bytes: Bytes) => {
  *
  * @param index: The byte index to access
  * @param bytes: The byte sequence to access
- * @returns A 32-bit integer representing an unsigned 8-bit integer that starts at the given index
+ * @returns An unsigned 8-bit integer that starts at the given index
  *
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 1` is greater than the bytes size
  *
- * @since v0.3.2
+ * @example
+ * let bytes = Bytes.make(1)
+ * Bytes.setUint8(0, 1us, bytes)
+ * assert Bytes.getUint8(0, bytes) == 1us
+ *
+ * @since v0.6.0
+ * @history v0.3.2: Originally called `getInt8U`, returning an `Int32`
  */
 @unsafe
-export let getInt8U = (index: Number, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let getUint8 = (index: Number, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
   let n = WasmI32.load8U(ptr + offset, _VALUE_OFFSET)
-  Conv.toInt32(n)
+  tagUint8(n)
 }
 
 /**
- * Sets a signed 8-bit integer starting at the given byte index.
+ * Sets an unsigned 8-bit integer starting at the given byte index.
  *
  * @param index: The byte index to update
  * @param value: The value to set
@@ -394,16 +482,21 @@ export let getInt8U = (index: Number, bytes: Bytes) => {
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 1` is greater than the bytes size
  *
- * @since v0.3.2
+ * @example
+ * let bytes = Bytes.make(2)
+ * Bytes.setUint8(1, 2us, bytes)
+ * assert Bytes.getUint8(1, bytes) == 2us
+ *
+ * @since v0.6.0
  */
 @unsafe
-export let setInt8 = (index: Number, value: Int32, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let setUint8 = (index: Number, value: Uint8, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
-  let v = Conv.fromInt32(value)
+  let v = untagUint8(value)
   WasmI32.store8(ptr + offset, v, _VALUE_OFFSET)
 }
 
@@ -412,22 +505,57 @@ export let setInt8 = (index: Number, value: Int32, bytes: Bytes) => {
  *
  * @param index: The byte index to access
  * @param bytes: The byte sequence to access
- * @returns A 32-bit integer representing a signed 16-bit integer that starts at the given index
+ * @returns A signed 16-bit integer that starts at the given index
  *
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 2` is greater than the bytes size
  *
- * @since v0.3.2
+ * @example
+ * let bytes = Bytes.make(2)
+ * Bytes.setInt16(0, -2S, bytes)
+ * assert Bytes.getInt16(0, bytes) == -2S
+ *
+ * @since v0.6.0
+ * @history v0.3.2: Originally called `getInt16S`, returning an `Int32`
  */
 @unsafe
-export let getInt16S = (index: Number, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let getInt16 = (index: Number, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   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)
-  Conv.toInt32(n)
+  tagInt16(n)
+}
+
+/**
+ * Sets a signed 16-bit integer starting at the given byte index.
+ *
+ * @param index: The byte index to update
+ * @param value: The value to set
+ * @param bytes: The byte sequence to mutate
+ *
+ * @throws IndexOutOfBounds: When `index` is negative
+ * @throws IndexOutOfBounds: When `index + 2` is greater than the bytes size
+ *
+ * @example
+ * let bytes = Bytes.make(2)
+ * Bytes.setInt16(0, -1S, bytes)
+ * assert Bytes.getInt16(0, bytes) == -1S
+ *
+ * @since v0.3.2
+ * @history v0.6.0: `value` argument type changed to `Int16`
+ */
+@unsafe
+provide let setInt16 = (index: Number, value: Int16, bytes: Bytes) => {
+  use WasmI32.{ (+) }
+  let ptr = WasmI32.fromGrain(bytes)
+  let size = getSize(ptr)
+  let offset = coerceNumberToWasmI32(index)
+  checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
+  let v = untagInt16(value)
+  WasmI32.store16(ptr + offset, v, _VALUE_OFFSET)
 }
 
 /**
@@ -435,26 +563,32 @@ export let getInt16S = (index: Number, bytes: Bytes) => {
  *
  * @param index: The byte index to access
  * @param bytes: The byte sequence to access
- * @returns A 32-bit integer representing an unsigned 16-bit integer that starts at the given index
+ * @returns An unsigned 16-bit integer that starts at the given index
  *
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 2` is greater than the bytes size
  *
- * @since v0.3.2
+ * @example
+ * let bytes = Bytes.make(2)
+ * Bytes.setUint16(0, 2uS, bytes)
+ * assert Bytes.getUint16(0, bytes) == 2uS
+ *
+ * @since v0.6.0
+ * @history v0.3.2: Originally called `getInt16U`, returning an `Int32`
  */
 @unsafe
-export let getInt16U = (index: Number, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let getUint16 = (index: Number, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   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)
-  Conv.toInt32(n)
+  tagUint16(n)
 }
 
 /**
- * Sets a signed 16-bit integer starting at the given byte index.
+ * Sets an unsigned 16-bit integer starting at the given byte index.
  *
  * @param index: The byte index to update
  * @param value: The value to set
@@ -463,16 +597,21 @@ export let getInt16U = (index: Number, bytes: Bytes) => {
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 2` is greater than the bytes size
  *
- * @since v0.3.2
+ * @example
+ * let bytes = Bytes.make(2)
+ * Bytes.setUint16(0, 2uS, bytes)
+ * assert Bytes.getUint16(0, bytes) == 2uS
+ *
+ * @since v0.6.0
  */
 @unsafe
-export let setInt16 = (index: Number, value: Int32, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let setUint16 = (index: Number, value: Uint16, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   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 v = untagUint16(value)
   WasmI32.store16(ptr + offset, v, _VALUE_OFFSET)
 }
 
@@ -486,11 +625,16 @@ export let setInt16 = (index: Number, value: Int32, bytes: Bytes) => {
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 4` is greater than the bytes size
  *
+ * @example
+ * let bytes = Bytes.make(4)
+ * Bytes.setInt32(0, 1l, bytes)
+ * assert Bytes.getInt32(0, bytes) == 1l
+ *
  * @since v0.3.2
  */
 @unsafe
-export let getInt32 = (index: Number, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let getInt32 = (index: Number, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
@@ -509,11 +653,16 @@ export let getInt32 = (index: Number, bytes: Bytes) => {
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 4` is greater than the bytes size
  *
+ * @example
+ * let bytes = Bytes.make(4)
+ * Bytes.setInt32(0, 1l, bytes)
+ * assert Bytes.getInt32(0, bytes) == 1l
+ *
  * @since v0.3.2
  */
 @unsafe
-export let setInt32 = (index: Number, value: Int32, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let setInt32 = (index: Number, value: Int32, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
@@ -522,6 +671,62 @@ export let setInt32 = (index: Number, value: Int32, bytes: Bytes) => {
   WasmI32.store(ptr + offset, v, _VALUE_OFFSET)
 }
 
+/**
+ * Gets an unsigned 32-bit integer starting at the given byte index.
+ *
+ * @param index: The byte index to access
+ * @param bytes: The byte sequence to access
+ * @returns An unsigned 32-bit integer that starts at the given index
+ *
+ * @throws IndexOutOfBounds: When `index` is negative
+ * @throws IndexOutOfBounds: When `index + 4` is greater than the bytes size
+ *
+ * @example
+ * let bytes = Bytes.make(4)
+ * Bytes.setUint32(0, 1ul, bytes)
+ * assert Bytes.getUint32(0, bytes) == 1ul
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let getUint32 = (index: Number, bytes: Bytes) => {
+  use WasmI32.{ (+) }
+  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)
+  Conv.toUint32(n)
+}
+
+/**
+ * Sets an unsigned 32-bit integer starting at the given byte index.
+ *
+ * @param index: The byte index to update
+ * @param value: The value to set
+ * @param bytes: The byte sequence to mutate
+ *
+ * @throws IndexOutOfBounds: When `index` is negative
+ * @throws IndexOutOfBounds: When `index + 4` is greater than the bytes size
+ *
+ * @example
+ * let bytes = Bytes.make(4)
+ * Bytes.setUint32(0, 1ul, bytes)
+ * assert Bytes.getUint32(0, bytes) == 1ul
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let setUint32 = (index: Number, value: Uint32, bytes: Bytes) => {
+  use WasmI32.{ (+) }
+  let ptr = WasmI32.fromGrain(bytes)
+  let size = getSize(ptr)
+  let offset = coerceNumberToWasmI32(index)
+  checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
+  let v = Conv.fromUint32(value)
+  WasmI32.store(ptr + offset, v, _VALUE_OFFSET)
+}
+
 /**
  * Gets a 32-bit float starting at the given byte index.
  *
@@ -532,11 +737,16 @@ export let setInt32 = (index: Number, value: Int32, bytes: Bytes) => {
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 4` is greater than the bytes size
  *
+ * @example
+ * let bytes = Bytes.make(4)
+ * Bytes.setFloat32(0, 1.0f, bytes)
+ * assert Bytes.getFloat32(0, bytes) == 1.0f
+ *
  * @since v0.3.2
  */
 @unsafe
-export let getFloat32 = (index: Number, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let getFloat32 = (index: Number, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
@@ -555,11 +765,16 @@ export let getFloat32 = (index: Number, bytes: Bytes) => {
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 4` is greater than the bytes size
  *
+ * @example
+ * let bytes = Bytes.make(4)
+ * Bytes.setFloat32(0, 1.0f, bytes)
+ * assert Bytes.getFloat32(0, bytes) == 1.0f
+ *
  * @since v0.3.2
  */
 @unsafe
-export let setFloat32 = (index: Number, value: Float32, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let setFloat32 = (index: Number, value: Float32, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
@@ -578,11 +793,16 @@ export let setFloat32 = (index: Number, value: Float32, bytes: Bytes) => {
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 8` is greater than the bytes size
  *
+ * @example
+ * let bytes = Bytes.make(8)
+ * Bytes.setInt64(0, 1L, bytes)
+ * assert Bytes.getInt64(0, bytes) == 1L
+ *
  * @since v0.3.2
  */
 @unsafe
-export let getInt64 = (index: Number, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let getInt64 = (index: Number, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
@@ -601,11 +821,16 @@ export let getInt64 = (index: Number, bytes: Bytes) => {
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 8` is greater than the bytes size
  *
+ * @example
+ * let bytes = Bytes.make(8)
+ * Bytes.setInt64(0, 1L, bytes)
+ * assert Bytes.getInt64(0, bytes) == 1L
+ *
  * @since v0.3.2
  */
 @unsafe
-export let setInt64 = (index: Number, value: Int64, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let setInt64 = (index: Number, value: Int64, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
@@ -614,6 +839,62 @@ export let setInt64 = (index: Number, value: Int64, bytes: Bytes) => {
   WasmI64.store(ptr + offset, v, _VALUE_OFFSET)
 }
 
+/**
+ * Gets an unsigned 64-bit integer starting at the given byte index.
+ *
+ * @param index: The byte index to access
+ * @param bytes: The byte sequence to access
+ * @returns An unsigned 64-bit integer that starts at the given index
+ *
+ * @throws IndexOutOfBounds: When `index` is negative
+ * @throws IndexOutOfBounds: When `index + 8` is greater than the bytes size
+ *
+ * @example
+ * let bytes = Bytes.make(8)
+ * Bytes.setUint64(0, 1uL, bytes)
+ * assert Bytes.getUint64(0, bytes) == 1uL
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let getUint64 = (index: Number, bytes: Bytes) => {
+  use WasmI32.{ (+) }
+  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)
+  Conv.toUint64(n)
+}
+
+/**
+ * Sets an unsigned 64-bit integer starting at the given byte index.
+ *
+ * @param index: The byte index to update
+ * @param value: The value to set
+ * @param bytes: The byte sequence to mutate
+ *
+ * @throws IndexOutOfBounds: When `index` is negative
+ * @throws IndexOutOfBounds: When `index + 8` is greater than the bytes size
+ *
+ * @example
+ * let bytes = Bytes.make(8)
+ * Bytes.setUint64(0, 1uL, bytes)
+ * assert Bytes.getUint64(0, bytes) == 1uL
+ *
+ * @since v0.6.0
+ */
+@unsafe
+provide let setUint64 = (index: Number, value: Uint64, bytes: Bytes) => {
+  use WasmI32.{ (+) }
+  let ptr = WasmI32.fromGrain(bytes)
+  let size = getSize(ptr)
+  let offset = coerceNumberToWasmI32(index)
+  checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
+  let v = Conv.fromUint64(value)
+  WasmI64.store(ptr + offset, v, _VALUE_OFFSET)
+}
+
 /**
  * Gets a 64-bit float starting at the given byte index.
  *
@@ -624,11 +905,16 @@ export let setInt64 = (index: Number, value: Int64, bytes: Bytes) => {
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 8` is greater than the bytes size
  *
+ * @example
+ * let bytes = Bytes.make(8)
+ * Bytes.setFloat64(0, 1.0d, bytes)
+ * assert Bytes.getFloat64(0, bytes) == 1.0d
+ *
  * @since v0.3.2
  */
 @unsafe
-export let getFloat64 = (index: Number, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let getFloat64 = (index: Number, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)
@@ -647,11 +933,16 @@ export let getFloat64 = (index: Number, bytes: Bytes) => {
  * @throws IndexOutOfBounds: When `index` is negative
  * @throws IndexOutOfBounds: When `index + 8` is greater than the bytes size
  *
+ * @example
+ * let bytes = Bytes.make(8)
+ * Bytes.setFloat64(0, 1.0d, bytes)
+ * assert Bytes.getFloat64(0, bytes) == 1.0d
+ *
  * @since v0.3.2
  */
 @unsafe
-export let setFloat64 = (index: Number, value: Float64, bytes: Bytes) => {
-  let (+) = WasmI32.add
+provide let setFloat64 = (index: Number, value: Float64, bytes: Bytes) => {
+  use WasmI32.{ (+) }
   let ptr = WasmI32.fromGrain(bytes)
   let size = getSize(ptr)
   let offset = coerceNumberToWasmI32(index)