[−][src]Struct gluon::Thread
Representation of the virtual machine
Implementations
impl Thread
[src]
pub fn new_thread(&self) -> Result<RootedThread, Error>
[src]
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
[src]
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)>
[src]
pub fn get_global<'vm, T>(&'vm self, name: &str) -> Result<T, Error> where
T: for<'value> Getable<'vm, 'value> + VmType,
[src]
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<Symbol>, Error>
[src]
pub fn find_type_info(
&self,
name: &str
) -> Result<Alias<Symbol, ArcType<Symbol>>, Error>
[src]
&self,
name: &str
) -> Result<Alias<Symbol, ArcType<Symbol>>, 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<Symbol>> where
T: Any + ?Sized,
[src]
T: Any + ?Sized,
Returns the gluon type that was bound to T
pub fn register_type<T>(
&self,
name: &str,
args: &[&str]
) -> Result<ArcType<Symbol>, Error> where
T: Any + ?Sized,
[src]
&self,
name: &str,
args: &[&str]
) -> Result<ArcType<Symbol>, 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<Symbol>>,
id: TypeId
) -> Result<ArcType<Symbol>, Error>
[src]
&self,
name: Symbol,
alias: Alias<Symbol, ArcType<Symbol>>,
id: TypeId
) -> Result<ArcType<Symbol>, Error>
pub fn get_cache_alias(&self, name: &str) -> Option<ArcType<Symbol>>
[src]
pub fn cache_alias(
&self,
alias: Alias<Symbol, ArcType<Symbol>>
) -> ArcType<Symbol>
[src]
&self,
alias: Alias<Symbol, ArcType<Symbol>>
) -> ArcType<Symbol>
pub fn get_env(&'b self) -> VmEnvInstance<'b>
[src]
Locks and retrieves the global environment of the vm
pub fn get_macros(&self) -> &MacroEnv
[src]
Retrieves the macros defined for this vm
pub fn collect(&self)
[src]
Runs a garbage collection.
pub fn push<'vm, T>(&'vm self, v: T) -> Result<(), Error> where
T: Pushable<'vm>,
[src]
T: Pushable<'vm>,
Pushes a value to the top of the stack
pub fn pop(&self)
[src]
Removes the top value from the stack
pub fn allocated_memory(&self) -> usize
[src]
pub fn set_memory_limit(&self, memory_limit: usize)
[src]
pub fn interrupt(&self)
[src]
pub fn interrupted(&self) -> bool
[src]
pub fn current_context(&self) -> ActiveThread<'_>
[src]
Trait Implementations
impl Debug for Thread
[src]
impl<'de, 'gc> DeserializeState<'de, DeSeed<'gc>> for Thread
[src]
fn deserialize_state<__D>(
__seed: &mut DeSeed<'gc>,
__deserializer: __D
) -> Result<Thread, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
[src]
__seed: &mut DeSeed<'gc>,
__deserializer: __D
) -> Result<Thread, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
impl Drop for Thread
[src]
impl PartialEq<Thread> for Thread
[src]
impl PostDeserialize for Thread
[src]
impl SerializeState<SeSeed> for Thread
[src]
fn serialize_state<__S>(
&self,
__serializer: __S,
__seed: &SeSeed
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
[src]
&self,
__serializer: __S,
__seed: &SeSeed
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
impl ThreadExt for Thread
[src]
fn get_database(&self) -> DatabaseSnapshot
[src]
fn get_database_mut(&self) -> DatabaseMut
[src]
fn thread(&self) -> &Thread
[src]
fn run_io(&self, run: bool)
[src]
fn module_compiler<'a, 'b>(
&'a self,
database: impl Into<OwnedDb<'a, dyn Compilation + 'b>>
) -> ModuleCompiler<'a, 'b>
[src]
&'a self,
database: impl Into<OwnedDb<'a, dyn Compilation + 'b>>
) -> ModuleCompiler<'a, 'b>
fn parse_expr(
&self,
type_cache: &TypeCache<Symbol, ArcType>,
file: &str,
expr_str: &str
) -> StdResult<OwnedExpr<Symbol>, InFile<Error>>
[src]
&self,
type_cache: &TypeCache<Symbol, ArcType>,
file: &str,
expr_str: &str
) -> StdResult<OwnedExpr<Symbol>, InFile<Error>>
fn parse_partial_expr(
&self,
type_cache: &TypeCache<Symbol, ArcType>,
file: &str,
expr_str: &str
) -> SalvageResult<OwnedExpr<Symbol>, InFile<Error>>
[src]
&self,
type_cache: &TypeCache<Symbol, ArcType>,
file: &str,
expr_str: &str
) -> SalvageResult<OwnedExpr<Symbol>, InFile<Error>>
#[must_use]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
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
Self: 'async_trait,
[src]
&'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
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
Self: 'async_trait,
fn typecheck_str(
&self,
file: &str,
expr_str: &str,
expected_type: Option<&ArcType>
) -> Result<(Arc<OwnedExpr<Symbol>>, ArcType)>
[src]
&self,
file: &str,
expr_str: &str,
expected_type: Option<&ArcType>
) -> Result<(Arc<OwnedExpr<Symbol>>, ArcType)>
#[must_use]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
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
Self: 'async_trait,
[src]
&'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
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
Self: 'async_trait,
#[must_use]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
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
Self: 'async_trait,
[src]
&'life0 self,
filename: &'life1 str,
expr_str: &'life2 str,
expr: &'life3 OwnedExpr<Symbol>
) -> Pin<Box<dyn Future<Output = Result<CompiledModule>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
Self: 'async_trait,
#[must_use]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,
S::Error: 'static,
S: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
[src]
&'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,
S::Error: 'static,
S: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
#[must_use]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,
E: Send + Sync,
'vm: 'async_trait,
D: 'async_trait,
E: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
[src]
&'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,
E: Send + Sync,
'vm: 'async_trait,
D: 'async_trait,
E: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
#[must_use]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
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
[src]
&'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
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
fn load_script(&self, filename: &str, input: &str) -> Result<()>
[src]
#[must_use]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
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
[src]
&'life0 self,
filename: &'life1 str,
input: &'life2 str
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
Self: 'async_trait,
fn load_file<'vm>(&'vm self, filename: &str) -> Result<()>
[src]
#[must_use]fn load_file_async<'vm, 'life0, 'life1, 'async_trait>(
&'life0 self,
filename: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
'vm: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
[src]
&'life0 self,
filename: &'life1 str
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
'vm: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
Self: '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,
[src]
&'vm self,
name: &str,
expr_str: &str
) -> Result<(T, ArcType)> where
T: for<'value> Getable<'vm, 'value> + VmType + Send + 'vm,
#[must_use]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,
'vm: 'async_trait,
T: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
[src]
&'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,
'vm: 'async_trait,
T: 'async_trait,
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn format_expr(
&self,
formatter: &mut Formatter,
file: &str,
input: &str
) -> Result<String>
[src]
&self,
formatter: &mut Formatter,
file: &str,
input: &str
) -> Result<String>
#[must_use]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
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
Self: 'async_trait,
[src]
&'life0 self,
formatter: &'life1 mut Formatter,
file: &'life2 str,
input: &'life3 str
) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>> where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
Self: 'async_trait,
impl ThreadInternal for Thread
[src]
fn context(&self) -> OwnedContext<'_>
[src]
fn root_value<'vm, T>(&'vm self, value: Variants<'_>) -> RootedValue<T> where
T: VmRoot<'vm>,
[src]
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>, Error>> + 'async_trait + Send>> where
'life0: 'async_trait,
'life1: 'async_trait,
Thread: 'async_trait,
[src]
&'life0 self,
closure: &'life1 GcPtr<ClosureData>
) -> Pin<Box<dyn Future<Output = Result<RootedValue<RootedThread>, Error>> + 'async_trait + Send>> where
'life0: 'async_trait,
'life1: 'async_trait,
Thread: 'async_trait,
fn execute_io<'life0, 'life1, 'async_trait>(
&'life0 self,
value: Variants<'life1>
) -> Pin<Box<dyn Future<Output = Result<RootedValue<RootedThread>, Error>> + 'async_trait + Send>> where
'life0: 'async_trait,
'life1: 'async_trait,
Thread: 'async_trait,
[src]
&'life0 self,
value: Variants<'life1>
) -> Pin<Box<dyn Future<Output = Result<RootedValue<RootedThread>, Error>> + 'async_trait + Send>> where
'life0: 'async_trait,
'life1: 'async_trait,
Thread: 'async_trait,
Calls a module, allowed to to run IO expressions
fn call_function(
&'b self,
cx: &mut Context<'_>,
context: OwnedContext<'b>,
args: u32
) -> Poll<Result<Option<OwnedContext<'b>>, Error>>
[src]
&'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 resume(&self, cx: &mut Context<'_>) -> Poll<Result<OwnedContext<'_>, Error>>
[src]
fn deep_clone_value(
&self,
owner: &Thread,
value: &Value
) -> Result<RootedValue<&Thread>, Error>
[src]
&self,
owner: &Thread,
value: &Value
) -> Result<RootedValue<&Thread>, Error>
fn can_share_values_with(&self, gc: &mut Gc, other: &Thread) -> bool
[src]
#[must_use]fn call_thunk_top<'life0, 'life1, 'async_trait>(
&'life0 self,
closure: &'life1 GcPtr<ClosureData>
) -> Pin<Box<dyn Future<Output = Result<RootedValue<RootedThread>, Error>> + 'async_trait + Send>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: Send + Sync + 'async_trait,
[src]
&'life0 self,
closure: &'life1 GcPtr<ClosureData>
) -> Pin<Box<dyn Future<Output = Result<RootedValue<RootedThread>, Error>> + 'async_trait + Send>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: Send + 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>, Error>> + 'async_trait + Send>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: Send + Sync + 'async_trait,
[src]
&'life0 self,
value: Variants<'life1>
) -> Pin<Box<dyn Future<Output = Result<RootedValue<RootedThread>, Error>> + 'async_trait + Send>> where
'life0: 'async_trait,
'life1: 'async_trait,
Self: Send + Sync + 'async_trait,
impl Trace for Thread
[src]
impl Userdata for Thread
[src]
fn deep_clone(
&self,
deep_cloner: &'gc mut Cloner<'_>
) -> Result<Borrow<'gc, GcPtr<Box<dyn Userdata + 'static>>>, Error>
[src]
&self,
deep_cloner: &'gc mut Cloner<'_>
) -> Result<Borrow<'gc, GcPtr<Box<dyn Userdata + 'static>>>, Error>
impl<'a> VmRoot<'a> for &'a Thread
[src]
impl<'a> VmRootInternal for &'a Thread
[src]
fn root_vm(&mut self)
[src]
fn unroot_vm(&mut self)
[src]
unsafe fn root_value_with_self(self, value: &Value) -> RootedValue<Self>
[src]
impl VmType for Thread
[src]
Auto Trait Implementations
impl !RefUnwindSafe for Thread
impl Send for Thread
impl Sync for Thread
impl Unpin for Thread
impl !UnwindSafe for Thread
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Any for T where
T: Any,
T: Any,
impl<Id> AsId<Id> for Id where
Id: ?Sized,
[src]
Id: ?Sized,
impl<'vm, T> AsyncPushable<'vm> for T where
T: Pushable<'vm>,
[src]
T: Pushable<'vm>,
fn async_push(
self,
context: &mut ActiveThread<'vm>,
lock: Lock,
u32
) -> Poll<Result<(), Error>>
[src]
self,
context: &mut ActiveThread<'vm>,
lock: Lock,
u32
) -> Poll<Result<(), Error>>
fn async_status_push(
self,
context: &mut ActiveThread<'vm>,
lock: Lock,
frame_index: u32
) -> Status
[src]
self,
context: &mut ActiveThread<'vm>,
lock: Lock,
frame_index: u32
) -> Status
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<'_, T> Captures<'_> for T
[src]
impl<Choices> CoproductSubsetter<CNil, HNil> for Choices
type Remainder = Choices
fn subset(
self
) -> Result<CNil, <Choices as CoproductSubsetter<CNil, HNil>>::Remainder>
self
) -> Result<CNil, <Choices as CoproductSubsetter<CNil, HNil>>::Remainder>
impl<T> Downcast for T where
T: Any,
T: Any,
fn into_any(self: Box<T>) -> Box<dyn Any + 'static>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
fn as_any(&self) -> &(dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
impl<T> DowncastArc for T where
T: Downcast + Send + Sync,
[src]
T: Downcast + Send + Sync,
impl<T> DowncastSync for T where
T: Send + Sync + Any,
T: Send + Sync + Any,
impl<T> From<T> for T
[src]
impl<D, T> FromPtr<D> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U, I> LiftInto<U, I> for T where
U: LiftFrom<T, I>,
U: LiftFrom<T, I>,
fn lift_into(self) -> U
impl<'vm, T> Pushable<'vm> for T where
T: Userdata,
[src]
T: Userdata,
fn vm_push(self, context: &mut ActiveThread<'vm>) -> Result<(), Error>
[src]
fn status_push(self, context: &mut ActiveThread<'vm>) -> Status
[src]
unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value, Error>
[src]
fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>, Error> where
T: VmRoot<'vm>,
[src]
T: VmRoot<'vm>,
impl<Source> Sculptor<HNil, HNil> for Source
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
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<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,