@raviqqe/stak 0.11.9 → 0.11.11

package/README.md

@@ -16,16 +16,23 @@ Stak Scheme aims to be:
   - A subset of [Chibi Scheme](https://github.com/ashinn/chibi-scheme), [Gauche](https://github.com/shirok/Gauche), and [Guile](https://www.gnu.org/software/guile/)
 - A portable scripting environment that supports even no-`std` and no-`alloc` platforms
 
-For more information and usage, visit [the full documentation](https://raviqqe.com/stak/install).
+For the usage and examples, see [the documentation](https://raviqqe.com/stak/install).
 
 ## Install
 
-### Interpreter
+### Commands
 
-To install the Scheme interpreter as a command, run:
+To install [the interpreter](https://crates.io/crates/stak) and [REPL](https://crates.io/crates/stak-repl), run:
 
 ```sh
 cargo install stak
+cargo install stak-repl
+```
+
+To install [the minimal interpreter](https://crates.io/crates/mstak), run:
+
+```sh
+cargo install mstak
 ```
 
 ### Libraries
@@ -38,166 +45,13 @@ cargo add --build stak-build
 cargo install stak-compile
 ```
 
-For full examples, see [the `examples` directory](https://github.com/raviqqe/stak/tree/main/examples).
-
-## Examples
-
-### Dynamic scripting in Rust
-
-First, prepare a Scheme script named `src/fight.scm`:
-
-```scheme
-; Import a base library and the library named `(stak rust)` for Rust integration.
-(import (scheme base) (stak rust))
-
-; Make two people with a number of pies they have and their dodge rates.
-(define me (make-person 4 0.2))
-(define friend (make-person 2 0.6))
-
-; The fight begins. Let's throw pies to each other!
-(do ()
-  ((or
-      (person-wasted me)
-      (person-wasted friend)
-      (and
-        (zero? (person-pies me))
-        (zero? (person-pies friend)))))
-  (person-throw-pie me friend)
-  (person-throw-pie friend me))
-
-; Output the winner.
-(write-string
-  (cond
-    ((person-wasted friend)
-      "You won!")
-    ((person-wasted me)
-      "You lost...")
-    (else
-      "Draw...")))
-```
-
-Then, add a build script at `build.rs` to build the Scheme source file
-into bytecode.
-
-```rust no_run
-use stak_build::{build_r7rs, BuildError};
-
-fn main() -> Result<(), BuildError> {
-    build_r7rs()
-}
-```
-
-Finally, you can embed and run the Scheme script in a Rust program.
-
-```rust
-use any_fn::{r#fn, Ref};
-use core::error::Error;
-use rand::random;
-use stak::{
-    engine::{Engine, EngineError},
-    include_module,
-    module::UniversalModule,
-};
-
-const HEAP_SIZE: usize = 1 << 16;
-
-/// A person who holds pies to throw.
-struct Person {
-    pies: usize,
-    dodge: f64,
-    wasted: bool,
-}
-
-impl Person {
-    /// Creates a person.
-    pub fn new(pies: usize, dodge: f64) -> Self {
-        Self {
-            pies,
-            dodge,
-            wasted: false,
-        }
-    }
-
-    /// Returns a number of pies the person has.
-    pub fn pies(&self) -> usize {
-        self.pies
-    }
-
-    /// Returns `true` if a person is wasted.
-    pub fn wasted(&self) -> bool {
-        self.wasted
-    }
-
-    /// Throws a pie to another person.
-    pub fn throw_pie(&mut self, other: &mut Person) {
-        if self.pies == 0 || self.wasted {
-            return;
-        }
-
-        self.pies -= 1;
-
-        if random::<f64>() > other.dodge {
-            other.wasted = true;
-        }
-    }
-}
-
-fn main() -> Result<(), Box<dyn Error>> {
-    // Include and run the Scheme module.
-    run_scheme(&include_module!("fight.scm"))?;
-
-    Ok(())
-}
-
-fn run_scheme(module: &UniversalModule) -> Result<(), EngineError> {
-    // Initialize a heap memory for a Scheme scripting engine.
-    let mut heap = [Default::default(); HEAP_SIZE];
-    // Define Rust functions to pass to the engine.
-    let mut functions = [
-        ("make-person", r#fn(Person::new)),
-        ("person-pies", r#fn::<(Ref<_>,), _>(Person::pies)),
-        ("person-wasted", r#fn::<(Ref<_>,), _>(Person::wasted)),
-        ("person-throw-pie", r#fn(Person::throw_pie)),
-    ];
-    // Initialize the engine.
-    let mut engine = Engine::new(&mut heap, &mut functions)?;
-
-    // Finally, run the module!
-    engine.run(module)
-}
-```
-
 ## Performance
 
-### Computational benchmarks
-
-The Stak Scheme interpreter runs 1.6 to 2.3 times slower than Python 3 at computationally heavy tasks depending on its configuration and benchmarks. For all the benchmark results, see [the GitHub Action](https://github.com/raviqqe/stak/actions/workflows/bench.yaml).
-
-- Baseline: Python 3.13
-- Environment: Ubuntu 24.04, x86-64
-
-| Benchmark        | Stak (minimal [^1]) | Stak (full [^2]) |
-| ---------------- | ------------------: | ---------------: |
-| Fibonacci number |        1.80x slower |     1.98x slower |
-| Integer sum      |        1.61x slower |     1.87x slower |
-| Tak function     |        2.10x slower |     2.27x slower |
-
-### Startup benchmarks
-
-Although Stak Scheme's minimality comes at the cost of speed, it is very fast at startup.
-
-This means that Stak Scheme is suitable for embedding many small pieces of Scheme programs in Rust due to its tiny overhead on program initialization.
-
-- Environment: Ubuntu 24.04, x86-64
-
-| Benchmark        | Stak (full [^2]) | Lua 5.4 |
-| ---------------- | ---------------: | ------: |
-| Empty program    |         0.534 us | 48.9 us |
-| Integer addition |          22.9 us | 50.0 us |
+See [Performance](https://raviqqe.com/stak/performance).
 
-[^1]: Minimal: Integer-only support + standard libraries based on libc
+## Limitations
 
-[^2]: Full: 64-bit floating-point number support + standard libraries based on the `std` library in Rust
+See [Limitations](https://raviqqe.com/stak/limitations).
 
 ## References
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@raviqqe/stak",
   "type": "module",
   "description": "Stak Scheme in WebAssembly",
-  "version": "0.11.9",
+  "version": "0.11.11",
   "license": "MIT",
   "repository": {
     "type": "git",

package/stak_wasm.d.ts

@@ -1,17 +1,17 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
- * Runs a Scheme script with standard input and returns its standard output.
+ * Compiles source codes in Scheme.
  */
-export function run(source: string, input: Uint8Array, heap_size: number): Uint8Array;
+export function compile(source: string): Uint8Array;
 /**
  * Interprets bytecode with standard input and returns its standard output.
  */
 export function interpret(bytecode: Uint8Array, input: Uint8Array, heap_size: number): Uint8Array;
 /**
- * Compiles source codes in Scheme.
+ * Runs a Scheme script with standard input and returns its standard output.
  */
-export function compile(source: string): Uint8Array;
+export function run(source: string, input: Uint8Array, heap_size: number): Uint8Array;
 /**
  * Runs a REPL interpreter.
  */
@@ -33,8 +33,8 @@ export interface InitOutput {
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __externref_table_dealloc: (a: number) => void;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly closure33_externref_shim: (a: number, b: number, c: any) => void;
-  readonly closure57_externref_shim: (a: number, b: number, c: any, d: any) => void;
+  readonly closure19_externref_shim: (a: number, b: number, c: any) => void;
+  readonly closure43_externref_shim: (a: number, b: number, c: any, d: any) => void;
   readonly __wbindgen_start: () => void;
 }
 

package/stak_wasm.js

@@ -198,13 +198,6 @@ function getDataViewMemory0() {
     return cachedDataViewMemory0;
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
 function takeFromExternrefTable0(idx) {
     const value = wasm.__wbindgen_export_2.get(idx);
     wasm.__externref_table_dealloc(idx);
@@ -216,26 +209,28 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 /**
- * Runs a Scheme script with standard input and returns its standard output.
+ * Compiles source codes in Scheme.
  * @param {string} source
- * @param {Uint8Array} input
- * @param {number} heap_size
  * @returns {Uint8Array}
  */
-export function run(source, input, heap_size) {
+export function compile(source) {
     const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.run(ptr0, len0, ptr1, len1, heap_size);
+    const ret = wasm.compile(ptr0, len0);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
-    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v3;
+    return v2;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
  * Interprets bytecode with standard input and returns its standard output.
  * @param {Uint8Array} bytecode
@@ -258,20 +253,24 @@ export function interpret(bytecode, input, heap_size) {
 }
 
 /**
- * Compiles source codes in Scheme.
+ * Runs a Scheme script with standard input and returns its standard output.
  * @param {string} source
+ * @param {Uint8Array} input
+ * @param {number} heap_size
  * @returns {Uint8Array}
  */
-export function compile(source) {
+export function run(source, input, heap_size) {
     const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.compile(ptr0, len0);
+    const ptr1 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.run(ptr0, len0, ptr1, len1, heap_size);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
-    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
-    return v2;
+    return v3;
 }
 
 /**
@@ -285,11 +284,11 @@ export function repl(heap_size) {
 }
 
 function __wbg_adapter_24(arg0, arg1, arg2) {
-    wasm.closure33_externref_shim(arg0, arg1, arg2);
+    wasm.closure19_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_45(arg0, arg1, arg2, arg3) {
-    wasm.closure57_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_39(arg0, arg1, arg2, arg3) {
+    wasm.closure43_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 async function __wbg_load(module, imports) {
@@ -341,7 +340,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wbg_adapter_45(a, state0.b, arg0, arg1);
+                    return __wbg_adapter_39(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -363,7 +362,7 @@ function __wbg_get_imports() {
         const ret = arg0.queueMicrotask;
         return ret;
     };
-    imports.wbg.__wbg_readstdin_397badeaadecad8a = function() {
+    imports.wbg.__wbg_readstdin_3bf4dcd8f2b8f9d7 = function() {
         const ret = read_stdin();
         return ret;
     };
@@ -395,11 +394,11 @@ function __wbg_get_imports() {
         const ret = arg0.then(arg1, arg2);
         return ret;
     };
-    imports.wbg.__wbg_writestderr_89ebdcb15680582e = function(arg0) {
+    imports.wbg.__wbg_writestderr_a813e552f8d790ee = function(arg0) {
         const ret = write_stderr(arg0);
         return ret;
     };
-    imports.wbg.__wbg_writestdout_05ad3300bf790c89 = function(arg0) {
+    imports.wbg.__wbg_writestdout_80b2bfe386799c6e = function(arg0) {
         const ret = write_stdout(arg0);
         return ret;
     };
@@ -413,7 +412,7 @@ function __wbg_get_imports() {
         return ret;
     };
     imports.wbg.__wbindgen_closure_wrapper84 = function(arg0, arg1, arg2) {
-        const ret = makeMutClosure(arg0, arg1, 34, __wbg_adapter_24);
+        const ret = makeMutClosure(arg0, arg1, 20, __wbg_adapter_24);
         return ret;
     };
     imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {