@grain/stdlib 0.4.4 → 0.5.0

package/runtime/dataStructures.gr

@@ -1,367 +1,187 @@
-/* grainc-flags --compilation-mode=runtime */
-
-import Memory from "runtime/unsafe/memory"
-import Tags from "runtime/unsafe/tags"
-import WasmI32, {
-  add as (+),
-  mul as (*),
-  xor as (^),
-  shl as (<<)
-} from "runtime/unsafe/wasmi32"
-import WasmI64 from "runtime/unsafe/wasmi64"
-import WasmF32 from "runtime/unsafe/wasmf32"
-import WasmF64 from "runtime/unsafe/wasmf64"
-
-//
-// For performance reasons, all functions in this module do not
-// decRef their arguments. Consequently, callers should not incRef them before calling.
-//
+/* grainc-flags --no-pervasives */
 
 /**
  * Allocates a new Grain array.
  *
- * @param {WasmI32} numElts The number of elements to be contained in this array
- * @returns {WasmI32} The pointer to the array
- */
-export let allocateArray = (numElts) => {
-  let arr = Memory.malloc((numElts + 2n) * 4n)
-
-  WasmI32.store(arr, Tags._GRAIN_ARRAY_HEAP_TAG, 0n)
-  WasmI32.store(arr, numElts, 4n)
-
-  arr
-}
-
-/**
- * Stores an item in a Grain array.
- *
- * @param {WasmI32} array The array to store the item in
- * @param {WasmI32} idx The index to store the item
- * @param {WasmI32} item The item to store
+ * @param numElts: The number of elements to be contained in this array
+ * @returns The pointer to the array
  */
-export let storeInArray = (arr, idx, item) => {
-  WasmI32.store(arr + idx * 4n, item, 8n)
-}
+@unsafe
+export primitive allocateArray: WasmI32 -> WasmI32 = "@allocate.array"
 
 /**
  * Allocates a new Grain tuple.
  *
- * @param {WasmI32} numElts The number of elements to be contained in this tuple
- * @returns {WasmI32} The pointer to the tuple
+ * @param numElts: The number of elements to be contained in this tuple
+ * @returns The pointer to the tuple
  */
-export let allocateTuple = (numElts) => {
-  let tuple = Memory.malloc((numElts + 2n) * 4n)
-
-  WasmI32.store(tuple, Tags._GRAIN_TUPLE_HEAP_TAG, 0n)
-  WasmI32.store(tuple, numElts, 4n)
-
-  tuple
-}
-
-/**
- * Stores an item in a Grain tuple.
- *
- * @param {WasmI32} tuple The tuple to store the item in
- * @param {WasmI32} idx The index to store the item
- * @param {WasmI32} item The item to store
- */
-export let storeInTuple = (tuple, idx, item) => {
-  WasmI32.store(tuple + idx * 4n, item, 8n)
-}
+@unsafe
+export primitive allocateTuple: WasmI32 -> WasmI32 = "@allocate.tuple"
 
 /**
  * Allocates a new Grain bytes.
  *
- * @param {WasmI32} size The number of bytes to be contained in this buffer
- * @returns {WasmI32} The pointer to the bytes
+ * @param size: The number of bytes to be contained in this buffer
+ * @returns The pointer to the bytes
  */
-export let allocateBytes = (size) => {
-  let len = size + 8n
-  let bytes = Memory.malloc(len)
-  Memory.fill(bytes, 0n, len)
-  WasmI32.store(bytes, Tags._GRAIN_BYTES_HEAP_TAG, 0n)
-  WasmI32.store(bytes, size, 4n)
-  bytes
-}
+@unsafe
+export primitive allocateBytes: WasmI32 -> WasmI32 = "@allocate.bytes"
 
 /**
  * Allocates a new Grain string.
  *
- * @param {WasmI32} size The size (in bytes) of the string to allocate
- * @returns {WasmI32} The pointer to the string
+ * @param size: The size (in bytes) of the string to allocate
+ * @returns The pointer to the string
  */
-export let allocateString = (size) => {
-  let str = Memory.malloc(size + 8n)
-
-  WasmI32.store(str, Tags._GRAIN_STRING_HEAP_TAG, 0n)
-  WasmI32.store(str, size, 4n)
+@unsafe
+export primitive allocateString: WasmI32 -> WasmI32 = "@allocate.string"
 
-  str
-}
+// INT32/INT64
 
 /**
- * Creates a new Grain string containing the given character
+ * Allocates a new Int32.
  *
- * @param {WasmI32} c The character for which to allocate a string
- * @returns {WasmI32} The pointer to the string
+ * @returns The pointer to the empty Int32
  */
-export let singleByteString = (c) => {
-  let str = Memory.malloc(9n)
-
-  WasmI32.store(str, Tags._GRAIN_STRING_HEAP_TAG, 0n)
-  WasmI32.store(str, 1n, 4n)
-  WasmI32.store8(str, c, 8n)
-
-  str
-}
+@unsafe
+export primitive allocateInt32: () -> WasmI32 = "@allocate.int32"
 
 /**
- * Allocates a new Grain char.
- *
- * @returns {WasmI32} The pointer to the char
+ * Allocates a new Int32 with a prepopulated value
+ * @param value: The value to store
+ * @returns The pointer to the Int32
  */
-export let allocateChar = () => {
-  let char = Memory.malloc(8n)
-
-  WasmI32.store(char, Tags._GRAIN_CHAR_HEAP_TAG, 0n)
-
-  char
-}
-
-// INT32/INT64
+@unsafe
+export primitive newInt32: WasmI32 -> WasmI32 = "@new.int32"
 
 /**
  * Allocates a new Int64.
  *
- * @returns {WasmI32}
+ * @returns The pointer to the empty Int64
  */
-export let allocateInt64 = () => {
-  let ptr = Memory.malloc(16n)
-
-  WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
-  WasmI32.store(ptr, Tags._GRAIN_INT64_BOXED_NUM_TAG, 4n)
-
-  ptr
-}
+@unsafe
+export primitive allocateInt64: () -> WasmI32 = "@allocate.int64"
 
 /**
  * Allocates a new Int64 with a prepopulated value
- * @param value The value to store
- */
-export let newInt64 = (value) => {
-  let ptr = allocateInt64()
-  WasmI64.store(ptr, value, 8n)
-  ptr
-}
-
-/**
- * Returns a pointer to the heap location containing this boxed number's Int64
- * @param wrappedInt64 The boxed int64 to return
- */
-export let rawInt64Ptr = (wrappedInt64) => {
-  wrappedInt64 + 8n
-}
-
-export let loadInt64 = (xptr) => {
-  WasmI64.load(xptr, 8n)
-}
-
-/**
- * Allocates a new Int32.
- *
- * @returns {WasmI32}
- */
-export let allocateInt32 = () => {
-  let ptr = Memory.malloc(12n)
-
-  WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
-  WasmI32.store(ptr, Tags._GRAIN_INT32_BOXED_NUM_TAG, 4n)
-
-  ptr
-}
-
-/**
- * Allocates a new Int32 with a prepopulated value
- * @param value The value to store
+ * @param value: The value to store
+ * @returns The pointer to the Int64
  */
-export let newInt32 = (value) => {
-  let ptr = allocateInt32()
-  WasmI32.store(ptr, value, 8n)
-  ptr
-}
-
-/**
- * Returns a pointer to the heap location containing this boxed number's Int32
- * @param wrappedInt32 The boxed int32 to return
- */
-export let rawInt32Ptr = (wrappedInt32) => {
-  wrappedInt32 + 8n
-}
-
-export let loadInt32 = (xptr) => {
-  WasmI32.load(xptr, 8n)
-}
+@unsafe
+export primitive newInt64: WasmI64 -> WasmI32 = "@new.int64"
 
 // FLOATS
 
 /**
  * Allocates a new Float32.
  *
- * @returns {WasmI32}
+ * @returns The pointer to the empty Float32
  */
-export let allocateFloat32 = () => {
-  let ptr = Memory.malloc(12n)
-
-  WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
-  WasmI32.store(ptr, Tags._GRAIN_FLOAT32_BOXED_NUM_TAG, 4n)
-
-  ptr
-}
+@unsafe
+export primitive allocateFloat32: () -> WasmI32 = "@allocate.float32"
 
 /**
  * Allocates a new Float32 with a prepopulated value
- * @param value The value to store
+ * @param value: The value to store
+ * @returns the pointer to the Float32
  */
-export let newFloat32 = (value) => {
-  let ptr = allocateFloat32()
-  WasmF32.store(ptr, value, 8n)
-  ptr
-}
-
-/**
- * Returns a pointer to the heap location containing this boxed number's Float32
- * @param wrappedFloat32 The boxed float32 to return
- */
-export let rawFloat32Ptr = (wrappedFloat32) => {
-  wrappedFloat32 + 8n
-}
-
-export let loadFloat32 = (xptr) => {
-  WasmF32.load(xptr, 8n)
-}
+@unsafe
+export primitive newFloat32: WasmF32 -> WasmI32 = "@new.float32"
 
 /**
  * Allocates a new Float64.
  *
- * @returns {WasmI32}
+ * @returns The pointer to the empty Float64
  */
-export let allocateFloat64 = () => {
-  let ptr = Memory.malloc(16n)
-
-  WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
-  WasmI32.store(ptr, Tags._GRAIN_FLOAT64_BOXED_NUM_TAG, 4n)
-
-  ptr
-}
+@unsafe
+export primitive allocateFloat64: () -> WasmI32 = "@allocate.float64"
 
 /**
  * Allocates a new Float64 with a prepopulated value
- * @param value The value to store
+ * @param value: The value to store
+ * @returns The pointer to the Float64
  */
-export let newFloat64 = (value) => {
-  let ptr = allocateFloat64()
-  WasmF64.store(ptr, value, 8n)
-  ptr
-}
-
-/**
- * Returns a pointer to the heap location containing this boxed number's Float64
- * @param wrappedFloat64 The boxed float64 to return
- */
-export let rawFloat64Ptr = (wrappedFloat64) => {
-  wrappedFloat64 + 8n
-}
-
-export let loadFloat64 = (xptr) => {
-  WasmF64.load(xptr, 8n)
-}
+@unsafe
+export primitive newFloat64: WasmF64 -> WasmI32 = "@new.float64"
 
 // RATIONALS
 
 /**
  * Allocates a new Rational.
  *
- * @returns {WasmI32}
+ * @returns The pointer to the empty Rational
  */
-export let allocateRational = () => {
-  let ptr = Memory.malloc(16n)
-
-  WasmI32.store(ptr, Tags._GRAIN_BOXED_NUM_HEAP_TAG, 0n)
-  WasmI32.store(ptr, Tags._GRAIN_RATIONAL_BOXED_NUM_TAG, 4n)
-
-  ptr
-}
+@unsafe
+export primitive allocateRational: () -> WasmI32 = "@allocate.rational"
 
 /**
  * Allocates a new Rational with a prepopulated value
- * @param value The value to store
+ * @param value: The numerator value to store
+ * @param value: The denominator value to store
+ * @returns The pointer to the Rational
  */
-export let newRational = (numerator, denominator) =>{
-  let ptr = allocateRational()
-  WasmI32.store(ptr, numerator, 8n)
-  WasmI32.store(ptr, denominator, 12n)
-  ptr
-}
+@unsafe
+export primitive newRational: (WasmI32, WasmI32) -> WasmI32 = "@new.rational"
 
 /**
- * Returns a pointer to the heap location containing this boxed number's Rational numerator
- * @param wrappedRational The boxed rational to return
+ * Load the (tagged) variant of an ADT.
+ *
+ * @param ptr: Untagged pointer to the ADT
+ * @returns The (tagged) ADT variant id
  */
-export let rawRationalNumeratorPtr = (wrappedRational) => {
-  wrappedRational + 8n
-}
+@unsafe
+export primitive loadAdtVariant: WasmI32 -> WasmI32 = "@adt.load_variant"
 
 /**
- * Returns a pointer to the heap location containing this boxed number's Rational numerator
- * @param wrappedRational The boxed rational to return
+ * Load an untagged string's size.
+ *
+ * @param ptr: Untagged pointer to the string
+ * @returns The string size (in bytes)
  */
-export let rawRationalDenominatorPtr = (wrappedRational) => {
-  wrappedRational + 12n
-}
-
-export let loadRationalNumerator = (xptr) => {
-  WasmI32.load(xptr, 8n)
-}
-
-export let loadRationalDenominator = (xptr) => {
-  WasmI32.load(xptr, 12n)
-}
+@unsafe
+export primitive stringSize: WasmI32 -> WasmI32 = "@string.size"
 
+/**
+ * Load an untagged Bytes' size.
+ *
+ * @param ptr: Untagged pointer to the Bytes
+ * @returns The Bytes size (in bytes)
+ */
+@unsafe
+export primitive bytesSize: WasmI32 -> WasmI32 = "@bytes.size"
 
 /**
- * Load a value from an ADT.
+ * Tag a simple number.
  *
- * @export
- * @param {WasmI32} ptr Untagged pointer to the ADT
- * @param {WasmI32} idx Index (from zero) of the item
- * @returns {WasmI32} The value located at the index
+ * @param num: The number to tag
+ * @returns The tagged number
  */
-export let loadAdtVal = (ptr, idx) => {
-  WasmI32.load(ptr + (idx * 4n), 20n)
-}
+@unsafe
+export primitive tagSimpleNumber: WasmI32 -> Number = "@tag.simple_number"
 
 /**
- * Load the (tagged) variant of an ADT.
+ * Untag a simple number.
  *
- * @export
- * @param {WasmI32} ptr Untagged pointer to the ADT
- * @returns {WasmI32} The (tagged) ADT variant id
+ * @param num: The number to untag
+ * @returns The untagged number
  */
-export let loadAdtVariant = (ptr) => {
-  WasmI32.load(ptr, 12n)
-}
+@unsafe
+export primitive untagSimpleNumber: Number -> WasmI32 = "@untag.simple_number"
 
 /**
- * Load an untagged string's size.
+ * Tag a char.
  *
- * @export
- * @param {WasmI32} ptr Untagged pointer to the string
- * @returns {WasmI32} The string size (in bytes)
+ * @param num: The usv to tag
+ * @returns The tagged char
  */
-export let stringSize = (ptr) => {
-  WasmI32.load(ptr, 4n)
-}
+@unsafe
+export primitive tagChar: WasmI32 -> Char = "@tag.char"
 
-export let tagSimpleNumber = (x) => {
-  WasmI32.toGrain((x << 1n) ^ 1n): Number
-}
+/**
+ * Untag a char.
+ *
+ * @param num: The char to untag
+ * @returns The untagged usv
+ */
+@unsafe
+export primitive untagChar: Char -> WasmI32 = "@untag.char"