Struct gluon_vm::thread::Thread

pub struct Thread { /* fields omitted */ }

Representation of the virtual machine

Methods

impl Thread

pub fn new_thread(&self) -> Result<RootedThread>

Spawns a new gluon thread with its own stack and heap but while still sharing the same global environment

pub fn root_thread(&self) -> RootedThread

Roots self, extending the lifetime of this thread until at least the returned RootedThread is droppped

pub fn spawner(&self) -> Option<&(dyn Spawn + Send + Sync)>

pub fn get_global<'vm, T>(&'vm self, name: &str) -> Result<T> where
    T: for<'value> Getable<'vm, 'value> + VmType, 

Retrieves the global called name.

Examples

Bind the (+) function in gluon's prelude standard library to an add function in rust

let vm = new_vm();

vm.run_expr::<OpaqueValue<&Thread, Hole>>("example", r#" import! std.int "#)
    .unwrap_or_else(|err| panic!("{}", err));
let mut add: FunctionRef<fn(i32, i32) -> i32> =
    vm.get_global("std.int.num.(+)").unwrap();
let result = add.call(1, 2);
assert_eq!(result, Ok(3));

Errors

if the global does not exist or it does not have the correct type.

pub fn get_global_type(&self, name: &str) -> Result<ArcType>

pub fn find_type_info(&self, name: &str) -> Result<Alias<Symbol, ArcType>>

Retrieves type information about the type name. Types inside records can be accessed using dot notation (std.prelude.Option)

pub fn get_type<T: ?Sized + Any>(&self) -> Option<ArcType>

Returns the gluon type that was bound to T

pub fn register_type<T: ?Sized + Any>(
    &self,
    name: &str,
    args: &[&str]
) -> Result<ArcType>

Registers the type T as being a gluon type called name with generic arguments args

pub fn register_type_as(
    &self,
    name: Symbol,
    alias: Alias<Symbol, ArcType>,
    id: TypeId
) -> Result<ArcType>

pub fn cache_alias(&self, alias: Alias<Symbol, ArcType>) -> ArcType

pub fn get_env<'b>(&'b self) -> VmEnvInstance<'b>

Locks and retrieves the global environment of the vm

pub fn get_macros(&self) -> &MacroEnv

Retrieves the macros defined for this vm

pub fn collect(&self)

Runs a garbage collection.

pub fn push<'vm, T>(&'vm self, v: T) -> Result<()> where
    T: Pushable<'vm>, 

Pushes a value to the top of the stack

pub fn pop(&self)

Removes the top value from the stack

pub fn allocated_memory(&self) -> usize

pub fn set_memory_limit(&self, memory_limit: usize)

pub fn interrupt(&self)

pub fn interrupted(&self) -> bool

pub fn current_context(&self) -> ActiveThread

Trait Implementations

impl Debug for Thread

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

Formats the value using the given formatter.

impl<'de, 'gc> DeserializeState<'de, DeSeed<'gc>> for Thread

fn deserialize_state<__D>(
    __seed: &mut DeSeed<'gc>,
    __deserializer: __D
) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserializes Self using seed and the deserializer

impl Drop for Thread

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq<Thread> for Thread

fn eq(&self, other: &Thread) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PostDeserialize for Thread

fn init<'gc>(parent: &Thread, ptr: OwnedGcRef<'gc, Self>) -> GcRef<'gc, Self>

impl SerializeState<SeSeed> for Thread

fn serialize_state<__S>(
    &self,
    __serializer: __S,
    __seed: &SeSeed
) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serializes self

impl<T> SerializeState<Thread> for Opaque<T, str> where
    T: AsValueRef, 

fn serialize_state<S>(
    &self,
    serializer: S,
    _thread: &Thread
) -> StdResult<S::Ok, S::Error> where
    S: Serializer, 

Serializes self

impl SerializeState<Thread> for Value

fn serialize_state<__S>(
    &self,
    __serializer: __S,
    __seed: &Thread
) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serializes self

impl SerializeState<Thread> for JsonString

fn serialize_state<__S>(
    &self,
    __serializer: __S,
    __seed: &Thread
) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serializes self

impl SerializeState<Thread> for JsonValue

fn serialize_state<S>(
    &self,
    serializer: S,
    vm: &Thread
) -> StdResult<S::Ok, S::Error> where
    S: Serializer, 

Serializes self

impl ThreadInternal for Thread

fn context(&self) -> OwnedContext

Locks and retrives this threads stack

fn root_value<'vm, T>(&'vm self, value: Variants) -> RootedValue<T> where
    T: VmRoot<'vm>, 

Roots a value

fn call_thunk<'life0, 'life1, 'async_trait>(
    &'life0 self,
    closure: &'life1 GcPtr<ClosureData>
) -> Pin<Box<dyn Future<Output = Result<RootedValue<RootedThread>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Evaluates a zero argument function (a thunk)

fn execute_io<'life0, 'life1, 'async_trait>(
    &'life0 self,
    value: Variants<'life1>
) -> Pin<Box<dyn Future<Output = Result<RootedValue<RootedThread>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Calls a module, allowed to to run IO expressions

fn call_function<'b>(
    &'b self,
    cx: &mut Context,
    context: OwnedContext<'b>,
    args: VmIndex
) -> Poll<Result<Option<OwnedContext<'b>>>>

Calls a function on the stack. When this function is called it is expected that the function exists at stack.len() - args - 1 and that the arguments are of the correct type

fn resume(&self, cx: &mut Context) -> Poll<Result<OwnedContext>>

fn set_global(
    &self,
    name: Symbol,
    typ: ArcType,
    metadata: Arc<Metadata>,
    value: &Value
) -> Result<()>

fn deep_clone_value(
    &self,
    owner: &Thread,
    value: &Value
) -> Result<RootedValue<&Thread>>

owner is theread that owns value which is not necessarily the same as self

fn can_share_values_with(&self, gc: &mut Gc, other: &Thread) -> bool

#[must_use]fn call_thunk_top<'life0, 'life1, 'async_trait>(
    &'life0 self,
    closure: &'life1 GcPtr<ClosureData>
) -> Pin<Box<dyn Future<Output = Result<RootedValue<RootedThread>>> + Send + 'async_trait>> where
    Self: Send + Sync,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, 

#[must_use]fn execute_io_top<'life0, 'life1, 'async_trait>(
    &'life0 self,
    value: Variants<'life1>
) -> Pin<Box<dyn Future<Output = Result<RootedValue<RootedThread>>> + Send + 'async_trait>> where
    Self: Send + Sync,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait, 

impl Trace for Thread

unsafe fn root(&mut self)

unsafe fn unroot(&mut self)

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

impl Userdata for Thread

fn deep_clone<'gc>(
    &self,
    deep_cloner: &'gc mut Cloner
) -> Result<GcRef<'gc, Box<dyn Userdata>>>

impl<'a> VmRoot<'a> for &'a Thread

fn new_root(thread: &'a Thread) -> Self

impl<'a> VmRootInternal for &'a Thread

fn root_vm(&mut self)

fn unroot_vm(&mut self)

unsafe fn root_value_with_self(self, value: &Value) -> RootedValue<Self> where
    Self: Sized, 

Roots a value

impl VmType for Thread

type Type = Self

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

fn make_forall_type(vm: &Thread) -> ArcType

fn make_type(vm: &Thread) -> ArcType

Creates an gluon type which maps to Self in rust

fn extra_args() -> VmIndex

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