Struct gluon::Thread

pub struct Thread { /* private fields */ }

Representation of the virtual machine

Implementations

impl Thread

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

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, Error>

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_async().await;

vm.run_expr_async::<OpaqueValue<&Thread, Hole>>("example", r#" import! std.int "#)
    .await
    .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_async(1, 2).await;
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, Error>

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

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

pub fn get_type<T>(&self) -> Option<ArcType>

where T: Any + ?Sized,

Returns the gluon type that was bound to T

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

where T: Any + ?Sized,

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, Error>

pub fn get_cache_alias(&self, name: &str) -> Option<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<(), Error>

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<(), Error>

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<Thread, <__D as Deserializer<'de>>::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 for Thread

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PostDeserialize for Thread

fn init<'gc>( parent: &Thread, ptr: Borrow<'gc, OwnedPtr<Thread>> ) -> Borrow<'gc, GcPtr<Thread>>

impl SerializeState<SeSeed> for Thread

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

where __S: Serializer,

Serializes self

impl ThreadExt for Thread

fn get_database(&self) -> Snapshot<CompilerDatabase>

fn get_database_mut(&self) -> DatabaseMut

fn run_io(&self, run: bool)

fn module_compiler<'a, 'b>( &'a self, database: impl IntoDb<'a, 'b> ) -> ModuleCompiler<'a, 'b>

fn parse_expr( &self, type_cache: &TypeCache<Symbol, ArcType>, file: &str, expr_str: &str ) -> StdResult<OwnedExpr<Symbol>, InFile<Error>>

Parse expr_str, returning an expression if successful

fn parse_partial_expr( &self, type_cache: &TypeCache<Symbol, ArcType>, file: &str, expr_str: &str ) -> SalvageResult<OwnedExpr<Symbol>, InFile<Error>>

Parse input, returning an expression if successful

fn typecheck_expr<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, file: &'life1 str, expr_str: &'life2 str, expr: &'life3 mut OwnedExpr<Symbol> ) -> Pin<Box<dyn Future<Output = Result<ArcType>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Parse and typecheck expr_str returning the typechecked expression and type of the expression

fn typecheck_str( &self, file: &str, expr_str: &str, expected_type: Option<&ArcType> ) -> Result<(Arc<OwnedExpr<Symbol>>, ArcType)>

fn typecheck_str_async<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, file: &'life1 str, expr_str: &'life2 str, expected_type: Option<&'life3 ArcType> ) -> Pin<Box<dyn Future<Output = Result<(Arc<OwnedExpr<Symbol>>, ArcType)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn compile_script<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, filename: &'life1 str, expr_str: &'life2 str, expr: &'life3 OwnedExpr<Symbol> ) -> Pin<Box<dyn Future<Output = Result<CompiledModule>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Compiles expr into a function which can be added and run by the vm

fn compile_to_bytecode<'life0, 'life1, 'life2, 'async_trait, S>( &'life0 self, name: &'life1 str, expr_str: &'life2 str, serializer: S ) -> Pin<Box<dyn Future<Output = StdResult<S::Ok, Either<Error, S::Error>>> + Send + 'async_trait>>

where S: Serializer + Send + 'async_trait, S::Error: 'static, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Compiles the source code expr_str into bytecode serialized using serializer

fn load_bytecode<'vm, 'life0, 'life1, 'async_trait, D, E>( &'life0 self, name: &'life1 str, deserializer: D ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where D: for<'de> Deserializer<'de, Error = E> + Send + 'async_trait, E: Send + Sync + 'async_trait, Self: 'async_trait, 'vm: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads bytecode from a Deserializer and stores it into the module name.

fn extract_metadata<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, file: &'life1 str, expr_str: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<(Arc<OwnedExpr<Symbol>>, ArcType, Arc<Metadata>)>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Parses and typechecks expr_str followed by extracting metadata from the created expression

fn load_script(&self, filename: &str, input: &str) -> Result<()>

Compiles input and if it is successful runs the resulting code and stores the resulting value in the vm.

fn load_script_async<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, filename: &'life1 str, input: &'life2 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn load_file<'vm>(&'vm self, filename: &str) -> Result<()>

Loads filename and compiles and runs its input by calling load_script

fn load_file_async<'vm, 'life0, 'life1, 'async_trait>( &'life0 self, filename: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'vm: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn run_expr<'vm, T>( &'vm self, name: &str, expr_str: &str ) -> Result<(T, ArcType)>

where T: for<'value> Getable<'vm, 'value> + VmType + Send + 'vm,

Compiles and runs the expression in expr_str. If successful the value from running the expression is returned

fn run_expr_async<'vm, 'life0, 'life1, 'async_trait, T>( &'vm self, name: &'life0 str, expr_str: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<(T, ArcType)>> + Send + 'async_trait>>

where T: for<'value> Getable<'vm, 'value> + VmType + Send + 'vm + 'async_trait, Self: 'async_trait, 'vm: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Compiles and runs the expression in expr_str. If successful the value from running the expression is returned

fn format_expr( &self, formatter: &mut Formatter, file: &str, input: &str ) -> Result<String>

fn format_expr_async<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, formatter: &'life1 mut Formatter, file: &'life2 str, input: &'life3 str ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

impl ThreadInternal for Thread

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

where T: VmRoot<'vm>,

Roots a value

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

where 'life0: 'async_trait, 'life1: 'async_trait, Thread: 'async_trait,

Calls a module, allowed to to run IO expressions

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

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 context(&self) -> OwnedContext<'_>

Locks and retrives this threads stack

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

where 'life0: 'async_trait, 'life1: 'async_trait, Thread: 'async_trait,

Evaluates a zero argument function (a thunk)

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

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

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

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

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + Sync + 'async_trait,

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

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Send + 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<Borrow<'gc, GcPtr<Box<dyn Userdata>>>, Error>

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

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

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 = Thread

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

const EXTRA_ARGS: u32 = 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