@grain/stdlib 0.4.3 → 0.4.4

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+### [0.4.4](https://www.github.com/grain-lang/grain/compare/stdlib-v0.4.3...stdlib-v0.4.4) (2021-12-11)
+
+
+### Features
+
+* **stdlib:** Add reverse function to String module ([#1027](https://www.github.com/grain-lang/grain/issues/1027)) ([df761db](https://www.github.com/grain-lang/grain/commit/df761db55b3e14e31190090ae008ce5047135c09))
+* **stdlib:** Add rotate function in Array module ([#838](https://www.github.com/grain-lang/grain/issues/838)) ([98fc577](https://www.github.com/grain-lang/grain/commit/98fc577ee754317cd2421bfaa8e3c1e049488949))
+* **stdlib:** Add sort function to Array module ([#1012](https://www.github.com/grain-lang/grain/issues/1012)) ([9091930](https://www.github.com/grain-lang/grain/commit/9091930344224925bb7b2e1ef6f879c79a5c2f62))
+* **stdlib:** Implement List.sort via mergesort ([#1014](https://www.github.com/grain-lang/grain/issues/1014)) ([a076e20](https://www.github.com/grain-lang/grain/commit/a076e200013114ccf16c2e6cbe814af1ec09c1ce))
+* **stdlib:** Number.parseInt ([#1051](https://www.github.com/grain-lang/grain/issues/1051)) ([abafb58](https://www.github.com/grain-lang/grain/commit/abafb587e54219a32ed77ba09863bb2d6a80bac8))
+
+
+### Bug Fixes
+
+* **graindoc:** Ensure value_description is resolved to outcome before printing ([#1070](https://www.github.com/grain-lang/grain/issues/1070)) ([5eb05cc](https://www.github.com/grain-lang/grain/commit/5eb05cc2dedc3b933e194be86dd5d3c3656d6490))
+* **stdlib:** Add bounds checking to Buffer addStringSlice & addBytesSlice ([#1065](https://www.github.com/grain-lang/grain/issues/1065)) ([06fe512](https://www.github.com/grain-lang/grain/commit/06fe512e863aeeb855ccf3e3b83bcd3bc8854723))
+* **stdlib:** Fix String.encode GC ([#1067](https://www.github.com/grain-lang/grain/issues/1067)) ([0ab38c9](https://www.github.com/grain-lang/grain/commit/0ab38c9f4aa0ee84688ba5c6bec1521b380d38b1))
+* **stdlib:** Removed memory leak in Hash module ([#1045](https://www.github.com/grain-lang/grain/issues/1045)) ([01a81c6](https://www.github.com/grain-lang/grain/commit/01a81c6a2573cca94b2d57d0fc70693d39f810a1))
+* **stdlib:** Removed memory leaks in Buffer module ([#1047](https://www.github.com/grain-lang/grain/issues/1047)) ([d33017b](https://www.github.com/grain-lang/grain/commit/d33017b37e988d3facbca2e30e3de4fb8c7b5b8a))
+* **stdlib:** Support arrays of any type in Array rotate ([#1048](https://www.github.com/grain-lang/grain/issues/1048)) ([3ceb1cf](https://www.github.com/grain-lang/grain/commit/3ceb1cf04c1604f49077e8733dcccb6cdaaf9f3a))
+* **stdlib:** Support empty arrays in Array rotate ([3ceb1cf](https://www.github.com/grain-lang/grain/commit/3ceb1cf04c1604f49077e8733dcccb6cdaaf9f3a))
+
 ### [0.4.3](https://www.github.com/grain-lang/grain/compare/stdlib-v0.4.2...stdlib-v0.4.3) (2021-10-27)
 
 

package/array.gr

@@ -243,15 +243,10 @@ export let copy = (array) => {
  */
 export let cycle = (fn, n, array) => {
   let length = length(array)
-  let mut iteration = 0
-  let mut count = 0
-  while (iteration < n) {
-    while (count < length) {
-      fn(array[count]): Void
-      count = incr(count)
+  for (let mut iteration = 0; iteration < n; iteration += 1) {
+    for (let mut count = 0; count < length; count += 1) {
+      fn(array[count]): (Void)
     }
-    iteration = incr(iteration)
-    count = 0
   }
 }
 
@@ -266,10 +261,8 @@ export let cycle = (fn, n, array) => {
  */
 export let forEach = (fn, array) => {
   let length = length(array)
-  let mut count = 0
-  while (count < length) {
-    fn(array[count]): Void
-    count = incr(count)
+  for (let mut count = 0; count < length; count += 1) {
+    fn(array[count]): (Void)
   }
 }
 
@@ -285,10 +278,8 @@ export let forEach = (fn, array) => {
  */
 export let forEachi = (fn, array) => {
   let length = length(array)
-  let mut count = 0
-  while (count < length) {
+  for (let mut count = 0; count < length; count += 1) {
     fn(array[count], count): (Void)
-    count = incr(count)
   }
 }
 
@@ -458,9 +449,12 @@ export let fillRange = (value, start, stop, array) => {
   }
 
   let mut index = startIndex
-  while (index < stopIndex && index < length) {
-    array[index] = value
+  for (
+    let mut index = startIndex;
+    index < stopIndex && index < length;
     index += 1
+  ) {
+    array[index] = value
   }
   void
 }
@@ -543,11 +537,9 @@ export let fromList = (list) => {
 export let contains = (search, array) => {
   // TODO: This should use recursion when we can pattern match arrays
   let len = length(array)
-  let mut index = 0
   let mut found = false
-  while ((!found) && (index < len)) {
-    found = (array[index] == search)
-    index += 1
+  for (let mut index = 0; !found && index < len; index += 1) {
+    found = array[index] == search
   }
   found
 }
@@ -575,7 +567,7 @@ export let find = (fn, array) => {
         matchedItem = array[count]
         count = length
       } else {
-        count = incr(count)
+        count += 1
       }
     }
     if(!matching) {
@@ -609,7 +601,7 @@ export let findIndex = (fn, array) => {
         matchedIndex = count
         count = length
       } else {
-        count = incr(count)
+        count += 1
       }
     }
     if(!matching) {
@@ -637,7 +629,7 @@ export let product = (array1: Array<a>, array2: Array<b>) => {
 
   init(lenA * lenB, n => {
     if(n % lenB == 0){
-      indexA = incr(indexA)
+      indexA += 1
     } else {
       indexA = indexA
     }
@@ -658,12 +650,9 @@ export let count = (fn, array) => {
   let length = length(array)
   let mut position = 0
   let mut count = 0
-  while (position < length) {
+  for (let mut position = 0; position < length; position += 1) {
     if(fn(array[position])) {
-      count = incr(count)
-      position = incr(position)
-    } else {
-      position = incr(position)
+      count += 1
     }
   }
   count
@@ -681,14 +670,10 @@ export let count = (fn, array) => {
  */
 export let counti = (fn, array) => {
   let length = length(array)
-  let mut position = 0
   let mut count = 0
-  while (position < length) {
-    if(fn(array[position], position)) {
-      count = incr(count)
-      position = incr(position)
-    } else {
-      position = incr(position)
+  for (let mut position = 0; position < length; position += 1) {
+    if (fn(array[position], position)) {
+      count += 1
     }
   }
   count
@@ -711,7 +696,7 @@ export let filter = (fn, array) => {
   forEach((el) => {
     if (fn(el)) {
       filtered[position] = el
-      position = incr(position)
+      position += 1
     }
   }, array)
   init(position, (index) => {
@@ -736,7 +721,7 @@ export let filteri = (fn, array) => {
   forEachi((el, index) => {
     if (fn(el, index)) {
       filtered[position] = el
-      position = incr(position)
+      position += 1
     }
   }, array)
   init(position, (index) => {
@@ -828,6 +813,18 @@ export let join = (separator: String, items: Array<String>) => {
   }
 }
 
+/**
+ * A simple helper function to convert a negative array index
+ * number to its positive positional equivalent.
+ */
+let wrapNegativeIndex = (arrLen, idx) => {
+  if (idx >= 0) {
+    idx
+  } else {
+    arrLen + idx
+  }
+}
+
 /**
  * Slices an array given zero-based start and end indexes. The value
  * at the end index will not be included in the result.
@@ -844,17 +841,8 @@ export let join = (separator: String, items: Array<String>) => {
  */
 export let slice = (startIndex, endIndex, array) => {
   let arrayLength = length(array)
-
-  let wrapNegativeIndex = idx => {
-    if (idx >= 0) {
-      idx
-    } else {
-      arrayLength + idx
-    }
-  }
-
-  let startIndex = wrapNegativeIndex(startIndex)
-  let endIndex = wrapNegativeIndex(endIndex)
+  let startIndex = wrapNegativeIndex(arrayLength, startIndex)
+  let endIndex = wrapNegativeIndex(arrayLength, endIndex)
   // Ensure we aren't working with an `end` value that is too big
   let endIndex = if (endIndex > arrayLength) {
     arrayLength
@@ -871,3 +859,84 @@ export let slice = (startIndex, endIndex, array) => {
     init(newLength, n => array[startIndex + n])
   }
 }
+
+/**
+ * Sorts an array in-place.
+ *
+ * Ordering is calculated using a comparator function which takes two array elements and must return 0 if both are equal, a positive number if the first is greater, and a negative number if the first is smaller.
+ * @param comp: The comparator function used to indicate sort order
+ * @param array: The array to be sorted
+ * @since v0.4.5
+ */
+export let sort = (comp, array) => {
+  let partition = (low, high) => {
+    let pivot = array[high]
+    let mut i = low - 1
+    for(let mut j = low; j < high; j += 1) {
+      if(comp(array[j], pivot) < 0){
+        i += 1
+        let temp = array[i]
+        array[i] = array[j]
+        array[j] = temp
+      }
+    }
+    let temp = array[i + 1]
+    array[i + 1] = array[high]
+    array[high] = temp
+    i + 1
+  }
+  let rec quicksort = (low, high) => {
+    if(low < high){
+      let partitionIndex = partition(low, high)
+      quicksort(partitionIndex + 1, high)
+      quicksort(low, partitionIndex - 1)
+    }
+  }
+  let len = length(array)
+  quicksort(0, len - 1)
+}
+
+/**
+ * Rotates an array by n elements to the right, in place.
+ *
+ * If n is negative, the array will be rotated by n elements
+ * to the left. See examples.
+ *
+ * @param n: The number of elements to rotate by
+ * @param arr: The array to be rotated
+ *
+ * @example let array = [> 1, 2, 3, 4, 5]; rotate(2, arr); arr == [> 4, 5, 1, 2, 3]
+ * @example let array = [> 1, 2, 3, 4, 5]; rotate(-1, arr); arr == [> 2, 3, 4, 5, 1]
+ * @since v0.4.5
+ */
+export let rotate = (n, arr) => {
+  let rec gcd = (a, b) => {
+    if (b == 0) {
+      a
+    }
+    else{
+      gcd(b, a % b)
+    }
+  }
+
+  let arrLen = length(arr)
+  if (arrLen > 0) {
+    let k = n % arrLen
+    let mut d = -1
+    let mut j  = 0
+    for (let mut i = 0; i < gcd(arrLen, k); i += 1) {
+      j = i
+      let temp = arr[i]
+      while (true) {
+        d = (j - k) % arrLen
+        if (d == i) {
+          break
+        }
+        let newVal = arr[d]
+        arr[j] = newVal
+        j = d
+      }
+      arr[j] = temp
+    }
+  }
+}

package/array.md

@@ -371,7 +371,7 @@ Returns:
 
 |type|description|
 |----|-----------|
-|`Array<a>`|The new array with mapped values|
+|`Array<b>`|The new array with mapped values|
 
 ### Array.**mapi**
 
@@ -398,7 +398,7 @@ Returns:
 
 |type|description|
 |----|-----------|
-|`Array<a>`|The new array with mapped values|
+|`Array<b>`|The new array with mapped values|
 
 ### Array.**reduce**
 
@@ -425,7 +425,7 @@ Parameters:
 |-----|----|-----------|
 |`fn`|`(a, b) -> a`|The reducer function to call on each element, where the value returned will be the next accumulator value|
 |`initial`|`a`|The initial value to use for the accumulator on the first iteration|
-|`array`|`Array<a>`|The array to iterate|
+|`array`|`Array<b>`|The array to iterate|
 
 Returns:
 
@@ -465,7 +465,7 @@ Parameters:
 |-----|----|-----------|
 |`fn`|`(a, b, Number) -> a`|The reducer function to call on each element, where the value returned will be the next accumulator value|
 |`initial`|`a`|The initial value to use for the accumulator on the first iteration|
-|`array`|`Array<a>`|The array to iterate|
+|`array`|`Array<b>`|The array to iterate|
 
 Returns:
 
@@ -500,7 +500,7 @@ Returns:
 
 |type|description|
 |----|-----------|
-|`Array<a>`|The new array|
+|`Array<b>`|The new array|
 
 ### Array.**every**
 
@@ -1027,3 +1027,58 @@ Returns:
 |----|-----------|
 |`Array<a>`|The subset of the array that was sliced|
 
+### Array.**sort**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+sort : (((a, a) -> Number), Array<a>) -> Void
+```
+
+Sorts an array in-place.
+
+Ordering is calculated using a comparator function which takes two array elements and must return 0 if both are equal, a positive number if the first is greater, and a negative number if the first is smaller.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`comp`|`(a, a) -> Number`|The comparator function used to indicate sort order|
+|`array`|`Array<a>`|The array to be sorted|
+
+### Array.**rotate**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+rotate : (Number, Array<a>) -> Void
+```
+
+Rotates an array by n elements to the right, in place.
+
+If n is negative, the array will be rotated by n elements
+to the left. See examples.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`n`|`Number`|The number of elements to rotate by|
+|`arr`|`Array<a>`|The array to be rotated|
+
+Examples:
+
+```grain
+let array = [> 1, 2, 3, 4, 5]; rotate(2, arr); arr == [> 4, 5, 1, 2, 3]
+```
+
+```grain
+let array = [> 1, 2, 3, 4, 5]; rotate(-1, arr); arr == [> 2, 3, 4, 5, 1]
+```
+

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
@@ -132,13 +129,11 @@ let addInt32help = (value, buffer) => {
  *
  * @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 make = initialSize => {
+  if (initialSize < 0) throw Exception.InvalidArgument(
+    "Buffers size must be >= 0",
+  )
+  { len: 0, initialSize, data: Bytes.make(initialSize) }
 }
 
 /**
@@ -149,7 +144,7 @@ export let make = (initialSize) => {
  *
  * @since v0.4.0
  */
-export let length = (buffer) => buffer.len
+export let length = buffer => buffer.len
 
 /**
  * Clears data in the buffer and sets its length to zero.
@@ -160,7 +155,7 @@ export let length = (buffer) => buffer.len
  *
  * @since v0.4.0
  */
-export let clear = (buffer) => {
+export let clear = buffer => {
   Bytes.fill(0x0l, buffer.data)
   buffer.len = 0
 }
@@ -174,7 +169,7 @@ export let clear = (buffer) => {
  *
  * @since v0.4.0
  */
-export let reset = (buffer) => {
+export let reset = buffer => {
   buffer.data = Bytes.make(buffer.initialSize)
   buffer.len = 0
 }
@@ -192,7 +187,6 @@ export let reset = (buffer) => {
 @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
 
@@ -217,7 +211,7 @@ export let rec truncate = (length, buffer) => {
  *
  * @since v0.4.0
  */
-export let toBytes = (buffer) => {
+export let toBytes = buffer => {
   let len = Bytes.length(buffer.data)
   if (buffer.len == len) {
     buffer.data
@@ -249,7 +243,7 @@ export let toBytesSlice = (start, length, buffer) => {
  *
  * @since v0.4.0
  */
-export let toString = (buffer) => {
+export let toString = buffer => {
   Bytes.toString(toBytes(buffer))
 }
 
@@ -286,6 +280,8 @@ export let rec addChar = (char: Char, buffer: Buffer) => {
       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)
@@ -293,6 +289,8 @@ export let rec addChar = (char: Char, buffer: Buffer) => {
       Memory.incRef(WasmI32.fromGrain(c))
       Memory.incRef(WasmI32.fromGrain(buffer))
       addInt16help(c, buffer)
+      Memory.decRef(WasmI32.fromGrain(c))
+      void
     },
     3n => {
       let (<) = WasmI32.ltU
@@ -300,12 +298,14 @@ export let rec addChar = (char: Char, buffer: Buffer) => {
       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)
+      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
       }
     },
     _ => {
@@ -314,6 +314,8 @@ export let rec addChar = (char: Char, buffer: Buffer) => {
       Memory.incRef(WasmI32.fromGrain(c))
       Memory.incRef(WasmI32.fromGrain(buffer))
       addInt32help(c, buffer)
+      Memory.decRef(WasmI32.fromGrain(c))
+      void
     },
   }
 
@@ -406,28 +408,58 @@ export let rec addString = (string, buffer) => {
  * @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))
+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 bytelen = String.byteLength(String.slice(start, length, 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 = coerceNumberToWasmI32(start)
+  let srcOff = 0n
   let dstOff = coerceNumberToWasmI32(buffer.len)
-  let src = WasmI32.fromGrain(string)
+  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))
@@ -448,17 +480,40 @@ export let rec addStringSlice = (start, length, string, buffer) => {
  * @since v0.4.0
  */
 @disableGC
-export let rec addBytesSlice = (start: Number, length: Number, bytes: Bytes, buffer: Buffer) => {
+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 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)
+  appendBytes(srcOff, dstOff, len, src, dst)
 
   Memory.incRef(WasmI32.fromGrain((+)))
   Memory.incRef(WasmI32.fromGrain(buffer.len))
@@ -507,7 +562,6 @@ export let addBufferSlice = (start, length, srcBuffer, dstBuffer) => {
  * @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.
  *
@@ -783,4 +837,4 @@ export let addFloat64 = (value, buffer) => {
   let index = buffer.len
   buffer.len = buffer.len + _64BIT_LEN
   setFloat64(index, value, buffer)
-}
+}