@grain/stdlib 0.6.5 → 0.7.0

package/runtime/string.gr

@@ -27,7 +27,8 @@ from "runtime/bigint" include Bigint as BI
 from "runtime/unsafe/memory" include Memory
 from "runtime/unsafe/tags" include Tags
 from "runtime/numberUtils" include NumberUtils
-
+from "runtime/utf8" include Utf8
+use Utf8.{ usvEncodeLength, writeUtf8CodePoint }
 from "runtime/dataStructures" include DataStructures
 use DataStructures.{ allocateString, allocateArray, untagSimpleNumber }
 
@@ -39,9 +40,6 @@ primitive (&&) = "@and"
 primitive (||) = "@or"
 primitive builtinId = "@builtin.id"
 primitive ignore = "@ignore"
-primitive throw = "@throw"
-
-exception MalformedUnicode
 
 @unsafe
 primitive typeMetadata = "@heap.type_metadata"
@@ -71,12 +69,16 @@ let _LIST_ID = untagSimpleNumber(builtinId("List"))
 let _OPTION_ID = untagSimpleNumber(builtinId("Option"))
 @unsafe
 let _RESULT_ID = untagSimpleNumber(builtinId("Result"))
+@unsafe
+let _RANGE_ID = untagSimpleNumber(builtinId("Range"))
 
 let _SOME = "Some"
 let _NONE = "None"
 let _OK = "Ok"
 let _ERR = "Err"
 
+let _RANGE_FIELDS = [> "rangeStart", "rangeEnd"]
+
 // Resizable arrays: <num items> <capacity> <...data>
 @unsafe
 let _VEC_LEN_OFFSET = 0n
@@ -163,6 +165,12 @@ let isListVariant = variant => {
   typeId == _LIST_ID
 }
 
+@unsafe
+let isRangeRecord = record_ => {
+  let typeId = WasmI32.load(record_, 8n) >> 1n
+  typeId == _RANGE_ID
+}
+
 @unsafe
 let getBuiltinVariantName = variant => {
   let typeId = WasmI32.load(variant, 8n) >> 1n
@@ -231,14 +239,18 @@ let getVariantMetadata = variant => {
 @unsafe
 let getRecordFieldNames = record_ => {
   let typeHash = WasmI32.load(record_, 4n) >> 1n
-  let arity = WasmI32.load(record_, 12n)
+  if (isRangeRecord(record_)) {
+    return Memory.incRef(WasmI32.fromGrain(_RANGE_FIELDS))
+  } else {
+    let arity = WasmI32.load(record_, 12n)
 
-  let mut fields = findTypeMetadata(typeHash)
+    let mut fields = findTypeMetadata(typeHash)
 
-  if (fields == -1n) return -1n
+    if (fields == -1n) return -1n
 
-  fields += 4n
-  return getFieldArray(fields, arity)
+    fields += 4n
+    return getFieldArray(fields, arity)
+  }
 }
 
 @unsafe
@@ -333,9 +345,10 @@ let escape = (ptr, isString) => {
   for (let mut i = 0n; i < size; i += 1n) {
     let byte = WasmI32.load8U(ptr + i, startOffset)
     if (
-      byte >= _SEQ_B && byte <= _SEQ_R || /* b, f, n, r, t, v */
-      byte == _SEQ_SLASH ||
-      byte == _SEQ_QUOTE
+      byte >= _SEQ_B && byte <= _SEQ_R
+      || /* b, f, n, r, t, v */
+      byte == _SEQ_SLASH
+      || byte == _SEQ_QUOTE
     ) {
       newSize += 2n
     } else {
@@ -351,9 +364,10 @@ let escape = (ptr, isString) => {
   for (let mut i = 0n; i < size; i += 1n) {
     let byte = WasmI32.load8U(ptr + i, startOffset)
     if (
-      byte >= _SEQ_B && byte <= _SEQ_R || /* b, f, n, r, t, v */
-      byte == _SEQ_SLASH ||
-      byte == _SEQ_QUOTE
+      byte >= _SEQ_B && byte <= _SEQ_R
+      || /* b, f, n, r, t, v */
+      byte == _SEQ_SLASH
+      || byte == _SEQ_QUOTE
     ) {
       WasmI32.store8(escapedString + j, _SEQ_SLASH, stringOffset)
       j += 1n
@@ -390,40 +404,6 @@ let escapeChar = (s: String) => {
   escape(WasmI32.fromGrain(s), false)
 }
 
-@unsafe
-let usvToString = usv => {
-  if (usv < 0x80n) {
-    let string = allocateString(1n)
-    WasmI32.store8(string, usv, 8n)
-    WasmI32.toGrain(string): String
-  } 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 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
-  }
-}
-
 @unsafe
 let reportCycle = (ptr, cycles) => {
   let mut cycleNum = vecFindIndex(cycles, ptr)
@@ -693,20 +673,23 @@ and toStringHelp = (grainValue, extraIndents, toplevel, cycles) => {
       let shortVal = grainValue >> 8n
       let shortValTag = (grainValue & 0xF8n) >> 3n
       if (shortValTag == Tags._GRAIN_CHAR_SHORTVAL_TAG) {
-        let string = usvToString(shortVal)
+        let byteCount = usvEncodeLength(shortVal)
+        let string = allocateString(byteCount)
+        writeUtf8CodePoint(string + 8n, shortVal)
+        let string = WasmI32.toGrain(string): String
         if (toplevel) {
           string
         } else {
           escapeChar(string)
         }
       } else if (
-        shortValTag == Tags._GRAIN_INT8_SHORTVAL_TAG ||
-        shortValTag == Tags._GRAIN_INT16_SHORTVAL_TAG
+        shortValTag == Tags._GRAIN_INT8_SHORTVAL_TAG
+        || shortValTag == Tags._GRAIN_INT16_SHORTVAL_TAG
       ) {
         NumberUtils.itoa32(shortVal, 10n)
       } else if (
-        shortValTag == Tags._GRAIN_UINT8_SHORTVAL_TAG ||
-        shortValTag == Tags._GRAIN_UINT16_SHORTVAL_TAG
+        shortValTag == Tags._GRAIN_UINT8_SHORTVAL_TAG
+        || shortValTag == Tags._GRAIN_UINT16_SHORTVAL_TAG
       ) {
         NumberUtils.utoa32(shortVal, 10n)
       } else {
@@ -878,54 +861,3 @@ provide let print = (value, suffix="\n") => {
   ignore(suffix)
   void
 }
-
-@unsafe
-provide let getCodePoint = (ptr: WasmI32) => {
-  // Algorithm from https://encoding.spec.whatwg.org/#utf-8-decoder
-  use WasmI32.{ (+), (&), (|), (<<), leU as (<=), geU as (>=), (==) }
-
-  let mut codePoint = 0n
-  let mut bytesSeen = 0n
-  let mut bytesNeeded = 0n
-  let mut lowerBoundary = 0x80n
-  let mut upperBoundary = 0xBFn
-
-  let mut offset = 0n
-
-  while (true) {
-    let byte = WasmI32.load8U(ptr + offset, 0n)
-    offset += 1n
-    if (bytesNeeded == 0n) {
-      if (byte >= 0x00n && byte <= 0x7Fn) {
-        return byte
-      } 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 MalformedUnicode
-      }
-      continue
-    }
-    if (!(lowerBoundary <= byte && byte <= upperBoundary)) {
-      throw MalformedUnicode
-    }
-    lowerBoundary = 0x80n
-    upperBoundary = 0xBFn
-    codePoint = codePoint << 6n | byte & 0x3Fn
-    bytesSeen += 1n
-    if (bytesSeen == bytesNeeded) {
-      return codePoint
-    }
-  }
-  return 0n
-}

package/runtime/string.md

@@ -14,7 +14,7 @@ No other changes yet.
 </details>
 
 ```grain
-concat : (str1: String, str2: String) => String
+concat: (str1: String, str2: String) => String
 ```
 
 Concatenate two strings.
@@ -46,7 +46,7 @@ No other changes yet.
 </details>
 
 ```grain
-toString : (value: a) => String
+toString: (value: a) => String
 ```
 
 Converts the given operand to a string.
@@ -79,7 +79,7 @@ Returns:
 </details>
 
 ```grain
-print : (value: a, ?suffix: String) => Void
+print: (value: a, ?suffix: String) => Void
 ```
 
 Prints the given operand to the console. Works for any type. Internally, calls `toString`
@@ -93,9 +93,3 @@ Parameters:
 |`value`|`a`|The operand|
 |`?suffix`|`String`|The string to print after the argument|
 
-### String.**getCodePoint**
-
-```grain
-getCodePoint : (ptr: WasmI32) => WasmI32
-```
-

package/runtime/unsafe/constants.md

@@ -9,144 +9,144 @@ Functions and constants included in the Constants module.
 ### Constants.**_SMIN_I32**
 
 ```grain
-_SMIN_I32 : WasmI32
+_SMIN_I32: WasmI32
 ```
 
 ### Constants.**_SMAX_I32**
 
 ```grain
-_SMAX_I32 : WasmI32
+_SMAX_I32: WasmI32
 ```
 
 ### Constants.**_UMIN_I32**
 
 ```grain
-_UMIN_I32 : WasmI32
+_UMIN_I32: WasmI32
 ```
 
 ### Constants.**_UMAX_I32**
 
 ```grain
-_UMAX_I32 : WasmI32
+_UMAX_I32: WasmI32
 ```
 
 ### Constants.**_SMIN8_I32**
 
 ```grain
-_SMIN8_I32 : WasmI32
+_SMIN8_I32: WasmI32
 ```
 
 ### Constants.**_SMAX8_I32**
 
 ```grain
-_SMAX8_I32 : WasmI32
+_SMAX8_I32: WasmI32
 ```
 
 ### Constants.**_UMAX8_I32**
 
 ```grain
-_UMAX8_I32 : WasmI32
+_UMAX8_I32: WasmI32
 ```
 
 ### Constants.**_SMIN16_I32**
 
 ```grain
-_SMIN16_I32 : WasmI32
+_SMIN16_I32: WasmI32
 ```
 
 ### Constants.**_SMAX16_I32**
 
 ```grain
-_SMAX16_I32 : WasmI32
+_SMAX16_I32: WasmI32
 ```
 
 ### Constants.**_UMAX16_I32**
 
 ```grain
-_UMAX16_I32 : WasmI32
+_UMAX16_I32: WasmI32
 ```
 
 ### Constants.**_SMIN_I64**
 
 ```grain
-_SMIN_I64 : WasmI64
+_SMIN_I64: WasmI64
 ```
 
 ### Constants.**_SMAX_I64**
 
 ```grain
-_SMAX_I64 : WasmI64
+_SMAX_I64: WasmI64
 ```
 
 ### Constants.**_UMIN_I64**
 
 ```grain
-_UMIN_I64 : WasmI64
+_UMIN_I64: WasmI64
 ```
 
 ### Constants.**_UMAX_I64**
 
 ```grain
-_UMAX_I64 : WasmI64
+_UMAX_I64: WasmI64
 ```
 
 ### Constants.**_SMIN8_I64**
 
 ```grain
-_SMIN8_I64 : WasmI64
+_SMIN8_I64: WasmI64
 ```
 
 ### Constants.**_SMAX8_I64**
 
 ```grain
-_SMAX8_I64 : WasmI64
+_SMAX8_I64: WasmI64
 ```
 
 ### Constants.**_UMAX8_I64**
 
 ```grain
-_UMAX8_I64 : WasmI64
+_UMAX8_I64: WasmI64
 ```
 
 ### Constants.**_SMIN16_I64**
 
 ```grain
-_SMIN16_I64 : WasmI64
+_SMIN16_I64: WasmI64
 ```
 
 ### Constants.**_SMAX16_I64**
 
 ```grain
-_SMAX16_I64 : WasmI64
+_SMAX16_I64: WasmI64
 ```
 
 ### Constants.**_UMAX16_I64**
 
 ```grain
-_UMAX16_I64 : WasmI64
+_UMAX16_I64: WasmI64
 ```
 
 ### Constants.**_SMIN32_I64**
 
 ```grain
-_SMIN32_I64 : WasmI64
+_SMIN32_I64: WasmI64
 ```
 
 ### Constants.**_SMAX32_I64**
 
 ```grain
-_SMAX32_I64 : WasmI64
+_SMAX32_I64: WasmI64
 ```
 
 ### Constants.**_UMIN32_I64**
 
 ```grain
-_UMIN32_I64 : WasmI64
+_UMIN32_I64: WasmI64
 ```
 
 ### Constants.**_UMAX32_I64**
 
 ```grain
-_UMAX32_I64 : WasmI64
+_UMAX32_I64: WasmI64
 ```
 

package/runtime/unsafe/conv.md

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

package/runtime/unsafe/memory.gr

@@ -4,38 +4,42 @@ module Memory
 from "runtime/gc" include GC
 use GC.{ malloc, free, incRef, decRef }
 from "runtime/unsafe/wasmi32" include WasmI32
-use WasmI32.{ (+), (-), (<<), (==), (!=), ltU as (<) }
+use WasmI32.{ (+), (-), (!=), ltU as (<), gtU as (>) }
 
 provide { malloc, free, incRef, decRef }
 
-provide let copy = (dest, src, n) => {
-  let mut dest = dest
-  let mut src = src
-  let mut n = n
+/**
+ * Copies the source memory region to the destination memory region. Regions may overlap.
+ *
+ * @param dest: The destination memory region
+ * @param src: The source memory region
+ * @param length: The length of the memory region to copy
+ */
+provide let copy = (dest, src, length) => {
   if (dest != src) {
     if (dest < src) {
-      while (n != 0n) {
-        WasmI32.store8(dest, WasmI32.load8U(src, 0n), 0n)
-        dest += 1n
-        src += 1n
-        n -= 1n
+      for (let mut i = 0n; i < length; i += 1n) {
+        WasmI32.store8(dest, WasmI32.load8U(src, i), i)
       }
     } else {
-      while (n != 0n) {
-        n -= 1n
-        WasmI32.store8(dest + n, WasmI32.load8U(src + n, 0n), 0n)
+      // Copy backwards to ensure we do not overwrite on overlapping regions
+      for (let mut n = length; n > 0n; n -= 1n) {
+        WasmI32.store8(dest + n - 1n, WasmI32.load8U(src + n - 1n, 0n), 0n)
       }
     }
   }
 }
 
-provide let fill = (dest, c, n) => {
-  let mut dest = dest
-  let mut n = n
-  while (n != 0n) {
-    WasmI32.store8(dest, c, 0n)
-    dest += 1n
-    n -= 1n
+/**
+ * Fills the given memory region with the given 1-byte value. Values larger than 1 byte will be truncated.
+ *
+ * @param dest: The destination memory region
+ * @param value: The value to fill the memory region with
+ * @param length: The length of the memory region to fill
+ */
+provide let fill = (dest, value, length) => {
+  for (let mut i = 0n; i < length; i += 1n) {
+    WasmI32.store8(dest, value, i)
   }
 }
 

package/runtime/unsafe/memory.md

@@ -9,42 +9,62 @@ Functions and constants included in the Memory module.
 ### Memory.**malloc**
 
 ```grain
-malloc : (size: WasmI32) => WasmI32
+malloc: (size: WasmI32) => WasmI32
 ```
 
 ### Memory.**free**
 
 ```grain
-free : (userPtr: WasmI32) => Void
+free: (userPtr: WasmI32) => Void
 ```
 
 ### Memory.**incRef**
 
 ```grain
-incRef : (userPtr: WasmI32) => WasmI32
+incRef: (userPtr: WasmI32) => WasmI32
 ```
 
 ### Memory.**decRef**
 
 ```grain
-decRef : (userPtr: WasmI32) => WasmI32
+decRef: (userPtr: WasmI32) => WasmI32
 ```
 
 ### Memory.**copy**
 
 ```grain
-copy : (dest: WasmI32, src: WasmI32, n: WasmI32) => Void
+copy: (dest: WasmI32, src: WasmI32, length: WasmI32) => Void
 ```
 
+Copies the source memory region to the destination memory region. Regions may overlap.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`dest`|`WasmI32`|The destination memory region|
+|`src`|`WasmI32`|The source memory region|
+|`length`|`WasmI32`|The length of the memory region to copy|
+
 ### Memory.**fill**
 
 ```grain
-fill : (dest: WasmI32, c: WasmI32, n: WasmI32) => Void
+fill: (dest: WasmI32, value: WasmI32, length: WasmI32) => Void
 ```
 
+Fills the given memory region with the given 1-byte value. Values larger than 1 byte will be truncated.
+
+Parameters:
+
+|param|type|description|
+|-----|----|-----------|
+|`dest`|`WasmI32`|The destination memory region|
+|`value`|`WasmI32`|The value to fill the memory region with|
+|`length`|`WasmI32`|The length of the memory region to fill|
+
 ### Memory.**compare**
 
 ```grain
-compare : (ptr1: WasmI32, ptr2: WasmI32, length: WasmI32) => WasmI32
+compare: (ptr1: WasmI32, ptr2: WasmI32, length: WasmI32) => WasmI32
 ```
 

package/runtime/unsafe/offsets.gr

@@ -0,0 +1,36 @@
+/**
+ * Various common offsets for data structures throughout the runtime.
+ */
+@runtimeMode
+module Offsets
+
+// String
+provide let _STR_LEN_OFFSET = 4n
+provide let _STR_DATA_OFFSET = 8n
+
+// Array
+provide let _ARRAY_LEN_OFFSET = 4n
+provide let _ARRAY_DATA_OFFSET = 8n
+provide let _ARRAY_ITEM_SIZE = 4n
+
+// Bytes
+provide let _BYTES_LEN_OFFSET = 4n
+provide let _BYTES_DATA_OFFSET = 8n
+
+// Int32
+provide let _INT32_VALUE_OFFSET = 4n
+
+// Uint32
+provide let _UINT32_VALUE_OFFSET = 4n
+
+// Float32
+provide let _FLOAT32_VALUE_OFFSET = 4n
+
+// Int64
+provide let _INT64_VALUE_OFFSET = 8n
+
+// Uint64
+provide let _UINT64_VALUE_OFFSET = 8n
+
+// Float64
+provide let _FLOAT64_VALUE_OFFSET = 8n