@grain/stdlib 0.5.12 → 0.6.0

package/runtime/string.md

@@ -1,24 +1,94 @@
-### String.**StringList**
+---
+title: String
+---
+
+## Values
+
+Functions and constants included in the String module.
+
+### String.**concat**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.2.0</code></summary>
+No other changes yet.
+</details>
 
 ```grain
-type StringList
+concat : (str1: String, str2: String) => String
 ```
 
-### String.**concat**
+Concatenate two strings.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`str1`|`String`|The beginning string|
+|`str2`|`String`|The ending string|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`String`|The combined string|
+
+Examples:
 
 ```grain
-concat : (String, String) -> String
+"Foo" ++ "Bar" == "FooBar"
 ```
 
 ### String.**toString**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.1.0</code></summary>
+No other changes yet.
+</details>
+
 ```grain
-toString : a -> String
+toString : (value: a) => String
 ```
 
+Converts the given operand to a string.
+Provides a better representation of data types if those types are provided from the module.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`value`|`a`|The operand|
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`String`|The operand, as a string|
+
 ### String.**print**
 
+<details disabled>
+<summary tabindex="-1">Added in <code>0.1.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+print : (value: a, ?suffix: String) => Void
+```
+
+Prints the given operand to the console. Works for any type. Internally, calls `toString`
+on the operand, so a better representation of data type will be printed if those types
+are provided from the module.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`value`|`a`|The operand|
+|`?suffix`|`String`|The string to print after the argument|
+
+### String.**getCodePoint**
+
 ```grain
-print : a -> Void
+getCodePoint : (ptr: WasmI32) => WasmI32
 ```
 

package/runtime/unsafe/constants.gr

@@ -1,17 +1,34 @@
-/* grainc-flags --compilation-mode=runtime */
+@runtimeMode
+module Constants
 
 // Signed/Unsigned Min/Max Constants
-export let _SMIN_I32 = 0xFFFFFFFFn
-export let _SMAX_I32 = 0x7FFFFFFFn
-export let _UMIN_I32 = 0x0n
-export let _UMAX_I32 = 0xFFFFFFFFn
+provide let _SMIN_I32 = 0x80000000n
+provide let _SMAX_I32 = 0x7FFFFFFFn
+provide let _UMIN_I32 = 0x0n
+provide let _UMAX_I32 = 0xFFFFFFFFn
 
-export let _SMIN_I64 = 0xFFFFFFFFFFFFFFFFN
-export let _SMAX_I64 = 0x7FFFFFFFFFFFFFFFN
-export let _UMIN_I64 = 0x0N
-export let _UMAX_I64 = 0xFFFFFFFFFFFFFFFFN
+provide let _SMIN8_I32 = -0x7Fn
+provide let _SMAX8_I32 = 0x7Fn
+provide let _UMAX8_I32 = 0xFFn
 
-export let _SMIN32_I64 = -0x7FFFFFFFN
-export let _SMAX32_I64 = 0x7FFFFFFFN
-export let _UMIN32_I64 = 0x0N
-export let _UMAX32_I64 = 0xFFFFFFFFN
+provide let _SMIN16_I32 = -0x7FFFn
+provide let _SMAX16_I32 = 0x7FFFn
+provide let _UMAX16_I32 = 0xFFFFn
+
+provide let _SMIN_I64 = 0x8000000000000000N
+provide let _SMAX_I64 = 0x7FFFFFFFFFFFFFFFN
+provide let _UMIN_I64 = 0x0N
+provide let _UMAX_I64 = 0xFFFFFFFFFFFFFFFFN
+
+provide let _SMIN8_I64 = -0x7FN
+provide let _SMAX8_I64 = 0x7FN
+provide let _UMAX8_I64 = 0xFFN
+
+provide let _SMIN16_I64 = -0x7FFFN
+provide let _SMAX16_I64 = 0x7FFFN
+provide let _UMAX16_I64 = 0xFFFFN
+
+provide let _SMIN32_I64 = 0xFFFFFFFF80000000N
+provide let _SMAX32_I64 = 0x7FFFFFFFN
+provide let _UMIN32_I64 = 0x0N
+provide let _UMAX32_I64 = 0xFFFFFFFFN

package/runtime/unsafe/constants.md

@@ -1,3 +1,11 @@
+---
+title: Constants
+---
+
+## Values
+
+Functions and constants included in the Constants module.
+
 ### Constants.**_SMIN_I32**
 
 ```grain
@@ -22,6 +30,42 @@ _UMIN_I32 : WasmI32
 _UMAX_I32 : WasmI32
 ```
 
+### Constants.**_SMIN8_I32**
+
+```grain
+_SMIN8_I32 : WasmI32
+```
+
+### Constants.**_SMAX8_I32**
+
+```grain
+_SMAX8_I32 : WasmI32
+```
+
+### Constants.**_UMAX8_I32**
+
+```grain
+_UMAX8_I32 : WasmI32
+```
+
+### Constants.**_SMIN16_I32**
+
+```grain
+_SMIN16_I32 : WasmI32
+```
+
+### Constants.**_SMAX16_I32**
+
+```grain
+_SMAX16_I32 : WasmI32
+```
+
+### Constants.**_UMAX16_I32**
+
+```grain
+_UMAX16_I32 : WasmI32
+```
+
 ### Constants.**_SMIN_I64**
 
 ```grain
@@ -46,6 +90,42 @@ _UMIN_I64 : WasmI64
 _UMAX_I64 : WasmI64
 ```
 
+### Constants.**_SMIN8_I64**
+
+```grain
+_SMIN8_I64 : WasmI64
+```
+
+### Constants.**_SMAX8_I64**
+
+```grain
+_SMAX8_I64 : WasmI64
+```
+
+### Constants.**_UMAX8_I64**
+
+```grain
+_UMAX8_I64 : WasmI64
+```
+
+### Constants.**_SMIN16_I64**
+
+```grain
+_SMIN16_I64 : WasmI64
+```
+
+### Constants.**_SMAX16_I64**
+
+```grain
+_SMAX16_I64 : WasmI64
+```
+
+### Constants.**_UMAX16_I64**
+
+```grain
+_UMAX16_I64 : WasmI64
+```
+
 ### Constants.**_SMIN32_I64**
 
 ```grain

package/runtime/unsafe/conv.gr

@@ -1,66 +1,94 @@
-import WasmI32 from "runtime/unsafe/wasmi32"
-import WasmI64 from "runtime/unsafe/wasmi64"
-import WasmF32 from "runtime/unsafe/wasmf32"
-import WasmF64 from "runtime/unsafe/wasmf64"
-import {
+module Conv
+
+from "runtime/unsafe/wasmi32" include WasmI32
+from "runtime/unsafe/wasmi64" include WasmI64
+from "runtime/unsafe/wasmf32" include WasmF32
+from "runtime/unsafe/wasmf64" include WasmF64
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{
   newInt32,
+  newUint32,
   newInt64,
+  newUint64,
   newFloat32,
   newFloat64,
-} from "runtime/dataStructures"
+}
 
 @unsafe
-export let toInt32 = n => {
+provide let toInt32 = n => {
   WasmI32.toGrain(newInt32(n)): Int32
 }
 
 @unsafe
-export let fromInt32 = (n: Int32) => {
+provide let toUint32 = n => {
+  WasmI32.toGrain(newUint32(n)): Uint32
+}
+
+@unsafe
+provide let fromInt32 = (n: Int32) => {
+  let ptr = WasmI32.fromGrain(n)
+  WasmI32.load(ptr, 4n)
+}
+
+@unsafe
+provide let fromUint32 = (n: Uint32) => {
   let ptr = WasmI32.fromGrain(n)
-  WasmI32.load(ptr, 8n)
+  WasmI32.load(ptr, 4n)
 }
 
 @unsafe
-export let toInt64 = n => {
+provide let toInt64 = n => {
   WasmI32.toGrain(newInt64(n)): Int64
 }
 
 @unsafe
-export let fromInt64 = (n: Int64) => {
+provide let toUint64 = n => {
+  WasmI32.toGrain(newUint64(n)): Uint64
+}
+
+@unsafe
+provide let fromInt64 = (n: Int64) => {
   let ptr = WasmI32.fromGrain(n)
   WasmI64.load(ptr, 8n)
 }
 
 @unsafe
-export let toFloat32 = n => {
+provide let fromUint64 = (n: Uint64) => {
+  let ptr = WasmI32.fromGrain(n)
+  WasmI64.load(ptr, 8n)
+}
+
+@unsafe
+provide let toFloat32 = n => {
   WasmI32.toGrain(newFloat32(n)): Float32
 }
 
 @unsafe
-export let fromFloat32 = (n: Float32) => {
+provide let fromFloat32 = (n: Float32) => {
   let ptr = WasmI32.fromGrain(n)
-  WasmF32.load(ptr, 8n)
+  WasmF32.load(ptr, 4n)
 }
 
 @unsafe
-export let toFloat64 = n => {
+provide let toFloat64 = n => {
   WasmI32.toGrain(newFloat64(n)): Float64
 }
 
 @unsafe
-export let fromFloat64 = (n: Float64) => {
+provide let fromFloat64 = (n: Float64) => {
   let ptr = WasmI32.fromGrain(n)
   WasmF64.load(ptr, 8n)
 }
 
 /**
  * Converts a WasmI32 value to Number.
- * 
+ *
  * @param n: The WasmI32 to convert
  * @returns The value converted to either a simple or a 32 bit heap allocated number.
  */
 @unsafe
-export let wasmI32ToNumber = (n: WasmI32) => {
+provide let wasmI32ToNumber = (n: WasmI32) => {
+  use WasmI32.{ (^), (<<), (>>), (==) }
   // Follows a little optimization. Instead of testing if n is range of allowed
   // non heap allocated simple numbers (-1073741824n..1073741823n), actually
   // make a simple number, convert it back to WasmI32, and test if it stayed
@@ -73,21 +101,20 @@ export let wasmI32ToNumber = (n: WasmI32) => {
 
   // First step: naively convert to simple number, just like tagSimpleNumber.
   // This will overflow for values not in the range, but it's fine.
-  let simple = WasmI32.xor(WasmI32.shl(n, 1n), 1n)
+  let simple = n << 1n ^ 1n
 
   // Untag it, just like numbers.untagSimple.
-  let untagged = WasmI32.shrS(simple, 1n)
+  let untagged = simple >> 1n
 
-  let result = if (WasmI32.eq(untagged, n)) {
+  if (untagged == n) {
     // Just test if the untagged number is the same. If it didn't overflow, then
     // we're good. We just need to cast the raw value into a Number at the type
     // system level.
-    WasmI32.toGrain(simple): Number
-  } else {
-    // If it did overflow, then the value differs and we need to discard it and
-    // allocate the number on the heap. A boxed 32 bit number actually is the
-    // same thing as an Int32. It only needs to be cast into Number.
-    WasmI32.toGrain(newInt32(n)): Number
+    return WasmI32.toGrain(simple): Number
   }
-  result
+
+  // If it did overflow, then the value differs and we need to discard it and
+  // allocate the number on the heap. We can do this by extending the 32 bit
+  // number to an Int64.
+  return WasmI32.toGrain(newInt64(WasmI64.extendI32S(n))): Number
 }

package/runtime/unsafe/conv.md

@@ -1,55 +1,87 @@
+---
+title: Conv
+---
+
+## Values
+
+Functions and constants included in the Conv module.
+
 ### Conv.**toInt32**
 
 ```grain
-toInt32 : WasmI32 -> Int32
+toInt32 : (n: WasmI32) => Int32
+```
+
+### Conv.**toUint32**
+
+```grain
+toUint32 : (n: WasmI32) => Uint32
 ```
 
 ### Conv.**fromInt32**
 
 ```grain
-fromInt32 : Int32 -> WasmI32
+fromInt32 : (n: Int32) => WasmI32
+```
+
+### Conv.**fromUint32**
+
+```grain
+fromUint32 : (n: Uint32) => WasmI32
 ```
 
 ### Conv.**toInt64**
 
 ```grain
-toInt64 : WasmI64 -> Int64
+toInt64 : (n: WasmI64) => Int64
+```
+
+### Conv.**toUint64**
+
+```grain
+toUint64 : (n: WasmI64) => Uint64
 ```
 
 ### Conv.**fromInt64**
 
 ```grain
-fromInt64 : Int64 -> WasmI64
+fromInt64 : (n: Int64) => WasmI64
+```
+
+### Conv.**fromUint64**
+
+```grain
+fromUint64 : (n: Uint64) => WasmI64
 ```
 
 ### Conv.**toFloat32**
 
 ```grain
-toFloat32 : WasmF32 -> Float32
+toFloat32 : (n: WasmF32) => Float32
 ```
 
 ### Conv.**fromFloat32**
 
 ```grain
-fromFloat32 : Float32 -> WasmF32
+fromFloat32 : (n: Float32) => WasmF32
 ```
 
 ### Conv.**toFloat64**
 
 ```grain
-toFloat64 : WasmF64 -> Float64
+toFloat64 : (n: WasmF64) => Float64
 ```
 
 ### Conv.**fromFloat64**
 
 ```grain
-fromFloat64 : Float64 -> WasmF64
+fromFloat64 : (n: Float64) => WasmF64
 ```
 
 ### Conv.**wasmI32ToNumber**
 
 ```grain
-wasmI32ToNumber : WasmI32 -> Number
+wasmI32ToNumber : (n: WasmI32) => Number
 ```
 
 Converts a WasmI32 value to Number.

package/runtime/unsafe/memory.gr

@@ -1,30 +1,14 @@
-/* grainc-flags --compilation-mode=runtime */
+@runtimeMode
+module Memory
 
-import {
-  malloc,
-  free,
-  incRef,
-  decRef,
-  utoa32Buffered,
-  decimalCount32,
-} from "runtime/gc"
-import WasmI32, {
-  add as (+),
-  sub as (-),
-  shl as (<<),
-  eq as (==),
-  ne as (!=),
-  ltU as (<),
-} from "runtime/unsafe/wasmi32"
+from "runtime/gc" include GC
+use GC.{ malloc, free, incRef, decRef }
+from "runtime/unsafe/wasmi32" include WasmI32
+use WasmI32.{ (+), (-), (<<), (==), (!=), ltU as (<) }
 
-export malloc
-export free
-export incRef
-export decRef
-export utoa32Buffered
-export decimalCount32
+provide { malloc, free, incRef, decRef }
 
-export let copy = (dest, src, n) => {
+provide let copy = (dest, src, n) => {
   let mut dest = dest
   let mut src = src
   let mut n = n
@@ -45,7 +29,7 @@ export let copy = (dest, src, n) => {
   }
 }
 
-export let fill = (dest, c, n) => {
+provide let fill = (dest, c, n) => {
   let mut dest = dest
   let mut n = n
   while (n != 0n) {
@@ -55,8 +39,4 @@ export let fill = (dest, c, n) => {
   }
 }
 
-export primitive compare: (
-  WasmI32,
-  WasmI32,
-  WasmI32,
-) -> WasmI32 = "@wasm.memory_compare"
+provide primitive compare = "@wasm.memory_compare"

package/runtime/unsafe/memory.md

@@ -1,54 +1,50 @@
+---
+title: Memory
+---
+
+## Values
+
+Functions and constants included in the Memory module.
+
 ### Memory.**malloc**
 
 ```grain
-malloc : WasmI32 -> WasmI32
+malloc : (size: WasmI32) => WasmI32
 ```
 
 ### Memory.**free**
 
 ```grain
-free : WasmI32 -> Void
+free : (userPtr: WasmI32) => Void
 ```
 
 ### Memory.**incRef**
 
 ```grain
-incRef : WasmI32 -> WasmI32
+incRef : (userPtr: WasmI32) => WasmI32
 ```
 
 ### Memory.**decRef**
 
 ```grain
-decRef : WasmI32 -> WasmI32
-```
-
-### Memory.**utoa32Buffered**
-
-```grain
-utoa32Buffered : Box<(WasmI32, WasmI32, WasmI32) -> Void>
-```
-
-### Memory.**decimalCount32**
-
-```grain
-decimalCount32 : Box<WasmI32 -> WasmI32>
+decRef : (userPtr: WasmI32) => WasmI32
 ```
 
 ### Memory.**copy**
 
 ```grain
-copy : (WasmI32, WasmI32, WasmI32) -> Void
+copy : (dest: WasmI32, src: WasmI32, n: WasmI32) => Void
 ```
 
 ### Memory.**fill**
 
 ```grain
-fill : (WasmI32, WasmI32, WasmI32) -> Void
+fill : (dest: WasmI32, c: WasmI32, n: WasmI32) => Void
 ```
 
 ### Memory.**compare**
 
 ```grain
-compare : (WasmI32, WasmI32, WasmI32) -> WasmI32
+compare : (ptr1: WasmI32, ptr2: WasmI32, length: WasmI32) => WasmI32
 ```
 

package/runtime/unsafe/tags.gr

@@ -1,26 +1,42 @@
-/* grainc-flags --compilation-mode=runtime */
+@runtimeMode
+module Tags
 
-export let _GRAIN_NUMBER_TAG_TYPE = 0b0001n
-export let _GRAIN_CHAR_TAG_TYPE = 0b0010n
-export let _GRAIN_CONST_TAG_TYPE = 0b0110n
-export let _GRAIN_GENERIC_HEAP_TAG_TYPE = 0b0000n
+provide let _GRAIN_NUMBER_TAG_TYPE = 0b0001n
+provide let _GRAIN_SHORTVAL_TAG_TYPE = 0b0010n
+provide let _GRAIN_CONST_TAG_TYPE = 0b0110n
+provide let _GRAIN_GENERIC_HEAP_TAG_TYPE = 0b0000n
 
-export let _GRAIN_NUMBER_TAG_MASK = 0b0001n
-export let _GRAIN_GENERIC_TAG_MASK = 0b0111n
+provide let _GRAIN_NUMBER_TAG_MASK = 0b0001n
+provide let _GRAIN_GENERIC_TAG_MASK = 0b0111n
 
-export let _GRAIN_STRING_HEAP_TAG = 1n
-export let _GRAIN_ADT_HEAP_TAG = 2n
-export let _GRAIN_RECORD_HEAP_TAG = 3n
-export let _GRAIN_ARRAY_HEAP_TAG = 4n
-export let _GRAIN_BOXED_NUM_HEAP_TAG = 5n
-export let _GRAIN_LAMBDA_HEAP_TAG = 6n
-export let _GRAIN_TUPLE_HEAP_TAG = 7n
-export let _GRAIN_BYTES_HEAP_TAG = 8n
+// Short val types
+provide let _GRAIN_CHAR_SHORTVAL_TAG = 0n
+provide let _GRAIN_INT8_SHORTVAL_TAG = 1n
+provide let _GRAIN_INT16_SHORTVAL_TAG = 2n
+provide let _GRAIN_UINT8_SHORTVAL_TAG = 3n
+provide let _GRAIN_UINT16_SHORTVAL_TAG = 4n
+
+provide let _GRAIN_GENERIC_SHORTVAL_TAG_MASK = 0b11111000n
+provide let _GRAIN_INT8_TAG_MASK = 0b1000n
+provide let _GRAIN_INT16_TAG_MASK = 0b10000n
+provide let _GRAIN_UINT8_TAG_MASK = 0b11000n
+provide let _GRAIN_UINT16_TAG_MASK = 0b100000n
+
+provide let _GRAIN_STRING_HEAP_TAG = 1n
+provide let _GRAIN_ADT_HEAP_TAG = 2n
+provide let _GRAIN_RECORD_HEAP_TAG = 3n
+provide let _GRAIN_ARRAY_HEAP_TAG = 4n
+provide let _GRAIN_BOXED_NUM_HEAP_TAG = 5n
+provide let _GRAIN_LAMBDA_HEAP_TAG = 6n
+provide let _GRAIN_TUPLE_HEAP_TAG = 7n
+provide let _GRAIN_BYTES_HEAP_TAG = 8n
+provide let _GRAIN_INT32_HEAP_TAG = 9n
+provide let _GRAIN_FLOAT32_HEAP_TAG = 10n
+provide let _GRAIN_UINT32_HEAP_TAG = 11n
+provide let _GRAIN_UINT64_HEAP_TAG = 12n
 
 // Boxed number types
-export let _GRAIN_FLOAT32_BOXED_NUM_TAG = 1n
-export let _GRAIN_FLOAT64_BOXED_NUM_TAG = 2n
-export let _GRAIN_INT32_BOXED_NUM_TAG = 3n
-export let _GRAIN_INT64_BOXED_NUM_TAG = 4n
-export let _GRAIN_RATIONAL_BOXED_NUM_TAG = 5n
-export let _GRAIN_BIGINT_BOXED_NUM_TAG = 6n
+provide let _GRAIN_FLOAT64_BOXED_NUM_TAG = 1n
+provide let _GRAIN_INT64_BOXED_NUM_TAG = 2n
+provide let _GRAIN_RATIONAL_BOXED_NUM_TAG = 3n
+provide let _GRAIN_BIGINT_BOXED_NUM_TAG = 4n