Type Alias gluon_vm::api::function::FunctionRef

pub type FunctionRef<'vm, F> = Function<&'vm Thread, F>;

Type which represents a function reference in gluon

Aliased Type

struct FunctionRef<'vm, F> { /* private fields */ }

Implementations

impl<T, F> Function<T, F>where T: VmRootInternal,

pub fn get_variant(&self) -> Variants<'_>

pub fn vm(&self) -> &Thread

pub fn re_root<'vm, U>(&self, vm: U) -> Result<Function<U, F>>where U: VmRoot<'vm>,

impl<T, R> Function<T, fn() -> IO<R>>where T: VmRootInternal, R: VmType + for<'x, 'value> Getable<'x, 'value>, <IO<R> as VmType>::Type: Sized, R::Type: Sized,

pub fn call(&mut self) -> Result<IO<R>>

impl<T, R> Function<T, fn() -> IO<R>>where T: VmRootInternal + Clone + Send, R: VmType + for<'x, 'value> Getable<'x, 'value> + Send + Sync + 'static, <IO<R> as VmType>::Type: Sized, R::Type: Sized,

pub async fn call_async(&mut self) -> Result<IO<R>>

impl<T, A, R> Function<T, fn(_: A) -> R>where A: for<'vm> Pushable<'vm>, T: VmRootInternal, R: VmType + for<'x, 'value> Getable<'x, 'value>, <R as VmType>::Type: Sized, R::Type: Sized,

pub fn call(&mut self, A: A) -> Result<R>

impl<T, A, R> Function<T, fn(_: A) -> R>where A: for<'vm> Pushable<'vm>, T: VmRootInternal + Clone + Send, R: VmType + for<'x, 'value> Getable<'x, 'value> + Send + Sync + 'static, <R as VmType>::Type: Sized, R::Type: Sized,

pub async fn call_async(&mut self, A: A) -> Result<R>

impl<T, A, B, R> Function<T, fn(_: A, _: B) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, T: VmRootInternal, R: VmType + for<'x, 'value> Getable<'x, 'value>, <R as VmType>::Type: Sized, R::Type: Sized,

pub fn call(&mut self, A: A, B: B) -> Result<R>

impl<T, A, B, R> Function<T, fn(_: A, _: B) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, T: VmRootInternal + Clone + Send, R: VmType + for<'x, 'value> Getable<'x, 'value> + Send + Sync + 'static, <R as VmType>::Type: Sized, R::Type: Sized,

pub async fn call_async(&mut self, A: A, B: B) -> Result<R>

impl<T, A, B, C, R> Function<T, fn(_: A, _: B, _: C) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, C: for<'vm> Pushable<'vm>, T: VmRootInternal, R: VmType + for<'x, 'value> Getable<'x, 'value>, <R as VmType>::Type: Sized, R::Type: Sized,

pub fn call(&mut self, A: A, B: B, C: C) -> Result<R>

impl<T, A, B, C, R> Function<T, fn(_: A, _: B, _: C) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, C: for<'vm> Pushable<'vm>, T: VmRootInternal + Clone + Send, R: VmType + for<'x, 'value> Getable<'x, 'value> + Send + Sync + 'static, <R as VmType>::Type: Sized, R::Type: Sized,

pub async fn call_async(&mut self, A: A, B: B, C: C) -> Result<R>

impl<T, A, B, C, D, R> Function<T, fn(_: A, _: B, _: C, _: D) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, C: for<'vm> Pushable<'vm>, D: for<'vm> Pushable<'vm>, T: VmRootInternal, R: VmType + for<'x, 'value> Getable<'x, 'value>, <R as VmType>::Type: Sized, R::Type: Sized,

pub fn call(&mut self, A: A, B: B, C: C, D: D) -> Result<R>

impl<T, A, B, C, D, R> Function<T, fn(_: A, _: B, _: C, _: D) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, C: for<'vm> Pushable<'vm>, D: for<'vm> Pushable<'vm>, T: VmRootInternal + Clone + Send, R: VmType + for<'x, 'value> Getable<'x, 'value> + Send + Sync + 'static, <R as VmType>::Type: Sized, R::Type: Sized,

pub async fn call_async(&mut self, A: A, B: B, C: C, D: D) -> Result<R>

impl<T, A, B, C, D, E, R> Function<T, fn(_: A, _: B, _: C, _: D, _: E) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, C: for<'vm> Pushable<'vm>, D: for<'vm> Pushable<'vm>, E: for<'vm> Pushable<'vm>, T: VmRootInternal, R: VmType + for<'x, 'value> Getable<'x, 'value>, <R as VmType>::Type: Sized, R::Type: Sized,

pub fn call(&mut self, A: A, B: B, C: C, D: D, E: E) -> Result<R>

impl<T, A, B, C, D, E, R> Function<T, fn(_: A, _: B, _: C, _: D, _: E) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, C: for<'vm> Pushable<'vm>, D: for<'vm> Pushable<'vm>, E: for<'vm> Pushable<'vm>, T: VmRootInternal + Clone + Send, R: VmType + for<'x, 'value> Getable<'x, 'value> + Send + Sync + 'static, <R as VmType>::Type: Sized, R::Type: Sized,

pub async fn call_async(&mut self, A: A, B: B, C: C, D: D, E: E) -> Result<R>

impl<T, A, B, C, D, E, F, R> Function<T, fn(_: A, _: B, _: C, _: D, _: E, _: F) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, C: for<'vm> Pushable<'vm>, D: for<'vm> Pushable<'vm>, E: for<'vm> Pushable<'vm>, F: for<'vm> Pushable<'vm>, T: VmRootInternal, R: VmType + for<'x, 'value> Getable<'x, 'value>, <R as VmType>::Type: Sized, R::Type: Sized,

pub fn call(&mut self, A: A, B: B, C: C, D: D, E: E, F: F) -> Result<R>

impl<T, A, B, C, D, E, F, R> Function<T, fn(_: A, _: B, _: C, _: D, _: E, _: F) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, C: for<'vm> Pushable<'vm>, D: for<'vm> Pushable<'vm>, E: for<'vm> Pushable<'vm>, F: for<'vm> Pushable<'vm>, T: VmRootInternal + Clone + Send, R: VmType + for<'x, 'value> Getable<'x, 'value> + Send + Sync + 'static, <R as VmType>::Type: Sized, R::Type: Sized,

pub async fn call_async( &mut self, A: A, B: B, C: C, D: D, E: E, F: F ) -> Result<R>

impl<T, A, B, C, D, E, F, G, R> Function<T, fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, C: for<'vm> Pushable<'vm>, D: for<'vm> Pushable<'vm>, E: for<'vm> Pushable<'vm>, F: for<'vm> Pushable<'vm>, G: for<'vm> Pushable<'vm>, T: VmRootInternal, R: VmType + for<'x, 'value> Getable<'x, 'value>, <R as VmType>::Type: Sized, R::Type: Sized,

pub fn call(&mut self, A: A, B: B, C: C, D: D, E: E, F: F, G: G) -> Result<R>

impl<T, A, B, C, D, E, F, G, R> Function<T, fn(_: A, _: B, _: C, _: D, _: E, _: F, _: G) -> R>where A: for<'vm> Pushable<'vm>, B: for<'vm> Pushable<'vm>, C: for<'vm> Pushable<'vm>, D: for<'vm> Pushable<'vm>, E: for<'vm> Pushable<'vm>, F: for<'vm> Pushable<'vm>, G: for<'vm> Pushable<'vm>, T: VmRootInternal + Clone + Send, R: VmType + for<'x, 'value> Getable<'x, 'value> + Send + Sync + 'static, <R as VmType>::Type: Sized, R::Type: Sized,

pub async fn call_async( &mut self, A: A, B: B, C: C, D: D, E: E, F: F, G: G ) -> Result<R>

impl<'vm, T, F> Function<T, F>where T: VmRootInternal + 'vm, F: VmType,

pub fn cast<F2>(self) -> Result<Function<T, F2>>where F2: VmType,

pub fn call_any<A, R>(&'vm self, args: impl IntoIterator<Item = A>) -> Result<R>where A: Pushable<'vm>, R: for<'value> Getable<'vm, 'value> + VmType,

Calls self with a number of arguments that is only known at runtime.

WARNING: No check is done that the number of arguments is correct. The VM may return an error or panic if an incorrect number of arguments is passed.

Trait Implementations

impl<T, F: Clone> Clone for Function<T, F>where T: VmRootInternal + Clone,

fn clone(&self) -> Function<T, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, F: Debug> Debug for Function<T, F>where T: VmRootInternal + Debug,

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

Formats the value using the given formatter.

impl<'vm, 'value, F> Getable<'vm, 'value> for Function<&'vm Thread, F>

type Proxy = Variants<'value>

fn to_proxy(_vm: &'vm Thread, value: Variants<'value>) -> Result<Self::Proxy>

fn from_proxy(vm: &'vm Thread, proxy: &'value mut Self::Proxy) -> Self

fn from_value( vm: &'vm Thread, value: Variants<'value> ) -> Function<&'vm Thread, F>

impl<'vm, T, F> Pushable<'vm> for Function<T, F>where T: VmRootInternal, F: VmType + Any,

fn vm_push(self, context: &mut ActiveThread<'vm>) -> Result<()>

Pushes self to stack. If the call is successful a single element should have been added to the stack and Ok(()) should be returned. If the call is unsuccessful Status:Error should be returned and the stack should be left intact

fn status_push(self, context: &mut ActiveThread<'vm>) -> Statuswhere Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value>where Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>>where Self: Sized, T: VmRoot<'vm>,

impl<T: VmRootInternal + Trace, F> Trace for Function<T, F>

unsafe fn root(&mut self)

unsafe fn unroot(&mut self)

fn trace(&self, gc: &mut Gc)

impl<T, F> VmType for Function<T, F>where T: VmRootInternal, F: VmType,

type Type = <F as VmType>::Type

A version of Self which implements Any allowing a TypeId to be retrieved

fn make_type(vm: &Thread) -> ArcType

Creates an gluon type which maps to Self in rust

fn make_forall_type(vm: &Thread) -> ArcType

const EXTRA_ARGS: VmIndex = 0u32

How many extra arguments a function returning this type requires. Used for abstract types which when used in return position should act like they still need more arguments before they are called