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

pub fn new() -> RootedThread

Creates a new virtual machine with an empty global environment

pub fn with_global_state(global_state: GlobalVmState) -> RootedThread

pub 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

pub 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>

pub 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

pub fn root_thread(&self) -> RootedThread

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,

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_async::<i32>(&vm, "example", "factorial 5")
    .sync_or_error()
    .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> + 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::<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 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)

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

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,

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>

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

Locks and retrieves the global environment of the vm

pub fn get_macros(&self) -> &MacroEnv

Retrieves the macros defined for this vm

pub fn get_event_loop(&self) -> Option<Remote>

pub fn collect(&self)

Runs a garbage collection.

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

Pushes a value to the top of the stack

pub fn pop(&self)

Removes the top value from the stack

pub fn set_memory_limit(&self, memory_limit: usize)

pub fn interrupt(&self)

pub fn interrupted(&self) -> bool

Trait Implementations

impl<'vm> Getable<'vm> for RootedThread

fn from_value(&'vm Thread, value: Variants) -> RootedThread

unsafe fn from_value_unsafe(vm: &'vm Thread, value: Variants) -> Self

unsafe version of from_value which allows references to the internal of GcPtr's to be extracted if value is rooted

impl VmType for RootedThread

type Type = Thread

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

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

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 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 Debug for RootedThread

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

Formats the value using the given formatter.

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

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

fn root_value_with_self(self, value: Value) -> RootedValue<Self>

Roots a value

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

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

Pushes self to stack. If the call is successful a single element should have been added to the stack and Ok(()) should be returned. If the call is unsuccessful Status:Error should be returned and the stack should be left intact

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value, Error>

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>, Error> where     T: VmRoot<'vm>,

impl Deref for RootedThread

type Target = Thread

The resulting type after dereferencing.

fn deref(&self) -> &Thread

Dereferences the value.

impl Traverseable for RootedThread

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

impl SerializeState<SeSeed> for RootedThread

fn serialize_state<__S>(     &self,     __serializer: __S,     __seed: &SeSeed ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where     __S: Serializer,

Placeholder

impl Drop for RootedThread

fn drop(&mut self)

Executes the destructor for this type.

impl<'de> DeserializeState<'de, DeSeed> for RootedThread

fn deserialize_state<__D>(     __seed: &mut DeSeed,     __deserializer: __D ) -> Result<RootedThread, <__D as Deserializer<'de>>::Error> where     __D: Deserializer<'de>,

Deserializes Self using seed and the deserializer