Struct gluon::RootedThread

pub struct RootedThread(_);

An instance of Thread which is rooted. See the Thread type for documentation on interacting with the type.

Methods

impl RootedThread

fn new() -> RootedThread

Creates a new virtual machine with an empty global environment

fn into_raw(self) -> *const Thread

Converts a RootedThread into a raw pointer allowing to be passed through a C api. The reference count for the thread is not modified

unsafe fn from_raw(ptr: *const Thread) -> RootedThread

Converts a raw pointer into a RootedThread. The reference count for the thread is not modified so it is up to the caller to ensure that the count is correct.

Methods from Deref<Target = 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 Clone for RootedThread

fn clone(&self) -> RootedThread

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Traverseable for RootedThread

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

impl Drop for RootedThread

fn drop(&mut self)

impl VmType for RootedThread

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 RootedThread

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

Formats the value using the given formatter.

impl Deref for RootedThread

type Target = Thread

fn deref(&self) -> &Thread

impl<'a> VmRoot<'a> for RootedThread

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

impl<'vm> Pushable<'vm> for RootedThread

fn push(self, _vm: &'vm Thread, context: &mut Context) -> Result<(), Error>