[][src]Struct gluon::Thread

pub struct Thread { /* fields omitted */ }

Representation of the virtual machine

Methods

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 define_global<'vm, T>(
    &'vm self,
    name: &str,
    value: T
) -> Result<(), Error> where
    T: Pushable<'vm> + VmType
[src]

Deprecated since 0.7.0:

Use gluon::import::add_extern_module instead

Creates a new global value at name. Fails if a global called name already exists.

Examples

Load the factorial rust function into gluon and evaluate factorial 5

fn factorial(x: i32) -> i32 {
    if x <= 1 { 1 } else { x * factorial(x - 1) }
}


let vm = new_vm();

vm.define_global("factorial", primitive!(1, factorial)).unwrap();

let result = Compiler::new()
    .run_expr::<i32>(&vm, "example", "factorial 5")
    .unwrap_or_else(|err| panic!("{}", err));
let expected = (120, Type::int());

assert_eq!(result, expected);

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

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();

Compiler::new()
    .run_expr::<OpaqueValue<&Thread, Hole>>(&vm, "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<Symbol>, Error>[src]

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

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]

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]

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]

pub fn get_env(&'b self) -> RwLockReadGuard<'b, VmEnv>[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]

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 Traverseable for Thread[src]

impl<'a> VmRoot<'a> for &'a Thread[src]

fn root_value_with_self(self, value: Variants) -> RootedValue<Self>[src]

Roots a value

impl PartialEq<Thread> for Thread[src]

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

This method tests for !=.

impl SerializeState<SeSeed> for Thread[src]

impl Debug for Thread[src]

impl VmType for Thread[src]

type Type = Thread

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

fn make_forall_type(vm: &Thread) -> ArcType<Symbol>[src]

fn make_type(vm: &Thread) -> ArcType<Symbol>[src]

Creates an gluon type which maps to Self in rust

fn extra_args() -> u32[src]

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

impl ThreadInternal for Thread[src]

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

Roots a value

fn execute_io(
    &'vm self,
    value: Variants
) -> Either<FutureResult<<Execute<RootedThread> as Future>::Item, <Execute<RootedThread> as Future>::Error>, Execute<RootedThread>>
[src]

Calls a module, allowed to to run IO expressions

fn call_function(
    &'b self,
    context: OwnedContext<'b>,
    args: u32
) -> Result<Async<Option<OwnedContext<'b>>>, Error>
[src]

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 call_thunk_top(
    &'vm self,
    closure: GcPtr<ClosureData>
) -> Box<dyn Future<Item = RootedValue<RootedThread>, Error = Error> + 'static + Send> where
    Self: Send + Sync
[src]

fn execute_io_top(
    &'vm self,
    value: Variants
) -> Box<dyn Future<Item = RootedValue<RootedThread>, Error = Error> + 'static + Send> where
    Self: Send + Sync
[src]

impl<'de> DeserializeState<'de, DeSeed> for Thread[src]

impl Userdata for Thread[src]

fn deep_clone(
    &self,
    deep_cloner: &mut Cloner
) -> Result<GcPtr<Box<dyn Userdata + 'static>>, Error>
[src]

Auto Trait Implementations

impl Send for Thread

impl Sync for Thread

Blanket Implementations

impl<T> From for T[src]

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Any for T where
    T: Any
[src]

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

fn async_status_push(
    self,
    context: &mut ActiveThread<'vm>,
    frame_index: u32
) -> Status
[src]

impl<'vm, T> Pushable for T where
    T: Userdata
[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]

impl<D, T> FromPtr for T[src]

impl<Choices> CoproductSubsetter for Choices[src]

type Remainder = Choices

impl<Source> Sculptor for Source[src]

type Remainder = Source

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

impl<T> Any for T where
    T: Any
[src]

impl<T> Erased for T[src]