@grain/stdlib 0.4.6 → 0.5.2

package/char.gr

@@ -9,11 +9,12 @@
  */
 
 import WasmI32 from "runtime/unsafe/wasmi32"
-import Memory from "runtime/unsafe/memory"
 import Errors from "runtime/unsafe/errors"
+import Tags from "runtime/unsafe/tags"
 import {
   tagSimpleNumber,
-  allocateChar,
+  tagChar,
+  untagChar,
   allocateString,
 } from "runtime/dataStructures"
 
@@ -58,71 +59,13 @@ export let isValid = charCode => {
  * 
  * @since 0.3.0
  */
-@disableGC
-export let rec code = (char: Char) => {
-  // Algorithm from https://encoding.spec.whatwg.org/#utf-8-decoder
+@unsafe
+export let code = (char: Char) => {
+  let usv = untagChar(char)
 
-  let char = WasmI32.fromGrain(char)
-
-  let (+) = WasmI32.add
-  let (==) = WasmI32.eq
-  let (>=) = WasmI32.geU
-  let (<=) = WasmI32.leU
-  let (<<) = WasmI32.shl
-  let (&) = WasmI32.and
-  let (|) = WasmI32.or
-
-  let mut codePoint = 0n
-  let mut bytesSeen = 0n
-  let mut bytesNeeded = 0n
-  let mut lowerBoundary = 0x80n
-  let mut upperBoundary = 0xBFn
-
-  let mut offset = 0n
-
-  let mut result = 0n
-
-  while (true) {
-    let byte = WasmI32.load8U(char + offset, 4n)
-    offset += 1n
-    if (bytesNeeded == 0n) {
-      if (byte >= 0x00n && byte <= 0x7Fn) {
-        result = byte
-        break
-      } else if (byte >= 0xC2n && byte <= 0xDFn) {
-        bytesNeeded = 1n
-        codePoint = byte & 0x1Fn
-      } else if (byte >= 0xE0n && byte <= 0xEFn) {
-        if (byte == 0xE0n) lowerBoundary = 0xA0n
-        if (byte == 0xEDn) upperBoundary = 0x9Fn
-        bytesNeeded = 2n
-        codePoint = byte & 0xFn
-      } else if (byte >= 0xF0n && byte <= 0xF4n) {
-        if (byte == 0xF0n) lowerBoundary = 0x90n
-        if (byte == 0xF4n) upperBoundary = 0x8Fn
-        bytesNeeded = 3n
-        codePoint = byte & 0x7n
-      } else {
-        throw MalformedUtf8
-      }
-      continue
-    }
-    if (!(lowerBoundary <= byte && byte <= upperBoundary)) {
-      throw MalformedUtf8
-    }
-    lowerBoundary = 0x80n
-    upperBoundary = 0xBFn
-    codePoint = codePoint << 6n | byte & 0x3Fn
-    bytesSeen += 1n
-    if (bytesSeen == bytesNeeded) {
-      result = codePoint
-      break
-    }
-  }
-
-  Memory.decRef(char)
-  Memory.decRef(WasmI32.fromGrain(code))
-  tagSimpleNumber(result)
+  // This could save an instruction by combining the two tagging operations,
+  // though we stick with tagSimpleNumber for simplicity.
+  tagSimpleNumber(usv)
 }
 
 /**
@@ -134,62 +77,26 @@ export let rec code = (char: Char) => {
  * 
  * @since 0.3.0
  */
-@disableGC
-export let rec fromCode = (usv: Number) => {
-  // Algorithm from https://encoding.spec.whatwg.org/#utf-8-encoder
-
-  let (+) = WasmI32.add
+@unsafe
+export let fromCode = (usv: Number) => {
   let (-) = WasmI32.sub
-  let (*) = WasmI32.mul
-  let (==) = WasmI32.eq
-  let (>) = WasmI32.gtU
-  let (<=) = WasmI32.leU
-  let (<) = WasmI32.ltU
-  let (>>>) = WasmI32.shrU
-  let (&) = WasmI32.and
-  let (|) = WasmI32.or
+  let (<<) = WasmI32.shl
 
-  let usv = WasmI32.fromGrain(usv)
-  if ((usv & 1n) == 0n) {
+  if (!isValid(usv)) {
     throw InvalidArgument("Invalid character code")
   }
 
-  let usv = usv >>> 1n
-  let result = if (usv < 0x80n) {
-    let char = allocateChar()
-    WasmI32.store8(char, usv, 4n)
-    WasmI32.toGrain(char): Char
-  } else {
-    let mut count = 0n
-    let mut offset = 0n
-    if (usv <= 0x07FFn) {
-      count = 1n
-      offset = 0xC0n
-    } else if (usv <= 0xFFFFn) {
-      count = 2n
-      offset = 0xE0n
-    } else {
-      count = 3n
-      offset = 0xF0n
-    }
-    let char = allocateChar()
-    WasmI32.store8(char, (usv >>> 6n * count) + offset, 4n)
-
-    let mut n = 0n
-    while (count > 0n) {
-      n += 1n
-      let temp = usv >>> 6n * (count - 1n)
-      WasmI32.store8(char + n, 0x80n | temp & 0x3Fn, 4n)
-      count -= 1n
-    }
+  // usv is now guaranteed to be a simple number
+  let usv = WasmI32.fromGrain(usv)
 
-    WasmI32.toGrain(char): Char
-  }
+  // Here we use a math trick to avoid fully untagging and retagging.
+  // Simple numbers are represented as 2n + 1 and chars are represented as
+  // 8n + 2. Quick reminder that shifting left is the equivalent of multiplying
+  // by 2, and that _GRAIN_CHAR_TAG_TYPE is equal to 2:
+  // 4(2n + 1) - 2 = 8n + 2
+  let char = (usv << 2n) - Tags._GRAIN_CHAR_TAG_TYPE
 
-  // We've asserted that the original `code` was a stack allocated number so
-  // no need to decRef it
-  Memory.decRef(WasmI32.fromGrain(fromCode))
-  result
+  WasmI32.toGrain(char): Char
 }
 
 /**
@@ -240,27 +147,50 @@ export let pred = char => {
  * 
  * @since 0.3.0
  */
-@disableGC
-export let rec toString = (char: Char) => {
+@unsafe
+export let toString = (char: Char) => {
   let (+) = WasmI32.add
+  let (-) = WasmI32.sub
+  let (*) = WasmI32.mul
   let (&) = WasmI32.and
-  let (==) = WasmI32.eq
+  let (|) = WasmI32.or
+  let (>>>) = WasmI32.shrU
+  let (<) = WasmI32.ltU
+  let (>) = WasmI32.gtU
+  let (<=) = WasmI32.leU
+
+  let usv = untagChar(char)
 
-  let char = WasmI32.fromGrain(char)
-  let byte = WasmI32.load8U(char, 4n)
-  let n = if ((byte & 0x80n) == 0x00n) {
-    1n
-  } else if ((byte & 0xF0n) == 0xF0n) {
-    4n
-  } else if ((byte & 0xE0n) == 0xE0n) {
-    3n
+  let result = if (usv < 0x80n) {
+    let string = allocateString(1n)
+    WasmI32.store8(string, usv, 8n)
+    WasmI32.toGrain(string): String
   } else {
-    2n
+    let mut count = 0n
+    let mut offset = 0n
+    if (usv <= 0x07FFn) {
+      count = 1n
+      offset = 0xC0n
+    } else if (usv <= 0xFFFFn) {
+      count = 2n
+      offset = 0xE0n
+    } else {
+      count = 3n
+      offset = 0xF0n
+    }
+    let string = allocateString(count + 1n)
+    WasmI32.store8(string, (usv >>> 6n * count) + offset, 8n)
+
+    let mut n = 0n
+    while (count > 0n) {
+      n += 1n
+      let temp = usv >>> 6n * (count - 1n)
+      WasmI32.store8(string + n, 0x80n | temp & 0x3Fn, 8n)
+      count -= 1n
+    }
+
+    WasmI32.toGrain(string): String
   }
-  let str = allocateString(n)
-  Memory.copy(str + 8n, char + 4n, n)
-  let ret = WasmI32.toGrain(str): String
-  Memory.decRef(WasmI32.fromGrain(char))
-  Memory.decRef(WasmI32.fromGrain(toString))
-  ret
+
+  result
 }

package/exception.gr

@@ -1,11 +1,37 @@
+/**
+ * @module Exception: Utilities for working with the Exception type.
+ *
+ * The Exception type represents an error that has occured during computation.
+ *
+ * @example import Exception from "exception"
+ *
+ * @since 0.3.0
+ */
+
 import WasmI32 from "runtime/unsafe/wasmi32"
 import Memory from "runtime/unsafe/memory"
 import Exception from "runtime/exception"
 
+/**
+ * @section Values: Functions included in the Exception module.
+ */
+
+/**
+ * Registers an exception printer. When an exception is thrown, all registered
+ * printers are called in order from the most recently registered printer to
+ * the least recently registered printer. The first `Some` value returned is
+ * used as the exception's string value.
+ *
+ * @param printer: The exception printer to register
+ * @since v0.3.0
+ */
 @disableGC
-export let rec registerPrinter = (f: Exception -> Option<String>) => {
+export let rec registerPrinter = (printer: Exception -> Option<String>) => {
+  // This function _must_ be @disableGC because the printer list uses
+  // unsafe types. Not really a memory leak as this list is never collected
+
   // no need to increment refcount on f; we just don't decRef it at the end of the function
-  Exception.printers = WasmI32.fromGrain((f, Exception.printers))
+  Exception.printers = WasmI32.fromGrain((printer, Exception.printers))
   Memory.decRef(WasmI32.fromGrain(registerPrinter))
   void
 }

package/exception.md

@@ -0,0 +1,43 @@
+---
+title: Exception
+---
+
+Utilities for working with the Exception type.
+
+The Exception type represents an error that has occured during computation.
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.3.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+import Exception from "exception"
+```
+
+## Values
+
+Functions included in the Exception module.
+
+### Exception.**registerPrinter**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.3.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+registerPrinter : (Exception -> Option<String>) -> Void
+```
+
+Registers an exception printer. When an exception is thrown, all registered
+printers are called in order from the most recently registered printer to
+the least recently registered printer. The first `Some` value returned is
+used as the exception's string value.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`printer`|`Exception -> Option<String>`|The exception printer to register|
+

package/float32.gr

@@ -6,16 +6,63 @@
  */
 import WasmI32 from "runtime/unsafe/wasmi32"
 import WasmF32 from "runtime/unsafe/wasmf32"
-import Memory from "runtime/unsafe/memory"
-import {
-  newFloat32
-} from "runtime/dataStructures"
+import { newFloat32 } from "runtime/dataStructures"
 
 import {
   coerceNumberToFloat32 as fromNumber,
-  coerceFloat32ToNumber as toNumber
+  coerceFloat32ToNumber as toNumber,
 } from "runtime/numbers"
 
+/**
+ * @section Constants: Float32 constant values.
+ */
+
+/**
+ * Infinity represented as a Float32 value.
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let infinity = {
+  let ptr = newFloat32(
+    WasmF32.reinterpretI32(0b01111111100000000000000000000000n)
+  )
+  WasmI32.toGrain(ptr): Float32
+}
+
+/**
+ * NaN (Not a Number) represented as a Float32 value.
+ * 
+ * @since v0.4.0
+ */
+@unsafe
+export let nan = {
+  let ptr = newFloat32(
+    WasmF32.reinterpretI32(0b01111111100000000000000000000001n)
+  )
+  WasmI32.toGrain(ptr): Float32
+}
+
+/**
+ * Pi represented as a Float32 value.
+ * 
+ * @since v0.5.2
+ */
+export let pi = 3.1415927f
+
+/**
+ * Tau represented as a Float32 value.
+ * 
+ * @since v0.5.2
+ */
+export let tau = 6.2831853f
+
+/**
+ * Euler's number represented as a Float32 value.
+ * 
+ * @since v0.5.2
+ */
+export let e = 2.7182817f
 /**
  * @section Conversions: Functions for converting between Numbers and the Float32 type.
  */
@@ -53,16 +100,12 @@ export toNumber
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec add = (x: Float32, y: Float32) => {
+@unsafe
+export let add = (x: Float32, y: Float32) => {
   let xv = WasmF32.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF32.load(WasmI32.fromGrain(y), 8n)
   let ptr = newFloat32(WasmF32.add(xv, yv))
-  let ret = WasmI32.toGrain(ptr) : Float32
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(add))
-  ret
+  WasmI32.toGrain(ptr): Float32
 }
 
 /**
@@ -74,16 +117,12 @@ export let rec add = (x: Float32, y: Float32) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec sub = (x: Float32, y: Float32) => {
+@unsafe
+export let sub = (x: Float32, y: Float32) => {
   let xv = WasmF32.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF32.load(WasmI32.fromGrain(y), 8n)
   let ptr = newFloat32(WasmF32.sub(xv, yv))
-  let ret = WasmI32.toGrain(ptr) : Float32
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(sub))
-  ret
+  WasmI32.toGrain(ptr): Float32
 }
 
 /**
@@ -95,16 +134,12 @@ export let rec sub = (x: Float32, y: Float32) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec mul = (x: Float32, y: Float32) => {
+@unsafe
+export let mul = (x: Float32, y: Float32) => {
   let xv = WasmF32.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF32.load(WasmI32.fromGrain(y), 8n)
   let ptr = newFloat32(WasmF32.mul(xv, yv))
-  let ret = WasmI32.toGrain(ptr) : Float32
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(mul))
-  ret
+  WasmI32.toGrain(ptr): Float32
 }
 
 /**
@@ -116,16 +151,12 @@ export let rec mul = (x: Float32, y: Float32) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec div = (x: Float32, y: Float32) => {
+@unsafe
+export let div = (x: Float32, y: Float32) => {
   let xv = WasmF32.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF32.load(WasmI32.fromGrain(y), 8n)
   let ptr = newFloat32(WasmF32.div(xv, yv))
-  let ret = WasmI32.toGrain(ptr) : Float32
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(div))
-  ret
+  WasmI32.toGrain(ptr): Float32
 }
 
 /**
@@ -141,15 +172,11 @@ export let rec div = (x: Float32, y: Float32) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec lt = (x: Float32, y: Float32) => {
+@unsafe
+export let lt = (x: Float32, y: Float32) => {
   let xv = WasmF32.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF32.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmF32.lt(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(lt))
-  ret
+  WasmF32.lt(xv, yv)
 }
 
 /**
@@ -161,15 +188,11 @@ export let rec lt = (x: Float32, y: Float32) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec gt = (x: Float32, y: Float32) => {
+@unsafe
+export let gt = (x: Float32, y: Float32) => {
   let xv = WasmF32.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF32.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmF32.gt(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(gt))
-  ret
+  WasmF32.gt(xv, yv)
 }
 
 /**
@@ -181,15 +204,11 @@ export let rec gt = (x: Float32, y: Float32) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec lte = (x: Float32, y: Float32) => {
+@unsafe
+export let lte = (x: Float32, y: Float32) => {
   let xv = WasmF32.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF32.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmF32.le(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(lte))
-  ret
+  WasmF32.le(xv, yv)
 }
 
 /**
@@ -201,47 +220,9 @@ export let rec lte = (x: Float32, y: Float32) => {
  * 
  * @since v0.2.0
  */
-@disableGC
-export let rec gte = (x: Float32, y: Float32) => {
+@unsafe
+export let gte = (x: Float32, y: Float32) => {
   let xv = WasmF32.load(WasmI32.fromGrain(x), 8n)
   let yv = WasmF32.load(WasmI32.fromGrain(y), 8n)
-  let ret = WasmF32.ge(xv, yv)
-  Memory.decRef(WasmI32.fromGrain(x))
-  Memory.decRef(WasmI32.fromGrain(y))
-  Memory.decRef(WasmI32.fromGrain(gte))
-  ret
+  WasmF32.ge(xv, yv)
 }
-
-/**
- * @section Constants: Float32 constant values.
- */
-
-@disableGC
-let rec makeInfinity = () => {
-  let ptr = newFloat32(WasmF32.reinterpretI32(0b01111111100000000000000000000000n))
-  let ret = WasmI32.toGrain(ptr) : Float32
-  Memory.decRef(WasmI32.fromGrain(makeInfinity))
-  ret
-}
-
-/**
- * Infinity represented as a Float32 value.
- * 
- * @since v0.4.0
- */
-export let infinity = makeInfinity()
-
-@disableGC
-let rec makeNaN = () => {
-  let ptr = newFloat32(WasmF32.reinterpretI32(0b01111111100000000000000000000001n))
-  let ret = WasmI32.toGrain(ptr) : Float32
-  Memory.decRef(WasmI32.fromGrain(makeNaN))
-  ret
-}
-
-/**
- * NaN (Not a Number) represented as a Float32 value.
- * 
- * @since v0.4.0
- */
-export let nan = makeNaN()

package/float32.md

@@ -13,6 +13,75 @@ No other changes yet.
 import Float32 from "float32"
 ```
 
+## Constants
+
+Float32 constant values.
+
+### Float32.**infinity**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.4.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+infinity : Float32
+```
+
+Infinity represented as a Float32 value.
+
+### Float32.**nan**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.4.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+nan : Float32
+```
+
+NaN (Not a Number) represented as a Float32 value.
+
+### Float32.**pi**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+pi : Float32
+```
+
+Pi represented as a Float32 value.
+
+### Float32.**tau**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+tau : Float32
+```
+
+Tau represented as a Float32 value.
+
+### Float32.**e**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>next</code></summary>
+No other changes yet.
+</details>
+
+```grain
+e : Float32
+```
+
+Euler's number represented as a Float32 value.
+
 ## Conversions
 
 Functions for converting between Numbers and the Float32 type.
@@ -283,33 +352,3 @@ Returns:
 |----|-----------|
 |`Bool`|`true` if the first value is greater than or equal to the second value or `false` otherwise|
 
-## Constants
-
-Float32 constant values.
-
-### Float32.**infinity**
-
-<details disabled>
-<summary tabindex="-1">Added in <code>0.4.0</code></summary>
-No other changes yet.
-</details>
-
-```grain
-infinity : Float32
-```
-
-Infinity represented as a Float32 value.
-
-### Float32.**nan**
-
-<details disabled>
-<summary tabindex="-1">Added in <code>0.4.0</code></summary>
-No other changes yet.
-</details>
-
-```grain
-nan : Float32
-```
-
-NaN (Not a Number) represented as a Float32 value.
-