Struct gluon::RootedThread
[−]
[src]
pub struct RootedThread(_);
An instance of Thread
which is rooted. See the Thread
type for documentation on interacting
with the type.
Methods
impl RootedThread
[src]
fn new() -> RootedThread
[src]
Creates a new virtual machine with an empty global environment
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
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>
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
fn root_thread(&self) -> RootedThread
[src]
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,
[src]
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,
[src]
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>
[src]
&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,
[src]
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,
[src]
&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>
[src]
Locks and retrieves the global environment of the vm
fn get_macros(&self) -> &MacroEnv
[src]
Retrieves the macros defined for this vm
fn collect(&self)
[src]
Runs a garbage collection.
fn push<'vm, T>(&'vm self, v: T) -> Result<(), Error> where
T: Pushable<'vm>,
[src]
T: Pushable<'vm>,
Pushes a value to the top of the stack
fn pop(&self)
[src]
Removes the top value from the stack
fn set_memory_limit(&self, memory_limit: usize)
[src]
Trait Implementations
impl Clone for RootedThread
[src]
fn clone(&self) -> RootedThread
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl Traverseable for RootedThread
[src]
impl Drop 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_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 Debug for RootedThread
[src]
fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter.