@grain/stdlib 0.6.3 → 0.6.5

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.6.5](https://github.com/grain-lang/grain/compare/stdlib-v0.6.4...stdlib-v0.6.5) (2024-07-31)
+
+
+### Features
+
+* **stdlib:** Add `abs`, `neg`, `isNaN`, `isInfinite` to `Float32` ([#2116](https://github.com/grain-lang/grain/issues/2116)) ([fb1d481](https://github.com/grain-lang/grain/commit/fb1d481715974c6639588a9a72d4739516319e40))
+* **stdlib:** Add `abs`, `neg`, `isNaN`, `isInfinite` to `Float64` ([#2117](https://github.com/grain-lang/grain/issues/2117)) ([9469346](https://github.com/grain-lang/grain/commit/9469346fa26a4df4188e53f8994d5692286d2e9f))
+* **stdlib:** Add `forEachChar`, `forEachCharI`, `map` and `mapi` to String module ([#1864](https://github.com/grain-lang/grain/issues/1864)) ([4305e82](https://github.com/grain-lang/grain/commit/4305e829e160c6d2e49a249e3ec19baaa3c33744))
+
+
+### Bug Fixes
+
+* **stdlib:** Ensure references are retained in unsafe stdlib functions ([#2118](https://github.com/grain-lang/grain/issues/2118)) ([639856f](https://github.com/grain-lang/grain/commit/639856f9f99edb00bfb19a0ec6f298d48972d3e4))
+
+## [0.6.4](https://github.com/grain-lang/grain/compare/stdlib-v0.6.3...stdlib-v0.6.4) (2024-06-27)
+
+
+### Features
+
+* **stdlib:** Faster memory allocator ([#2124](https://github.com/grain-lang/grain/issues/2124)) ([03e10c4](https://github.com/grain-lang/grain/commit/03e10c49d204a488f8bd56c7b7262e717ee61762))
+
 ## [0.6.3](https://github.com/grain-lang/grain/compare/stdlib-v0.6.2...stdlib-v0.6.3) (2024-04-06)
 
 

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2023 Oscar Spencer <oscar@grain-lang.org> and Philip Blair <philip@grain-lang.org>
+Copyright (c) 2017-2024 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

@@ -91,6 +91,7 @@ provide let make = (length: Number, item: a) => {
       _ARRAY_START_OFFSET
     )
   }
+  ignore(item)
   WasmI32.toGrain(array): Array<a>
 }
 
@@ -988,6 +989,7 @@ provide let join = (separator: String, items: Array<String>) => {
     if (i != arrLen) Memory.copy(offset, sepPtr, sepSize)
     offset += sepSize
   }
+  ignore(separator)
   WasmI32.toGrain(newString): String
 }
 

package/bytes.gr

@@ -113,6 +113,7 @@ provide let fromString = (string: String) => {
   let size = getSize(src)
   let dst = allocateBytes(size)
   Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
+  ignore(string)
   WasmI32.toGrain(dst): Bytes
 }
 
@@ -134,6 +135,7 @@ provide let toString = (bytes: Bytes) => {
   let size = getSize(src)
   let dst = allocateString(size)
   Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
+  ignore(bytes)
   WasmI32.toGrain(dst): String
 }
 
@@ -151,7 +153,9 @@ provide let toString = (bytes: Bytes) => {
 @unsafe
 provide let length = (bytes: Bytes) => {
   let b = WasmI32.fromGrain(bytes)
-  Conv.wasmI32ToNumber(getSize(b))
+  let result = Conv.wasmI32ToNumber(getSize(b))
+  ignore(bytes)
+  result
 }
 
 /**
@@ -171,6 +175,7 @@ provide let copy = (bytes: Bytes) => {
   let size = getSize(src)
   let dst = allocateBytes(size)
   Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET, size)
+  ignore(bytes)
   WasmI32.toGrain(dst): Bytes
 }
 
@@ -208,6 +213,7 @@ provide let slice = (start: Number, length: Number, bytes: Bytes) => {
   let dst = allocateBytes(length)
   let offset = start
   Memory.copy(dst + _VALUE_OFFSET, src + _VALUE_OFFSET + start, length)
+  ignore(bytes)
   WasmI32.toGrain(dst): Bytes
 }
 
@@ -263,6 +269,7 @@ provide let resize = (left: Number, right: Number, bytes: Bytes) => {
       len
     )
   }
+  ignore(bytes)
   WasmI32.toGrain(dst): Bytes
 }
 
@@ -298,11 +305,11 @@ provide let move = (
   let srcIndexOrig = srcIndex
   let dstIndexOrig = dstIndex
   let lenthOrig = length
-  let src = WasmI32.fromGrain(src)
-  let srcSize = getSize(src)
+  let srcPtr = WasmI32.fromGrain(src)
+  let srcSize = getSize(srcPtr)
   let srcIndex = coerceNumberToWasmI32(srcIndex)
-  let dst = WasmI32.fromGrain(dst)
-  let dstSize = getSize(dst)
+  let dstPtr = WasmI32.fromGrain(dst)
+  let dstSize = getSize(dstPtr)
   let dstIndex = coerceNumberToWasmI32(dstIndex)
   let length = coerceNumberToWasmI32(length)
   if (srcIndex + length > srcSize) {
@@ -313,10 +320,12 @@ provide let move = (
   }
   let end = srcIndex + length
   Memory.copy(
-    dst + _VALUE_OFFSET + dstIndex,
-    src + _VALUE_OFFSET + srcIndex,
+    dstPtr + _VALUE_OFFSET + dstIndex,
+    srcPtr + _VALUE_OFFSET + srcIndex,
     length
   )
+  ignore(src)
+  ignore(dst)
 }
 
 /**
@@ -362,6 +371,7 @@ provide let fill = (value: Uint8, bytes: Bytes) => {
   let size = getSize(src)
   let v = untagUint8(value)
   Memory.fill(src + _VALUE_OFFSET, v, size)
+  ignore(bytes)
 }
 
 /**
@@ -383,6 +393,7 @@ provide let clear = (bytes: Bytes) => {
   let src = WasmI32.fromGrain(bytes)
   let size = getSize(src)
   Memory.fill(src + _VALUE_OFFSET, 0n, size)
+  ignore(bytes)
 }
 
 /**
@@ -411,6 +422,7 @@ provide let getInt8 = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
   let n = WasmI32.load8S(ptr + offset, _VALUE_OFFSET)
+  ignore(bytes)
   tagInt8(n)
 }
 
@@ -440,6 +452,7 @@ provide let setInt8 = (index: Number, value: Int8, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
   let v = untagInt8(value)
+  ignore(bytes)
   WasmI32.store8(ptr + offset, v, _VALUE_OFFSET)
 }
 
@@ -469,6 +482,7 @@ provide let getUint8 = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
   let n = WasmI32.load8U(ptr + offset, _VALUE_OFFSET)
+  ignore(bytes)
   tagUint8(n)
 }
 
@@ -498,6 +512,7 @@ provide let setUint8 = (index: Number, value: Uint8, bytes: Bytes) => {
   checkIndexIsInBounds(offset, _INT8_BYTE_SIZE, size)
   let v = untagUint8(value)
   WasmI32.store8(ptr + offset, v, _VALUE_OFFSET)
+  ignore(bytes)
 }
 
 /**
@@ -526,6 +541,7 @@ provide let getInt16 = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
   let n = WasmI32.load16S(ptr + offset, _VALUE_OFFSET)
+  ignore(bytes)
   tagInt16(n)
 }
 
@@ -556,6 +572,7 @@ provide let setInt16 = (index: Number, value: Int16, bytes: Bytes) => {
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
   let v = untagInt16(value)
   WasmI32.store16(ptr + offset, v, _VALUE_OFFSET)
+  ignore(bytes)
 }
 
 /**
@@ -584,6 +601,7 @@ provide let getUint16 = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
   let n = WasmI32.load16U(ptr + offset, _VALUE_OFFSET)
+  ignore(bytes)
   tagUint16(n)
 }
 
@@ -613,6 +631,7 @@ provide let setUint16 = (index: Number, value: Uint16, bytes: Bytes) => {
   checkIndexIsInBounds(offset, _INT16_BYTE_SIZE, size)
   let v = untagUint16(value)
   WasmI32.store16(ptr + offset, v, _VALUE_OFFSET)
+  ignore(bytes)
 }
 
 /**
@@ -640,6 +659,7 @@ provide let getInt32 = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let n = WasmI32.load(ptr + offset, _VALUE_OFFSET)
+  ignore(bytes)
   Conv.toInt32(n)
 }
 
@@ -669,6 +689,7 @@ provide let setInt32 = (index: Number, value: Int32, bytes: Bytes) => {
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let v = Conv.fromInt32(value)
   WasmI32.store(ptr + offset, v, _VALUE_OFFSET)
+  ignore(bytes)
 }
 
 /**
@@ -696,6 +717,7 @@ provide let getUint32 = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let n = WasmI32.load(ptr + offset, _VALUE_OFFSET)
+  ignore(bytes)
   Conv.toUint32(n)
 }
 
@@ -725,6 +747,7 @@ provide let setUint32 = (index: Number, value: Uint32, bytes: Bytes) => {
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let v = Conv.fromUint32(value)
   WasmI32.store(ptr + offset, v, _VALUE_OFFSET)
+  ignore(bytes)
 }
 
 /**
@@ -752,6 +775,7 @@ provide let getFloat32 = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let n = WasmF32.load(ptr + offset, _VALUE_OFFSET)
+  ignore(bytes)
   Conv.toFloat32(n)
 }
 
@@ -781,6 +805,7 @@ provide let setFloat32 = (index: Number, value: Float32, bytes: Bytes) => {
   checkIndexIsInBounds(offset, _INT32_BYTE_SIZE, size)
   let v = Conv.fromFloat32(value)
   WasmF32.store(ptr + offset, v, _VALUE_OFFSET)
+  ignore(bytes)
 }
 
 /**
@@ -808,6 +833,7 @@ provide let getInt64 = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
   let n = WasmI64.load(ptr + offset, _VALUE_OFFSET)
+  ignore(bytes)
   Conv.toInt64(n)
 }
 
@@ -837,6 +863,7 @@ provide let setInt64 = (index: Number, value: Int64, bytes: Bytes) => {
   checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
   let v = Conv.fromInt64(value)
   WasmI64.store(ptr + offset, v, _VALUE_OFFSET)
+  ignore(bytes)
 }
 
 /**
@@ -864,6 +891,7 @@ provide let getUint64 = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
   let n = WasmI64.load(ptr + offset, _VALUE_OFFSET)
+  ignore(bytes)
   Conv.toUint64(n)
 }
 
@@ -893,6 +921,7 @@ provide let setUint64 = (index: Number, value: Uint64, bytes: Bytes) => {
   checkIndexIsInBounds(offset, _INT64_BYTE_SIZE, size)
   let v = Conv.fromUint64(value)
   WasmI64.store(ptr + offset, v, _VALUE_OFFSET)
+  ignore(bytes)
 }
 
 /**
@@ -920,6 +949,7 @@ provide let getFloat64 = (index: Number, bytes: Bytes) => {
   let offset = coerceNumberToWasmI32(index)
   checkIndexIsInBounds(offset, _FLOAT64_BYTE_SIZE, size)
   let n = WasmF64.load(ptr + offset, _VALUE_OFFSET)
+  ignore(bytes)
   Conv.toFloat64(n)
 }
 
@@ -949,4 +979,5 @@ provide let setFloat64 = (index: Number, value: Float64, bytes: Bytes) => {
   checkIndexIsInBounds(offset, _FLOAT64_BYTE_SIZE, size)
   let v = Conv.fromFloat64(value)
   WasmF64.store(ptr + offset, v, _VALUE_OFFSET)
+  ignore(bytes)
 }

package/float32.gr

@@ -247,3 +247,71 @@ provide let (>=) = (x: Float32, y: Float32) => {
   let yv = WasmF32.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
   xv >= yv
 }
+
+/**
+ * Checks if the value is a float NaN value (Not A Number).
+ *
+ * @param x: The value to check
+ * @returns `true` if the value is NaN, otherwise `false`
+ *
+ * @example Float32.isNaN(NaNf)
+ * @example Float32.isNaN(Infinityf) == false
+ * @example Float32.isNaN(-Infinityf) == false
+ * @example Float32.isNaN(0.5f) == false
+ * @example Float32.isNaN(1.0f) == false
+ *
+ * @since v0.6.5
+ */
+provide let isNaN = (x: Float32) => x != x
+
+/**
+ * Checks if a float is infinite, that is either of positive or negative infinity.
+ *
+ * @param x: The value to check
+ * @returns `true` if the value is infinite or `false` otherwise
+ *
+ * @example Float32.isInfinite(Infinityf)
+ * @example Float32.isInfinite(-Infinityf)
+ * @example Float32.isInfinite(NaNf) == false
+ * @example Float32.isInfinite(0.5f) == false
+ * @example Float32.isInfinite(1.0f) == false
+ *
+ * @since v0.6.5
+ */
+provide let isInfinite = (x: Float32) => x == Infinityf || x == -Infinityf
+
+/**
+ * Returns the absolute value. That is, it returns `x` if `x` is positive or zero and the negation of `x` if `x` is negative.
+ *
+ * @param x: The operand
+ * @returns The absolute value of the operand
+ *
+ * @example Float32.abs(-1.0f) == 1.0f
+ * @example Float32.abs(5.0f) == 5.0f
+ *
+ * @since v0.6.5
+ */
+@unsafe
+provide let abs = (x: Float32) => {
+  let xv = WasmF32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let ptr = newFloat32(WasmF32.abs(xv))
+  WasmI32.toGrain(ptr): Float32
+}
+
+/**
+ * Returns the negation of its operand.
+ *
+ * @param x: The operand
+ * @returns The negated operand
+ *
+ * @example Float32.neg(-1.0f) == 1.0f
+ * @example Float32.neg(1.0f) == -1.0f
+ *
+ * @since v0.6.5
+ */
+@unsafe
+provide let neg = (x: Float32) => {
+  let xv = WasmF32.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let ptr = newFloat32(WasmF32.neg(xv))
+  WasmI32.toGrain(ptr): Float32
+}

package/float32.md

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

package/float64.gr

@@ -24,6 +24,9 @@ use Numbers.{
   coerceFloat64ToNumber as toNumber,
 }
 
+@unsafe
+let _VALUE_OFFSET = 8n
+
 /**
  * Infinity represented as a Float64 value.
  * This is an alternative to the `Infinityd` literal.
@@ -81,8 +84,8 @@ provide { fromNumber, toNumber }
  */
 @unsafe
 provide let (+) = (x: Float64, y: Float64) => {
-  let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
   let ptr = newFloat64(xv + yv)
   WasmI32.toGrain(ptr): Float64
 }
@@ -103,8 +106,8 @@ provide let (+) = (x: Float64, y: Float64) => {
  */
 @unsafe
 provide let (-) = (x: Float64, y: Float64) => {
-  let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
   let ptr = newFloat64(xv - yv)
   WasmI32.toGrain(ptr): Float64
 }
@@ -125,8 +128,8 @@ provide let (-) = (x: Float64, y: Float64) => {
  */
 @unsafe
 provide let (*) = (x: Float64, y: Float64) => {
-  let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
   let ptr = newFloat64(xv * yv)
   WasmI32.toGrain(ptr): Float64
 }
@@ -147,8 +150,8 @@ provide let (*) = (x: Float64, y: Float64) => {
  */
 @unsafe
 provide let (/) = (x: Float64, y: Float64) => {
-  let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
   let ptr = newFloat64(xv / yv)
   WasmI32.toGrain(ptr): Float64
 }
@@ -169,8 +172,8 @@ provide let (/) = (x: Float64, y: Float64) => {
  */
 @unsafe
 provide let (<) = (x: Float64, y: Float64) => {
-  let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
   xv < yv
 }
 
@@ -190,8 +193,8 @@ provide let (<) = (x: Float64, y: Float64) => {
  */
 @unsafe
 provide let (>) = (x: Float64, y: Float64) => {
-  let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
   xv > yv
 }
 
@@ -215,8 +218,8 @@ provide let (>) = (x: Float64, y: Float64) => {
  */
 @unsafe
 provide let (<=) = (x: Float64, y: Float64) => {
-  let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
   xv <= yv
 }
 
@@ -240,7 +243,75 @@ provide let (<=) = (x: Float64, y: Float64) => {
  */
 @unsafe
 provide let (>=) = (x: Float64, y: Float64) => {
-  let xv = WasmF64.load(WasmI32.fromGrain(x), 8n)
-  let yv = WasmF64.load(WasmI32.fromGrain(y), 8n)
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let yv = WasmF64.load(WasmI32.fromGrain(y), _VALUE_OFFSET)
   xv >= yv
 }
+
+/**
+ * Checks if the value is a float NaN value (Not A Number).
+ *
+ * @param x: The value to check
+ * @returns `true` if the value is NaN, otherwise `false`
+ *
+ * @example Float64.isNaN(NaNd)
+ * @example Float64.isNaN(Infinityd) == false
+ * @example Float64.isNaN(-Infinityd) == false
+ * @example Float64.isNaN(0.5d) == false
+ * @example Float64.isNaN(1.0d) == false
+ *
+ * @since v0.6.5
+ */
+provide let isNaN = (x: Float64) => x != x
+
+/**
+ * Checks if a float is infinite, that is either of positive or negative infinity.
+ *
+ * @param x: The value to check
+ * @returns `true` if the value is infinite or `false` otherwise
+ *
+ * @example Float64.isInfinite(Infinityd)
+ * @example Float64.isInfinite(-Infinityd)
+ * @example Float64.isInfinite(NaNd) == false
+ * @example Float64.isInfinite(0.5d) == false
+ * @example Float64.isInfinite(1.0d) == false
+ *
+ * @since v0.6.5
+ */
+provide let isInfinite = (x: Float64) => x == Infinityd || x == -Infinityd
+
+/**
+ * Returns the absolute value. That is, it returns `x` if `x` is positive or zero and the negation of `x` if `x` is negative.
+ *
+ * @param x: The operand
+ * @returns The absolute value of the operand
+ *
+ * @example Float64.abs(-1.0d) == 1.0d
+ * @example Float64.abs(5.0d) == 5.0d
+ *
+ * @since v0.6.5
+ */
+@unsafe
+provide let abs = (x: Float64) => {
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let ptr = newFloat64(WasmF64.abs(xv))
+  WasmI32.toGrain(ptr): Float64
+}
+
+/**
+ * Returns the negation of its operand.
+ *
+ * @param x: The operand
+ * @returns The negated operand
+ *
+ * @example Float64.neg(-1.0d) == 1.0d
+ * @example Float64.neg(1.0d) == -1.0d
+ *
+ * @since v0.6.5
+ */
+@unsafe
+provide let neg = (x: Float64) => {
+  let xv = WasmF64.load(WasmI32.fromGrain(x), _VALUE_OFFSET)
+  let ptr = newFloat64(WasmF64.neg(xv))
+  WasmI32.toGrain(ptr): Float64
+}