Trait NativeFunction 

pub trait NativeFunction<'a> {
    // Required methods
    unsafe fn call(&self, args: &'a [MArgument], ret: MArgument);
    fn signature(&self) -> Result<(Vec<Expr>, Expr), String>;
}

Trait implemented for any function whose parameters and return type are native LibraryLink MArgument types.

#[export] can only be used with functions that implement this trait.

A function implements this trait if all of its parameters implement FromArg and its return type implements IntoArg.

Functions that pass their arguments and return value using a [wstp::Link] do not implement this trait. See [WstpFunction].

Required Methods

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

Call the function using the raw LibraryLink MArgument fields.

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

Get the type signature of this function, suitable for use in LibraryFunctionLoad[_, _, parameters, ret].

See also FromArg::parameter_type() and IntoArg::return_type().

The function generated by [generate_loader!][crate::generate_loader] uses this method to generate the type signature for functions exported by #[export].

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'a, 'b> NativeFunction<'a> for fn(&'b [MArgument], MArgument)

where 'a: 'b,

Implement NativeFunction for functions that use raw MArguments for their arguments and return value.

Example

use wolfram_library_link::{self as wll, sys::MArgument, FromArg};

#[wll::export]
fn raw_add2(args: &[MArgument], ret: MArgument) {
    let x = unsafe { i64::from_arg(&args[0]) };
    let y = unsafe { i64::from_arg(&args[1]) };

    unsafe {
        *ret.integer = x + y;
    }
}

LibraryFunctionLoad["...", "raw_add2", {Integer, Integer}, Integer]

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R> NativeFunction<'a> for fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>, A3: FromArg<'a>, A4: FromArg<'a>, A5: FromArg<'a>, A6: FromArg<'a>, A7: FromArg<'a>, A8: FromArg<'a>, A9: FromArg<'a>, A10: FromArg<'a>, A11: FromArg<'a>, A12: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R> NativeFunction<'a> for fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>, A3: FromArg<'a>, A4: FromArg<'a>, A5: FromArg<'a>, A6: FromArg<'a>, A7: FromArg<'a>, A8: FromArg<'a>, A9: FromArg<'a>, A10: FromArg<'a>, A11: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R> NativeFunction<'a> for fn(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>, A3: FromArg<'a>, A4: FromArg<'a>, A5: FromArg<'a>, A6: FromArg<'a>, A7: FromArg<'a>, A8: FromArg<'a>, A9: FromArg<'a>, A10: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, A3, A4, A5, A6, A7, A8, A9, R> NativeFunction<'a> for fn(A1, A2, A3, A4, A5, A6, A7, A8, A9) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>, A3: FromArg<'a>, A4: FromArg<'a>, A5: FromArg<'a>, A6: FromArg<'a>, A7: FromArg<'a>, A8: FromArg<'a>, A9: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, A3, A4, A5, A6, A7, A8, R> NativeFunction<'a> for fn(A1, A2, A3, A4, A5, A6, A7, A8) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>, A3: FromArg<'a>, A4: FromArg<'a>, A5: FromArg<'a>, A6: FromArg<'a>, A7: FromArg<'a>, A8: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, A3, A4, A5, A6, A7, R> NativeFunction<'a> for fn(A1, A2, A3, A4, A5, A6, A7) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>, A3: FromArg<'a>, A4: FromArg<'a>, A5: FromArg<'a>, A6: FromArg<'a>, A7: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, A3, A4, A5, A6, R> NativeFunction<'a> for fn(A1, A2, A3, A4, A5, A6) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>, A3: FromArg<'a>, A4: FromArg<'a>, A5: FromArg<'a>, A6: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, A3, A4, A5, R> NativeFunction<'a> for fn(A1, A2, A3, A4, A5) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>, A3: FromArg<'a>, A4: FromArg<'a>, A5: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, A3, A4, R> NativeFunction<'a> for fn(A1, A2, A3, A4) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>, A3: FromArg<'a>, A4: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, A3, R> NativeFunction<'a> for fn(A1, A2, A3) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>, A3: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, A2, R> NativeFunction<'a> for fn(A1, A2) -> R

where R: IntoArg, A1: FromArg<'a>, A2: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, A1, R> NativeFunction<'a> for fn(A1) -> R

where R: IntoArg, A1: FromArg<'a>,

unsafe fn call(&self, args: &'a [MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

impl<'a, R> NativeFunction<'a> for fn() -> R

where R: IntoArg,

unsafe fn call(&self, args: &[MArgument], ret: MArgument)

fn signature(&self) -> Result<(Vec<Expr>, Expr), String>

Implementors