@grain/stdlib 0.5.12 → 0.6.0

package/marshal.gr

@@ -1,10 +1,15 @@
 /**
- * @module Marshal: Utilities for serializing and deserializing Grain data.
+ * Utilities for serializing and deserializing Grain data.
  *
- * @example import Marshal from "marshal"
+ * @example from "marshal" include Marshal
+ *
+ * @example Marshal.marshal(1)
+ * @example Marshal.marshal("Hello World")
+ * @example Marshal.unmarshal(b"\x03\x00\x00\x00")
  *
  * @since v0.5.3
  */
+module Marshal
 
 /*
   SERIALIZED BINARY FORMAT
@@ -20,16 +25,13 @@
   or a "pointer" to a heap-allocated value.
 */
 
-/**
- * @section Values: Functions for marshaling and unmarshaling data.
- */
-
-import WasmI32, {
-  add as (+),
-  mul as (*),
-  and as (&),
-  eq as (==),
-  ne as (!=),
+from "runtime/unsafe/wasmi32" include WasmI32
+use WasmI32.{
+  (+),
+  (*),
+  (&),
+  (==),
+  (!=),
   gtU as (>),
   ltU as (<),
   leU as (<=),
@@ -37,14 +39,14 @@ import WasmI32, {
   store,
   fromGrain,
   toGrain,
-} from "runtime/unsafe/wasmi32"
-import WasmI64 from "runtime/unsafe/wasmi64"
-import Memory from "runtime/unsafe/memory"
-import Tags from "runtime/unsafe/tags"
-import { allocateBytes, newInt32 } from "runtime/dataStructures"
-import Map from "map"
-import Set from "set"
-import Option from "option"
+}
+from "runtime/unsafe/wasmi64" include WasmI64
+from "runtime/unsafe/memory" include Memory
+from "runtime/unsafe/tags" include Tags
+from "runtime/dataStructures" include DataStructures
+use DataStructures.{ allocateBytes, newInt32 }
+from "map" include Map
+from "set" include Set
 
 @unsafe
 let roundTo8 = n => {
@@ -53,8 +55,7 @@ let roundTo8 = n => {
 
 @unsafe
 let isHeapPtr = value =>
-  (value & Tags._GRAIN_GENERIC_TAG_MASK) ==
-    Tags._GRAIN_GENERIC_HEAP_TAG_TYPE
+  (value & Tags._GRAIN_GENERIC_TAG_MASK) == Tags._GRAIN_GENERIC_HEAP_TAG_TYPE
 
 @unsafe
 let rec size = (value, acc, valuesSeen, toplevel) => {
@@ -74,9 +75,8 @@ let rec size = (value, acc, valuesSeen, toplevel) => {
       }
       let heapPtr = value
       match (load(heapPtr, 0n)) {
-        t when (
-          t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG
-        ) => {
+        t when t == Tags._GRAIN_STRING_HEAP_TAG ||
+          t == Tags._GRAIN_BYTES_HEAP_TAG => {
           acc + roundTo8(8n + load(heapPtr, 4n))
         },
         t when t == Tags._GRAIN_ADT_HEAP_TAG => {
@@ -142,14 +142,8 @@ let rec size = (value, acc, valuesSeen, toplevel) => {
         t when t == Tags._GRAIN_BOXED_NUM_HEAP_TAG => {
           let tag = load(heapPtr, 4n)
           match (tag) {
-            t when (
-              t == Tags._GRAIN_INT32_BOXED_NUM_TAG ||
-              t == Tags._GRAIN_INT64_BOXED_NUM_TAG ||
-              t == Tags._GRAIN_FLOAT32_BOXED_NUM_TAG ||
-              t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG
-            ) => {
-              // The 32-bit values only take 12 bytes of memory, but we report 16
-              // for alignment
+            t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG ||
+              t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => {
               acc + 16n
             },
             t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
@@ -166,6 +160,15 @@ let rec size = (value, acc, valuesSeen, toplevel) => {
             },
           }
         },
+        t when t == Tags._GRAIN_INT32_HEAP_TAG ||
+          t == Tags._GRAIN_FLOAT32_HEAP_TAG ||
+          t == Tags._GRAIN_UINT32_HEAP_TAG => {
+          acc + 8n
+        },
+        t when t == Tags._GRAIN_UINT64_HEAP_TAG => {
+          // 16 for alignment
+          acc + 16n
+        },
         _ => {
           fail "Unknown heap type"
         },
@@ -193,9 +196,7 @@ let rec marshalHeap = (heapPtr, buf, offset, valuesSeen) => {
   Map.set(asInt32, offsetAsInt32, valuesSeen)
 
   match (load(heapPtr, 0n)) {
-    t when (
-      t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG
-    ) => {
+    t when t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG => {
       let size = 8n + load(heapPtr, 4n)
       Memory.copy(buf + offset, heapPtr, size)
       roundTo8(offset + size)
@@ -214,7 +215,7 @@ let rec marshalHeap = (heapPtr, buf, offset, valuesSeen) => {
           let asInt32 = toGrain(newInt32(value)): Int32
           match (Map.get(asInt32, valuesSeen)) {
             Some(value) => {
-              let ptr = load(fromGrain(value), 8n)
+              let ptr = load(fromGrain(value), 4n)
               store(buf, ptr, offset + i + 20n)
             },
             None => {
@@ -243,7 +244,7 @@ let rec marshalHeap = (heapPtr, buf, offset, valuesSeen) => {
           let asInt32 = toGrain(newInt32(value)): Int32
           match (Map.get(asInt32, valuesSeen)) {
             Some(value) => {
-              let ptr = load(fromGrain(value), 8n)
+              let ptr = load(fromGrain(value), 4n)
               store(buf, ptr, offset + i + 16n)
             },
             None => {
@@ -272,7 +273,7 @@ let rec marshalHeap = (heapPtr, buf, offset, valuesSeen) => {
           let asInt32 = toGrain(newInt32(value)): Int32
           match (Map.get(asInt32, valuesSeen)) {
             Some(value) => {
-              let ptr = load(fromGrain(value), 8n)
+              let ptr = load(fromGrain(value), 4n)
               store(buf, ptr, offset + i + 8n)
             },
             None => {
@@ -301,7 +302,7 @@ let rec marshalHeap = (heapPtr, buf, offset, valuesSeen) => {
           let asInt32 = toGrain(newInt32(value)): Int32
           match (Map.get(asInt32, valuesSeen)) {
             Some(value) => {
-              let ptr = load(fromGrain(value), 8n)
+              let ptr = load(fromGrain(value), 4n)
               store(buf, ptr, offset + i + 8n)
             },
             None => {
@@ -330,7 +331,7 @@ let rec marshalHeap = (heapPtr, buf, offset, valuesSeen) => {
           let asInt32 = toGrain(newInt32(value)): Int32
           match (Map.get(asInt32, valuesSeen)) {
             Some(value) => {
-              let ptr = load(fromGrain(value), 8n)
+              let ptr = load(fromGrain(value), 4n)
               store(buf, ptr, offset + i + 16n)
             },
             None => {
@@ -348,10 +349,6 @@ let rec marshalHeap = (heapPtr, buf, offset, valuesSeen) => {
     t when t == Tags._GRAIN_BOXED_NUM_HEAP_TAG => {
       let tag = load(heapPtr, 4n)
       match (tag) {
-        t when t == Tags._GRAIN_INT32_BOXED_NUM_TAG => {
-          Memory.copy(buf + offset, heapPtr, 12n)
-          offset + 16n
-        },
         t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
           Memory.copy(buf + offset, heapPtr, 16n)
           offset + 16n
@@ -361,26 +358,22 @@ let rec marshalHeap = (heapPtr, buf, offset, valuesSeen) => {
           Memory.copy(buf + offset, heapPtr, size)
           offset + size
         },
-        t when t == Tags._GRAIN_FLOAT32_BOXED_NUM_TAG => {
-          Memory.copy(buf + offset, heapPtr, 12n)
-          offset + 16n
-        },
         t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => {
           Memory.copy(buf + offset, heapPtr, 16n)
           offset + 16n
         },
         t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => {
           Memory.copy(buf + offset, heapPtr, 8n)
-          let mut payloadOffset = offset + 16n
+          let payloadOffset = offset + 16n
           store(buf, payloadOffset, offset + 8n)
-          payloadOffset = marshalHeap(
+          let payloadOffset = marshalHeap(
             load(heapPtr, 8n),
             buf,
             payloadOffset,
             valuesSeen
           )
           store(buf, payloadOffset, offset + 12n)
-          payloadOffset = marshalHeap(
+          let payloadOffset = marshalHeap(
             load(heapPtr, 12n),
             buf,
             payloadOffset,
@@ -393,6 +386,16 @@ let rec marshalHeap = (heapPtr, buf, offset, valuesSeen) => {
         },
       }
     },
+    t when t == Tags._GRAIN_INT32_HEAP_TAG ||
+      t == Tags._GRAIN_FLOAT32_HEAP_TAG ||
+      t == Tags._GRAIN_UINT32_HEAP_TAG => {
+      Memory.copy(buf + offset, heapPtr, 8n)
+      offset + 8n
+    },
+    t when t == Tags._GRAIN_UINT64_HEAP_TAG => {
+      Memory.copy(buf + offset, heapPtr, 16n)
+      offset + 16n
+    },
     _ => {
       fail "Unknown heap type"
     },
@@ -419,13 +422,19 @@ let marshal = (value, buf) => {
  * @param value: The value to serialize
  * @returns A byte-based representation of the value
  *
+ * @example Marshal.marshal(1) == b"\x03\x00\x00\x00"
+ * @example Marshal.marshal("🌾") == Marshal.marshal("🌾")
+ *
  * @since v0.5.3
  */
 @unsafe
-export let marshal = value => {
+provide let marshal = value => {
   let valuePtr = fromGrain(value)
-  let buf = allocateBytes(size(valuePtr))
+  let size = size(valuePtr)
+  let buf = allocateBytes(size)
+  Memory.fill(buf + 8n, 0n, size)
   marshal(valuePtr, buf + 8n)
+  ignore(value)
   toGrain(buf): Bytes
 }
 
@@ -440,13 +449,11 @@ let reportError = (message, offset) => {
 @unsafe
 let validateStack = (value, offset) => {
   match (value) {
-    _ when (
-      value == fromGrain(true) ||
+    _ when value == fromGrain(true) ||
       value == fromGrain(false) ||
       value == fromGrain(void) ||
       (value & Tags._GRAIN_NUMBER_TAG_MASK) == Tags._GRAIN_NUMBER_TAG_TYPE ||
-      (value & Tags._GRAIN_GENERIC_TAG_MASK) == Tags._GRAIN_CHAR_TAG_TYPE
-    ) =>
+      (value & Tags._GRAIN_GENERIC_TAG_MASK) == Tags._GRAIN_SHORTVAL_TAG_TYPE =>
       None,
     _ => reportError("Unknown value", offset),
   }
@@ -459,276 +466,281 @@ let rec validateHeap = (buf, bufSize, offset, valuesChecked) => {
 
   let valuePtr = buf + offset
   match (load(valuePtr, 0n)) {
-    t when (
-      t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG
-    ) => {
+    t when t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG => {
       let size = 8n + load(valuePtr, 4n)
       if (offset + size > bufSize) {
-        reportError("String/Bytes length exceeds buffer size", offset)
-      } else {
-        None
+        return reportError("String/Bytes length exceeds buffer size", offset)
       }
     },
     t when t == Tags._GRAIN_ADT_HEAP_TAG => {
       let arity = load(valuePtr, 16n)
       let size = 20n + arity * 4n
 
-      let mut error = if (offset + size > bufSize) {
-        reportError("Enum payload size exceeds buffer size", offset)
-      } else {
-        None
+      if (offset + size > bufSize) {
+        return reportError("Enum payload size exceeds buffer size", offset)
       }
 
       let a = arity * 4n
       for (let mut i = 0n; i < a; i += 4n) {
-        if (Option.isSome(error)) break
-
         let value = load(valuePtr + i, 20n)
         if (isHeapPtr(value)) {
           let asInt32 = toGrain(newInt32(value)): Int32
           if (Set.contains(asInt32, valuesChecked)) {
             continue
           }
-          error = Option.or(
-            error,
-            validateHeap(buf, bufSize, value, valuesChecked)
-          )
+          match (validateHeap(buf, bufSize, value, valuesChecked)) {
+            Some(e) => return Some(e),
+            None => void,
+          }
         } else {
-          error = Option.or(error, validateStack(value, offset))
+          match (validateStack(value, offset)) {
+            Some(e) => return Some(e),
+            None => void,
+          }
         }
       }
-
-      error
     },
     t when t == Tags._GRAIN_RECORD_HEAP_TAG => {
       let arity = load(valuePtr, 12n)
       let size = 16n + arity * 4n
 
-      let mut error = if (offset + size > bufSize) {
-        reportError("Record payload size exceeds buffer size", offset)
-      } else {
-        None
+      if (offset + size > bufSize) {
+        return reportError("Record payload size exceeds buffer size", offset)
       }
 
       let a = arity * 4n
       for (let mut i = 0n; i < a; i += 4n) {
-        if (Option.isSome(error)) break
-
         let value = load(valuePtr + i, 16n)
         if (isHeapPtr(value)) {
           let asInt32 = toGrain(newInt32(value)): Int32
           if (Set.contains(asInt32, valuesChecked)) {
             continue
           }
-          error = Option.or(
-            error,
-            validateHeap(buf, bufSize, value, valuesChecked)
-          )
+          match (validateHeap(buf, bufSize, value, valuesChecked)) {
+            Some(e) => return Some(e),
+            None => void,
+          }
         } else {
-          error = Option.or(error, validateStack(value, offset))
+          match (validateStack(value, offset)) {
+            Some(e) => return Some(e),
+            None => void,
+          }
         }
       }
-
-      error
     },
     t when t == Tags._GRAIN_ARRAY_HEAP_TAG => {
       let arity = load(valuePtr, 4n)
       let size = 8n + arity * 4n
 
-      let mut error = if (offset + size > bufSize) {
-        reportError("Array payload size exceeds buffer size", offset)
-      } else {
-        None
+      if (offset + size > bufSize) {
+        return reportError("Array payload size exceeds buffer size", offset)
       }
 
       let a = arity * 4n
       for (let mut i = 0n; i < a; i += 4n) {
-        if (Option.isSome(error)) break
-
         let value = load(valuePtr + i, 8n)
         if (isHeapPtr(value)) {
           let asInt32 = toGrain(newInt32(value)): Int32
           if (Set.contains(asInt32, valuesChecked)) {
             continue
           }
-          error = Option.or(
-            error,
-            validateHeap(buf, bufSize, value, valuesChecked)
-          )
+          match (validateHeap(buf, bufSize, value, valuesChecked)) {
+            Some(e) => return Some(e),
+            None => void,
+          }
         } else {
-          error = Option.or(error, validateStack(value, offset))
+          match (validateStack(value, offset)) {
+            Some(e) => return Some(e),
+            None => void,
+          }
         }
       }
-
-      error
     },
     t when t == Tags._GRAIN_TUPLE_HEAP_TAG => {
       let arity = load(valuePtr, 4n)
       let size = 8n + arity * 4n
 
-      let mut error = if (offset + size > bufSize) {
-        reportError("Tuple payload size exceeds buffer size", offset)
-      } else {
-        None
+      if (offset + size > bufSize) {
+        return reportError("Tuple payload size exceeds buffer size", offset)
       }
 
       let a = arity * 4n
       for (let mut i = 0n; i < a; i += 4n) {
-        if (Option.isSome(error)) break
-
         let value = load(valuePtr + i, 8n)
         if (isHeapPtr(value)) {
           let asInt32 = toGrain(newInt32(value)): Int32
           if (Set.contains(asInt32, valuesChecked)) {
             continue
           }
-          error = Option.or(
-            error,
-            validateHeap(buf, bufSize, value, valuesChecked)
-          )
+          match (validateHeap(buf, bufSize, value, valuesChecked)) {
+            Some(e) => return Some(e),
+            None => void,
+          }
         } else {
-          error = Option.or(error, validateStack(value, offset))
+          match (validateStack(value, offset)) {
+            Some(e) => return Some(e),
+            None => void,
+          }
         }
       }
-
-      error
     },
     t when t == Tags._GRAIN_LAMBDA_HEAP_TAG => {
       let arity = load(valuePtr, 12n)
       let size = 16n + arity * 4n
 
-      let mut error = if (offset + size > bufSize) {
-        reportError("Closure payload size exceeds buffer size", offset)
-      } else {
-        None
+      if (offset + size > bufSize) {
+        return reportError("Closure payload size exceeds buffer size", offset)
       }
 
       let a = arity * 4n
       for (let mut i = 0n; i < a; i += 4n) {
-        if (Option.isSome(error)) break
-
         let value = load(valuePtr + i, 16n)
         if (isHeapPtr(value)) {
           let asInt32 = toGrain(newInt32(value)): Int32
           if (Set.contains(asInt32, valuesChecked)) {
             continue
           }
-          error = Option.or(
-            error,
-            validateHeap(buf, bufSize, value, valuesChecked)
-          )
+          match (validateHeap(buf, bufSize, value, valuesChecked)) {
+            Some(e) => return Some(e),
+            None => void,
+          }
         } else {
-          error = Option.or(error, validateStack(value, offset))
+          match (validateStack(value, offset)) {
+            Some(e) => return Some(e),
+            None => void,
+          }
         }
       }
-
-      error
     },
     t when t == Tags._GRAIN_BOXED_NUM_HEAP_TAG => {
       let tag = load(valuePtr, 4n)
       match (tag) {
-        t when t == Tags._GRAIN_INT32_BOXED_NUM_TAG => {
-          if (offset + 12n > bufSize) {
-            reportError(
-              "Not enough bytes remaining in buffer for Int32/Number",
-              offset
-            )
-          } else {
-            None
-          }
-        },
         t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
           if (offset + 16n > bufSize) {
-            reportError(
+            return reportError(
               "Not enough bytes remaining in buffer for Int64/Number",
               offset
             )
-          } else {
-            None
           }
         },
         t when t == Tags._GRAIN_BIGINT_BOXED_NUM_TAG => {
           let size = 16n + load(valuePtr, 8n) * 8n
           if (offset + size > bufSize) {
-            reportError("BigInt/Number payload size exeeds buffer size", offset)
-          } else {
-            None
-          }
-        },
-        t when t == Tags._GRAIN_FLOAT32_BOXED_NUM_TAG => {
-          if (offset + 12n > bufSize) {
-            reportError(
-              "Not enough bytes remaining in buffer for Float32/Number",
+            return reportError(
+              "BigInt/Number payload size exeeds buffer size",
               offset
             )
-          } else {
-            None
           }
         },
         t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => {
           if (offset + 16n > bufSize) {
-            reportError(
+            return reportError(
               "Not enough bytes remaining in buffer for Float64/Number",
               offset
             )
-          } else {
-            None
           }
         },
         t when t == Tags._GRAIN_RATIONAL_BOXED_NUM_TAG => {
           if (offset + 16n > bufSize) {
-            reportError(
+            return reportError(
               "Not enough bytes remaining in buffer for Rational/Number",
               offset
             )
           } else {
             let numeratorOffset = load(valuePtr, 8n)
             let denominatorOffset = load(valuePtr, 12n)
-            let error = Option.or(
-              validateHeap(buf, bufSize, numeratorOffset, valuesChecked),
-              validateHeap(buf, bufSize, denominatorOffset, valuesChecked)
-            )
-            if (Option.isNone(error)) {
-              let numeratorError = if (
-                load(buf, numeratorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG &&
-                load(buf, numeratorOffset + 4n) !=
+            match (validateHeap(buf, bufSize, numeratorOffset, valuesChecked)) {
+              Some(err) => return Some(err),
+              None => void,
+            }
+            match (validateHeap(buf, bufSize, denominatorOffset, valuesChecked)) {
+              Some(err) => return Some(err),
+              None => void,
+            }
+            if (
+              load(buf, numeratorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG &&
+              load(buf, numeratorOffset + 4n) !=
+                Tags._GRAIN_BIGINT_BOXED_NUM_TAG
+            ) {
+              return reportError(
+                "Rational/Number numerator was not in the expected format",
+                offset
+              )
+            }
+            if (
+              load(buf, denominatorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG &&
+              load(buf, denominatorOffset + 4n) !=
+                Tags._GRAIN_BIGINT_BOXED_NUM_TAG
+            ) {
+              return reportError(
+                "Rational/Number denominator was not in the expected format",
+                offset
+              )
+            }
+            match (validateHeap(buf, bufSize, denominatorOffset, valuesChecked)) {
+              Some(e) => return Some(e),
+              None => void,
+            }
+            if (
+              load(buf, numeratorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG &&
+              load(buf, numeratorOffset + 4n) !=
                 Tags._GRAIN_BIGINT_BOXED_NUM_TAG
-              ) {
-                reportError(
-                  "Rational/Number numerator was not in the expected format",
-                  offset
-                )
-              } else {
-                None
-              }
-              let denominatorError = if (
-                load(buf, denominatorOffset) !=
-                Tags._GRAIN_BOXED_NUM_HEAP_TAG &&
-                load(buf, denominatorOffset + 4n) !=
+            ) {
+              return reportError(
+                "Rational/Number numerator was not in the expected format",
+                offset
+              )
+            }
+            let denominatorError = if (
+              load(buf, denominatorOffset) != Tags._GRAIN_BOXED_NUM_HEAP_TAG &&
+              load(buf, denominatorOffset + 4n) !=
                 Tags._GRAIN_BIGINT_BOXED_NUM_TAG
-              ) {
-                reportError(
-                  "Rational/Number denominator was not in the expected format",
-                  offset
-                )
-              } else {
-                None
-              }
-              Option.or(numeratorError, denominatorError)
-            } else {
-              error
+            ) {
+              return reportError(
+                "Rational/Number denominator was not in the expected format",
+                offset
+              )
             }
           }
         },
-        _ => {
-          None
-        },
+        _ => void,
       }
     },
-    _ => {
-      None
+    t when t == Tags._GRAIN_INT32_HEAP_TAG => {
+      if (offset + 8n > bufSize) {
+        return reportError(
+          "Not enough bytes remaining in buffer for Int32",
+          offset
+        )
+      }
+    },
+    t when t == Tags._GRAIN_FLOAT32_HEAP_TAG => {
+      if (offset + 8n > bufSize) {
+        return reportError(
+          "Not enough bytes remaining in buffer for Float32",
+          offset
+        )
+      }
+    },
+    t when t == Tags._GRAIN_UINT32_HEAP_TAG => {
+      if (offset + 8n > bufSize) {
+        return reportError(
+          "Not enough bytes remaining in buffer for Uint32",
+          offset
+        )
+      }
+    },
+    t when t == Tags._GRAIN_UINT64_HEAP_TAG => {
+      if (offset + 16n > bufSize) {
+        return reportError(
+          "Not enough bytes remaining in buffer for Uint64",
+          offset
+        )
+      }
     },
+    _ => void,
   }
+  return None
 }
 
 @unsafe
@@ -742,15 +754,12 @@ let validate = (buf, bufSize) => {
     } else {
       // Handle non-heap values: booleans, chars, void, etc.
       match (value) {
-        _ when (
-          value == fromGrain(true) ||
+        _ when value == fromGrain(true) ||
           value == fromGrain(false) ||
           value == fromGrain(void) ||
-          (value & Tags._GRAIN_NUMBER_TAG_MASK) ==
-          Tags._GRAIN_NUMBER_TAG_TYPE ||
-          (value & Tags._GRAIN_GENERIC_TAG_MASK) == Tags._GRAIN_CHAR_TAG_TYPE
-        ) =>
-          None,
+          (value & Tags._GRAIN_NUMBER_TAG_MASK) == Tags._GRAIN_NUMBER_TAG_TYPE ||
+          (value & Tags._GRAIN_GENERIC_TAG_MASK) ==
+            Tags._GRAIN_SHORTVAL_TAG_TYPE => None,
         _ => reportError("Unknown value", 0n),
       }
     }
@@ -763,9 +772,7 @@ let rec unmarshalHeap = (buf, offset, valuesUnmarshaled) => {
 
   let valuePtr = buf + offset
   match (load(valuePtr, 0n)) {
-    t when (
-      t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG
-    ) => {
+    t when t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG => {
       let size = 8n + load(valuePtr, 4n)
       let value = Memory.malloc(size)
       Memory.copy(value, valuePtr, size)
@@ -792,7 +799,7 @@ let rec unmarshalHeap = (buf, offset, valuesUnmarshaled) => {
           let asInt32 = toGrain(newInt32(subvalue)): Int32
           match (Map.get(asInt32, valuesUnmarshaled)) {
             Some(ptr) => {
-              let ptr = load(fromGrain(ptr), 8n)
+              let ptr = load(fromGrain(ptr), 4n)
               store(value + i, Memory.incRef(ptr), 20n)
             },
             None => {
@@ -827,7 +834,7 @@ let rec unmarshalHeap = (buf, offset, valuesUnmarshaled) => {
           let asInt32 = toGrain(newInt32(subvalue)): Int32
           match (Map.get(asInt32, valuesUnmarshaled)) {
             Some(ptr) => {
-              let ptr = load(fromGrain(ptr), 8n)
+              let ptr = load(fromGrain(ptr), 4n)
               store(value + i, Memory.incRef(ptr), 16n)
             },
             None => {
@@ -862,7 +869,7 @@ let rec unmarshalHeap = (buf, offset, valuesUnmarshaled) => {
           let asInt32 = toGrain(newInt32(subvalue)): Int32
           match (Map.get(asInt32, valuesUnmarshaled)) {
             Some(ptr) => {
-              let ptr = load(fromGrain(ptr), 8n)
+              let ptr = load(fromGrain(ptr), 4n)
               store(value + i, Memory.incRef(ptr), 8n)
             },
             None => {
@@ -897,7 +904,7 @@ let rec unmarshalHeap = (buf, offset, valuesUnmarshaled) => {
           let asInt32 = toGrain(newInt32(subvalue)): Int32
           match (Map.get(asInt32, valuesUnmarshaled)) {
             Some(ptr) => {
-              let ptr = load(fromGrain(ptr), 8n)
+              let ptr = load(fromGrain(ptr), 4n)
               store(value + i, Memory.incRef(ptr), 8n)
             },
             None => {
@@ -932,7 +939,7 @@ let rec unmarshalHeap = (buf, offset, valuesUnmarshaled) => {
           let asInt32 = toGrain(newInt32(subvalue)): Int32
           match (Map.get(asInt32, valuesUnmarshaled)) {
             Some(ptr) => {
-              let ptr = load(fromGrain(ptr), 8n)
+              let ptr = load(fromGrain(ptr), 4n)
               store(value + i, Memory.incRef(ptr), 16n)
             },
             None => {
@@ -953,15 +960,6 @@ let rec unmarshalHeap = (buf, offset, valuesUnmarshaled) => {
     t when t == Tags._GRAIN_BOXED_NUM_HEAP_TAG => {
       let tag = load(valuePtr, 4n)
       match (tag) {
-        t when t == Tags._GRAIN_INT32_BOXED_NUM_TAG => {
-          let value = Memory.malloc(12n)
-          Memory.copy(value, valuePtr, 12n)
-
-          let asInt32 = toGrain(newInt32(value)): Int32
-          Map.set(offsetAsInt32, asInt32, valuesUnmarshaled)
-
-          value
-        },
         t when t == Tags._GRAIN_INT64_BOXED_NUM_TAG => {
           let value = Memory.malloc(16n)
           Memory.copy(value, valuePtr, 16n)
@@ -981,15 +979,6 @@ let rec unmarshalHeap = (buf, offset, valuesUnmarshaled) => {
 
           value
         },
-        t when t == Tags._GRAIN_FLOAT32_BOXED_NUM_TAG => {
-          let value = Memory.malloc(12n)
-          Memory.copy(value, valuePtr, 12n)
-
-          let asInt32 = toGrain(newInt32(value)): Int32
-          Map.set(offsetAsInt32, asInt32, valuesUnmarshaled)
-
-          value
-        },
         t when t == Tags._GRAIN_FLOAT64_BOXED_NUM_TAG => {
           let value = Memory.malloc(16n)
           Memory.copy(value, valuePtr, 16n)
@@ -1017,6 +1006,26 @@ let rec unmarshalHeap = (buf, offset, valuesUnmarshaled) => {
         },
       }
     },
+    t when t == Tags._GRAIN_INT32_HEAP_TAG ||
+      t == Tags._GRAIN_FLOAT32_HEAP_TAG ||
+      t == Tags._GRAIN_UINT32_HEAP_TAG => {
+      let value = Memory.malloc(8n)
+      Memory.copy(value, valuePtr, 8n)
+
+      let asInt32 = toGrain(newInt32(value)): Int32
+      Map.set(offsetAsInt32, asInt32, valuesUnmarshaled)
+
+      value
+    },
+    t when t == Tags._GRAIN_UINT64_HEAP_TAG => {
+      let value = Memory.malloc(16n)
+      Memory.copy(value, valuePtr, 16n)
+
+      let asInt32 = toGrain(newInt32(value)): Int32
+      Map.set(offsetAsInt32, asInt32, valuesUnmarshaled)
+
+      value
+    },
     _ => {
       fail "Unknown heap type"
     },
@@ -1045,10 +1054,13 @@ let unmarshal = buf => {
  * @param bytes: The data to deserialize
  * @returns An in-memory value
  *
+ * @example Marshal.unmarshal(Marshal.marshal('🌾')) == Ok('🌾')
+ * @example Marshal.unmarshal(b"\x03\x00\x00\x00") == Ok(1)
+ *
  * @since v0.5.3
  */
 @unsafe
-export let unmarshal = (bytes: Bytes) => {
+provide let unmarshal = (bytes: Bytes) => {
   let buf = fromGrain(bytes) + 8n
   let bufSize = load(fromGrain(bytes), 4n)
   match (validate(buf, bufSize)) {