@grain/stdlib 0.4.6 → 0.5.2

package/sys/process.gr

@@ -1,4 +1,3 @@
-/* grainc-flags --no-gc */
 /**
  * @module Sys/Process: Utilities for accessing functionality and information about the Grain program's process.
  *
@@ -95,31 +94,20 @@ export enum Signal {
  * @section Values: Functions and constants included in the Sys/Process module.
  */
 
-let wasmSafeOk = val => {
-  Memory.incRef(WasmI32.fromGrain(Ok))
-  Memory.incRef(WasmI32.fromGrain(val))
-  Ok(val)
-}
-
-let wasmSafeErr = err => {
-  Memory.incRef(WasmI32.fromGrain(Err))
-  Memory.incRef(WasmI32.fromGrain(err))
-  Err(err)
-}
-
 /**
  * Access command line arguments.
  *
  * @returns `Ok(args)` of an array containing positional string arguments to the process if successful or `Err(exception)` otherwise
  */
-export let rec argv = () => {
+@unsafe
+export let argv = () => {
   let argcPtr = Memory.malloc(8n)
   let argvBufSizePtr = argcPtr + 4n
 
   let mut err = Wasi.args_sizes_get(argcPtr, argvBufSizePtr)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(argcPtr)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     let argc = WasmI32.load(argcPtr, 0n)
     let argvBufSize = WasmI32.load(argvBufSizePtr, 0n)
@@ -132,7 +120,7 @@ export let rec argv = () => {
       Memory.free(argcPtr)
       Memory.free(argvPtr)
       Memory.free(argvBufPtr)
-      wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+      Err(Wasi.SystemError(tagSimpleNumber(err)))
     } else {
       let arr = allocateArray(argc)
 
@@ -154,11 +142,9 @@ export let rec argv = () => {
       Memory.free(argvPtr)
       Memory.free(argvBufPtr)
 
-      wasmSafeOk(WasmI32.toGrain(arr): (Array<String>))
+      Ok(WasmI32.toGrain(arr): Array<String>)
     }
   }
-  Memory.decRef(WasmI32.fromGrain(argv))
-  ret
 }
 
 /**
@@ -166,14 +152,15 @@ export let rec argv = () => {
  *
  * @returns `Ok(vars)` of an array containing environment variables supplied to the process if successful or `Err(exception)` otherwise
  */
-export let rec env = () => {
+@unsafe
+export let env = () => {
   let envcPtr = Memory.malloc(8n)
   let envvBufSizePtr = envcPtr + 4n
 
   let mut err = Wasi.environ_sizes_get(envcPtr, envvBufSizePtr)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(envcPtr)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     let envc = WasmI32.load(envcPtr, 0n)
     let envvBufSize = WasmI32.load(envvBufSizePtr, 0n)
@@ -186,7 +173,7 @@ export let rec env = () => {
       Memory.free(envcPtr)
       Memory.free(envvPtr)
       Memory.free(envvBufPtr)
-      wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+      Err(Wasi.SystemError(tagSimpleNumber(err)))
     } else {
       let arr = allocateArray(envc)
 
@@ -208,11 +195,9 @@ export let rec env = () => {
       Memory.free(envvPtr)
       Memory.free(envvBufPtr)
 
-      wasmSafeOk(WasmI32.toGrain(arr): (Array<String>))
+      Ok(WasmI32.toGrain(arr): Array<String>)
     }
   }
-  Memory.decRef(WasmI32.fromGrain(env))
-  ret
 }
 
 /**
@@ -221,19 +206,18 @@ export let rec env = () => {
  * @param code: The value to exit with. An exit code of 0 is considered normal, with other values having meaning depending on the platform
  * @returns `Err(exception)` if unsuccessful. Will not actually return a value if successful, as the process has ended
  */
-export let rec exit = (code: Number) => {
+@unsafe
+export let exit = (code: Number) => {
   let mut code = WasmI32.fromGrain(code)
 
-  let ret = if ((code & 1n) == 0n) {
-    wasmSafeErr(InvalidArgument("Invalid exit code"))
+  if ((code & 1n) == 0n) {
+    Err(InvalidArgument("Invalid exit code"))
   } else {
     code = code >> 1n
     Wasi.proc_exit(code)
     // Never actually hit because it exited
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(exit))
-  ret
 }
 
 /**
@@ -242,17 +226,16 @@ export let rec exit = (code: Number) => {
  * @param signal: The signal to send
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec sigRaise = (signalPtr: Signal) => {
+@unsafe
+export let sigRaise = (signalPtr: Signal) => {
   let signal = WasmI32.fromGrain(signalPtr)
   let signal = WasmI32.load(signal, 12n) >> 1n
   let err = Wasi.proc_raise(signal)
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(sigRaise))
-  ret
 }
 
 /**
@@ -260,13 +243,12 @@ export let rec sigRaise = (signalPtr: Signal) => {
  *
  * @returns `Ok(void)` if successful or `Err(exception)` otherwise
  */
-export let rec schedYield = () => {
+@unsafe
+export let schedYield = () => {
   let err = Wasi.sched_yield()
-  let ret = if (err != Wasi._ESUCCESS) {
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+  if (err != Wasi._ESUCCESS) {
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(void)
+    Ok(void)
   }
-  Memory.decRef(WasmI32.fromGrain(schedYield))
-  ret
 }

package/sys/random.gr

@@ -1,4 +1,3 @@
-/* grainc-flags --no-gc */
 /**
  * @module Sys/Random: System access to random values.
  *
@@ -6,24 +5,57 @@
  */
 
 import WasmI32, { eq as (==), ne as (!=) } from "runtime/unsafe/wasmi32"
+import WasmI64 from "runtime/unsafe/wasmi64"
 import Memory from "runtime/unsafe/memory"
 import Wasi from "runtime/wasi"
-import { tagSimpleNumber } from "runtime/dataStructures"
+import { tagSimpleNumber, newInt32, newInt64 } from "runtime/dataStructures"
 
 /**
  * @section Values: Functions and constants included in the Sys/Random module.
  */
 
-let wasmSafeOk = val => {
-  Memory.incRef(WasmI32.fromGrain(Ok))
-  Memory.incRef(WasmI32.fromGrain(val))
-  Ok(val)
+/**
+ * Produce a random 32-bit integer. This function can be slow, so it's best to seed a generator if lots of random data is needed.
+ *
+ * @returns `Ok(num)` of a random Int32 if successful or `Err(exception)` otherwise
+ *
+ * @since v0.5.0
+ */
+@unsafe
+export let randomInt32 = () => {
+  let buf = Memory.malloc(4n)
+
+  let err = Wasi.random_get(buf, 4n)
+  if (err != Wasi._ESUCCESS) {
+    Memory.free(buf)
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
+  } else {
+    let rand = WasmI32.load(buf, 0n)
+    Memory.free(buf)
+    Ok(WasmI32.toGrain(newInt32(rand)): Int32)
+  }
 }
 
-let wasmSafeErr = err => {
-  Memory.incRef(WasmI32.fromGrain(Err))
-  Memory.incRef(WasmI32.fromGrain(err))
-  Err(err)
+/**
+ * Produce a random 64-bit integer. This function can be slow, so it's best to seed a generator if lots of random data is needed.
+ *
+ * @returns `Ok(num)` of a random Int64 if successful or `Err(exception)` otherwise
+ *
+ * @since v0.5.0
+ */
+@unsafe
+export let randomInt64 = () => {
+  let buf = Memory.malloc(8n)
+
+  let err = Wasi.random_get(buf, 8n)
+  if (err != Wasi._ESUCCESS) {
+    Memory.free(buf)
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
+  } else {
+    let rand = WasmI64.load(buf, 0n)
+    Memory.free(buf)
+    Ok(WasmI32.toGrain(newInt64(rand)): Int64)
+  }
 }
 
 /**
@@ -31,18 +63,17 @@ let wasmSafeErr = err => {
  *
  * @returns `Ok(num)` of a random number if successful or `Err(exception)` otherwise
  */
-export let rec random = () => {
+@unsafe
+export let random = () => {
   let buf = Memory.malloc(4n)
 
   let err = Wasi.random_get(buf, 4n)
-  let ret = if (err != Wasi._ESUCCESS) {
+  if (err != Wasi._ESUCCESS) {
     Memory.free(buf)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
     let rand = WasmI32.load(buf, 0n)
     Memory.free(buf)
-    wasmSafeOk(tagSimpleNumber(rand))
+    Ok(tagSimpleNumber(rand))
   }
-  Memory.decRef(WasmI32.fromGrain(random))
-  ret
 }

package/sys/random.md

@@ -12,6 +12,44 @@ import Random from "sys/random"
 
 Functions and constants included in the Sys/Random module.
 
+### Random.**randomInt32**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+randomInt32 : () -> Result<Int32, Exception>
+```
+
+Produce a random 32-bit integer. This function can be slow, so it's best to seed a generator if lots of random data is needed.
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Result<Int32, Exception>`|`Ok(num)` of a random Int32 if successful or `Err(exception)` otherwise|
+
+### Random.**randomInt64**
+
+<details disabled>
+<summary tabindex="-1">Added in <code>0.5.0</code></summary>
+No other changes yet.
+</details>
+
+```grain
+randomInt64 : () -> Result<Int64, Exception>
+```
+
+Produce a random 64-bit integer. This function can be slow, so it's best to seed a generator if lots of random data is needed.
+
+Returns:
+
+|type|description|
+|----|-----------|
+|`Result<Int64, Exception>`|`Ok(num)` of a random Int64 if successful or `Err(exception)` otherwise|
+
 ### Random.**random**
 
 ```grain

package/sys/time.gr

@@ -1,4 +1,3 @@
-/* grainc-flags --no-gc */
 /**
  * @module Sys/Time: Access to system clocks.
  *
@@ -19,27 +18,16 @@ import { allocateInt64, tagSimpleNumber } from "runtime/dataStructures"
  * @section Values: Functions and constants included in the Sys/Time module.
  */
 
-let wasmSafeOk = val => {
-  Memory.incRef(WasmI32.fromGrain(Ok))
-  Memory.incRef(WasmI32.fromGrain(val))
-  Ok(val)
-}
-
-let wasmSafeErr = err => {
-  Memory.incRef(WasmI32.fromGrain(Err))
-  Memory.incRef(WasmI32.fromGrain(err))
-  Err(err)
-}
-
+@unsafe
 let getClockTime = (clockid, precision) => {
   let int64Ptr = allocateInt64()
   let timePtr = int64Ptr + 8n
   let err = Wasi.clock_time_get(clockid, precision, timePtr)
   if (err != Wasi._ESUCCESS) {
     Memory.free(int64Ptr)
-    wasmSafeErr(Wasi.SystemError(tagSimpleNumber(err)))
+    Err(Wasi.SystemError(tagSimpleNumber(err)))
   } else {
-    wasmSafeOk(WasmI32.toGrain(int64Ptr): Int64)
+    Ok(WasmI32.toGrain(int64Ptr): Int64)
   }
 }
 
@@ -49,10 +37,9 @@ let getClockTime = (clockid, precision) => {
  *
  * @returns `Ok(time)` of the current time if successful or `Err(exception)` otherwise
  */
+@unsafe
 export let rec realTime = () => {
-  let ret = getClockTime(Wasi._CLOCK_REALTIME, 1000N)
-  Memory.decRef(WasmI32.fromGrain(realTime))
-  ret
+  getClockTime(Wasi._CLOCK_REALTIME, 1000N)
 }
 
 /**
@@ -63,10 +50,9 @@ export let rec realTime = () => {
  *
  * @returns `Ok(time)` of the current time if successful or `Err(exception)` otherwise
  */
+@unsafe
 export let rec monotonicTime = () => {
-  let ret = getClockTime(Wasi._CLOCK_MONOTONIC, 1N)
-  Memory.decRef(WasmI32.fromGrain(monotonicTime))
-  ret
+  getClockTime(Wasi._CLOCK_MONOTONIC, 1N)
 }
 
 /**
@@ -74,10 +60,9 @@ export let rec monotonicTime = () => {
  *
  * @returns `Ok(elapsed)` of the elapsed nanoseconds if successful or `Err(exception)` otherwise
  */
+@unsafe
 export let rec processCpuTime = () => {
-  let ret = getClockTime(Wasi._CLOCK_PROCESS_CPUTIME, 1N)
-  Memory.decRef(WasmI32.fromGrain(processCpuTime))
-  ret
+  getClockTime(Wasi._CLOCK_PROCESS_CPUTIME, 1N)
 }
 
 /**
@@ -85,8 +70,7 @@ export let rec processCpuTime = () => {
  *
  * @returns `Ok(elapsed)` of the elapsed nanoseconds if successful or `Err(exception)` otherwise
  */
+@unsafe
 export let rec threadCpuTime = () => {
-  let ret = getClockTime(Wasi._CLOCK_THREAD_CPUTIME, 1N)
-  Memory.decRef(WasmI32.fromGrain(threadCpuTime))
-  ret
+  getClockTime(Wasi._CLOCK_THREAD_CPUTIME, 1N)
 }