Struct rquickjs_core::prelude::Func

#[repr(transparent)]
pub struct Func<F>(pub F);

The wrapper for function to convert is into JS

The Rust functions should be wrapped to convert it to JS using IntoJs trait.

// Anonymous function
ctx.globals().set("sum", Func::from(|a: i32, b: i32| a + b))?;
assert_eq!(ctx.eval::<i32, _>("sum(3, 2)")?, 5);
assert_eq!(ctx.eval::<usize, _>("sum.length")?, 2);
assert_eq!(ctx.eval::<String, _>("sum.name")?, "");
// Call/apply works as expected
assert_eq!(ctx.eval::<i32, _>("sum.call(sum, 3, 2)")?, 5);
assert_eq!(ctx.eval::<i32, _>("sum.apply(sum, [3, 2])")?, 5);

// Named function
ctx.globals().set("prod", Func::new("multiply", |a: i32, b: i32| a * b))?;
assert_eq!(ctx.eval::<i32, _>("prod(3, 2)")?, 6);
assert_eq!(ctx.eval::<usize, _>("prod.length")?, 2);
assert_eq!(ctx.eval::<String, _>("prod.name")?, "multiply");
// Call/apply works as expected
assert_eq!(ctx.eval::<i32, _>("prod.call(prod, 3, 2)")?, 6);
assert_eq!(ctx.eval::<i32, _>("prod.apply(prod, [3, 2])")?, 6);

Tuple Fields

0: F

Implementations

impl<N, F, A, R> Func<(N, F, PhantomData<(A, R)>)>

pub fn new(name: N, func: F) -> Self

Trait Implementations

impl<F> AsRef<F> for Func<F>

fn as_ref(&self) -> &F

Converts this type into a shared reference of the (usually inferred) input type.

impl<F> Deref for Func<F>

type Target = F

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<F, A, R> From<F> for Func<(F, PhantomData<(A, R)>)>

fn from(func: F) -> Self

Converts to this type from the input type.

impl<'js, F, A, R> IntoJs<'js> for Func<(F, PhantomData<(A, R)>)>where F: AsFunction<'js, A, R> + 'js,

fn into_js(self, ctx: Ctx<'js>) -> Result<Value<'js>>

impl<'js, N, F, A, R> IntoJs<'js> for Func<(N, F, PhantomData<(A, R)>)>where N: AsRef<str>, F: AsFunction<'js, A, R> + 'js,

fn into_js(self, ctx: Ctx<'js>) -> Result<Value<'js>>