@grain/stdlib 0.6.3 → 0.6.5

package/float64.md

@@ -480,3 +480,167 @@ use Float64.{ (>=) }
 assert -1.0d >= -1.0d
 ```
 
+### Float64.**isNaN**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.6.5</code></summary>
+No other changes yet.
+</details>
+
+```grain
+isNaN : (x: Float64) => Bool
+```
+
+Checks if the value is a float NaN value (Not A Number).
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`x`|`Float64`|The value to check|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Bool`|`true` if the value is NaN, otherwise `false`|
+
+Examples:
+
+```grain
+Float64.isNaN(NaNd)
+```
+
+```grain
+Float64.isNaN(Infinityd) == false
+```
+
+```grain
+Float64.isNaN(-Infinityd) == false
+```
+
+```grain
+Float64.isNaN(0.5d) == false
+```
+
+```grain
+Float64.isNaN(1.0d) == false
+```
+
+### Float64.**isInfinite**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.6.5</code></summary>
+No other changes yet.
+</details>
+
+```grain
+isInfinite : (x: Float64) => Bool
+```
+
+Checks if a float is infinite, that is either of positive or negative infinity.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`x`|`Float64`|The value to check|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Bool`|`true` if the value is infinite or `false` otherwise|
+
+Examples:
+
+```grain
+Float64.isInfinite(Infinityd)
+```
+
+```grain
+Float64.isInfinite(-Infinityd)
+```
+
+```grain
+Float64.isInfinite(NaNd) == false
+```
+
+```grain
+Float64.isInfinite(0.5d) == false
+```
+
+```grain
+Float64.isInfinite(1.0d) == false
+```
+
+### Float64.**abs**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.6.5</code></summary>
+No other changes yet.
+</details>
+
+```grain
+abs : (x: Float64) => Float64
+```
+
+Returns the absolute value. That is, it returns `x` if `x` is positive or zero and the negation of `x` if `x` is negative.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`x`|`Float64`|The operand|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Float64`|The absolute value of the operand|
+
+Examples:
+
+```grain
+Float64.abs(-1.0d) == 1.0d
+```
+
+```grain
+Float64.abs(5.0d) == 5.0d
+```
+
+### Float64.**neg**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.6.5</code></summary>
+No other changes yet.
+</details>
+
+```grain
+neg : (x: Float64) => Float64
+```
+
+Returns the negation of its operand.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`x`|`Float64`|The operand|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Float64`|The negated operand|
+
+Examples:
+
+```grain
+Float64.neg(-1.0d) == 1.0d
+```
+
+```grain
+Float64.neg(1.0d) == -1.0d
+```
+

package/hash.gr

@@ -262,6 +262,8 @@ provide let hash = anything => {
   }
 
   hashOne(WasmI32.fromGrain(anything), 0n)
+  ignore(anything)
+
   finalize(0n)
 
   // Tag the number on the way out.

package/int16.gr

@@ -2,6 +2,9 @@
  * Utilities for working with the Int16 type.
  * @example from "int16" include Int16
  *
+ * @example 1S
+ * @example -1S
+ *
  * @since v0.6.0
  */
 module Int16
@@ -51,6 +54,8 @@ let signExtend = x => (x << _DATA_OFFSET) >> _DATA_OFFSET
  * @param number: The value to convert
  * @returns The Uint16 represented as an Int16
  *
+ * @example Int16.fromUint16(1uS) == 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -67,6 +72,9 @@ provide let fromUint16 = (number: Uint16) => {
  * @param value: The value to increment
  * @returns The incremented value
  *
+ * @example Int16.incr(1S) == 2S
+ * @example Int16.incr(-2S) == -1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -83,6 +91,9 @@ provide let incr = (value: Int16) => {
  * @param value: The value to decrement
  * @returns The decremented value
  *
+ * @example Int16.decr(2S) == 1S
+ * @example Int16.decr(0S) == -1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -100,6 +111,10 @@ provide let decr = (value: Int16) => {
  * @param y: The second operand
  * @returns The sum of the two operands
  *
+ * @example
+ * use Int16.{ (+) }
+ * assert 1S + 1S == 2S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -121,6 +136,10 @@ provide let (+) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns The difference of the two operands
  *
+ * @example
+ * use Int16.{ (-) }
+ * assert 2S - 1S == 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -139,6 +158,10 @@ provide let (-) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns The product of the two operands
  *
+ * @example
+ * use Int16.{ (*) }
+ * assert 2S * 2S == 4S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -156,6 +179,10 @@ provide let (*) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns The quotient of its operands
  *
+ * @example
+ * use Int16.{ (/) }
+ * assert 8S / 2S == 4S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -174,6 +201,8 @@ provide let (/) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns The remainder of its operands
  *
+ * @example Int16.rem(8S, 3S) == 2S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -202,6 +231,10 @@ let abs = n => {
  *
  * @throws ModuloByZero: When `y` is zero
  *
+ * @example
+ * use Int16.{ (%) }
+ * assert -5S % 3S == 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -233,6 +266,10 @@ provide let (%) = (x: Int16, y: Int16) => {
  * @param amount: The number of bits to shift by
  * @returns The shifted value
  *
+ * @example
+ * use Int16.{ (<<) }
+ * assert (5S << 1S) == 10S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -252,6 +289,10 @@ provide let (<<) = (value: Int16, amount: Int16) => {
  * @param amount: The amount to shift by
  * @returns The shifted value
  *
+ * @example
+ * use Int16.{ (>>) }
+ * assert (5S >> 1S) == 2S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -271,6 +312,10 @@ provide let (>>) = (value: Int16, amount: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is equal to the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (==) }
+ * assert 1S == 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -287,6 +332,10 @@ provide let (==) = (x: Int16, y: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is not equal to the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (!=) }
+ * assert 1S != 2S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -303,6 +352,10 @@ provide let (!=) = (x: Int16, y: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is less than the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (<) }
+ * assert 1S < 2S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -319,6 +372,10 @@ provide let (<) = (x: Int16, y: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is greater than the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (>) }
+ * assert 2S > 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -335,6 +392,13 @@ provide let (>) = (x: Int16, y: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is less than or equal to the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (<=) }
+ * assert 1S <= 2S
+ * @example
+ * use Int16.{ (<=) }
+ * assert 1S <= 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -351,6 +415,13 @@ provide let (<=) = (x: Int16, y: Int16) => {
  * @param y: The second value
  * @returns `true` if the first value is greater than or equal to the second value or `false` otherwise
  *
+ * @example
+ * use Int16.{ (>=) }
+ * assert 2S >= 1S
+ * @example
+ * use Int16.{ (>=) }
+ * assert 1S >= 1S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -366,6 +437,8 @@ provide let (>=) = (x: Int16, y: Int16) => {
  * @param value: The given value
  * @returns Containing the inverted bits of the given value
  *
+ * @example Int16.lnot(-5S) == 4S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -381,6 +454,10 @@ provide let lnot = (value: Int16) => {
  * @param y: The second operand
  * @returns Containing a `1` in each bit position for which the corresponding bits of both operands are `1`
  *
+ * @example
+ * use Int16.{ (&) }
+ * assert (3S & 4S) == 0S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -399,6 +476,10 @@ provide let (&) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns Containing a `1` in each bit position for which the corresponding bits of either or both operands are `1`
  *
+ * @example
+ * use Int16.{ (|) }
+ * assert (3S | 4S) == 7S
+ *
  * @since v0.6.0
  */
 @unsafe
@@ -417,6 +498,10 @@ provide let (|) = (x: Int16, y: Int16) => {
  * @param y: The second operand
  * @returns Containing a `1` in each bit position for which the corresponding bits of either but not both operands are `1`
  *
+ * @example
+ * use Int16.{ (^) }
+ * assert (3S ^ 5S) == 6S
+ *
  * @since v0.6.0
  */
 @unsafe

package/int16.md

@@ -13,6 +13,14 @@ No other changes yet.
 from "int16" include Int16
 ```
 
+```grain
+1S
+```
+
+```grain
+-1S
+```
+
 ## Values
 
 Functions and constants included in the Int16 module.
@@ -92,6 +100,12 @@ Returns:
 |----|-----------|
 |`Int16`|The Uint16 represented as an Int16|
 
+Examples:
+
+```grain
+Int16.fromUint16(1uS) == 1S
+```
+
 ### Int16.**incr**
 
 <details disabled>
@@ -117,6 +131,16 @@ Returns:
 |----|-----------|
 |`Int16`|The incremented value|
 
+Examples:
+
+```grain
+Int16.incr(1S) == 2S
+```
+
+```grain
+Int16.incr(-2S) == -1S
+```
+
 ### Int16.**decr**
 
 <details disabled>
@@ -142,6 +166,16 @@ Returns:
 |----|-----------|
 |`Int16`|The decremented value|
 
+Examples:
+
+```grain
+Int16.decr(2S) == 1S
+```
+
+```grain
+Int16.decr(0S) == -1S
+```
+
 ### Int16.**(+)**
 
 <details disabled>
@@ -168,6 +202,13 @@ Returns:
 |----|-----------|
 |`Int16`|The sum of the two operands|
 
+Examples:
+
+```grain
+use Int16.{ (+) }
+assert 1S + 1S == 2S
+```
+
 ### Int16.**(-)**
 
 <details disabled>
@@ -194,6 +235,13 @@ Returns:
 |----|-----------|
 |`Int16`|The difference of the two operands|
 
+Examples:
+
+```grain
+use Int16.{ (-) }
+assert 2S - 1S == 1S
+```
+
 ### Int16.**(*)**
 
 <details disabled>
@@ -220,6 +268,13 @@ Returns:
 |----|-----------|
 |`Int16`|The product of the two operands|
 
+Examples:
+
+```grain
+use Int16.{ (*) }
+assert 2S * 2S == 4S
+```
+
 ### Int16.**(/)**
 
 <details disabled>
@@ -246,6 +301,13 @@ Returns:
 |----|-----------|
 |`Int16`|The quotient of its operands|
 
+Examples:
+
+```grain
+use Int16.{ (/) }
+assert 8S / 2S == 4S
+```
+
 ### Int16.**rem**
 
 <details disabled>
@@ -272,6 +334,12 @@ Returns:
 |----|-----------|
 |`Int16`|The remainder of its operands|
 
+Examples:
+
+```grain
+Int16.rem(8S, 3S) == 2S
+```
+
 ### Int16.**(%)**
 
 <details disabled>
@@ -305,6 +373,13 @@ Throws:
 
 * When `y` is zero
 
+Examples:
+
+```grain
+use Int16.{ (%) }
+assert -5S % 3S == 1S
+```
+
 ### Int16.**(<<)**
 
 <details disabled>
@@ -331,6 +406,13 @@ Returns:
 |----|-----------|
 |`Int16`|The shifted value|
 
+Examples:
+
+```grain
+use Int16.{ (<<) }
+assert (5S << 1S) == 10S
+```
+
 ### Int16.**(>>)**
 
 <details disabled>
@@ -357,6 +439,13 @@ Returns:
 |----|-----------|
 |`Int16`|The shifted value|
 
+Examples:
+
+```grain
+use Int16.{ (>>) }
+assert (5S >> 1S) == 2S
+```
+
 ### Int16.**(==)**
 
 <details disabled>
@@ -383,6 +472,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (==) }
+assert 1S == 1S
+```
+
 ### Int16.**(!=)**
 
 <details disabled>
@@ -409,6 +505,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is not equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (!=) }
+assert 1S != 2S
+```
+
 ### Int16.**(<)**
 
 <details disabled>
@@ -435,6 +538,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is less than the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (<) }
+assert 1S < 2S
+```
+
 ### Int16.**(>)**
 
 <details disabled>
@@ -461,6 +571,13 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is greater than the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (>) }
+assert 2S > 1S
+```
+
 ### Int16.**(<=)**
 
 <details disabled>
@@ -487,6 +604,18 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is less than or equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (<=) }
+assert 1S <= 2S
+```
+
+```grain
+use Int16.{ (<=) }
+assert 1S <= 1S
+```
+
 ### Int16.**(>=)**
 
 <details disabled>
@@ -513,6 +642,18 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is greater than or equal to the second value or `false` otherwise|
 
+Examples:
+
+```grain
+use Int16.{ (>=) }
+assert 2S >= 1S
+```
+
+```grain
+use Int16.{ (>=) }
+assert 1S >= 1S
+```
+
 ### Int16.**lnot**
 
 <details disabled>
@@ -538,6 +679,12 @@ Returns:
 |----|-----------|
 |`Int16`|Containing the inverted bits of the given value|
 
+Examples:
+
+```grain
+Int16.lnot(-5S) == 4S
+```
+
 ### Int16.**(&)**
 
 <details disabled>
@@ -564,6 +711,13 @@ Returns:
 |----|-----------|
 |`Int16`|Containing a `1` in each bit position for which the corresponding bits of both operands are `1`|
 
+Examples:
+
+```grain
+use Int16.{ (&) }
+assert (3S & 4S) == 0S
+```
+
 ### Int16.**(|)**
 
 <details disabled>
@@ -590,6 +744,13 @@ Returns:
 |----|-----------|
 |`Int16`|Containing a `1` in each bit position for which the corresponding bits of either or both operands are `1`|
 
+Examples:
+
+```grain
+use Int16.{ (|) }
+assert (3S | 4S) == 7S
+```
+
 ### Int16.**(^)**
 
 <details disabled>
@@ -616,3 +777,10 @@ Returns:
 |----|-----------|
 |`Int16`|Containing a `1` in each bit position for which the corresponding bits of either but not both operands are `1`|
 
+Examples:
+
+```grain
+use Int16.{ (^) }
+assert (3S ^ 5S) == 6S
+```
+