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/int.glu" "#)
    .sync_or_error()
    .unwrap();
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.

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

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

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

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

impl PartialEq<Thread> for Thread

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

impl Debug for Thread

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

Formats the value using the given formatter.