Struct jlrs::wrappers::ptr::function::Function

#[repr(transparent)]
pub struct Function<'scope, 'data> { /* fields omitted */ }

A Julia function.

Implementations

impl<'scope, 'data> Function<'scope, 'data>

pub fn datatype(self) -> DataType<'scope>

Returns the DataType of this function. In Julia, every function has its own DataType.

Trait Implementations

impl<'data> Call<'data> for Function<'_, 'data>

unsafe fn call0<'target, 'current, S, F>(
    self,
    scope: S
) -> JlrsResult<S::JuliaResult> where
    S: Scope<'target, 'current, 'data, F>,
    F: Frame<'current>, 

Call a function with no arguments and root the result in scope.

unsafe fn call1<'target, 'current, S, F>(
    self,
    scope: S,
    arg0: Value<'_, 'data>
) -> JlrsResult<S::JuliaResult> where
    S: Scope<'target, 'current, 'data, F>,
    F: Frame<'current>, 

Call a function with one argument and root the result in scope.

unsafe fn call2<'target, 'current, S, F>(
    self,
    scope: S,
    arg0: Value<'_, 'data>,
    arg1: Value<'_, 'data>
) -> JlrsResult<S::JuliaResult> where
    S: Scope<'target, 'current, 'data, F>,
    F: Frame<'current>, 

Call a function with two arguments and root the result in scope.

unsafe fn call3<'target, 'current, S, F>(
    self,
    scope: S,
    arg0: Value<'_, 'data>,
    arg1: Value<'_, 'data>,
    arg2: Value<'_, 'data>
) -> JlrsResult<S::JuliaResult> where
    S: Scope<'target, 'current, 'data, F>,
    F: Frame<'current>, 

Call a function with three arguments and root the result in scope.

unsafe fn call<'target, 'current, 'value, V, S, F>(
    self,
    scope: S,
    args: V
) -> JlrsResult<S::JuliaResult> where
    V: AsMut<[Value<'value, 'data>]>,
    S: Scope<'target, 'current, 'data, F>,
    F: Frame<'current>, 

Call a function with an arbitrary number arguments and root the result in scope.

unsafe fn call0_unrooted<'target>(
    self,
    global: Global<'target>
) -> JuliaResultRef<'target, 'data>

Call a function with no arguments without rooting the result.

unsafe fn call1_unrooted<'target>(
    self,
    global: Global<'target>,
    arg0: Value<'_, 'data>
) -> JuliaResultRef<'target, 'data>

Call a function with one argument without rooting the result.

unsafe fn call2_unrooted<'target>(
    self,
    global: Global<'target>,
    arg0: Value<'_, 'data>,
    arg1: Value<'_, 'data>
) -> JuliaResultRef<'target, 'data>

Call a function with two arguments without rooting the result.

unsafe fn call3_unrooted<'target>(
    self,
    global: Global<'target>,
    arg0: Value<'_, 'data>,
    arg1: Value<'_, 'data>,
    arg2: Value<'_, 'data>
) -> JuliaResultRef<'target, 'data>

Call a function with three arguments without rooting the result.

unsafe fn call_unrooted<'target, 'value, V>(
    self,
    global: Global<'target>,
    args: V
) -> JuliaResultRef<'target, 'data> where
    V: AsMut<[Value<'value, 'data>]>, 

Call a function with an abitrary number of arguments without rooting the result.

impl<'impl0, 'data> CallAsync<'data> for Function<'impl0, 'data>

unsafe fn call_async<'frame, 'value, 'life0, 'async_trait, V>(
    self,
    frame: &'life0 mut AsyncGcFrame<'frame>,
    args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'frame, 'data>>> + 'async_trait>> where
    V: AsMut<[Value<'value, 'data>]>,
    'frame: 'async_trait,
    'value: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Call a function on another thread with the given arguments. This method uses Base.Threads.@spawn to call the given function on another thread but return immediately. While awaiting the result the async runtime can work on other tasks, the current task resumes after the function call on the other thread completes.

unsafe fn schedule_async<'frame, 'value, V>(
    self,
    frame: &mut AsyncGcFrame<'frame>,
    args: V
) -> JlrsResult<JuliaResult<'frame, 'data, Task<'frame>>> where
    V: AsMut<[Value<'value, 'data>]>, 

Does the same thing as CallAsync::call_async, but the task is returned rather than an awaitable Future. This method should only be called in GeneratorTask::init, otherwise it’s not guaranteed this task can progress.

unsafe fn call_async_local<'frame, 'value, 'life0, 'async_trait, V>(
    self,
    frame: &'life0 mut AsyncGcFrame<'frame>,
    args: V
) -> Pin<Box<dyn Future<Output = JlrsResult<JuliaResult<'frame, 'data>>> + 'async_trait>> where
    V: AsMut<[Value<'value, 'data>]>,
    'frame: 'async_trait,
    'value: 'async_trait,
    V: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Call a function with the given arguments in an @async block. Like call_async, the function is not called on the main thread, but on a separate thread that handles all tasks created by this method. This method should only be used with functions that do very little computational work but mostly spend their time waiting on IO.

unsafe fn schedule_async_local<'frame, 'value, V>(
    self,
    frame: &mut AsyncGcFrame<'frame>,
    args: V
) -> JlrsResult<JuliaResult<'frame, 'data, Task<'frame>>> where
    V: AsMut<[Value<'value, 'data>]>, 

Does the same thing as CallAsync::call_async_local, but the task is returned rather than an awaitable Future. This method should only be called in GeneratorTask::init, otherwise it’s not guaranteed this task can progress.

impl<'target, 'current, 'value, 'data> CallExt<'target, 'current, 'value, 'data> for Function<'value, 'data>

fn with_keywords(
    self,
    kws: Value<'value, 'data>
) -> JlrsResult<WithKeywords<'value, 'data>>

Provide keyword arguments to the function. The keyword arguments must be a NamedTuple.

impl<'scope, 'data> Clone for Function<'scope, 'data>

fn clone(&self) -> Function<'scope, 'data>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Function<'_, '_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Typecheck for Function<'_, '_>

fn typecheck(t: DataType<'_>) -> bool

impl ValidLayout for Function<'_, '_>

fn valid_layout(ty: Value<'_, '_>) -> bool

Check if the layout of the implementor is compatible with the layout of ty. This argument is a Value to account for the fact that a field type can be a Union, UnionAll or Union{}.

impl<'scope, 'data> Copy for Function<'scope, 'data>