Struct gluon::Thread

pub struct Thread { /* fields omitted */ }

Representation of the virtual machine

Methods

impl Thread

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

fn root_thread(&self) -> RootedThread

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

fn define_global<'vm, T>(&'vm self, name: &str, value: T) -> Result<(), Error> where T: Pushable<'vm> + VmType

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

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

Retrieves the global called name. Fails if the global does not exist or it does not have the correct type.

fn find_type_info(&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)

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

Returns the gluon type that was bound to T

fn register_type<T>(&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

fn get_env(&'b self) -> RwLockReadGuard<'b, VmEnv>

Locks and retrieves the global environment of the vm

fn get_macros(&self) -> &MacroEnv

Retrieves the macros defined for this vm

fn collect(&self)

Runs a garbage collection.

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

Pushes a value to the top of the stack

fn pop(&self)

Removes the top value from the stack

fn set_memory_limit(&self, memory_limit: usize)

Trait Implementations

impl Traverseable for Thread

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

impl PartialEq<Thread> for Thread

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

impl Userdata for Thread

fn deep_clone(&self,
              visited: &mut HashMap<*const (), Value, BuildHasherDefault<FnvHasher>>,
              gc: &mut Gc,
              thread: &Thread)
              -> Result<GcPtr<Box<Userdata + 'static>>, Error>

impl VmType for Thread

type Type = Thread

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

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

Creates an gluon type which maps to Self in rust

fn extra_args() -> u32

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

impl Debug for Thread

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

Formats the value using the given formatter.

impl ThreadInternal for Thread

fn context(&self) -> OwnedContext

Locks and retrives this threads stack

fn root<T>(&'vm self, v: GcPtr<Box<Userdata + 'static>>) -> Option<Root<'vm, T>> where T: Userdata

Roots a userdata

fn root_string(&'vm self, ptr: GcPtr<Str>) -> RootStr<'vm>

Roots a string

fn root_value(&self, value: Value) -> RootedValue<RootedThread>

Roots a value

fn root_value_ref(&self, value: Value) -> RootedValue<&Thread>

Roots a value

fn add_bytecode(&self,
                name: &str,
                typ: ArcType<Symbol>,
                args: u32,
                instructions: Vec<Instruction>)
                -> Result<(), Error>

fn call_thunk(&self, closure: GcPtr<ClosureData>) -> Result<Value, Error>

Evaluates a zero argument function (a thunk)

fn execute_io(&self, value: Value) -> Result<Value, Error>

Calls a module, allowed to to run IO expressions

fn call_function(&'b self,
                 context: OwnedContext<'b>,
                 args: u32)
                 -> 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) -> Result<(), Error>

fn global_env(&self) -> &Arc<GlobalVmState>

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

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