@grain/stdlib 0.4.4 → 0.5.0

package/number.gr

@@ -13,7 +13,7 @@ import {
   coerceNumberToWasmF64,
   reducedInteger,
   isFloat,
-  isBoxedNumber
+  isBoxedNumber,
 } from "runtime/numbers"
 import { parseInt } from "runtime/stringUtils"
 import { newFloat64, newInt64 } from "runtime/dataStructures"
@@ -71,19 +71,34 @@ export let div = (/)
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec sqrt = (x: Number) => {
+@unsafe
+export let sqrt = (x: Number) => {
   let xval = coerceNumberToWasmF64(x)
   let x = WasmI32.fromGrain(x)
   let sqrtd = WasmF64.sqrt(xval)
-  let ret = if (!isFloat(x) && WasmF64.eq(sqrtd, WasmF64.trunc(sqrtd))) {
-    WasmI32.toGrain(reducedInteger(WasmI64.truncF64S(sqrtd))): (Number)
+  if (!isFloat(x) && WasmF64.eq(sqrtd, WasmF64.trunc(sqrtd))) {
+    WasmI32.toGrain(reducedInteger(WasmI64.truncF64S(sqrtd))): Number
   } else {
-    WasmI32.toGrain(newFloat64(sqrtd)): (Number)
+    WasmI32.toGrain(newFloat64(sqrtd)): Number
+  }
+}
+
+/**
+ * Determine the positivity or negativity of a Number.
+ *
+ * @param x: The number to inspect
+ * @returns `-1` if the number is negative, `1` if positive, or `0` otherwise; signedness of `-0.0` is preserved
+ *
+ * @example Number.sign(-10000) == -1
+ * @example Number.sign(222222) == 1
+ * @example Number.sign(0) == 0
+ */
+export let sign = x => {
+  match (x) {
+    x when x < 0 => -1,
+    x when x > 0 => 1,
+    _ => 0 * x,
   }
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(sqrt))
-  ret
 }
 
 /**
@@ -116,14 +131,11 @@ export let max = (x: Number, y: Number) => if (x > y) x else y
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec ceil = (x: Number) => {
+@unsafe
+export let ceil = (x: Number) => {
   let xval = coerceNumberToWasmF64(x)
   let ceiling = WasmI64.truncF64S(WasmF64.ceil(xval))
-  let ret = WasmI32.toGrain(reducedInteger(ceiling)): (Number)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(ceil))
-  ret
+  WasmI32.toGrain(reducedInteger(ceiling)): Number
 }
 
 /**
@@ -134,14 +146,11 @@ export let rec ceil = (x: Number) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec floor = (x: Number) => {
+@unsafe
+export let floor = (x: Number) => {
   let xval = coerceNumberToWasmF64(x)
   let floored = WasmI64.truncF64S(WasmF64.floor(xval))
-  let ret = WasmI32.toGrain(reducedInteger(floored)): (Number)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(floor))
-  ret
+  WasmI32.toGrain(reducedInteger(floored)): Number
 }
 
 /**
@@ -152,14 +161,11 @@ export let rec floor = (x: Number) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec trunc = (x: Number) => {
+@unsafe
+export let trunc = (x: Number) => {
   let xval = coerceNumberToWasmF64(x)
   let trunced = WasmI64.truncF64S(xval)
-  let ret = WasmI32.toGrain(reducedInteger(trunced)): (Number)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(trunc))
-  ret
+  WasmI32.toGrain(reducedInteger(trunced)): Number
 }
 
 /**
@@ -170,14 +176,11 @@ export let rec trunc = (x: Number) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec round = (x: Number) => {
+@unsafe
+export let round = (x: Number) => {
   let xval = coerceNumberToWasmF64(x)
   let rounded = WasmI64.truncF64S(WasmF64.nearest(xval))
-  let ret = WasmI32.toGrain(reducedInteger(rounded)): (Number)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(round))
-  ret
+  WasmI32.toGrain(reducedInteger(rounded)): Number
 }
 
 /**
@@ -198,21 +201,21 @@ export let abs = (x: Number) => if (0 > x) x * -1 else x
  *
  * @since v0.4.0
  */
-export let neg = (x: Number) => if (x > 0) x * -1 else x
+export let neg = (x: Number) => x * -1
 
 /**
  * Checks if a number is finite.
  * All values are finite exept for floating point NaN, infinity or negative infinity.
  *
  * @param x: The number to check
- * @returns `true` if the value is finite, otherwise `false`
+ * @returns `true` if the value is finite or `false` otherwise
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec isFinite = (x: Number) => {
+@unsafe
+export let isFinite = (x: Number) => {
   let asPtr = WasmI32.fromGrain(x)
-  let ret = if (isBoxedNumber(asPtr)) {
+  if (isBoxedNumber(asPtr)) {
     // Boxed numbers can have multiple subtypes, of which float32 and float64 can be infinite.
     let tag = WasmI32.load(asPtr, 4n)
     if (WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)) {
@@ -233,9 +236,6 @@ export let rec isFinite = (x: Number) => {
     // Simple numbers are integers and cannot be infinite.
     true
   }
-  Memory.decRef(asPtr)
-  Memory.decRef(WasmI32.fromGrain(isFinite))
-  ret
 }
 
 /**
@@ -247,10 +247,10 @@ export let rec isFinite = (x: Number) => {
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec isNaN = (x: Number) => {
+@unsafe
+export let isNaN = (x: Number) => {
   let asPtr = WasmI32.fromGrain(x)
-  let ret = if (isBoxedNumber(asPtr)) {
+  if (isBoxedNumber(asPtr)) {
     // Boxed numbers can have multiple subtypes, of which float32 and float64 can be NaN.
     let tag = WasmI32.load(asPtr, 4n)
     if (WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)) {
@@ -269,9 +269,6 @@ export let rec isNaN = (x: Number) => {
     // Simple numbers are integers and cannot be NaN.
     false
   }
-  Memory.decRef(asPtr)
-  Memory.decRef(WasmI32.fromGrain(isNaN))
-  ret
 }
 
 /**
@@ -279,16 +276,16 @@ export let rec isNaN = (x: Number) => {
  * Note that this function is not the exact opposite of isFinite(Number) in that it doesn't return true for NaN.
  *
  * @param x: The number to check
- * @returns `true` if the value is infinite, otherwise `false`
+ * @returns `true` if the value is infinite or `false` otherwise
  *
  * @since v0.4.0
  */
-@disableGC
-export let rec isInfinite = (x: Number) => {
+@unsafe
+export let isInfinite = (x: Number) => {
   // The following code is equivalent to (!isFinite(x) && !isNaN(x)),
   // so see those functions to understand what's going on here.
   let asPtr = WasmI32.fromGrain(x)
-  let ret = if (isBoxedNumber(asPtr)) {
+  if (isBoxedNumber(asPtr)) {
     let tag = WasmI32.load(asPtr, 4n)
     if (WasmI32.eq(tag, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG)) {
       let wf64 = WasmF64.load(asPtr, 8n)
@@ -302,24 +299,21 @@ export let rec isInfinite = (x: Number) => {
   } else {
     false
   }
-  Memory.decRef(asPtr)
-  Memory.decRef(WasmI32.fromGrain(isInfinite))
-  ret
 }
 
 /**
  * Parses a string representation of an integer into a `Number` using the
  * specified radix (also known as a number system "base").
- * 
+ *
  * If the string has a radix prefix (i.e. "0x"/"0X", "0o"/"0O", or "0b"/"0B"
  * for radixes 16, 8, or 2 respectively), the supplied radix is ignored in
  * favor of the prefix. Underscores that appear in the numeric portion of the
  * input are ignored.
- * 
+ *
  * @param input: The string to parse
  * @param radix: The number system base to use when parsing the input string
  * @returns `Ok(value)` containing the parsed number on a successful parse or `Err(msg)` containing an error message string otherwise
- * 
+ *
  * @since v0.4.5
  */
 export parseInt

package/number.md

@@ -142,6 +142,40 @@ Returns:
 |----|-----------|
 |`Number`|The square root of the operand|
 
+### Number.**sign**
+
+```grain
+sign : Number -> Number
+```
+
+Determine the positivity or negativity of a Number.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`x`|`Number`|The number to inspect|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Number`|`-1` if the number is negative, `1` if positive, or `0` otherwise; signedness of `-0.0` is preserved|
+
+Examples:
+
+```grain
+Number.sign(-10000) == -1
+```
+
+```grain
+Number.sign(222222) == 1
+```
+
+```grain
+Number.sign(0) == 0
+```
+
 ### Number.**min**
 
 <details disabled>
@@ -368,7 +402,7 @@ Returns:
 
 |type|description|
 |----|-----------|
-|`Bool`|`true` if the value is finite, otherwise `false`|
+|`Bool`|`true` if the value is finite or `false` otherwise|
 
 ### Number.**isNaN**
 
@@ -420,12 +454,12 @@ Returns:
 
 |type|description|
 |----|-----------|
-|`Bool`|`true` if the value is infinite, otherwise `false`|
+|`Bool`|`true` if the value is infinite or `false` otherwise|
 
 ### Number.**parseInt**
 
 <details disabled>
-<summary tabindex="-1">Added in <code>next</code></summary>
+<summary tabindex="-1">Added in <code>0.4.5</code></summary>
 No other changes yet.
 </details>
 

package/option.gr

@@ -23,10 +23,10 @@
  * 
  * @since v0.2.0
  */
-export let isSome = (option) => {
+export let isSome = option => {
   match (option) {
     Some(_) => true,
-    None => false
+    None => false,
   }
 }
 
@@ -38,10 +38,10 @@ export let isSome = (option) => {
  * 
  * @since v0.2.0
  */
-export let isNone = (option) => {
+export let isNone = option => {
   match (option) {
     None => true,
-    Some(_) => false
+    Some(_) => false,
   }
 }
 
@@ -57,7 +57,7 @@ export let isNone = (option) => {
 export let contains = (value, option) => {
   match (option) {
     Some(x) => x == value,
-    None => false
+    None => false,
   }
 }
 
@@ -74,7 +74,7 @@ export let contains = (value, option) => {
 export let expect = (msg, option) => {
   match (option) {
     Some(x) => x,
-    None => fail msg
+    None => fail msg,
   }
 }
 
@@ -87,7 +87,7 @@ export let expect = (msg, option) => {
  * 
  * @since v0.2.0
  */
-export let unwrap = (option) => {
+export let unwrap = option => {
   expect("Could not unwrap None value", option)
 }
 
@@ -103,7 +103,7 @@ export let unwrap = (option) => {
 export let unwrapWithDefault = (default, option) => {
   match (option) {
     Some(x) => x,
-    None => default
+    None => default,
   }
 }
 
@@ -119,7 +119,7 @@ export let unwrapWithDefault = (default, option) => {
 export let map = (fn, option) => {
   match (option) {
     Some(x) => Some(fn(x)),
-    None => None
+    None => None,
   }
 }
 
@@ -137,7 +137,7 @@ export let map = (fn, option) => {
 export let mapWithDefault = (fn, default, option) => {
   match (option) {
     Some(x) => fn(x),
-    None => default
+    None => default,
   }
 }
 
@@ -156,7 +156,7 @@ export let mapWithDefault = (fn, default, option) => {
 export let mapWithDefaultFn = (fn, defaultFn, option) => {
   match (option) {
     Some(x) => fn(x),
-    None => defaultFn()
+    None => defaultFn(),
   }
 }
 
@@ -172,7 +172,7 @@ export let mapWithDefaultFn = (fn, defaultFn, option) => {
 export let flatMap = (fn, option) => {
   match (option) {
     Some(x) => fn(x),
-    None => None
+    None => None,
   }
 }
 
@@ -194,7 +194,7 @@ export let filter = (fn, option) => {
       } else {
         None
       },
-    None => None
+    None => None,
   }
 }
 
@@ -210,7 +210,7 @@ export let filter = (fn, option) => {
 export let zip = (optionA, optionB) => {
   match ((optionA, optionB)) {
     (Some(a), Some(b)) => Some((a, b)),
-    _ => None
+    _ => None,
   }
 }
 
@@ -227,7 +227,7 @@ export let zip = (optionA, optionB) => {
 export let zipWith = (fn, optionA, optionB) => {
   match ((optionA, optionB)) {
     (Some(a), Some(b)) => Some(fn(a, b)),
-    _ => None
+    _ => None,
   }
 }
 
@@ -241,10 +241,10 @@ export let zipWith = (fn, optionA, optionB) => {
  *
  * @since v0.2.0
  */
-export let flatten = (option) => {
+export let flatten = option => {
   match (option) {
     Some(Some(x)) => Some(x),
-    _ => None
+    _ => None,
   }
 }
 
@@ -256,10 +256,10 @@ export let flatten = (option) => {
  * 
  * @since v0.2.0
  */
-export let toList = (option) => {
+export let toList = option => {
   match (option) {
     Some(x) => [x],
-    None => []
+    None => [],
   }
 }
 
@@ -271,10 +271,10 @@ export let toList = (option) => {
  * 
  * @since v0.2.0
  */
-export let toArray = (option) => {
+export let toArray = option => {
   match (option) {
     Some(x) => [> x],
-    None => [>]
+    None => [>],
   }
 }
 
@@ -290,7 +290,7 @@ export let toArray = (option) => {
 export let toResult = (err, option) => {
   match (option) {
     Some(a) => Ok(a),
-    None    => Err(err)
+    None => Err(err),
   }
 }
 
@@ -305,7 +305,7 @@ export let toResult = (err, option) => {
 export let sideEffect = (fn, option) => {
   match (option) {
     Some(x) => fn(x),
-    None => void
+    None => void,
   }
 }
 
@@ -336,7 +336,7 @@ export let peek = (fn, option) => {
 export let or = (optionA, optionB) => {
   match (optionA) {
     Some(x) => optionA,
-    None => optionB
+    None => optionB,
   }
 }
 
@@ -352,6 +352,6 @@ export let or = (optionA, optionB) => {
 export let and = (optionA, optionB) => {
   match (optionA) {
     Some(_) => optionB,
-    None => optionA
+    None => optionA,
   }
 }

package/option.md

@@ -533,7 +533,7 @@ No other changes yet.
 </details>
 
 ```grain
-( or ) : (Option<a>, Option<a>) -> Option<a>
+or : (Option<a>, Option<a>) -> Option<a>
 ```
 
 Behaves like a logical OR (`||`) where the first Option is only returned if it is the `Some` variant and falling back to the second Option in all other cases.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grain/stdlib",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "The standard library for the Grain language.",
   "license": "MIT",
   "homepage": "https://grain-lang.org",
@@ -18,7 +18,7 @@
     "directory": "stdlib"
   },
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   },
   "main": "index.js",
   "files": [
@@ -27,7 +27,7 @@
     "index.js"
   ],
   "scripts": {
-    "clean": "del-cli '**/*.wasm' '**/*.wat' '**/*.modsig'"
+    "clean": "del-cli \"**/*.wasm\" \"**/*.wat\" \"**/*.modsig\""
   },
   "dependencies": {},
   "devDependencies": {