@grain/stdlib 0.4.0 → 0.4.4

package/buffer.gr

@@ -16,24 +16,20 @@ import Bytes from "bytes"
 import String from "string"
 import { coerceNumberToWasmI32 } from "runtime/numbers"
 
-record Buffer {
-  mut len: Number,
-  initialSize: Number,
-  mut data: Bytes,
-}
+record Buffer { mut len: Number, initialSize: Number, mut data: Bytes }
 
 @disableGC
-let mut _SIZE_OFFSET = 1n;
+let mut _SIZE_OFFSET = 1n
 
 @disableGC
-let mut _VALUE_OFFSET = 1n;
+let mut _VALUE_OFFSET = 1n
 
 @disableGC
 let initOffsets = () => {
-  _SIZE_OFFSET = 4n;
-  _VALUE_OFFSET = 8n;
+  _SIZE_OFFSET = 4n
+  _VALUE_OFFSET = 8n
 }
-initOffsets();
+initOffsets()
 
 let _8BIT_LEN = 1
 
@@ -45,27 +41,28 @@ let _64BIT_LEN = 8
 
 /* Gets the size of a Bytes via its ptr */
 @disableGC
-let getSize = (ptr) => WasmI32.load(ptr, _SIZE_OFFSET)
+let getSize = ptr => WasmI32.load(ptr, _SIZE_OFFSET)
 
 /* Doubles the size of buffer's underlying byte sequence, if the given size is larger than the size of a buffer's underlying byte sequence */
 let autogrow = (len, buf) => {
   while (buf.len + len > Bytes.length(buf.data)) {
     let mut n = Bytes.length(buf.data)
-    if (n == 0) n = 4 // Make sure bytes of 0 length grow too
+    if (n == 0) n = 4
+    // Make sure bytes of 0 length grow too
     buf.data = Bytes.resize(0, n, buf.data)
   }
 }
 
 /* Gets the pointer for a char's bytes following the char's tag */
 @disableGC
-let rec getCharAsWasmI32 = (char) => {
+let rec getCharAsWasmI32 = char => {
   let c = WasmI32.fromGrain(char)
   WasmI32.load(c, 4n)
 }
 
 /* Gets the UTF-8 byte length of a char */
 @disableGC
-let rec getCharByteLength = (byte) => {
+let rec getCharByteLength = byte => {
   let (+) = WasmI32.add
   let (&) = WasmI32.and
   let (==) = WasmI32.eq
@@ -96,269 +93,505 @@ let checkIsIndexInBounds = (i, len, buf) => {
   if (i >= buf.len || i + len > buf.len) throw Exception.IndexOutOfBounds
 }
 
+let addInt8help = (value, buffer) => {
+  autogrow(_8BIT_LEN, buffer)
+  let index = buffer.len
+  buffer.len = buffer.len + _8BIT_LEN
+  Bytes.setInt8(index, value, buffer.data)
+}
+
+let addInt16help = (value, buffer) => {
+  autogrow(_16BIT_LEN, buffer)
+  let index = buffer.len
+  buffer.len = buffer.len + _16BIT_LEN
+  Bytes.setInt16(index, value, buffer.data)
+}
+
+let addInt32help = (value, buffer) => {
+  autogrow(_32BIT_LEN, buffer)
+  let index = buffer.len
+  buffer.len = buffer.len + _32BIT_LEN
+  Bytes.setInt32(index, value, buffer.data)
+}
+
 /**
  * @section Values: Functions for working with the Buffer data type.
  */
 
 /**
- * Gets a signed 8-bit integer starting at the given byte index.
+ * Creates a fresh buffer, initially empty.
  *
- * @param index: The byte index to access
- * @param buffer: The buffer to access
- * @returns A 32-bit integer representing a signed 8-bit integer that starts at the given index
+ * The `initialSize` parameter is the initial size of the internal byte sequence that holds the buffer contents.
+ * That byte sequence is automatically reallocated when more than `initialSize` bytes are stored in the buffer, but shrinks back to `initialSize` characters when reset is called.
+ *
+ * @param initialSize: The initial size of the buffer
+ * @returns The new buffer
  *
  * @since v0.4.0
  */
-export let getInt8S = (index, buffer) => {
-  checkIsIndexInBounds(index, _8BIT_LEN, buffer)
-  Bytes.getInt8S(index, buffer.data)
+export let make = initialSize => {
+  if (initialSize < 0) throw Exception.InvalidArgument(
+    "Buffers size must be >= 0",
+  )
+  { len: 0, initialSize, data: Bytes.make(initialSize) }
 }
 
 /**
- * Gets an unsigned 8-bit integer starting at the given byte index.
+ * Gets the number of bytes currently contained in a buffer.
  *
- * @param index: The byte index to access
  * @param buffer: The buffer to access
- * @returns A 32-bit integer representing an unsigned 8-bit integer that starts at the given index
+ * @returns The length of the buffer in bytes
  *
  * @since v0.4.0
  */
-export let getInt8U = (index, buffer) => {
-  checkIsIndexInBounds(index, _8BIT_LEN, buffer)
-  Bytes.getInt8U(index, buffer.data)
-}
+export let length = buffer => buffer.len
 
 /**
- * Sets a signed 8-bit integer starting at the given byte index.
+ * Clears data in the buffer and sets its length to zero.
  *
- * @param index: The byte index to update
- * @param value: The value to set
- * @param buffer: The buffer to mutate
+ * This operation does not resize the underlying byte sequence.
+ *
+ * @param buffer: The buffer to clear
  *
  * @since v0.4.0
  */
-export let setInt8 = (index, value, buffer) => {
-  checkIsIndexInBounds(index, _8BIT_LEN, buffer)
-  Bytes.setInt8(index, value, buffer.data)
+export let clear = buffer => {
+  Bytes.fill(0x0l, buffer.data)
+  buffer.len = 0
 }
 
 /**
- * Appends a signed 8-bit integer to a buffer.
+ * Empty a buffer and deallocate the internal byte sequence holding the buffer contents.
  *
- * @param value: The value to append
- * @param buffer: The buffer to mutate
+ * This operation resizes the underlying byte sequence to the initial size of the buffer.
+ *
+ * @param buffer: The buffer to reset
  *
  * @since v0.4.0
  */
-export let addInt8 = (value, buffer) => {
-  autogrow(_8BIT_LEN, buffer)
-  let index = buffer.len
-  buffer.len = buffer.len + _8BIT_LEN
-  setInt8(index, value, buffer)
+export let reset = buffer => {
+  buffer.data = Bytes.make(buffer.initialSize)
+  buffer.len = 0
 }
 
 /**
- * Gets a signed 16-bit integer starting at the given byte index.
+ * Shortens a buffer to the given length.
  *
- * @param index: The byte index to access
- * @param buffer: The buffer to access
- * @returns A 32-bit integer representing a signed 16-bit integer that starts at the given index
+ * This operation does not resize the underlying byte sequence.
+ *
+ * @param length: The number of bytes to truncate the buffer to
+ * @param buffer: The buffer to truncate
  *
  * @since v0.4.0
  */
-export let getInt16S = (index, buffer) => {
-  checkIsIndexInBounds(index, _16BIT_LEN, buffer)
-  Bytes.getInt16S(index, buffer.data)
+@disableGC
+export let rec truncate = (length, buffer) => {
+  Memory.incRef(WasmI32.fromGrain((<)))
+  Memory.incRef(WasmI32.fromGrain((>)))
+  if (length < 0 || length > buffer.len) throw Exception.IndexOutOfBounds
+
+  let (+) = WasmI32.add
+  let src = WasmI32.fromGrain(buffer.data)
+  let size = getSize(src)
+  let off = coerceNumberToWasmI32(length)
+  let ret = Memory.fill(src + _VALUE_OFFSET + off, 0n, size)
+  buffer.len = length
+
+  Memory.decRef(WasmI32.fromGrain(length))
+  Memory.decRef(WasmI32.fromGrain(buffer))
+  Memory.decRef(WasmI32.fromGrain(truncate))
+  void
 }
 
 /**
- * Gets an unsigned 16-bit integer starting at the given byte index.
+ * Returns a copy of the current contents of the buffer as a byte sequence.
  *
- * @param index: The byte index to access
- * @param buffer: The buffer to access
- * @returns A 32-bit integer representing an unsigned 16-bit integer that starts at the given index
+ * @param buffer: The buffer to copy into a byte sequence
+ * @returns A byte sequence made from copied buffer data
  *
  * @since v0.4.0
  */
-export let getInt16U = (index, buffer) => {
-  checkIsIndexInBounds(index, _16BIT_LEN, buffer)
-  Bytes.getInt16U(index, buffer.data)
+export let toBytes = buffer => {
+  let len = Bytes.length(buffer.data)
+  if (buffer.len == len) {
+    buffer.data
+  } else {
+    Bytes.slice(0, buffer.len, buffer.data)
+  }
 }
 
 /**
- * Sets a signed 16-bit integer starting at the given byte index.
+ * Returns a slice of the current contents of the buffer as a byte sequence.
  *
- * @param index: The byte index to update
- * @param value: The value to set
- * @param buffer: The buffer to mutate
+ * @param start: The start index
+ * @param length: The number of bytes to include after the starting index
+ * @param buffer: The buffer to copy from
+ * @returns A byte sequence with bytes copied from the buffer
  *
  * @since v0.4.0
  */
-export let setInt16 = (index, value, buffer) => {
-  checkIsIndexInBounds(index, _16BIT_LEN, buffer)
-  Bytes.setInt16(index, value, buffer.data)
+export let toBytesSlice = (start, length, buffer) => {
+  checkIsIndexInBounds(start, length, buffer)
+  Bytes.slice(start, length, buffer.data)
 }
 
 /**
- * Appends a signed 16-bit integer to a buffer.
+ * Returns a copy of the current contents of the buffer as a string.
  *
- * @param value: The value to append
- * @param buffer: The buffer to mutate
+ * @param buffer: The buffer to stringify
+ * @returns A string made with data copied from the buffer
  *
  * @since v0.4.0
  */
-export let addInt16 = (value, buffer) => {
-  autogrow(_16BIT_LEN, buffer)
-  let index = buffer.len
-  buffer.len = buffer.len + _16BIT_LEN
-  setInt16(index, value, buffer)
+export let toString = buffer => {
+  Bytes.toString(toBytes(buffer))
 }
 
 /**
- * Gets a signed 32-bit integer starting at the given byte index.
+ * Returns a copy of a subset of the current contents of the buffer as a string.
  *
- * @param index: The byte index to access
- * @param buffer: The buffer to access
- * @returns A signed 32-bit integer that starts at the given index
+ * @param start: The start index
+ * @param length: The number of bytes to include after the starting index
+ * @param buffer: The buffer to copy from
+ * @returns A string made with a subset of data copied from the buffer
  *
  * @since v0.4.0
  */
-export let getInt32 = (index, buffer) => {
-  checkIsIndexInBounds(index, _32BIT_LEN, buffer)
-  Bytes.getInt32(index, buffer.data)
+export let toStringSlice = (start, length, buffer) => {
+  Bytes.toString(toBytesSlice(start, length, buffer))
 }
 
 /**
- * Sets a signed 32-bit integer starting at the given byte index.
+ * Appends the bytes of a char to a buffer.
  *
- * @param index: The byte index to update
- * @param value: The value to set
+ * @param char: The character to append to the buffer
  * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let setInt32 = (index, value, buffer) => {
-  checkIsIndexInBounds(index, _32BIT_LEN, buffer)
-  Bytes.setInt32(index, value, buffer.data)
+@disableGC
+export let rec addChar = (char: Char, buffer: Buffer) => {
+  let n = getCharAsWasmI32(char)
+  let bytelen = getCharByteLength(n)
+  match (bytelen) {
+    1n => {
+      let c = Conv.toInt32(n)
+      Memory.incRef(WasmI32.fromGrain(addInt8help))
+      Memory.incRef(WasmI32.fromGrain(c))
+      Memory.incRef(WasmI32.fromGrain(buffer))
+      addInt8help(c, buffer)
+      Memory.decRef(WasmI32.fromGrain(c))
+      void
+    },
+    2n => {
+      let c = Conv.toInt32(n)
+      Memory.incRef(WasmI32.fromGrain(addInt16help))
+      Memory.incRef(WasmI32.fromGrain(c))
+      Memory.incRef(WasmI32.fromGrain(buffer))
+      addInt16help(c, buffer)
+      Memory.decRef(WasmI32.fromGrain(c))
+      void
+    },
+    3n => {
+      let (<) = WasmI32.ltU
+      let (+) = WasmI32.add
+      let (*) = WasmI32.mul
+      let (&) = WasmI32.and
+      let (>>) = WasmI32.shrU
+      for (let mut i = 0n; i < 3n; i += 1n) {
+        let c = Conv.toInt32(n >> i * 8n & 0xffn)
+        Memory.incRef(WasmI32.fromGrain(addInt8help))
+        Memory.incRef(WasmI32.fromGrain(c))
+        Memory.incRef(WasmI32.fromGrain(buffer))
+        addInt8help(c, buffer)
+        Memory.decRef(WasmI32.fromGrain(c))
+        void
+      }
+    },
+    _ => {
+      let c = Conv.toInt32(n)
+      Memory.incRef(WasmI32.fromGrain(addInt32help))
+      Memory.incRef(WasmI32.fromGrain(c))
+      Memory.incRef(WasmI32.fromGrain(buffer))
+      addInt32help(c, buffer)
+      Memory.decRef(WasmI32.fromGrain(c))
+      void
+    },
+  }
+
+  Memory.decRef(WasmI32.fromGrain(char))
+  Memory.decRef(WasmI32.fromGrain(buffer))
+  Memory.decRef(WasmI32.fromGrain(addChar))
+  void
 }
 
 /**
- * Appends a signed 32-bit integer to a buffer.
+ * Appends a byte sequence to a buffer.
  *
- * @param value: The value to append
+ * @param bytes: The byte sequence to append
  * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let addInt32 = (value, buffer) => {
-  autogrow(_32BIT_LEN, buffer)
-  let index = buffer.len
-  buffer.len = buffer.len + _32BIT_LEN
-  setInt32(index, value, buffer)
-}
+@disableGC
+export let rec addBytes = (bytes, buffer) => {
+  Memory.incRef(WasmI32.fromGrain(Bytes.length))
+  Memory.incRef(WasmI32.fromGrain(bytes))
+  let bytelen = Bytes.length(bytes)
 
-/**
- * Gets a 32-bit float starting at the given byte index.
- *
- * @param index: The byte index to access
- * @param buffer: The buffer to access
- * @returns A 32-bit float that starts at the given index
- *
- * @since v0.4.0
- */
-export let getFloat32 = (index, buffer) => {
-  checkIsIndexInBounds(index, _32BIT_LEN, buffer)
-  Bytes.getFloat32(index, buffer.data)
+  Memory.incRef(WasmI32.fromGrain(autogrow))
+  Memory.incRef(WasmI32.fromGrain(bytelen))
+  Memory.incRef(WasmI32.fromGrain(buffer))
+  autogrow(bytelen, buffer)
+
+  let off = coerceNumberToWasmI32(buffer.len)
+  let len = getSize(WasmI32.fromGrain(bytes))
+  let src = WasmI32.fromGrain(bytes)
+  let dst = WasmI32.fromGrain(buffer.data)
+  appendBytes(0n, off, len, src, dst)
+
+  Memory.incRef(WasmI32.fromGrain((+)))
+  Memory.incRef(WasmI32.fromGrain(buffer.len))
+  Memory.incRef(WasmI32.fromGrain(bytelen))
+  buffer.len = buffer.len + bytelen
+
+  Memory.decRef(WasmI32.fromGrain(bytes))
+  Memory.decRef(WasmI32.fromGrain(buffer))
+  Memory.decRef(WasmI32.fromGrain(addBytes))
+  void
 }
 
 /**
- * Sets a 32-bit float starting at the given byte index.
+ * Appends the bytes of a string to a buffer.
  *
- * @param index: The byte index to update
- * @param value: The value to set
+ * @param string: The string to append
  * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let setFloat32 = (index, value, buffer) => {
-  checkIsIndexInBounds(index, _32BIT_LEN, buffer)
-  Bytes.setFloat32(index, value, buffer.data)
-}
+@disableGC
+export let rec addString = (string, buffer) => {
+  Memory.incRef(WasmI32.fromGrain(String.byteLength))
+  Memory.incRef(WasmI32.fromGrain(string))
+  let bytelen = String.byteLength(string)
 
-/**
- * Appends a 32-bit float to a buffer.
+  Memory.incRef(WasmI32.fromGrain(autogrow))
+  Memory.incRef(WasmI32.fromGrain(bytelen))
+  Memory.incRef(WasmI32.fromGrain(buffer))
+  autogrow(bytelen, buffer)
+
+  let off = coerceNumberToWasmI32(buffer.len)
+  let len = getSize(WasmI32.fromGrain(string))
+  let src = WasmI32.fromGrain(string)
+  let dst = WasmI32.fromGrain(buffer.data)
+  appendBytes(0n, off, len, src, dst)
+
+  Memory.incRef(WasmI32.fromGrain((+)))
+  Memory.incRef(WasmI32.fromGrain(buffer.len))
+  Memory.incRef(WasmI32.fromGrain(bytelen))
+  buffer.len = buffer.len + bytelen
+
+  Memory.decRef(WasmI32.fromGrain(string))
+  Memory.decRef(WasmI32.fromGrain(buffer))
+  Memory.decRef(WasmI32.fromGrain(addString))
+  void
+}
+
+/**
+ * Appends the bytes of a subset of a string to a buffer.
  *
- * @param value: The value to append
+ * @param start: The char offset into the string
+ * @param length: The number of bytes to append
+ * @param string: The string to append
  * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let addFloat32 = (value, buffer) => {
-  autogrow(_32BIT_LEN, buffer)
-  let index = buffer.len
-  buffer.len = buffer.len + _32BIT_LEN
-  setFloat32(index, value, buffer)
+@disableGC
+export let rec addStringSlice = (start: Number, length, string, buffer) => {
+  // Handle negative start index (needed before #1071 is fixed)
+  let start = {
+    // this is a block to avoid making all of these operators
+    // overriden in the whole function
+    let (<<) = WasmI32.shl
+    let (>>) = WasmI32.shrS
+    let (+) = WasmI32.add
+    let (!=) = WasmI32.ne
+    let (&) = WasmI32.and
+    Memory.incRef(WasmI32.fromGrain(String.length))
+    Memory.incRef(WasmI32.fromGrain(string))
+    let strlen = WasmI32.fromGrain(String.length(string)) >> 1n
+    let mut startW = WasmI32.fromGrain(start)
+    if ((startW & 1n) != 1n) {
+      throw InvalidArgument("Invalid start index")
+    }
+    startW = startW >> 1n
+    if (WasmI32.ltS(startW, 0n)) {
+      WasmI32.toGrain(WasmI32.shl(startW + strlen, 1n) + 1n)
+    } else {
+      start
+    }
+  }
+  let end = start + length
+  Memory.incRef(WasmI32.fromGrain(String.slice))
+  // no incref for start since we know it's a simple num. Add back for good measure after #1071 is fixed!
+  Memory.incRef(WasmI32.fromGrain(end))
+  Memory.incRef(WasmI32.fromGrain(string))
+  let slice = String.slice(start, end, string)
+
+  Memory.incRef(WasmI32.fromGrain(String.byteLength))
+  Memory.incRef(WasmI32.fromGrain(slice))
+  let bytelen = String.byteLength(slice)
+
+  Memory.incRef(WasmI32.fromGrain(autogrow))
+  Memory.incRef(WasmI32.fromGrain(bytelen))
+  Memory.incRef(WasmI32.fromGrain(buffer))
+  autogrow(bytelen, buffer)
+
+  let srcOff = 0n
+  let dstOff = coerceNumberToWasmI32(buffer.len)
+  let src = WasmI32.fromGrain(slice)
+  let dst = WasmI32.fromGrain(buffer.data)
+  appendBytes(srcOff, dstOff, coerceNumberToWasmI32(bytelen), src, dst)
+  Memory.decRef(WasmI32.fromGrain(slice))
+
+  Memory.incRef(WasmI32.fromGrain((+)))
+  Memory.incRef(WasmI32.fromGrain(buffer.len))
+  Memory.incRef(WasmI32.fromGrain(bytelen))
+  buffer.len = buffer.len + bytelen
+  Memory.decRef(WasmI32.fromGrain(bytelen))
+
+  Memory.decRef(WasmI32.fromGrain(start))
+  Memory.decRef(WasmI32.fromGrain(length))
+  Memory.decRef(WasmI32.fromGrain(string))
+  Memory.decRef(WasmI32.fromGrain(buffer))
+  Memory.decRef(WasmI32.fromGrain(addStringSlice))
+  void
 }
 
 /**
- * Gets a signed 64-bit integer starting at the given byte index.
+ * Appends the bytes of a subset of a byte seuqnece to a buffer.
  *
- * @param index: The byte index to access
- * @param buffer: The buffer to access
- * @returns A signed 64-bit integer that starts at the given index
+ * @param start: The byte offset into the byte sequence
+ * @param length: The number of bytes to append
+ * @param bytes: The byte sequence to append
+ * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let getInt64 = (index, buffer) => {
-  checkIsIndexInBounds(index, _64BIT_LEN, buffer)
-  Bytes.getInt64(index, buffer.data)
+@disableGC
+export let rec addBytesSlice =
+  (
+    start: Number,
+    length: Number,
+    bytes: Bytes,
+    buffer: Buffer,
+  ) => {
+  let (-) = WasmI32.sub
+  let (<) = WasmI32.ltS
+  let (>) = WasmI32.gtS
+  let (>=) = WasmI32.geS
+
+  // bounds check start
+  let bytelen = WasmI32.load(WasmI32.fromGrain(bytes), 4n)
+  let srcOff = coerceNumberToWasmI32(start)
+  if (srcOff < 0n || srcOff >= bytelen) {
+    throw Exception.IndexOutOfBounds
+  }
+
+  // bounds check length
+  let len = coerceNumberToWasmI32(length)
+  if (len < 0n || len > bytelen - srcOff) {
+    throw Exception.IndexOutOfBounds
+  }
+
+  Memory.incRef(WasmI32.fromGrain(autogrow))
+  Memory.incRef(WasmI32.fromGrain(length))
+  Memory.incRef(WasmI32.fromGrain(buffer))
+  autogrow(length, buffer)
+
+  let dstOff = coerceNumberToWasmI32(buffer.len)
+  let src = WasmI32.fromGrain(bytes)
+  let dst = WasmI32.fromGrain(buffer.data)
+  appendBytes(srcOff, dstOff, len, src, dst)
+
+  Memory.incRef(WasmI32.fromGrain((+)))
+  Memory.incRef(WasmI32.fromGrain(buffer.len))
+  Memory.incRef(WasmI32.fromGrain(length))
+  buffer.len = buffer.len + length
+
+  Memory.decRef(WasmI32.fromGrain(start))
+  Memory.decRef(WasmI32.fromGrain(length))
+  Memory.decRef(WasmI32.fromGrain(bytes))
+  Memory.decRef(WasmI32.fromGrain(buffer))
+  Memory.decRef(WasmI32.fromGrain(addBytesSlice))
+  void
 }
 
 /**
- * Sets a signed 64-bit integer starting at the given byte index.
+ * Appends the bytes of a source buffer to destination buffer.
  *
- * @param index: The byte index to update
- * @param value: The value to set
- * @param buffer: The buffer to mutate
+ * The source buffer is not mutated by this operation. The destination buffer, however, is mutated.
+ *
+ * @param srcBuffer: The buffer to append
+ * @param dstBuffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let setInt64 = (index, value, buffer) => {
-  checkIsIndexInBounds(index, _64BIT_LEN, buffer)
-  Bytes.setInt64(index, value, buffer.data)
+export let addBuffer = (srcBuffer, dstBuffer) => {
+  addBytesSlice(0, srcBuffer.len, srcBuffer.data, dstBuffer)
 }
 
 /**
- * Appends a signed 64-bit integer to a buffer.
+ * Appends the bytes of a part of a buffer to the end of the buffer
  *
- * @param value: The value to set
- * @param buffer: The buffer to mutate
+ * The source buffer is not mutated by this operation. The destination buffer, however, is mutated.
+ *
+ * @param start: The byte offset into the buffer
+ * @param length: The number of bytes to append
+ * @param srcBuffer: The buffer to append
+ * @param dstBuffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let addInt64 = (value, buffer) => {
-  autogrow(_64BIT_LEN, buffer)
-  let index = buffer.len
-  buffer.len = buffer.len + _64BIT_LEN
-  setInt64(index, value, buffer)
+export let addBufferSlice = (start, length, srcBuffer, dstBuffer) => {
+  addBytesSlice(start, length, srcBuffer.data, dstBuffer)
 }
 
 /**
- * Gets a 64-bit float starting at the given byte index.
+ * @section Binary operations on integers: Functions for encoding and decoding integers stored in a buffer.
+ */
+
+/**
+ * Gets a signed 8-bit integer starting at the given byte index.
  *
  * @param index: The byte index to access
  * @param buffer: The buffer to access
- * @returns A 64-bit float that starts at the given index
+ * @returns A 32-bit integer representing a signed 8-bit integer that starts at the given index
  *
  * @since v0.4.0
  */
-export let getFloat64 = (index, buffer) => {
-  checkIsIndexInBounds(index, _64BIT_LEN, buffer)
-  Bytes.getFloat64(index, buffer.data)
+export let getInt8S = (index, buffer) => {
+  checkIsIndexInBounds(index, _8BIT_LEN, buffer)
+  Bytes.getInt8S(index, buffer.data)
 }
 
 /**
- * Sets a 64-bit float starting at the given byte index.
+ * Gets an unsigned 8-bit integer starting at the given byte index.
+ *
+ * @param index: The byte index to access
+ * @param buffer: The buffer to access
+ * @returns A 32-bit integer representing an unsigned 8-bit integer that starts at the given index
+ *
+ * @since v0.4.0
+ */
+export let getInt8U = (index, buffer) => {
+  checkIsIndexInBounds(index, _8BIT_LEN, buffer)
+  Bytes.getInt8U(index, buffer.data)
+}
+
+/**
+ * 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
@@ -366,404 +599,242 @@ export let getFloat64 = (index, buffer) => {
  *
  * @since v0.4.0
  */
-export let setFloat64 = (index, value, buffer) => {
-  checkIsIndexInBounds(index, _64BIT_LEN, buffer)
-  Bytes.setFloat64(index, value, buffer.data)
+export let setInt8 = (index, value, buffer) => {
+  checkIsIndexInBounds(index, _8BIT_LEN, buffer)
+  Bytes.setInt8(index, value, buffer.data)
 }
 
 /**
- * Appends a 64-bit float to a buffer.
+ * Appends a signed 8-bit integer to a buffer.
  *
  * @param value: The value to append
  * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let addFloat64 = (value, buffer) => {
-  autogrow(_64BIT_LEN, buffer)
-  let index = buffer.len
-  buffer.len = buffer.len + _64BIT_LEN
-  setFloat64(index, value, buffer)
+export let addInt8 = (value, buffer) => {
+  addInt8help(value, buffer)
 }
 
 /**
- * Creates a fresh buffer, initially empty.
- *
- * The `initialSize` parameter is the initial size of the internal byte sequence that holds the buffer contents.
- * That byte sequence is automatically reallocated when more than `initialSize` bytes are stored in the buffer, but shrinks back to `initialSize` characters when reset is called.
+ * Gets a signed 16-bit integer starting at the given byte index.
  *
- * @param initialSize: The initial size of the buffer
- * @returns The new buffer
+ * @param index: The byte index to access
+ * @param buffer: The buffer to access
+ * @returns A 32-bit integer representing a signed 16-bit integer that starts at the given index
  *
  * @since v0.4.0
  */
-export let make = (initialSize) => {
-  if (initialSize < 0) throw Exception.InvalidArgument("Buffers size must be >= 0")
-  {
-    len: 0,
-    initialSize,
-    data: Bytes.make(initialSize),
-  }
+export let getInt16S = (index, buffer) => {
+  checkIsIndexInBounds(index, _16BIT_LEN, buffer)
+  Bytes.getInt16S(index, buffer.data)
 }
 
 /**
- * Gets the number of bytes currently contained in a buffer.
+ * Gets an unsigned 16-bit integer starting at the given byte index.
  *
+ * @param index: The byte index to access
  * @param buffer: The buffer to access
- * @returns The length of the buffer in bytes
+ * @returns A 32-bit integer representing an unsigned 16-bit integer that starts at the given index
  *
  * @since v0.4.0
  */
-export let length = (buffer) => buffer.len
+export let getInt16U = (index, buffer) => {
+  checkIsIndexInBounds(index, _16BIT_LEN, buffer)
+  Bytes.getInt16U(index, buffer.data)
+}
 
 /**
- * Clears data in the buffer and sets its length to zero.
- *
- * This operation does not resize the underlying byte sequence.
+ * Sets a signed 16-bit integer starting at the given byte index.
  *
- * @param buffer: The buffer to clear
+ * @param index: The byte index to update
+ * @param value: The value to set
+ * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let clear = (buffer) => {
-  Bytes.fill(0x0l, buffer.data)
-  buffer.len = 0
+export let setInt16 = (index, value, buffer) => {
+  checkIsIndexInBounds(index, _16BIT_LEN, buffer)
+  Bytes.setInt16(index, value, buffer.data)
 }
 
 /**
- * Empty a buffer and deallocate the internal byte sequence holding the buffer contents.
- *
- * This operation resizes the underlying byte sequence to the initial size of the buffer.
+ * Appends a signed 16-bit integer to a buffer.
  *
- * @param buffer: The buffer to reset
+ * @param value: The value to append
+ * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let reset = (buffer) => {
-  buffer.data = Bytes.make(buffer.initialSize)
-  buffer.len = 0
+export let addInt16 = (value, buffer) => {
+  addInt16help(value, buffer)
 }
 
 /**
- * Shortens a buffer to the given length.
- *
- * This operation does not resize the underlying byte sequence.
+ * Gets a signed 32-bit integer starting at the given byte index.
  *
- * @param length: The number of bytes to truncate the buffer to
- * @param buffer: The buffer to truncate
+ * @param index: The byte index to access
+ * @param buffer: The buffer to access
+ * @returns A signed 32-bit integer that starts at the given index
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec truncate = (length, buffer) => {
-  Memory.incRef(WasmI32.fromGrain((<)))
-  Memory.incRef(WasmI32.fromGrain((||)))
-  Memory.incRef(WasmI32.fromGrain((>)))
-  if (length < 0 || length > buffer.len) throw Exception.IndexOutOfBounds
-
-  let (+) = WasmI32.add
-  let src = WasmI32.fromGrain(buffer.data)
-  let size = getSize(src)
-  let off = coerceNumberToWasmI32(length)
-  let ret = Memory.fill(src + _VALUE_OFFSET + off, 0n, size)
-  buffer.len = length
-
-  Memory.decRef(WasmI32.fromGrain(length))
-  Memory.decRef(WasmI32.fromGrain(buffer))
-  Memory.decRef(WasmI32.fromGrain(truncate))
-  void
+export let getInt32 = (index, buffer) => {
+  checkIsIndexInBounds(index, _32BIT_LEN, buffer)
+  Bytes.getInt32(index, buffer.data)
 }
 
 /**
- * Returns a copy of the current contents of the buffer as a byte sequence.
+ * Sets a signed 32-bit integer starting at the given byte index.
  *
- * @param buffer: The buffer to copy into a byte sequence
- * @returns A byte sequence made from copied buffer data
+ * @param index: The byte index to update
+ * @param value: The value to set
+ * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let toBytes = (buffer) => {
-  let len = Bytes.length(buffer.data)
-  if (buffer.len == len) {
-    buffer.data
-  } else {
-    Bytes.slice(0, buffer.len, buffer.data)
-  }
+export let setInt32 = (index, value, buffer) => {
+  checkIsIndexInBounds(index, _32BIT_LEN, buffer)
+  Bytes.setInt32(index, value, buffer.data)
 }
 
 /**
- * Returns a slice of the current contents of the buffer as a byte sequence.
+ * Appends a signed 32-bit integer to a buffer.
  *
- * @param start: The start index
- * @param length: The number of bytes to include after the starting index
- * @param buffer: The buffer to copy from
- * @returns A byte sequence with bytes copied from the buffer
+ * @param value: The value to append
+ * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let toBytesSlice = (start, length, buffer) => {
-  checkIsIndexInBounds(start, length, buffer)
-  Bytes.slice(start, length, buffer.data)
+export let addInt32 = (value, buffer) => {
+  addInt32help(value, buffer)
 }
 
 /**
- * Returns a copy of the current contents of the buffer as a string.
+ * Gets a 32-bit float starting at the given byte index.
  *
- * @param buffer: The buffer to stringify
- * @returns A string made with data copied from the buffer
+ * @param index: The byte index to access
+ * @param buffer: The buffer to access
+ * @returns A 32-bit float that starts at the given index
  *
  * @since v0.4.0
  */
-export let toString = (buffer) => {
-  Bytes.toString(toBytes(buffer))
+export let getFloat32 = (index, buffer) => {
+  checkIsIndexInBounds(index, _32BIT_LEN, buffer)
+  Bytes.getFloat32(index, buffer.data)
 }
 
 /**
- * Returns a copy of a subset of the current contents of the buffer as a string.
+ * Sets a 32-bit float starting at the given byte index.
  *
- * @param start: The start index
- * @param length: The number of bytes to include after the starting index
- * @param buffer: The buffer to copy from
- * @returns A string made with a subset of data copied from the buffer
+ * @param index: The byte index to update
+ * @param value: The value to set
+ * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let toStringSlice = (start, length, buffer) => {
-  Bytes.toString(toBytesSlice(start, length, buffer))
+export let setFloat32 = (index, value, buffer) => {
+  checkIsIndexInBounds(index, _32BIT_LEN, buffer)
+  Bytes.setFloat32(index, value, buffer.data)
 }
 
 /**
- * Appends the bytes of a char to a buffer.
+ * Appends a 32-bit float to a buffer.
  *
- * @param char: The character to append to the buffer
+ * @param value: The value to append
  * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec addChar = (char, buffer) => {
-  let n = getCharAsWasmI32(char)
-  let bytelen = getCharByteLength(n)
-  match (bytelen) {
-    1n => {
-      let c = Conv.toInt32(n)
-      Memory.incRef(WasmI32.fromGrain(addInt8))
-      Memory.incRef(WasmI32.fromGrain(c))
-      Memory.incRef(WasmI32.fromGrain(buffer))
-      addInt8(c, buffer)
-    },
-    2n => {
-      let c = Conv.toInt32(n)
-      Memory.incRef(WasmI32.fromGrain(addInt16))
-      Memory.incRef(WasmI32.fromGrain(c))
-      Memory.incRef(WasmI32.fromGrain(buffer))
-      addInt16(c, buffer)
-    },
-    3n => {
-      let (<) = WasmI32.ltU
-      let (+) = WasmI32.add
-      let (*) = WasmI32.mul
-      let (&) = WasmI32.and
-      let (>>) = WasmI32.shrU
-      for (let mut i = 0n; i < 3n; i = i + 1n) {
-        let c = Conv.toInt32(n >> (i * 8n) & 0xffn)
-        Memory.incRef(WasmI32.fromGrain(addInt8))
-        Memory.incRef(WasmI32.fromGrain(c))
-        Memory.incRef(WasmI32.fromGrain(buffer))
-        addInt8(c, buffer)
-      }
-    },
-    _ => {
-      let c = Conv.toInt32(n)
-      Memory.incRef(WasmI32.fromGrain(addInt32))
-      Memory.incRef(WasmI32.fromGrain(c))
-      Memory.incRef(WasmI32.fromGrain(buffer))
-      addInt32(c, buffer)
-    },
-  }
-
-  Memory.decRef(WasmI32.fromGrain(char))
-  Memory.decRef(WasmI32.fromGrain(buffer))
-  Memory.decRef(WasmI32.fromGrain(addChar))
-  void
+export let addFloat32 = (value, buffer) => {
+  autogrow(_32BIT_LEN, buffer)
+  let index = buffer.len
+  buffer.len = buffer.len + _32BIT_LEN
+  setFloat32(index, value, buffer)
 }
 
 /**
- * Appends a byte sequence to a buffer.
+ * Gets a signed 64-bit integer starting at the given byte index.
  *
- * @param bytes: The byte sequence to append
- * @param buffer: The buffer to mutate
+ * @param index: The byte index to access
+ * @param buffer: The buffer to access
+ * @returns A signed 64-bit integer that starts at the given index
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec addBytes = (bytes, buffer) => {
-  Memory.incRef(WasmI32.fromGrain(Bytes.length))
-  Memory.incRef(WasmI32.fromGrain(bytes))
-  let bytelen = Bytes.length(bytes)
-
-  Memory.incRef(WasmI32.fromGrain(autogrow))
-  Memory.incRef(WasmI32.fromGrain(bytelen))
-  Memory.incRef(WasmI32.fromGrain(buffer))
-  autogrow(bytelen, buffer)
-
-  let off = coerceNumberToWasmI32(buffer.len)
-  let len = getSize(WasmI32.fromGrain(bytes))
-  let src = WasmI32.fromGrain(bytes)
-  let dst = WasmI32.fromGrain(buffer.data)
-  appendBytes(0n, off, len, src, dst)
-
-  Memory.incRef(WasmI32.fromGrain((+)))
-  Memory.incRef(WasmI32.fromGrain(buffer.len))
-  Memory.incRef(WasmI32.fromGrain(bytelen))
-  buffer.len = buffer.len + bytelen
-
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(buffer))
-  Memory.decRef(WasmI32.fromGrain(addBytes))
-  void
+export let getInt64 = (index, buffer) => {
+  checkIsIndexInBounds(index, _64BIT_LEN, buffer)
+  Bytes.getInt64(index, buffer.data)
 }
 
 /**
- * Appends the bytes of a string to a buffer.
+ * Sets a signed 64-bit integer starting at the given byte index.
  *
- * @param string: The string to append
+ * @param index: The byte index to update
+ * @param value: The value to set
  * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec addString = (string, buffer) => {
-  Memory.incRef(WasmI32.fromGrain(String.byteLength))
-  Memory.incRef(WasmI32.fromGrain(string))
-  let bytelen = String.byteLength(string)
-
-  Memory.incRef(WasmI32.fromGrain(autogrow))
-  Memory.incRef(WasmI32.fromGrain(bytelen))
-  Memory.incRef(WasmI32.fromGrain(buffer))
-  autogrow(bytelen, buffer)
-
-  let off = coerceNumberToWasmI32(buffer.len)
-  let len = getSize(WasmI32.fromGrain(string))
-  let src = WasmI32.fromGrain(string)
-  let dst = WasmI32.fromGrain(buffer.data)
-  appendBytes(0n, off, len, src, dst)
-
-  Memory.incRef(WasmI32.fromGrain((+)))
-  Memory.incRef(WasmI32.fromGrain(buffer.len))
-  Memory.incRef(WasmI32.fromGrain(bytelen))
-  buffer.len = buffer.len + bytelen
-
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(buffer))
-  Memory.decRef(WasmI32.fromGrain(addString))
-  void
+export let setInt64 = (index, value, buffer) => {
+  checkIsIndexInBounds(index, _64BIT_LEN, buffer)
+  Bytes.setInt64(index, value, buffer.data)
 }
 
 /**
- * Appends the bytes of a subset of a string to a buffer.
+ * Appends a signed 64-bit integer to a buffer.
  *
- * @param start: The char offset into the string
- * @param length: The number of bytes to append
- * @param string: The string to append
+ * @param value: The value to set
  * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec addStringSlice = (start, length, string, buffer) => {
-  Memory.incRef(WasmI32.fromGrain(String.byteLength))
-  Memory.incRef(WasmI32.fromGrain(start))
-  Memory.incRef(WasmI32.fromGrain(length))
-  Memory.incRef(WasmI32.fromGrain(string))
-  let bytelen = String.byteLength(String.slice(start, length, string))
-
-  Memory.incRef(WasmI32.fromGrain(autogrow))
-  Memory.incRef(WasmI32.fromGrain(bytelen))
-  Memory.incRef(WasmI32.fromGrain(buffer))
-  autogrow(bytelen, buffer)
-
-  let srcOff = coerceNumberToWasmI32(start)
-  let dstOff = coerceNumberToWasmI32(buffer.len)
-  let src = WasmI32.fromGrain(string)
-  let dst = WasmI32.fromGrain(buffer.data)
-  appendBytes(srcOff, dstOff, coerceNumberToWasmI32(bytelen), src, dst)
-
-  Memory.incRef(WasmI32.fromGrain((+)))
-  Memory.incRef(WasmI32.fromGrain(buffer.len))
-  Memory.incRef(WasmI32.fromGrain(bytelen))
-  buffer.len = buffer.len + bytelen
-
-  Memory.decRef(WasmI32.fromGrain(start))
-  Memory.decRef(WasmI32.fromGrain(length))
-  Memory.decRef(WasmI32.fromGrain(string))
-  Memory.decRef(WasmI32.fromGrain(buffer))
-  Memory.decRef(WasmI32.fromGrain(addStringSlice))
-  void
+export let addInt64 = (value, buffer) => {
+  autogrow(_64BIT_LEN, buffer)
+  let index = buffer.len
+  buffer.len = buffer.len + _64BIT_LEN
+  setInt64(index, value, buffer)
 }
 
 /**
- * Appends the bytes of a subset of a byte seuqnece to a buffer.
+ * Gets a 64-bit float starting at the given byte index.
  *
- * @param start: The byte offset into the byte sequence
- * @param length: The number of bytes to append
- * @param bytes: The byte sequence to append
- * @param buffer: The buffer to mutate
+ * @param index: The byte index to access
+ * @param buffer: The buffer to access
+ * @returns A 64-bit float that starts at the given index
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec addBytesSlice = (start, length, bytes, buffer) => {
-  Memory.incRef(WasmI32.fromGrain(autogrow))
-  Memory.incRef(WasmI32.fromGrain(length))
-  Memory.incRef(WasmI32.fromGrain(buffer))
-  autogrow(length, buffer)
-
-  let srcOff = coerceNumberToWasmI32(start)
-  let dstOff = coerceNumberToWasmI32(buffer.len)
-  let src = WasmI32.fromGrain(bytes)
-  let dst = WasmI32.fromGrain(buffer.data)
-  appendBytes(srcOff, dstOff, coerceNumberToWasmI32(length), src, dst)
-
-  Memory.incRef(WasmI32.fromGrain((+)))
-  Memory.incRef(WasmI32.fromGrain(buffer.len))
-  Memory.incRef(WasmI32.fromGrain(length))
-  buffer.len = buffer.len + length
-
-  Memory.decRef(WasmI32.fromGrain(start))
-  Memory.decRef(WasmI32.fromGrain(length))
-  Memory.decRef(WasmI32.fromGrain(bytes))
-  Memory.decRef(WasmI32.fromGrain(buffer))
-  Memory.decRef(WasmI32.fromGrain(addBytesSlice))
-  void
+export let getFloat64 = (index, buffer) => {
+  checkIsIndexInBounds(index, _64BIT_LEN, buffer)
+  Bytes.getFloat64(index, buffer.data)
 }
 
 /**
- * Appends the bytes of a source buffer to destination buffer.
- *
- * The source buffer is not mutated by this operation. The destination buffer, however, is mutated.
+ * Sets a 64-bit float starting at the given byte index.
  *
- * @param srcBuffer: The buffer to append
- * @param dstBuffer: The buffer to mutate
+ * @param index: The byte index to update
+ * @param value: The value to set
+ * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let addBuffer = (srcBuffer, dstBuffer) => {
-  addBytesSlice(0, srcBuffer.len, srcBuffer.data, dstBuffer)
+export let setFloat64 = (index, value, buffer) => {
+  checkIsIndexInBounds(index, _64BIT_LEN, buffer)
+  Bytes.setFloat64(index, value, buffer.data)
 }
 
 /**
- * Appends the bytes of a part of a buffer to the end of the buffer
- *
- * The source buffer is not mutated by this operation. The destination buffer, however, is mutated.
+ * Appends a 64-bit float to a buffer.
  *
- * @param start: The byte offset into the buffer
- * @param length: The number of bytes to append
- * @param srcBuffer: The buffer to append
- * @param dstBuffer: The buffer to mutate
+ * @param value: The value to append
+ * @param buffer: The buffer to mutate
  *
  * @since v0.4.0
  */
-export let addBufferSlice = (start, length, srcBuffer, dstBuffer) => {
-  addBytesSlice(start, length, srcBuffer.data, dstBuffer)
+export let addFloat64 = (value, buffer) => {
+  autogrow(_64BIT_LEN, buffer)
+  let index = buffer.len
+  buffer.len = buffer.len + _64BIT_LEN
+  setFloat64(index, value, buffer)
 }