@grain/stdlib 0.4.4 → 0.4.5

package/option.gr

@@ -23,10 +23,10 @@
  * 
  * @since v0.2.0
  */
-export let isSome = (option) => {
+export let isSome = option => {
   match (option) {
     Some(_) => true,
-    None => false
+    None => false,
   }
 }
 
@@ -38,10 +38,10 @@ export let isSome = (option) => {
  * 
  * @since v0.2.0
  */
-export let isNone = (option) => {
+export let isNone = option => {
   match (option) {
     None => true,
-    Some(_) => false
+    Some(_) => false,
   }
 }
 
@@ -57,7 +57,7 @@ export let isNone = (option) => {
 export let contains = (value, option) => {
   match (option) {
     Some(x) => x == value,
-    None => false
+    None => false,
   }
 }
 
@@ -74,7 +74,7 @@ export let contains = (value, option) => {
 export let expect = (msg, option) => {
   match (option) {
     Some(x) => x,
-    None => fail msg
+    None => fail msg,
   }
 }
 
@@ -87,7 +87,7 @@ export let expect = (msg, option) => {
  * 
  * @since v0.2.0
  */
-export let unwrap = (option) => {
+export let unwrap = option => {
   expect("Could not unwrap None value", option)
 }
 
@@ -103,7 +103,7 @@ export let unwrap = (option) => {
 export let unwrapWithDefault = (default, option) => {
   match (option) {
     Some(x) => x,
-    None => default
+    None => default,
   }
 }
 
@@ -119,7 +119,7 @@ export let unwrapWithDefault = (default, option) => {
 export let map = (fn, option) => {
   match (option) {
     Some(x) => Some(fn(x)),
-    None => None
+    None => None,
   }
 }
 
@@ -137,7 +137,7 @@ export let map = (fn, option) => {
 export let mapWithDefault = (fn, default, option) => {
   match (option) {
     Some(x) => fn(x),
-    None => default
+    None => default,
   }
 }
 
@@ -156,7 +156,7 @@ export let mapWithDefault = (fn, default, option) => {
 export let mapWithDefaultFn = (fn, defaultFn, option) => {
   match (option) {
     Some(x) => fn(x),
-    None => defaultFn()
+    None => defaultFn(),
   }
 }
 
@@ -172,7 +172,7 @@ export let mapWithDefaultFn = (fn, defaultFn, option) => {
 export let flatMap = (fn, option) => {
   match (option) {
     Some(x) => fn(x),
-    None => None
+    None => None,
   }
 }
 
@@ -194,7 +194,7 @@ export let filter = (fn, option) => {
       } else {
         None
       },
-    None => None
+    None => None,
   }
 }
 
@@ -210,7 +210,7 @@ export let filter = (fn, option) => {
 export let zip = (optionA, optionB) => {
   match ((optionA, optionB)) {
     (Some(a), Some(b)) => Some((a, b)),
-    _ => None
+    _ => None,
   }
 }
 
@@ -227,7 +227,7 @@ export let zip = (optionA, optionB) => {
 export let zipWith = (fn, optionA, optionB) => {
   match ((optionA, optionB)) {
     (Some(a), Some(b)) => Some(fn(a, b)),
-    _ => None
+    _ => None,
   }
 }
 
@@ -241,10 +241,10 @@ export let zipWith = (fn, optionA, optionB) => {
  *
  * @since v0.2.0
  */
-export let flatten = (option) => {
+export let flatten = option => {
   match (option) {
     Some(Some(x)) => Some(x),
-    _ => None
+    _ => None,
   }
 }
 
@@ -256,10 +256,10 @@ export let flatten = (option) => {
  * 
  * @since v0.2.0
  */
-export let toList = (option) => {
+export let toList = option => {
   match (option) {
     Some(x) => [x],
-    None => []
+    None => [],
   }
 }
 
@@ -271,10 +271,10 @@ export let toList = (option) => {
  * 
  * @since v0.2.0
  */
-export let toArray = (option) => {
+export let toArray = option => {
   match (option) {
     Some(x) => [> x],
-    None => [>]
+    None => [>],
   }
 }
 
@@ -290,7 +290,7 @@ export let toArray = (option) => {
 export let toResult = (err, option) => {
   match (option) {
     Some(a) => Ok(a),
-    None    => Err(err)
+    None => Err(err),
   }
 }
 
@@ -305,7 +305,7 @@ export let toResult = (err, option) => {
 export let sideEffect = (fn, option) => {
   match (option) {
     Some(x) => fn(x),
-    None => void
+    None => void,
   }
 }
 
@@ -336,7 +336,7 @@ export let peek = (fn, option) => {
 export let or = (optionA, optionB) => {
   match (optionA) {
     Some(x) => optionA,
-    None => optionB
+    None => optionB,
   }
 }
 
@@ -352,6 +352,6 @@ export let or = (optionA, optionB) => {
 export let and = (optionA, optionB) => {
   match (optionA) {
     Some(_) => optionB,
-    None => optionA
+    None => optionA,
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grain/stdlib",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "description": "The standard library for the Grain language.",
   "license": "MIT",
   "homepage": "https://grain-lang.org",

package/pervasives.gr

@@ -24,7 +24,7 @@ import {
   (^),
   (<<),
   (>>>),
-  (>>)
+  (>>),
 } from "runtime/numbers"
 
 // Math operations
@@ -53,7 +53,6 @@ export (<<)
 export (>>>)
 export (>>)
 
-
 // Number coercions & conversions
 
 // [TODO] (#311) Commented until we nail down semantics
@@ -61,23 +60,23 @@ export (>>)
 // import foreign wasm convertInexactToExact : Number -> Number as exact from "stdlib-external/runtime"
 
 // Boolean operations
-primitive (!) : Bool -> Bool = "@not"
-primitive (&&) : (Bool, Bool) -> Bool = "@and"
-primitive (||) : (Bool, Bool) -> Bool = "@or"
+primitive (!): Bool -> Bool = "@not"
+primitive (&&): (Bool, Bool) -> Bool = "@and"
+primitive (||): (Bool, Bool) -> Bool = "@or"
 
 // Box operations
-primitive box : a -> Box<a> = "@box"
-primitive unbox : Box<a> -> a = "@unbox"
+primitive box: a -> Box<a> = "@box"
+primitive unbox: Box<a> -> a = "@unbox"
 
 // Exceptions
 exception Failure(String)
 exception InvalidArgument(String)
 
 // Other operations
-primitive ignore : a -> Void = "@ignore"
-primitive assert : Bool -> Void = "@assert"
-primitive throw : Exception -> a = "@throw"
-let fail : String -> a = msg => throw Failure(msg)
+primitive ignore: a -> Void = "@ignore"
+primitive assert: Bool -> Void = "@assert"
+primitive throw: Exception -> a = "@throw"
+let fail: String -> a = msg => throw Failure(msg)
 
 import { toString, print, concat as (++) } from "runtime/string"
 
@@ -91,28 +90,41 @@ export (++)
 
 // Checks the given items for structural equality.
 export (==)
-let (!=) : (a, a) -> Bool = (x, y) => !(x == y)
+let (!=): (a, a) -> Bool = (x, y) => !(x == y)
 // Checks the given items for physical equality.
-primitive (is) : (a, a) -> Bool = "@is"
+primitive (is): (a, a) -> Bool = "@is"
 // The opposite of is operator
-let (isnt) : (a, a) -> Bool = (x, y) => !(x is y)
+let (isnt): (a, a) -> Bool = (x, y) => !(x is y)
 
-export enum List<a> { [], [...](a, List<a>) }
+export enum List<a> {
+  [],
+  [...](a, List<a>),
+}
 
 /**
  * @deprecated This will be removed in a future release of Grain.
  */
-let cons = (a, b) => [a, ...b] // <- workaround for (grain-lang/grain#802) [TODO] fix #802 and delete
+let cons = (a, b) =>
+  [
+    a,
+    ...b
+  ] // <- workaround for (grain-lang/grain#802) [TODO] fix #802 and delete
 let empty = [] // <- for parity with `cons`, but should be deleted as well
 
 // Maybe some data, maybe not!
-enum Option<a> { Some(a), None }
+enum Option<a> {
+  Some(a),
+  None,
+}
 
 // Maybe some data, maybe an error!
-enum Result<t, e> { Ok(t), Err(e) }
+enum Result<t, e> {
+  Ok(t),
+  Err(e),
+}
 
 // Identity function
-let identity = (x) => x
+let identity = x => x
 
 // Setup exception printing
 @disableGC
@@ -121,7 +133,7 @@ let rec setupExceptions = () => {
     match (e) {
       Failure(msg) => Some("Failure: " ++ msg),
       InvalidArgument(msg) => Some("Invalid argument: " ++ msg),
-      _ => None
+      _ => None,
     }
   })
 

package/queue.gr

@@ -5,7 +5,10 @@
  */
 import List from "list"
 
-record Queue<a> { forwards: List<a>, backwards: List<a> }
+record Queue<a> {
+  forwards: List<a>,
+  backwards: List<a>,
+}
 
 /**
  * @section Values: Functions for working with queues.

package/range.gr

@@ -38,7 +38,7 @@ export let inRange = (value, range) => {
     Inclusive(upper, lower) when value >= lower && value <= upper => true,
     Exclusive(lower, upper) when value >= lower && value < upper => true,
     Exclusive(upper, lower) when value >= lower && value < upper => true,
-    _ => false
+    _ => false,
   }
 }
 
@@ -52,34 +52,34 @@ export let inRange = (value, range) => {
  *
  * @since v0.3.0
  */
-export let forEach = (fn: (Number) -> Void, range) => {
+export let forEach = (fn: Number -> Void, range) => {
   match (range) {
     Inclusive(lower, upper) when lower <= upper => {
-      let mut idx = lower;
+      let mut idx = lower
       while (idx <= upper) {
-        fn(idx);
-        idx += 1;
+        fn(idx)
+        idx += 1
       }
     },
     Inclusive(upper, lower) => {
-      let mut idx = upper;
+      let mut idx = upper
       while (idx >= lower) {
-        fn(idx);
-        idx -= 1;
+        fn(idx)
+        idx -= 1
       }
     },
     Exclusive(lower, upper) when lower <= upper => {
-      let mut idx = lower;
+      let mut idx = lower
       while (idx < upper) {
-        fn(idx);
-        idx += 1;
+        fn(idx)
+        idx += 1
       }
     },
     Exclusive(upper, lower) => {
-      let mut idx = upper;
+      let mut idx = upper
       while (idx > lower) {
-        fn(idx);
-        idx -= 1;
+        fn(idx)
+        idx -= 1
       }
     },
   }
@@ -100,31 +100,31 @@ export let map = (fn, range) => {
   let mut result = []
   match (range) {
     Inclusive(lower, upper) when lower <= upper => {
-      let mut idx = upper;
+      let mut idx = upper
       while (idx >= lower) {
-        result = [fn(idx), ...result];
-        idx -= 1;
+        result = [fn(idx), ...result]
+        idx -= 1
       }
     },
     Inclusive(upper, lower) => {
-      let mut idx = lower;
+      let mut idx = lower
       while (idx <= upper) {
-        result = [fn(idx), ...result];
-        idx += 1;
+        result = [fn(idx), ...result]
+        idx += 1
       }
     },
     Exclusive(lower, upper) when lower <= upper => {
-      let mut idx = upper - 1;
+      let mut idx = upper - 1
       while (idx >= lower) {
-        result = [fn(idx), ...result];
-        idx -= 1;
+        result = [fn(idx), ...result]
+        idx -= 1
       }
     },
     Exclusive(upper, lower) => {
-      let mut idx = lower + 1;
+      let mut idx = lower + 1
       while (idx <= upper) {
-        result = [fn(idx), ...result];
-        idx += 1;
+        result = [fn(idx), ...result]
+        idx += 1
       }
     },
   }

package/runtime/dataStructures.gr

@@ -6,7 +6,7 @@ import WasmI32, {
   add as (+),
   mul as (*),
   xor as (^),
-  shl as (<<)
+  shl as (<<),
 } from "runtime/unsafe/wasmi32"
 import WasmI64 from "runtime/unsafe/wasmi64"
 import WasmF32 from "runtime/unsafe/wasmf32"
@@ -23,7 +23,7 @@ import WasmF64 from "runtime/unsafe/wasmf64"
  * @param {WasmI32} numElts The number of elements to be contained in this array
  * @returns {WasmI32} The pointer to the array
  */
-export let allocateArray = (numElts) => {
+export let allocateArray = numElts => {
   let arr = Memory.malloc((numElts + 2n) * 4n)
 
   WasmI32.store(arr, Tags._GRAIN_ARRAY_HEAP_TAG, 0n)
@@ -49,7 +49,7 @@ export let storeInArray = (arr, idx, item) => {
  * @param {WasmI32} numElts The number of elements to be contained in this tuple
  * @returns {WasmI32} The pointer to the tuple
  */
-export let allocateTuple = (numElts) => {
+export let allocateTuple = numElts => {
   let tuple = Memory.malloc((numElts + 2n) * 4n)
 
   WasmI32.store(tuple, Tags._GRAIN_TUPLE_HEAP_TAG, 0n)
@@ -75,7 +75,7 @@ export let storeInTuple = (tuple, idx, item) => {
  * @param {WasmI32} size The number of bytes to be contained in this buffer
  * @returns {WasmI32} The pointer to the bytes
  */
-export let allocateBytes = (size) => {
+export let allocateBytes = size => {
   let len = size + 8n
   let bytes = Memory.malloc(len)
   Memory.fill(bytes, 0n, len)
@@ -90,7 +90,7 @@ export let allocateBytes = (size) => {
  * @param {WasmI32} size The size (in bytes) of the string to allocate
  * @returns {WasmI32} The pointer to the string
  */
-export let allocateString = (size) => {
+export let allocateString = size => {
   let str = Memory.malloc(size + 8n)
 
   WasmI32.store(str, Tags._GRAIN_STRING_HEAP_TAG, 0n)
@@ -105,7 +105,7 @@ export let allocateString = (size) => {
  * @param {WasmI32} c The character for which to allocate a string
  * @returns {WasmI32} The pointer to the string
  */
-export let singleByteString = (c) => {
+export let singleByteString = c => {
   let str = Memory.malloc(9n)
 
   WasmI32.store(str, Tags._GRAIN_STRING_HEAP_TAG, 0n)
@@ -148,7 +148,7 @@ export let allocateInt64 = () => {
  * Allocates a new Int64 with a prepopulated value
  * @param value The value to store
  */
-export let newInt64 = (value) => {
+export let newInt64 = value => {
   let ptr = allocateInt64()
   WasmI64.store(ptr, value, 8n)
   ptr
@@ -158,11 +158,11 @@ export let newInt64 = (value) => {
  * Returns a pointer to the heap location containing this boxed number's Int64
  * @param wrappedInt64 The boxed int64 to return
  */
-export let rawInt64Ptr = (wrappedInt64) => {
+export let rawInt64Ptr = wrappedInt64 => {
   wrappedInt64 + 8n
 }
 
-export let loadInt64 = (xptr) => {
+export let loadInt64 = xptr => {
   WasmI64.load(xptr, 8n)
 }
 
@@ -184,7 +184,7 @@ export let allocateInt32 = () => {
  * Allocates a new Int32 with a prepopulated value
  * @param value The value to store
  */
-export let newInt32 = (value) => {
+export let newInt32 = value => {
   let ptr = allocateInt32()
   WasmI32.store(ptr, value, 8n)
   ptr
@@ -194,11 +194,11 @@ export let newInt32 = (value) => {
  * Returns a pointer to the heap location containing this boxed number's Int32
  * @param wrappedInt32 The boxed int32 to return
  */
-export let rawInt32Ptr = (wrappedInt32) => {
+export let rawInt32Ptr = wrappedInt32 => {
   wrappedInt32 + 8n
 }
 
-export let loadInt32 = (xptr) => {
+export let loadInt32 = xptr => {
   WasmI32.load(xptr, 8n)
 }
 
@@ -222,7 +222,7 @@ export let allocateFloat32 = () => {
  * Allocates a new Float32 with a prepopulated value
  * @param value The value to store
  */
-export let newFloat32 = (value) => {
+export let newFloat32 = value => {
   let ptr = allocateFloat32()
   WasmF32.store(ptr, value, 8n)
   ptr
@@ -232,11 +232,11 @@ export let newFloat32 = (value) => {
  * Returns a pointer to the heap location containing this boxed number's Float32
  * @param wrappedFloat32 The boxed float32 to return
  */
-export let rawFloat32Ptr = (wrappedFloat32) => {
+export let rawFloat32Ptr = wrappedFloat32 => {
   wrappedFloat32 + 8n
 }
 
-export let loadFloat32 = (xptr) => {
+export let loadFloat32 = xptr => {
   WasmF32.load(xptr, 8n)
 }
 
@@ -258,7 +258,7 @@ export let allocateFloat64 = () => {
  * Allocates a new Float64 with a prepopulated value
  * @param value The value to store
  */
-export let newFloat64 = (value) => {
+export let newFloat64 = value => {
   let ptr = allocateFloat64()
   WasmF64.store(ptr, value, 8n)
   ptr
@@ -268,11 +268,11 @@ export let newFloat64 = (value) => {
  * Returns a pointer to the heap location containing this boxed number's Float64
  * @param wrappedFloat64 The boxed float64 to return
  */
-export let rawFloat64Ptr = (wrappedFloat64) => {
+export let rawFloat64Ptr = wrappedFloat64 => {
   wrappedFloat64 + 8n
 }
 
-export let loadFloat64 = (xptr) => {
+export let loadFloat64 = xptr => {
   WasmF64.load(xptr, 8n)
 }
 
@@ -296,7 +296,7 @@ export let allocateRational = () => {
  * Allocates a new Rational with a prepopulated value
  * @param value The value to store
  */
-export let newRational = (numerator, denominator) =>{
+export let newRational = (numerator, denominator) => {
   let ptr = allocateRational()
   WasmI32.store(ptr, numerator, 8n)
   WasmI32.store(ptr, denominator, 12n)
@@ -307,7 +307,7 @@ export let newRational = (numerator, denominator) =>{
  * Returns a pointer to the heap location containing this boxed number's Rational numerator
  * @param wrappedRational The boxed rational to return
  */
-export let rawRationalNumeratorPtr = (wrappedRational) => {
+export let rawRationalNumeratorPtr = wrappedRational => {
   wrappedRational + 8n
 }
 
@@ -315,19 +315,18 @@ export let rawRationalNumeratorPtr = (wrappedRational) => {
  * Returns a pointer to the heap location containing this boxed number's Rational numerator
  * @param wrappedRational The boxed rational to return
  */
-export let rawRationalDenominatorPtr = (wrappedRational) => {
+export let rawRationalDenominatorPtr = wrappedRational => {
   wrappedRational + 12n
 }
 
-export let loadRationalNumerator = (xptr) => {
+export let loadRationalNumerator = xptr => {
   WasmI32.load(xptr, 8n)
 }
 
-export let loadRationalDenominator = (xptr) => {
+export let loadRationalDenominator = xptr => {
   WasmI32.load(xptr, 12n)
 }
 
-
 /**
  * Load a value from an ADT.
  *
@@ -337,7 +336,7 @@ export let loadRationalDenominator = (xptr) => {
  * @returns {WasmI32} The value located at the index
  */
 export let loadAdtVal = (ptr, idx) => {
-  WasmI32.load(ptr + (idx * 4n), 20n)
+  WasmI32.load(ptr + idx * 4n, 20n)
 }
 
 /**
@@ -347,7 +346,7 @@ export let loadAdtVal = (ptr, idx) => {
  * @param {WasmI32} ptr Untagged pointer to the ADT
  * @returns {WasmI32} The (tagged) ADT variant id
  */
-export let loadAdtVariant = (ptr) => {
+export let loadAdtVariant = ptr => {
   WasmI32.load(ptr, 12n)
 }
 
@@ -358,10 +357,10 @@ export let loadAdtVariant = (ptr) => {
  * @param {WasmI32} ptr Untagged pointer to the string
  * @returns {WasmI32} The string size (in bytes)
  */
-export let stringSize = (ptr) => {
+export let stringSize = ptr => {
   WasmI32.load(ptr, 4n)
 }
 
-export let tagSimpleNumber = (x) => {
-  WasmI32.toGrain((x << 1n) ^ 1n): Number
+export let tagSimpleNumber = x => {
+  WasmI32.toGrain(x << 1n ^ 1n): Number
 }

package/runtime/debug.gr

@@ -1,3 +1,2 @@
 /* grainc-flags --compilation-mode=runtime */
 export foreign wasm debug: a -> Void from "console"
-