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.

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_async::<i32>(&vm, "example", "factorial 5")
    .sync_or_error()
    .unwrap();
let expected = (120, Type::int());

assert_eq!(result, expected);

fn get_global<'vm, T>(&'vm self, name: &str) -> Result<T, Error> where
    T: Getable<'vm> + 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();
Compiler::new()
    .run_expr_async::<OpaqueValue<&Thread, Hole>>(&vm, "example",
        r#" import! "std/prelude.glu" "#)
    .sync_or_error()
    .unwrap();
let mut add: FunctionRef<fn(i32, i32) -> i32> =
    vm.get_global("std.prelude.num_Int.(+)").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.

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 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 PartialEq<Thread> for Thread

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

impl Traverseable for Thread

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

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: GcStr) -> RootStr<'vm>

Roots a string

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

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>
) -> FutureValue<Execute<&Thread>>

Evaluates a zero argument function (a thunk)

fn execute_io(&self, value: Value) -> FutureValue<Execute<&Thread>>

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>

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<Async<OwnedContext>, 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, owner: &Thread, value: Value) -> Result<Value, Error>

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

fn lookup_field(&self, data: &DataStruct, field: &str) -> Result<Value, Error>

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

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

impl Userdata for Thread

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