@grain/stdlib 0.4.2 → 0.4.6

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # Changelog
 
+### [0.4.6](https://www.github.com/grain-lang/grain/compare/stdlib-v0.4.5...stdlib-v0.4.6) (2022-01-17)
+
+
+### Bug Fixes
+
+* **grainfmt:** Indent function application args when adding parens ([#1095](https://www.github.com/grain-lang/grain/issues/1095)) ([64af7d3](https://www.github.com/grain-lang/grain/commit/64af7d387dca2fddb9b3d190ccdf5790ec3d8e65))
+
+### [0.4.5](https://www.github.com/grain-lang/grain/compare/stdlib-v0.4.4...stdlib-v0.4.5) (2021-12-31)
+
+
+### Features
+
+* **stdlib:** Add sign function to Number module ([#1079](https://www.github.com/grain-lang/grain/issues/1079)) ([b6483d5](https://www.github.com/grain-lang/grain/commit/b6483d5046cd1b6b89a717a925594d3b20b05837))
+
+### [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)
+
+
+### Features
+
+* **stdlib:** Add cycle function to Array module ([#993](https://www.github.com/grain-lang/grain/issues/993)) ([c595622](https://www.github.com/grain-lang/grain/commit/c595622b28366655dfd5447270e8f9fc3f988a67))
+
+
+### Bug Fixes
+
+* **compiler:** Ensure TExpApp is always expansive in Grain ([ef0a69f](https://www.github.com/grain-lang/grain/commit/ef0a69fb4418d318b3227e5db7e743a026762274))
+* **compiler:** Handle let-mut value restriction, such that mutable lets are always expansive ([ef0a69f](https://www.github.com/grain-lang/grain/commit/ef0a69fb4418d318b3227e5db7e743a026762274))
+* **compiler:** Properly handle value restriction on function application & mutable vars ([#988](https://www.github.com/grain-lang/grain/issues/988)) ([ef0a69f](https://www.github.com/grain-lang/grain/commit/ef0a69fb4418d318b3227e5db7e743a026762274))
+* **runtime:** Add types to boxed GC functions to avoid weak type errors ([ef0a69f](https://www.github.com/grain-lang/grain/commit/ef0a69fb4418d318b3227e5db7e743a026762274))
+* **stdlib:** Fixed memory leak in String.explode ([#1001](https://www.github.com/grain-lang/grain/issues/1001)) ([c479a05](https://www.github.com/grain-lang/grain/commit/c479a05f48abcc4c9e98d5cf0ba698230d41031b))
+
 ### [0.4.2](https://www.github.com/grain-lang/grain/compare/stdlib-v0.4.1...stdlib-v0.4.2) (2021-10-11)
 
 

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2021 Oscar Spencer <oscar@grain-lang.org> and Philip Blair <philip@grain-lang.org>
+Copyright (c) 2017-2022 Oscar Spencer <oscar@grain-lang.org> and Philip Blair <philip@grain-lang.org>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/array.gr

@@ -30,7 +30,7 @@ let initPtr = () => {
 initPtr()
 
 @disableGC
-let initLength = (length) => {
+let initLength = length => {
   let length = WasmI32.fromGrain(length)
   if (WasmI32.eqz(WasmI32.and(length, 1n))) {
     throw Exception.InvalidArgument("Length argument must be an integer")
@@ -51,8 +51,8 @@ let initLength = (length) => {
  * @since v0.1.0
  */
 @disableGC
-export let rec length = (array) => {
-  let ptr = WasmI32.fromGrain(array: Array<a>)
+export let rec length = array => {
+  let ptr = WasmI32.fromGrain(array: (Array<a>))
   let ret = tagSimpleNumber(WasmI32.load(ptr, _ARRAY_LENGTH_OFFSET))
   Memory.decRef(ptr)
   Memory.decRef(WasmI32.fromGrain(length))
@@ -73,13 +73,21 @@ export let rec length = (array) => {
  * @since v0.1.0
  */
 @disableGC
-export let rec make /*: (Number, a) -> Array<a>*/  = (length: Number, item: a) => {
+export let rec make /*: (Number, a) -> Array<a>*/ =
+  (
+    length: Number,
+    item: a,
+  ) => {
   let lengthArg = length
   let length = initLength(length)
   let byteLength = WasmI32.mul(length, 4n)
   let array = allocateArray(length)
   for (let mut i = 0n; WasmI32.ltS(i, byteLength); i = WasmI32.add(i, 4n)) {
-    WasmI32.store(WasmI32.add(array, i), Memory.incRef(WasmI32.fromGrain(item)), _ARRAY_START_OFFSET)
+    WasmI32.store(
+      WasmI32.add(array, i),
+      Memory.incRef(WasmI32.fromGrain(item)),
+      _ARRAY_START_OFFSET
+    )
   }
   let ret = WasmI32.toGrain(array): (Array<a>)
   Memory.decRef(WasmI32.fromGrain(lengthArg))
@@ -102,16 +110,24 @@ export let rec make /*: (Number, a) -> Array<a>*/  = (length: Number, item: a) =
  * @since v0.1.0
  */
 @disableGC
-export let rec init /*: (Number, Number -> a) -> Array<a>*/ = (length: Number, fn: Number -> a) => {
+export let rec init /*: (Number, Number -> a) -> Array<a>*/ =
+  (
+    length: Number,
+    fn: Number -> a,
+  ) => {
   let length = initLength(length)
   let byteLength = WasmI32.mul(length, 4n)
   let array = allocateArray(length)
   let mut index = 0n
   for (let mut i = 0n; WasmI32.ltS(i, byteLength); i = WasmI32.add(i, 4n)) {
-    Memory.incRef(WasmI32.fromGrain(fn));
+    Memory.incRef(WasmI32.fromGrain(fn))
     // [FIXME] This line fails the array/map test suite (#815)
     //assert !WasmI32.eqz(WasmI32.and(WasmI32.fromGrain(index), 1n)) // must be a simple int for next line to be correct
-    WasmI32.store(WasmI32.add(array, i), WasmI32.fromGrain(fn(tagSimpleNumber(index))), _ARRAY_START_OFFSET)
+    WasmI32.store(
+      WasmI32.add(array, i),
+      WasmI32.fromGrain(fn(tagSimpleNumber(index))),
+      _ARRAY_START_OFFSET
+    )
     //WasmI32.store(WasmI32.add(array, i), WasmI32.fromGrain(4), _ARRAY_START_OFFSET)
     index = WasmI32.add(index, 1n)
   }
@@ -186,29 +202,29 @@ export let append = (array1, array2) => {
  *
  * @since v0.1.0
  */
-export let concat = (arrays) => {
+export let concat = arrays => {
   // This function is slightly verbose to avoid depending on the List stdlib.
 
   let rec findLength = (arrays, acc) => {
     match (arrays) {
       [fst, ...rest] => findLength(rest, acc + length(fst)),
-      [] => acc
+      [] => acc,
     }
   }
 
   let mut offset = 0
   let mut arrs = arrays
 
-  let rec next = (index) => {
+  let rec next = index => {
     let array = match (arrs) {
       [fst, ..._] => fst,
-      [] => fail "end of arrays list"
+      [] => fail "end of arrays list",
     }
     if (index - offset == length(array)) {
       offset += length(array)
       arrs = match (arrs) {
         [_, ...rest] => rest,
-        [] => fail "end of arrays list"
+        [] => fail "end of arrays list",
       }
       next(index)
     } else {
@@ -228,10 +244,28 @@ export let concat = (arrays) => {
  *
  * @since v0.1.0
  */
-export let copy = (array) => {
+export let copy = array => {
   init(length(array), n => array[n])
 }
 
+/**
+ * Iterates an array a given number of times, calling an iterator function on each element.
+ *
+ * @param fn: The iterator function to call with each element
+ * @param n: The number of times to iterate the given array
+ * @param array: The array to iterate
+ *
+ * @since v0.4.4
+ */
+export let cycle = (fn, n, array) => {
+  let length = length(array)
+  for (let mut iteration = 0; iteration < n; iteration += 1) {
+    for (let mut count = 0; count < length; count += 1) {
+      fn(array[count]): Void
+    }
+  }
+}
+
 /**
  * Iterates an array, calling an iterator function on each element.
  *
@@ -243,10 +277,8 @@ export let copy = (array) => {
  */
 export let forEach = (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]): Void
-    count = incr(count)
   }
 }
 
@@ -262,10 +294,8 @@ export let forEach = (fn, array) => {
  */
 export let forEachi = (fn, array) => {
   let length = length(array)
-  let mut count = 0
-  while (count < length) {
-    fn(array[count], count): (Void)
-    count = incr(count)
+  for (let mut count = 0; count < length; count += 1) {
+    fn(array[count], count): Void
   }
 }
 
@@ -282,7 +312,7 @@ export let forEachi = (fn, array) => {
  */
 export let map = (fn, array) => {
   let length = length(array)
-  init(length, (i) => {
+  init(length, i => {
     fn(array[i])
   })
 }
@@ -299,7 +329,7 @@ export let map = (fn, array) => {
  */
 export let mapi = (fn, array) => {
   let length = length(array)
-  init(length, (index) => {
+  init(length, index => {
     fn(array[index], index)
   })
 }
@@ -324,7 +354,7 @@ export let mapi = (fn, array) => {
  */
 export let reduce = (fn, initial, array) => {
   let mut acc = initial
-  forEach((el) => acc = fn(acc, el), array)
+  forEach(el => acc = fn(acc, el), array)
   acc
 }
 
@@ -378,7 +408,9 @@ export let flatMap = (fn, array) => {
  * @since v0.3.0
  */
 export let every = (fn, array) => {
-  reduce((acc, value) => { acc && fn(value) }, true, array)
+  reduce((acc, value) => {
+    acc && fn(value)
+  }, true, array)
 }
 
 /**
@@ -392,7 +424,9 @@ export let every = (fn, array) => {
  * @since v0.3.0
  */
 export let some = (fn, array) => {
-  reduce((acc, value) => { acc || fn(value) }, false, array)
+  reduce((acc, value) => {
+    acc || fn(value)
+  }, false, array)
 }
 
 /**
@@ -435,9 +469,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
 }
@@ -450,9 +487,9 @@ export let fillRange = (value, start, stop, array) => {
  *
  * @since v0.4.0
  */
-export let reverse = (array) => {
+export let reverse = array => {
   let len = length(array)
-  init(len, (index) => {
+  init(len, index => {
     let last = len - index - 1
     array[last]
   })
@@ -466,7 +503,7 @@ export let reverse = (array) => {
  *
  * @since v0.1.0
  */
-export let toList = (array) => {
+export let toList = array => {
   let rec buildList = (acc, index) => {
     let index = index - 1
     if (index < 0) {
@@ -486,22 +523,22 @@ export let toList = (array) => {
  *
  * @since v0.1.0
  */
-export let fromList = (list) => {
+export let fromList = list => {
   let rec listLength = (list, acc) => {
     match (list) {
       [_, ...rest] => listLength(rest, acc + 1),
-      [] => acc
+      [] => acc,
     }
   }
 
   let mut lst = list
-  let rec next = (index) => {
+  let rec next = index => {
     match (lst) {
       [fst, ...rest] => {
         lst = rest
         fst
       },
-      [] => next(index)
+      [] => next(index),
     }
   }
   init(listLength(list, 0), next)
@@ -520,11 +557,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
 }
@@ -540,22 +575,22 @@ export let contains = (search, array) => {
  */
 export let find = (fn, array) => {
   let length = length(array)
-  if(length == 0){
+  if (length == 0) {
     None
   } else {
     let mut count = 0
     let mut matching = false
     let mut matchedItem = array[0]
     while (count < length) {
-      if(fn(array[count])) {
+      if (fn(array[count])) {
         matching = true
         matchedItem = array[count]
         count = length
       } else {
-        count = incr(count)
+        count += 1
       }
     }
-    if(!matching) {
+    if (!matching) {
       None
     } else {
       Some(matchedItem)
@@ -574,22 +609,22 @@ export let find = (fn, array) => {
  */
 export let findIndex = (fn, array) => {
   let length = length(array)
-  if(length == 0){
+  if (length == 0) {
     None
   } else {
     let mut count = 0
     let mut matching = false
     let mut matchedIndex = 0
     while (count < length) {
-      if(fn(array[count])) {
+      if (fn(array[count])) {
         matching = true
         matchedIndex = count
         count = length
       } else {
-        count = incr(count)
+        count += 1
       }
     }
-    if(!matching) {
+    if (!matching) {
       None
     } else {
       Some(matchedIndex)
@@ -613,8 +648,8 @@ export let product = (array1: Array<a>, array2: Array<b>) => {
   let mut indexA = -1
 
   init(lenA * lenB, n => {
-    if(n % lenB == 0){
-      indexA = incr(indexA)
+    if (n % lenB == 0) {
+      indexA += 1
     } else {
       indexA = indexA
     }
@@ -635,12 +670,9 @@ export let count = (fn, array) => {
   let length = length(array)
   let mut position = 0
   let mut count = 0
-  while (position < length) {
-    if(fn(array[position])) {
-      count = incr(count)
-      position = incr(position)
-    } else {
-      position = incr(position)
+  for (let mut position = 0; position < length; position += 1) {
+    if (fn(array[position])) {
+      count += 1
     }
   }
   count
@@ -658,14 +690,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
@@ -685,13 +713,13 @@ export let counti = (fn, array) => {
 export let filter = (fn, array) => {
   let filtered = copy(array)
   let mut position = 0
-  forEach((el) => {
+  forEach(el => {
     if (fn(el)) {
       filtered[position] = el
-      position = incr(position)
+      position += 1
     }
   }, array)
-  init(position, (index) => {
+  init(position, index => {
     filtered[index]
   })
 }
@@ -713,10 +741,10 @@ export let filteri = (fn, array) => {
   forEachi((el, index) => {
     if (fn(el, index)) {
       filtered[position] = el
-      position = incr(position)
+      position += 1
     }
   }, array)
-  init(position, (index) => {
+  init(position, index => {
     filtered[index]
   })
 }
@@ -730,11 +758,9 @@ export let filteri = (fn, array) => {
  *
  * @since v0.3.0
  */
-export let unique = (array) => {
-  filteri(
-    (el, index) => findIndex(value => value == el, array) == Some(index),
-    array
-  )
+export let unique = array => {
+  filteri((el, index) =>
+    findIndex(value => value == el, array) == Some(index), array)
 }
 
 /**
@@ -769,15 +795,17 @@ export let zip = (array1: Array<a>, array2: Array<b>) => {
  *
  * @since v0.4.0
  */
-export let unzip = (array) => {
+export let unzip = array => {
   let lenArr = length(array)
 
   let a = init(lenArr, n => {
-    let (fst, _) = array[n]; fst
+    let (fst, _) = array[n]
+    fst
   })
 
   let b = init(lenArr, n => {
-    let (_, snd) = array[n]; snd
+    let (_, snd) = array[n]
+    snd
   })
 
   (a, b)
@@ -796,15 +824,27 @@ export let join = (separator: String, items: Array<String>) => {
   let iter = (acc, str) => {
     match (acc) {
       None => Some(str),
-      Some(prev) => Some(prev ++ separator ++ str)
+      Some(prev) => Some(prev ++ separator ++ str),
     }
   }
-  match(reduce(iter, None, items)) {
+  match (reduce(iter, None, items)) {
     None => "",
     Some(s) => s,
   }
 }
 
+/**
+ * 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.
@@ -821,17 +861,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
@@ -839,7 +870,7 @@ export let slice = (startIndex, endIndex, array) => {
     endIndex
   }
 
-  let newLength = endIndex - startIndex;
+  let newLength = endIndex - startIndex
   if (newLength < 0) {
     [>]
   } else if (newLength > arrayLength) {
@@ -848,3 +879,83 @@ 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
+    }
+  }
+}