Struct gluon_vm::api::function::Function

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. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

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. Read more

impl<'de, V> Deserialize<'de> for Function<RootedThread, V>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

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, 'value, F> Getable<'vm, 'value> for Function<RootedThread, 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>) -> Self

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>) -> Status
where 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

Auto Trait Implementations§

impl<T, F> !RefUnwindSafe for Function<T, F>

impl<T, F> Send for Function<T, F>
where F: Send, T: Send,

impl<T, F> Sync for Function<T, F>
where F: Sync, T: Sync,

impl<T, F> Unpin for Function<T, F>
where F: Unpin, T: Unpin,

impl<T, F> !UnwindSafe for Function<T, F>

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<Id> AsId<Id> for Id
where Id: ?Sized,

fn as_id(&self) -> &Id

impl<'vm, T> AsyncPushable<'vm> for T
where T: Pushable<'vm>,

fn async_push( self, context: &mut ActiveThread<'vm>, lock: Lock, _: u32 ) -> Poll<Result<(), Error>>

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. Read more

fn async_status_push( self, context: &mut ActiveThread<'vm>, lock: Lock, frame_index: VmIndex ) -> Status
where Self: Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<Choices> CoproductSubsetter<CNil, HNil> for Choices

type Remainder = Choices

fn subset( self ) -> Result<CNil, <Choices as CoproductSubsetter<CNil, HNil>>::Remainder>

Extract a subset of the possible types in a coproduct (or get the remaining possibilities) Read more

impl<T> Downcast for T
where T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

impl<T> DowncastArc for T
where T: Downcast + Send + Sync,

fn into_arc_any(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

impl<T> DowncastSync for T
where T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<D, T> FromPtr<D> for T

unsafe fn make_ptr(_: D, ptr: mut ()) -> mut T

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T, U, I> LiftInto<U, I> for T
where U: LiftFrom<T, I>,

fn lift_into(self) -> U

Performs the indexed conversion.

impl<Source> Sculptor<HNil, HNil> for Source

type Remainder = Source

fn sculpt(self) -> (HNil, <Source as Sculptor<HNil, HNil>>::Remainder)

Consumes the current HList and returns an HList with the requested shape. Read more

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<T> Any for T
where T: Any,

impl<T> Captures<'_> for T

impl<T> CloneAny for T
where T: Any + Clone,