Struct gluon::Thread

pub struct Thread { /* fields omitted */ }

Representation of the virtual machine

Methods

impl 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::<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.

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 get_global_type(&self, name: &str) -> Result<ArcType<Symbol>, Error>

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 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 allocated_memory(&self) -> usize

pub fn set_memory_limit(&self, memory_limit: usize)

pub fn interrupt(&self)

pub fn interrupted(&self) -> bool

pub fn current_context(&self) -> ActiveThread

Trait Implementations

impl Traverseable for Thread

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

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

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

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

Roots a value

impl Debug for Thread

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

Formats the value using the given formatter.

impl VmType for Thread

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

fn context(&self) -> OwnedContext

Locks and retrives this threads stack

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

Roots a value

fn call_thunk(
    &'vm self,
    closure: GcPtr<ClosureData>
) -> Either<FutureResult<<Execute<RootedThread> as Future>::Item, <Execute<RootedThread> as Future>::Error>, Execute<RootedThread>>

Evaluates a zero argument function (a thunk)

fn execute_io(
    &'vm self,
    value: Variants
) -> Either<FutureResult<<Execute<RootedThread> as Future>::Item, <Execute<RootedThread> as Future>::Error>, Execute<RootedThread>>

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 set_global(
    &self,
    name: Symbol,
    typ: ArcType<Symbol>,
    metadata: Metadata,
    value: Value
) -> Result<(), Error>

fn deep_clone_value(
    &self,
    owner: &Thread,
    value: Variants
) -> 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 call_thunk_top(
    &'vm self,
    closure: GcPtr<ClosureData>
) -> Box<dyn Future<Item = RootedValue<RootedThread>, Error = Error> + 'static + Send> where
    Self: Send + Sync, 

fn execute_io_top(
    &'vm self,
    value: Variants
) -> Box<dyn Future<Item = RootedValue<RootedThread>, Error = Error> + 'static + Send> where
    Self: Send + Sync, 

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

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

Deserializes Self using seed and the deserializer

impl PartialEq<Thread> for Thread

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl SerializeState<SeSeed> for Thread

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

Placeholder

impl Userdata for Thread

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