Struct rune::runtime::SyncFunction

pub struct SyncFunction(/* private fields */);

A callable sync function. This currently only supports a subset of values that are supported by the Vm.

Implementations

impl SyncFunction

pub async fn async_send_call<A, T>(&self, args: A) -> VmResult<T>

where A: Send + Args, T: Send + FromValue,

Perform an asynchronous call over the function which also implements Send.

Examples

use rune::{Hash, Vm};
use rune::runtime::SyncFunction;
use std::sync::Arc;

let mut sources = rune::sources! {
    entry => {
        async fn add(a, b) {
            a + b
        }

        pub fn main() { add }
    }
};

let unit = rune::prepare(&mut sources).build()?;
let mut vm = Vm::without_runtime(Arc::new(unit));
let add = vm.call(["main"], ())?;
let add: SyncFunction = rune::from_value(add)?;

let value = add.async_send_call::<_, u32>((1, 2)).await.into_result()?;
assert_eq!(value, 3);

pub fn call<A, T>(&self, args: A) -> VmResult<T>

where A: Args, T: FromValue,

Perform a call over the function represented by this function pointer.

Examples

use rune::{Hash, Vm};
use rune::runtime::SyncFunction;
use std::sync::Arc;

let mut sources = rune::sources! {
    entry => {
        fn add(a, b) {
            a + b
        }

        pub fn main() { add }
    }
};

let unit = rune::prepare(&mut sources).build()?;
let mut vm = Vm::without_runtime(Arc::new(unit));
let add = vm.call(["main"], ())?;
let add: SyncFunction = rune::from_value(add)?;

assert_eq!(add.call::<_, u32>((1, 2)).into_result()?, 3);

pub fn type_hash(&self) -> Hash

Type Hash of the underlying function.

Examples

The type hash of a top-level function matches what you get out of Hash::type_hash.

use rune::{Hash, Vm};
use rune::runtime::SyncFunction;
use std::sync::Arc;

let mut sources = rune::sources! {
    entry => {
        fn pony() { }

        pub fn main() { pony }
    }
};

let unit = rune::prepare(&mut sources).build()?;
let mut vm = Vm::without_runtime(Arc::new(unit));
let pony = vm.call(["main"], ())?;
let pony: SyncFunction = rune::from_value(pony)?;

assert_eq!(pony.type_hash(), Hash::type_hash(["pony"]));

Trait Implementations

impl FromValue for SyncFunction

fn from_value(value: Value) -> VmResult<Self>

Try to convert to the given type, from the given value.

impl TryClone for SyncFunction

fn try_clone(&self) -> Result<Self>

Try to clone the current value, raising an allocation error if it’s unsuccessful.

fn try_clone_from(&mut self, source: &Self) -> Result<(), Error>

Performs copy-assignment from source.