rustyscript

Struct Runtime

Source 
pub struct Runtime { /* private fields */ }
Expand description

A runtime instance that can be used to execute JavaScript code and interact with it.
Most runtime functions have 3 variants - blocking, async, and immediate

For example:

  • call_function will block until the function is resolved and the event loop is empty
  • call_function_async will return a future that resolves when the function is resolved and the event loop is empty
  • call_function_immediate will return the result immediately, without resolving promises or running the event loop (See crate::js_value::Promise)

Note: For multithreaded applications, you may need to call init_platform before creating a Runtime
(See [crate::init_platform)

Implementations§

Source§

impl Runtime

Source

pub fn new(options: RuntimeOptions) -> Result<Self, Error>

Creates a new instance of the runtime with the provided options.

§Arguments
  • options - A RuntimeOptions struct that specifies the configuration options for the runtime.
§Returns

A Result containing either the initialized runtime instance on success (Ok) or an error on failure (Err).

§Example
use rustyscript::{ json_args, Runtime, RuntimeOptions, Module };
use std::time::Duration;

// Creates a runtime that will attempt to run function load() on start
// And which will time-out after 50ms
let mut runtime = Runtime::new(RuntimeOptions {
    default_entrypoint: Some("load".to_string()),
    timeout: Duration::from_millis(50),
    ..Default::default()
})?;

let module = Module::new("test.js", "
    export const load = () => {
        return 'Hello World!';
    }
");

let module_handle = runtime.load_module(&module)?;
let value: String = runtime.call_entrypoint(&module_handle, json_args!())?;
assert_eq!("Hello World!", value);
§Errors

Can fail if the tokio runtime cannot be created,
Or if the deno runtime initialization fails (usually issues with extensions)

Source

pub fn with_tokio_runtime( options: RuntimeOptions, tokio: Rc<Runtime>, ) -> Result<Self, Error>

Creates a new instance of the runtime with the provided options and a pre-configured tokio runtime.
See Runtime::new for more information.

§Errors

Can fail if the deno runtime initialization fails (usually issues with extensions)

Source

pub fn with_tokio_runtime_handle( options: RuntimeOptions, handle: Handle, ) -> Result<Self, Error>

Creates a new instance of the runtime with the provided options and a borrowed tokio runtime handle.
See Runtime::new for more information.

§Errors

Can fail if the deno runtime initialization fails (usually issues with extensions)

Source

pub fn deno_runtime(&mut self) -> &mut JsRuntime

Access the underlying deno runtime instance directly

Source

pub fn tokio_runtime(&self) -> TokioRuntime

Access the underlying tokio runtime used for blocking operations

Source

pub fn timeout(&self) -> Duration

Returns the timeout for the runtime

Source

pub fn heap_exhausted_token(&self) -> CancellationToken

Returns the heap exhausted token for the runtime
Used to detect when the runtime has run out of memory

Source

pub fn into_tokio_runtime(self) -> TokioRuntime

Destroy the v8 runtime, releasing all resources
Then the internal tokio runtime will be returned

Source

pub fn set_current_dir( &mut self, path: impl AsRef<Path>, ) -> Result<&Path, Error>

Set the current working directory for the runtime
This is used to resolve relative paths in the module loader

The runtime will begin with the current working directory of the process

§Errors

Can fail if the given path is not valid

Source

pub fn current_dir(&self) -> &Path

Get the current working directory for the runtime
This is used to resolve relative paths in the module loader

The runtime will begin with the current working directory of the process

Source

pub fn advance_event_loop( &mut self, options: PollEventLoopOptions, ) -> Result<bool, Error>

Advance the JS event loop by a single tick
See Runtime::block_on_event_loop for fully running the event loop

Returns true if the event loop has pending work, or false if it has completed

§Arguments
§Errors

Can fail if a runtime error occurs during the event loop’s execution

Source

pub async fn advance_event_loop_async( &mut self, options: PollEventLoopOptions, ) -> Result<bool, Error>

Advance the JS event loop by a single tick
See Runtime::await_event_loop for fully running the event loop

Returns a future that resolves true if the event loop has pending work, or false if it has completed

§Arguments
§Errors

Can fail if a runtime error occurs during the event loop’s execution

Source

pub async fn await_event_loop( &mut self, options: PollEventLoopOptions, timeout: Option<Duration>, ) -> Result<(), Error>

Run the JS event loop to completion, or until a timeout is reached
Required when using the _immediate variants of functions

§Arguments
§Errors

Can fail if a runtime error occurs during the event loop’s execution

Source

pub fn block_on_event_loop( &mut self, options: PollEventLoopOptions, timeout: Option<Duration>, ) -> Result<(), Error>

Run the JS event loop to completion, or until a timeout is reached
Required when using the _immediate variants of functions

This is the blocking variant of Runtime::await_event_loop

§Arguments
§Errors

Can fail if a runtime error occurs during the event loop’s execution

Source

pub fn take<T>(&mut self) -> Option<T>
where T: 'static,

Remove and return a value from the state, if one exists

use rustyscript::{ Runtime };

let mut runtime = Runtime::new(Default::default())?;
runtime.put("test".to_string())?;
let value: String = runtime.take().unwrap();
assert_eq!(value, "test");
Source

pub fn put<T>(&mut self, value: T) -> Result<(), Error>
where T: 'static,

Add a value to the state
Only one value of each type is stored - additional calls to put overwrite the old value

§Errors

Can fail if the inner state cannot be borrowed mutably

use rustyscript::{ Runtime };

let mut runtime = Runtime::new(Default::default())?;
runtime.put("test".to_string())?;
let value: String = runtime.take().unwrap();
assert_eq!(value, "test");
Source

pub fn register_function<F>( &mut self, name: &str, callback: F, ) -> Result<(), Error>
where F: RsFunction,

Register a rust function to be callable from JS

§Errors

Since this function borrows the state, it can fail if the state cannot be borrowed mutably

use rustyscript::{ Runtime, Module, serde_json::Value };

let module = Module::new("test.js", " rustyscript.functions.foo(); ");
let mut runtime = Runtime::new(Default::default())?;
runtime.register_function("foo", |args| {
    if let Some(value) = args.get(0) {
        println!("called with: {}", value);
    }
    Ok(Value::Null)
})?;
Source

pub fn register_async_function<F>( &mut self, name: &str, callback: F, ) -> Result<(), Error>
where F: RsAsyncFunction,

Register a non-blocking rust function to be callable from JS

§Errors

Since this function borrows the state, it can fail if the state cannot be borrowed mutably

use rustyscript::{ Runtime, Module, serde_json::Value, async_callback, Error };

let module = Module::new("test.js", " rustyscript.async_functions.add(1, 2); ");
let mut runtime = Runtime::new(Default::default())?;
runtime.register_async_function("add", async_callback!(
    |a: i64, b: i64| async move {
        Ok::<i64, Error>(a + b)
    }
))?;
Source

pub fn eval<T>(&mut self, expr: impl ToString) -> Result<T, Error>
where T: DeserializeOwned,

Evaluate a piece of non-ECMAScript-module JavaScript code
The expression is evaluated in the global context, so changes persist

Blocks on promise resolution, and runs the event loop to completion

Asynchronous code is supported, partially

  • Top-level await is not supported
  • The event loop will be run to completion after the expression is evaluated

For top-level await support, use one of:

  • call_function_async
  • call_stored_function_async
  • load_module_async
  • load_modules_async

Or any of the _immmediate variants, paired with crate::js_value::Promise

§Arguments
  • expr - A string representing the JavaScript expression to evaluate
§Returns

A Result containing the deserialized result of the expression (T)
or an error (Error) if the expression cannot be evaluated or if the result cannot be deserialized.

§Errors

Can fail if the expression cannot be evaluated, or if the result cannot be deserialized into the requested type

§Example
use rustyscript::{ Runtime, Error };

let mut runtime = Runtime::new(Default::default())?;

let value: u32 = runtime.eval("2 + 2")?;
assert_eq!(4, value);

let value: String = runtime.eval("new Promise(resolve => resolve('test'))")?;
assert_eq!("test", value);
Source

pub async fn eval_async<T>(&mut self, expr: impl ToString) -> Result<T, Error>
where T: DeserializeOwned,

Evaluate a piece of non-ECMAScript-module JavaScript code
The expression is evaluated in the global context, so changes persist

Awaits promise resolution, and runs the event loop to completion

Asynchronous code is supported, partially

  • Top-level await is not supported
  • The event loop will be run to completion after the expression is evaluated

For top-level await support, use one of:

  • call_function_async
  • call_stored_function_async
  • load_module_async
  • load_modules_async

Or any of the _immmediate variants, paired with crate::js_value::Promise

§Arguments
  • expr - A string representing the JavaScript expression to evaluate
§Returns

A Result containing the deserialized result of the expression (T)
or an error (Error) if the expression cannot be evaluated or if the result cannot be deserialized.

§Errors

Can fail if the expression cannot be evaluated, or if the result cannot be deserialized into the requested type

§Example

For an example, see Runtime::eval

Source

pub async fn eval_immediate<T>( &mut self, expr: impl ToString, ) -> Result<T, Error>
where T: DeserializeOwned,

Evaluate a piece of non-ECMAScript-module JavaScript code
The expression is evaluated in the global context, so changes persist

Does not await promise resolution, or run the event loop
Promises can be returned by specifying the return type as crate::js_value::Promise
The event loop should be run using Runtime::await_event_loop

Note that this function needs to be async because calls to setTimeout must be evaluated from within an async runtime.

Asynchronous code is supported, partially

  • Top-level await is not supported

For top-level await support, use one of:

  • call_function_async
  • call_stored_function_async
  • load_module_async
  • load_modules_async

Or any of the _immmediate variants, paired with crate::js_value::Promise

§Arguments
  • expr - A string representing the JavaScript expression to evaluate
§Returns

A Result containing the deserialized result of the expression (T)
or an error (Error) if the expression cannot be evaluated or if the result cannot be deserialized.

§Errors

Can fail if the expression cannot be evaluated, or if the result cannot be deserialized into the requested type

§Example

For an example, see Runtime::eval

Source

pub async fn call_stored_function_async<T>( &mut self, module_context: Option<&ModuleHandle>, function: &Function, args: &impl Serialize, ) -> Result<T, Error>
where T: DeserializeOwned,

Calls a stored javascript function and deserializes its return value.

Returns a future that resolves when:

  • The event loop is resolved, and
  • If the value is a promise, the promise is resolved

See Runtime::call_function for an example

Note that synchronous functions are run synchronously. Returned promises will be run asynchronously, however.

§Arguments
  • module_context - Optional handle to a module providing global context for the function
  • function - A The function object
  • args - The arguments to pass to the function
§Returns

A Result containing the deserialized result of the function call (T)
or an error (Error) if there are issues with calling the function, or if the result cannot be deserialized.

§Errors

Can fail if there are issues with calling the function, or if the result cannot be deserialized into the requested type

Source

pub fn call_stored_function<T>( &mut self, module_context: Option<&ModuleHandle>, function: &Function, args: &impl Serialize, ) -> Result<T, Error>
where T: DeserializeOwned,

Calls a stored javascript function and deserializes its return value.

Blocks until:

  • The event loop is resolved, and
  • If the value is a promise, the promise is resolved

See Runtime::call_function for an example

§Arguments
  • module_context - Optional handle to a module providing global context for the function
  • function - A The function object
  • args - The arguments to pass to the function
§Returns

A Result containing the deserialized result of the function call (T)
or an error (Error) if there are issues with calling the function, or if the result cannot be deserialized.

§Errors

Can fail if there are issues with calling the function, or if the result cannot be deserialized into the requested type

Source

pub fn call_stored_function_immediate<T>( &mut self, module_context: Option<&ModuleHandle>, function: &Function, args: &impl Serialize, ) -> Result<T, Error>
where T: DeserializeOwned,

Calls a stored javascript function and deserializes its return value.

Will not attempt to resolve promises, or run the event loop
Promises can be returned by specifying the return type as crate::js_value::Promise
The event loop should be run using Runtime::await_event_loop

See Runtime::call_function for an example

§Arguments
  • module_context - Optional handle to a module providing global context for the function
  • function - A The function object
  • args - The arguments to pass to the function
§Returns

A Result containing the deserialized result of the function call (T)
or an error (Error) if there are issues with calling the function, or if the result cannot be deserialized.

§Errors

Can fail if there are issues with calling the function, or if the result cannot be deserialized into the requested type

Source

pub async fn call_function_async<T>( &mut self, module_context: Option<&ModuleHandle>, name: &str, args: &impl Serialize, ) -> Result<T, Error>
where T: DeserializeOwned,

Calls a javascript function within the Deno runtime by its name and deserializes its return value.

Returns a future that resolves when:

  • The event loop is resolved, and
  • If the value is a promise, the promise is resolved

Note that synchronous functions are run synchronously. Returned promises will be run asynchronously, however.

See Runtime::call_function for an example

§Arguments
  • module_context - Optional handle to a module to search - if None, or if the search fails, the global context is used
  • name - A string representing the name of the javascript function to call.
  • args - The arguments to pass to the function
§Returns

A Result containing the deserialized result of the function call (T)
or an error (Error) if the function cannot be found, if there are issues with calling the function, or if the result cannot be deserialized.

§Errors

Fails if the function cannot be found, if there are issues with calling the function, Or if the result cannot be deserialized into the requested type

Source

pub fn call_function<T>( &mut self, module_context: Option<&ModuleHandle>, name: &str, args: &impl Serialize, ) -> Result<T, Error>
where T: DeserializeOwned,

Calls a javascript function within the Deno runtime by its name and deserializes its return value.

Blocks until:

  • The event loop is resolved, and
  • If the value is a promise, the promise is resolved
§Arguments
  • module_context - Optional handle to a module to search - if None, or if the search fails, the global context is used
  • name - A string representing the name of the javascript function to call.
  • args - The arguments to pass to the function
§Returns

A Result containing the deserialized result of the function call (T)
or an error (Error) if the function cannot be found, if there are issues with calling the function, or if the result cannot be deserialized.

§Errors

Fails if the function cannot be found, if there are issues with calling the function,
Or if the result cannot be deserialized into the requested type

§Example
use rustyscript::{ json_args, Runtime, Module, Error };

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("/path/to/module.js", "export function f() { return 2; };");
let module = runtime.load_module(&module)?;
let value: usize = runtime.call_function(Some(&module), "f", json_args!())?;
Source

pub fn call_function_immediate<T>( &mut self, module_context: Option<&ModuleHandle>, name: &str, args: &impl Serialize, ) -> Result<T, Error>
where T: DeserializeOwned,

Calls a javascript function within the Deno runtime by its name and deserializes its return value.

Will not attempt to resolve promises, or run the event loop
Promises can be returned by specifying the return type as crate::js_value::Promise
The event loop should be run using Runtime::await_event_loop

§Arguments
  • module_context - Optional handle to a module to search - if None, or if the search fails, the global context is used
  • name - A string representing the name of the javascript function to call.
  • args - The arguments to pass to the function
§Returns

A Result containing the deserialized result of the function call (T)
or an error (Error) if the function cannot be found, if there are issues with calling the function, or if the result cannot be deserialized.

§Errors

Fails if the function cannot be found, if there are issues with calling the function,
Or if the result cannot be deserialized into the requested type

§Example
use rustyscript::{ json_args, Runtime, Module, Error };

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("/path/to/module.js", "export function f() { return 2; };");
let module = runtime.load_module(&module)?;
let value: usize = runtime.call_function_immediate(Some(&module), "f", json_args!())?;
Source

pub fn get_value<T>( &mut self, module_context: Option<&ModuleHandle>, name: &str, ) -> Result<T, Error>
where T: DeserializeOwned,

Get a value from a runtime instance

Blocks until:

  • The event loop is resolved, and
  • If the value is a promise, the promise is resolved
§Arguments
  • module_context - Optional handle to a module to search - if None, or if the search fails, the global context is used
  • name - A string representing the name of the value to find
§Returns

A Result containing the deserialized result or an error (Error) if the value cannot be found, Or if the result cannot be deserialized into the requested type

§Errors

Can fail if the value cannot be found, or if the result cannot be deserialized.

§Example
use rustyscript::{ Runtime, Module, Error };

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("/path/to/module.js", "globalThis.my_value = 2;");
let module = runtime.load_module(&module)?;
let value: usize = runtime.get_value(Some(&module), "my_value")?;
Source

pub async fn get_value_async<T>( &mut self, module_context: Option<&ModuleHandle>, name: &str, ) -> Result<T, Error>
where T: DeserializeOwned,

Get a value from a runtime instance

Returns a future that resolves when:

  • The event loop is resolved, and
  • If the value is a promise, the promise is resolved

See Runtime::get_value for an example

§Arguments
  • module_context - Optional handle to a module to search - if None, or if the search fails, the global context is used
  • name - A string representing the name of the value to find
§Returns

A Result containing the deserialized result or an error (Error) if the value cannot be found,
Or if the result cannot be deserialized into the requested type

§Errors

Can fail if the value cannot be found, or if the result cannot be deserialized.

Source

pub fn get_value_immediate<T>( &mut self, module_context: Option<&ModuleHandle>, name: &str, ) -> Result<T, Error>
where T: DeserializeOwned,

Get a value from a runtime instance

Will not attempt to resolve promises, or run the event loop
Promises can be returned by specifying the return type as crate::js_value::Promise
The event loop should be run using Runtime::await_event_loop

§Arguments
  • module_context - Optional handle to a module to search - if None, or if the search fails, the global context is used
  • name - A string representing the name of the value to find
§Returns

A Result containing the deserialized result or an error (Error) if the value cannot be found, Or if the result cannot be deserialized into the requested type

§Errors

Can fail if the value cannot be found, or if the result cannot be deserialized.

§Example
use rustyscript::{ Runtime, Module, Error };

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("/path/to/module.js", "globalThis.my_value = 2;");
let module = runtime.load_module(&module)?;
let value: usize = runtime.get_value_immediate(Some(&module), "my_value")?;
Source

pub fn load_module(&mut self, module: &Module) -> Result<ModuleHandle, Error>

Executes the given module, and returns a handle allowing you to extract values and call functions

Blocks until the module has been executed AND the event loop has fully resolved
See Runtime::load_module_async for a non-blocking variant, or use with async background tasks

§Arguments
  • module - A Module object containing the module’s filename and contents.
§Returns

A Result containing a handle for the loaded module or an error (Error) if there are issues with loading or executing the module

§Errors

Can fail if the module cannot be loaded, or execution fails

§Example
// Create a module with filename and contents
use rustyscript::{Runtime, Module, Error};

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "export default () => 'test'");
runtime.load_module(&module);
Source

pub async fn load_module_async( &mut self, module: &Module, ) -> Result<ModuleHandle, Error>

Executes the given module, and returns a handle allowing you to extract values and call functions

Returns a future that resolves to the handle for the loaded module
Makes no attempt to fully resolve the event loop - call Runtime::await_event_loop to resolve background tasks and async listeners

§Arguments
  • module - A Module object containing the module’s filename and contents.
§Returns

A Result containing a handle for the loaded module or an error (Error) if there are issues with loading or executing the module

§Errors

Can fail if the module cannot be loaded, or execution fails

See Runtime::load_module for an example

Source

pub fn load_modules( &mut self, module: &Module, side_modules: Vec<&Module>, ) -> Result<ModuleHandle, Error>

Executes the given module, and returns a handle allowing you to extract values and call functions.

Blocks until all modules have been executed AND the event loop has fully resolved
See Runtime::load_module_async for a non-blocking variant, or use with async background tasks

This will load ‘module’ as the main module, and the others as side-modules.
Only one main module can be loaded per runtime

§Arguments
  • module - A Module object containing the module’s filename and contents.
  • side_modules - A set of additional modules to be loaded into memory for use
§Returns

A Result containing a handle for the loaded module or an error (Error) if there are issues with loading or executing the module

§Errors

Can fail if the module cannot be loaded, or execution fails

§Example
// Create a module with filename and contents
use rustyscript::{Runtime, Module, Error};

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "export default () => 'test'");
runtime.load_modules(&module, vec![]);
Source

pub async fn load_modules_async( &mut self, module: &Module, side_modules: Vec<&Module>, ) -> Result<ModuleHandle, Error>

Executes the given module, and returns a handle allowing you to extract values and call functions.

Returns a future that resolves to the handle for the loaded module
Makes no attempt to resolve the event loop - call Runtime::await_event_loop to resolve background tasks and async listeners

This will load ‘module’ as the main module, and the others as side-modules.
Only one main module can be loaded per runtime

See Runtime::load_modules for an example

§Arguments
  • module - A Module object containing the module’s filename and contents.
  • side_modules - A set of additional modules to be loaded into memory for use
§Returns

A Result containing a handle for the loaded main module, or the last side-module or an error (Error) if there are issues with loading or executing the modules

§Errors

Can fail if the modules cannot be loaded, or execution fails

Source

pub fn call_entrypoint<T>( &mut self, module_context: &ModuleHandle, args: &impl Serialize, ) -> Result<T, Error>
where T: DeserializeOwned,

Executes the entrypoint function of a module within the Deno runtime.

Blocks until:

  • The event loop is resolved, and
  • If the value is a promise, the promise is resolved
§Arguments
  • module_context - A handle returned by loading a module into the runtime
§Returns

A Result containing the deserialized result of the entrypoint execution (T)
if successful, or an error (Error) if the entrypoint is missing, the execution fails, or the result cannot be deserialized.

§Errors

Can fail if the module cannot be loaded, if the entrypoint is missing, if the execution fails,
Or if the result cannot be deserialized into the requested type

§Example
use rustyscript::{json_args, Runtime, Module, Error};

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "export default () => 'test'");
let module = runtime.load_module(&module)?;

// Run the entrypoint and handle the result
let value: String = runtime.call_entrypoint(&module, json_args!())?;
Source

pub async fn call_entrypoint_async<T>( &mut self, module_context: &ModuleHandle, args: &impl Serialize, ) -> Result<T, Error>
where T: DeserializeOwned,

Executes the entrypoint function of a module within the Deno runtime.

Returns a future that resolves when:

  • The event loop is resolved, and
  • If the value is a promise, the promise is resolved

Note that synchronous functions are run synchronously. Returned promises will be run asynchronously, however.

See Runtime::call_entrypoint for an example

§Arguments
  • module_context - A handle returned by loading a module into the runtime
§Returns

A Result containing the deserialized result of the entrypoint execution (T)
if successful, or an error (Error) if the entrypoint is missing, the execution fails, or the result cannot be deserialized.

§Errors

Can fail if the module cannot be loaded, if the entrypoint is missing, if the execution fails,
Or if the result cannot be deserialized into the requested type

Source

pub fn call_entrypoint_immediate<T>( &mut self, module_context: &ModuleHandle, args: &impl Serialize, ) -> Result<T, Error>
where T: DeserializeOwned,

Executes the entrypoint function of a module within the Deno runtime.

Will not attempt to resolve promises, or run the event loop
Promises can be returned by specifying the return type as crate::js_value::Promise
The event loop should be run using Runtime::await_event_loop

§Arguments
  • module_context - A handle returned by loading a module into the runtime
§Returns

A Result containing the deserialized result of the entrypoint execution (T) if successful, or an error (Error) if the entrypoint is missing, the execution fails, or the result cannot be deserialized.

§Errors

Can fail if the module cannot be loaded, if the entrypoint is missing, if the execution fails, Or if the result cannot be deserialized into the requested type

§Example
use rustyscript::{json_args, Runtime, Module, Error};

let mut runtime = Runtime::new(Default::default())?;
let module = Module::new("test.js", "export default () => 'test'");
let module = runtime.load_module(&module)?;

// Run the entrypoint and handle the result
let value: String = runtime.call_entrypoint_immediate(&module, json_args!())?;
Source

pub fn execute_module<T>( module: &Module, side_modules: Vec<&Module>, runtime_options: RuntimeOptions, entrypoint_args: &impl Serialize, ) -> Result<T, Error>
where T: DeserializeOwned,

Loads a module into a new runtime, executes the entry function and returns the result of the module’s execution, deserialized into the specified Rust type (T).

§Arguments
  • module - A Module object containing the module’s filename and contents.
  • side_modules - A set of additional modules to be loaded into memory for use
  • runtime_options - Options for the creation of the runtime
  • entrypoint_args - Arguments to pass to the entrypoint function
§Returns

A Result containing the deserialized result of the entrypoint execution (T)
if successful, or an error (Error) if the entrypoint is missing, the execution fails, or the result cannot be deserialized.

§Errors

Can fail if the module cannot be loaded, if the entrypoint is missing, if the execution fails,
Or if the result cannot be deserialized into the requested type

§Example
// Create a module with filename and contents
use rustyscript::{json_args, Runtime, Module, Error};

let module = Module::new("test.js", "export default () => 2");
let value: usize = Runtime::execute_module(&module, vec![], Default::default(), json_args!())?;

Auto Trait Implementations§

§

impl Freeze for Runtime

§

impl !Send for Runtime

§

impl !Sync for Runtime

§

impl !RefUnwindSafe for Runtime

§

impl Unpin for Runtime

§

impl !UnwindSafe for Runtime

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

Source§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

Source§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

Source§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

Source§

impl<T> Az for T

Source§

fn az<Dst>(self) -> Dst
where T: Cast<Dst>,

Casts the value.
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<Src, Dst> CastFrom<Src> for Dst
where Src: Cast<Dst>,

Source§

fn cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T> CheckedAs for T

Source§

fn checked_as<Dst>(self) -> Option<Dst>
where T: CheckedCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> CheckedCastFrom<Src> for Dst
where Src: CheckedCast<Dst>,

Source§

fn checked_cast_from(src: Src) -> Option<Dst>

Casts the value.
Source§

impl<T> Conv for T

Source§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

impl<T> Downcast<T> for T

Source§

fn downcast(&self) -> &T

Source§

impl<T> FmtForward for T

Source§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
Source§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
Source§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
Source§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
Source§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
Source§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
Source§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
Source§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
Source§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> FutureExt for T

Source§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
Source§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoRequest<T> for T

Source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
Source§

impl<T> OverflowingAs for T

Source§

fn overflowing_as<Dst>(self) -> (Dst, bool)
where T: OverflowingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> OverflowingCastFrom<Src> for Dst
where Src: OverflowingCast<Dst>,

Source§

fn overflowing_cast_from(src: Src) -> (Dst, bool)

Casts the value.
Source§

impl<T> Pipe for T
where T: ?Sized,

Source§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
Source§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
Source§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
Source§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
Source§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
Source§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
Source§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
Source§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> SaturatingAs for T

Source§

fn saturating_as<Dst>(self) -> Dst
where T: SaturatingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> SaturatingCastFrom<Src> for Dst
where Src: SaturatingCast<Dst>,

Source§

fn saturating_cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T> Tap for T

Source§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
Source§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
Source§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
Source§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
Source§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
Source§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
Source§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
Source§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
Source§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
Source§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
Source§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
Source§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
Source§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
Source§

impl<T> TryConv for T

Source§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> UnwrappedAs for T

Source§

fn unwrapped_as<Dst>(self) -> Dst
where T: UnwrappedCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> UnwrappedCastFrom<Src> for Dst
where Src: UnwrappedCast<Dst>,

Source§

fn unwrapped_cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T> Upcast<T> for T

Source§

fn upcast(&self) -> Option<&T>

Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> WrappingAs for T

Source§

fn wrapping_as<Dst>(self) -> Dst
where T: WrappingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> WrappingCastFrom<Src> for Dst
where Src: WrappingCast<Dst>,

Source§

fn wrapping_cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T> ErasedDestructor for T
where T: 'static,

Source§

impl<T> ErasedDestructor for T
where T: 'static,

Source§

impl<T> Send for T
where T: ?Sized,

Source§

impl<T> Sync for T
where T: ?Sized,