[][src]Struct gluon::RootedThread

pub struct RootedThread(_);

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


impl RootedThread[src]

pub fn new() -> RootedThread[src]

Creates a new virtual machine with an empty global environment

pub fn with_global_state(global_state: GlobalVmState) -> RootedThread[src]

pub fn into_raw(self) -> *const Thread[src]

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[src]

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>[src]

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[src]

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.


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

Retrieves the global called name.


Bind the (+) function in gluon's prelude standard library to an add function in rust

let vm = new_vm();

    .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> =
let result = add.call(1, 2);
assert_eq!(result, Ok(3));


if the global does not exist or it does not have the correct type.

pub fn get_global_type(&self, name: &str) -> Result<ArcType<Symbol>, Error>[src]

pub fn find_type_info(
    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>(
    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(
    name: Symbol,
    alias: Alias<Symbol, ArcType<Symbol>>,
    id: TypeId
) -> Result<ArcType<Symbol>, Error>

pub fn cache_alias(
    alias: Alias<Symbol, ArcType<Symbol>>
) -> ArcType<Symbol>

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

Locks and retrieves the global environment of the vm

pub fn get_macros(&self) -> &MacroEnv[src]

Retrieves the macros defined for this vm

pub fn collect(&self)[src]

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)[src]

Removes the top value from the stack

pub fn allocated_memory(&self) -> usize[src]

pub fn set_memory_limit(&self, memory_limit: usize)[src]

pub fn interrupt(&self)[src]

pub fn interrupted(&self) -> bool[src]

pub fn current_context(&self) -> ActiveThread[src]

Trait Implementations

impl Drop for RootedThread[src]

impl<'vm, 'value> Getable<'vm, 'value> for RootedThread[src]

type Proxy = Variants<'value>

impl<'a> VmRoot<'a> for RootedThread[src]

fn root_value_with_self(self, value: Variants) -> RootedValue<Self>[src]

Roots a value

impl SerializeState<SeSeed> for RootedThread[src]

impl Debug for RootedThread[src]

impl VmType for RootedThread[src]

type Type = Thread

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

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

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

Creates an gluon type which maps to Self in rust

fn extra_args() -> u32[src]

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 Read more

impl Deref for RootedThread[src]

type Target = Thread

The resulting type after dereferencing.

impl<'vm> Pushable<'vm> for RootedThread[src]

fn status_push(self, context: &mut ActiveThread<'vm>) -> Status[src]

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

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

impl Clone for RootedThread[src]

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

Performs copy-assignment from source. Read more

impl Traverseable for RootedThread[src]

impl<'de> DeserializeState<'de, DeSeed> for RootedThread[src]

Auto Trait Implementations

impl Send for RootedThread

impl Sync for RootedThread

Blanket Implementations

impl<T> From for T[src]

impl<T, U> Into for T where
    U: From<T>, 

impl<T> ToOwned for T where
    T: Clone

type Owned = T

impl<T, U> TryFrom for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> BorrowMut for T where
    T: ?Sized

impl<T, U> TryInto for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Any for T where
    T: Any

impl<T> CloneAny for T where
    T: Clone + Any

impl<'vm, T> Pushable for T where
    T: Userdata

fn status_push(self, context: &mut ActiveThread<'vm>) -> Status[src]

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

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

impl<'vm, T> AsyncPushable for T where
    T: Pushable<'vm>, 

fn async_status_push(
    context: &mut ActiveThread<'vm>,
    frame_index: u32
) -> Status

impl<D, T> FromPtr for T[src]

impl<Choices> CoproductSubsetter for Choices[src]

type Remainder = Choices

impl<Source> Sculptor for Source[src]

type Remainder = Source

impl<T, U, I> LiftInto for T where
    U: LiftFrom<T, I>, 

impl<T> Any for T where
    T: Any

impl<T> Erased for T[src]