[−][src]Trait glsp::IntoVal

pub trait IntoVal {
    pub fn into_val(self) -> Result<Val, GError>;
}

A type which can be converted to a GameLisp value.

Many functions in the glsp crate receive a generic parameter T: IntoVal. This enables those functions to accept various different Rust types, silently converting those types into a Val.

glsp::set_global("numbers", (0, 1, 2, 3, 4))?;
arr.push("an example string")?;

Invoking a type's into_val method is usually the most convenient way to produce a Val. IntoVal is part of the prelude, so there's no need to import it into scope.

let thousand = 10.0_f64.pow(3.0).into_val()?;

We provide IntoVal implementations for many common types, including all of Rust's primitive integer and floating-point types; primitive Rust types like () and bool; most standard collections, including arrays, slices and tuples; Root and RRoot; type-erased enums like Deque and Callable; shared and mutable references to all of the above; and shared references to primitive GameLisp types like &Arr and &GFn.

Option and Result have special handling, which can be useful for return values:

  • Option will produce a nil value if it's None, or otherwise call into_val() for its Some value.

  • Result will trigger an error if it's Err, or otherwise call into_val() for its Ok value. Non-GameLisp errors are fully supported.

There is a default IntoVal implementation for all 'static types. This implementation moves the Rust value onto the garbage-collected heap, wrapping it in an RData. The conversion returns a Val::RData.

Because this default implementation applies to all 'static types, including those defined in external crates, it's possible to move most foreign types onto the GameLisp heap. For example, to construct a standard Rust File and transfer its ownership to GameLisp, you can simply call:

File::open("my_file.png").into_val()?

If you'd like one of your own types to be represented in GameLisp by something other than an rdata (for example, converting an enum to a GameLisp symbol, or a tuple struct to a GameLisp array), you can implement IntoVal for your type. This will enable automatic conversions when your type is passed to a generic function like glsp::set_global. It will also automatically convert your type into GameLisp data when it's used as an RFn return value.

Implementing IntoVal for your own types currently requires the min_specialization nightly feature. Enable it by writing #![feature(min_specialization)] at the top of your crate's main.rs or lib.rs file.

struct Rgb(u8, u8, u8);

impl IntoVal for Rgb {
	fn into_val(self) -> GResult<Val> {
		let Rgb(r, g, b) = self;
		arr![r, g, b].into_val()
	}
}

fn light_sea_green() -> Rgb {
	Rgb(32, 178, 170)
}

glsp::bind_rfn("light-sea-green", &light_sea_green)?;

//calling (light-sea-green) from a GameLisp script will 
//automatically call Rgb::into_val(), converting the function's
//Rgb return value into an array of three integers, (32 178 178)

When implementing IntoVal for your own types, it's generally a good idea to also provide implementations for shared and mutable references to your type. It makes the borrow checker easier to deal with, and it enables you to bind Rust functions which return references. It's usually straightforward:

impl<'a> IntoVal for &'a MyType {
	fn into_val(self) -> GResult<Val> {
		//...the actual conversion...
	}
}

impl<'a> IntoVal for &'a mut MyType {
	fn into_val(self) -> GResult<Val> {
		(self as &MyType).into_val()
	}
}

impl IntoVal for MyType {
	fn into_val(self) -> GResult<Val> {
		(&self).into_val()
	}
}

Required methods

pub fn into_val(self) -> Result<Val, GError>[src]

Loading content...

Implementations on Foreign Types

impl<'a, A> IntoVal for &'a mut (A,) where
    &'a mut A: IntoVal, [src]

impl IntoVal for i32[src]

impl<T> IntoVal for Option<T> where
    T: IntoVal, [src]

impl IntoVal for char[src]

impl<'a, T> IntoVal for &'a [T] where
    &'a T: IntoVal, [src]

impl<A, B, C, D, E, F, G> IntoVal for (A, B, C, D, E, F, G) where
    C: IntoVal,
    E: IntoVal,
    F: IntoVal,
    B: IntoVal,
    A: IntoVal,
    G: IntoVal,
    D: IntoVal, [src]

impl<'a, A, B, C, D, E, F, G, H> IntoVal for &'a (A, B, C, D, E, F, G, H) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal,
    &'a H: IntoVal, [src]

impl IntoVal for u64[src]

impl<A, B, C, D, E, F, G, H, I, J, K> IntoVal for (A, B, C, D, E, F, G, H, I, J, K) where
    C: IntoVal,
    E: IntoVal,
    F: IntoVal,
    B: IntoVal,
    I: IntoVal,
    A: IntoVal,
    K: IntoVal,
    G: IntoVal,
    H: IntoVal,
    D: IntoVal,
    J: IntoVal, [src]

impl<'a> IntoVal for &'a mut OsString[src]

impl<'a> IntoVal for &'a CString[src]

impl IntoVal for ()[src]

impl<'a> IntoVal for &'a mut f32[src]

impl<'a> IntoVal for &'a mut u8[src]

impl IntoVal for i16[src]

impl IntoVal for String[src]

impl<'a> IntoVal for &'a mut CStr[src]

impl<'a> IntoVal for &'a mut ()[src]

impl<'a, A, B, C, D, E, F, G> IntoVal for &'a (A, B, C, D, E, F, G) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal, [src]

impl<A, B, C, D> IntoVal for (A, B, C, D) where
    C: IntoVal,
    B: IntoVal,
    A: IntoVal,
    D: IntoVal, [src]

impl<'a, A, B, C> IntoVal for &'a (A, B, C) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal, [src]

impl<'a, A, B, C, D, E, F, G> IntoVal for &'a mut (A, B, C, D, E, F, G) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal, [src]

impl<'a, K, V> IntoVal for &'a mut BTreeMap<K, V> where
    &'a K: IntoVal,
    &'a mut V: IntoVal, [src]

impl<'a, A, B, C, D, E, F, G, H, I, J> IntoVal for &'a (A, B, C, D, E, F, G, H, I, J) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal,
    &'a H: IntoVal,
    &'a I: IntoVal,
    &'a J: IntoVal, [src]

impl<A, B, C, D, E> IntoVal for (A, B, C, D, E) where
    C: IntoVal,
    E: IntoVal,
    B: IntoVal,
    A: IntoVal,
    D: IntoVal, [src]

impl<K, V> IntoVal for BTreeMap<K, V> where
    V: IntoVal,
    K: IntoVal, [src]

impl IntoVal for f64[src]

impl<K, V, S> IntoVal for HashMap<K, V, S> where
    V: IntoVal,
    K: IntoVal, [src]

impl<'a, A, B, C, D, E, F, G, H> IntoVal for &'a mut (A, B, C, D, E, F, G, H) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal,
    &'a mut H: IntoVal, [src]

impl<'a, A, B, C, D, E, F> IntoVal for &'a (A, B, C, D, E, F) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal, [src]

impl<'a> IntoVal for &'a mut i16[src]

impl<'a> IntoVal for &'a OsStr[src]

impl<A, B, C, D, E, F> IntoVal for (A, B, C, D, E, F) where
    C: IntoVal,
    E: IntoVal,
    F: IntoVal,
    B: IntoVal,
    A: IntoVal,
    D: IntoVal, [src]

impl<'a, T, const N: usize> IntoVal for &'a [T; N] where
    &'a T: IntoVal, [src]

impl<'a> IntoVal for &'a mut u16[src]

impl<A> IntoVal for SmallVec<A> where
    A: Array,
    <A as Array>::Item: IntoVal, [src]

impl IntoVal for u8[src]

impl<A, B, C> IntoVal for (A, B, C) where
    C: IntoVal,
    B: IntoVal,
    A: IntoVal, [src]

impl IntoVal for isize[src]

impl<T, E> IntoVal for Result<T, E> where
    E: StaticMarker + ErrorMarker,
    T: IntoVal, [src]

impl<'a> IntoVal for &'a mut OsStr[src]

impl<'a> IntoVal for &'a mut char[src]

impl<'a> IntoVal for &'a i32[src]

impl<'a> IntoVal for &'a mut PathBuf[src]

impl<'a, A, B> IntoVal for &'a (A, B) where
    &'a A: IntoVal,
    &'a B: IntoVal, [src]

impl IntoVal for u32[src]

impl<'a, A, B, C, D, E, F, G, H, I, J> IntoVal for &'a mut (A, B, C, D, E, F, G, H, I, J) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal,
    &'a mut H: IntoVal,
    &'a mut I: IntoVal,
    &'a mut J: IntoVal, [src]

impl<'a, A, B, C, D, E, F, G, H, I> IntoVal for &'a mut (A, B, C, D, E, F, G, H, I) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal,
    &'a mut H: IntoVal,
    &'a mut I: IntoVal, [src]

impl<'a> IntoVal for &'a mut CString[src]

impl<'a> IntoVal for &'a PathBuf[src]

impl<'a> IntoVal for &'a mut Ordering[src]

impl IntoVal for f32[src]

impl IntoVal for u128[src]

impl IntoVal for bool[src]

impl<A, B> IntoVal for (A, B) where
    B: IntoVal,
    A: IntoVal, [src]

impl<'a, T> IntoVal for &'a mut VecDeque<T> where
    &'a mut T: IntoVal, [src]

impl<'a> IntoVal for &'a mut i32[src]

impl<'a, K, V, S> IntoVal for &'a mut HashMap<K, V, S> where
    &'a K: IntoVal,
    &'a mut V: IntoVal, [src]

impl IntoVal for i128[src]

impl<'a, A> IntoVal for &'a mut SmallVec<A> where
    A: Array,
    &'a mut <A as Array>::Item: IntoVal, [src]

impl IntoVal for PathBuf[src]

impl<'a> IntoVal for &'a u8[src]

impl<'a, K, V, S> IntoVal for &'a HashMap<K, V, S> where
    &'a K: IntoVal,
    &'a V: IntoVal, [src]

impl IntoVal for CString[src]

impl IntoVal for Ordering[src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K> IntoVal for &'a mut (A, B, C, D, E, F, G, H, I, J, K) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal,
    &'a mut H: IntoVal,
    &'a mut I: IntoVal,
    &'a mut J: IntoVal,
    &'a mut K: IntoVal, [src]

impl<A, B, C, D, E, F, G, H, I, J> IntoVal for (A, B, C, D, E, F, G, H, I, J) where
    C: IntoVal,
    E: IntoVal,
    F: IntoVal,
    B: IntoVal,
    I: IntoVal,
    A: IntoVal,
    G: IntoVal,
    H: IntoVal,
    D: IntoVal,
    J: IntoVal, [src]

impl<'a, A, B, C, D, E, F> IntoVal for &'a mut (A, B, C, D, E, F) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal, [src]

impl<'a> IntoVal for &'a mut str[src]

impl<A, B, C, D, E, F, G, H> IntoVal for (A, B, C, D, E, F, G, H) where
    C: IntoVal,
    E: IntoVal,
    F: IntoVal,
    B: IntoVal,
    A: IntoVal,
    G: IntoVal,
    H: IntoVal,
    D: IntoVal, [src]

impl<T> IntoVal for Vec<T, Global> where
    T: IntoVal, [src]

impl IntoVal for usize[src]

impl<'a> IntoVal for &'a bool[src]

impl IntoVal for i8[src]

impl<A, B, C, D, E, F, G, H, I> IntoVal for (A, B, C, D, E, F, G, H, I) where
    C: IntoVal,
    E: IntoVal,
    F: IntoVal,
    B: IntoVal,
    I: IntoVal,
    A: IntoVal,
    G: IntoVal,
    H: IntoVal,
    D: IntoVal, [src]

impl<'a, A, B, C, D, E> IntoVal for &'a mut (A, B, C, D, E) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal, [src]

impl<'a, A> IntoVal for &'a (A,) where
    &'a A: IntoVal, [src]

impl<'a, T, const N: usize> IntoVal for &'a mut [T; N] where
    &'a mut T: IntoVal, [src]

impl<'a, A> IntoVal for &'a SmallVec<A> where
    A: Array,
    &'a <A as Array>::Item: IntoVal, [src]

impl<'a> IntoVal for &'a mut String[src]

impl<'a, K, V> IntoVal for &'a BTreeMap<K, V> where
    &'a K: IntoVal,
    &'a V: IntoVal, [src]

impl<'a, A, B, C, D> IntoVal for &'a (A, B, C, D) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal, [src]

impl<'a, A, B, C, D, E, F, G, H, I> IntoVal for &'a (A, B, C, D, E, F, G, H, I) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal,
    &'a H: IntoVal,
    &'a I: IntoVal, [src]

impl<'a> IntoVal for &'a f32[src]

impl<'a> IntoVal for &'a CStr[src]

impl<'a, T> IntoVal for &'a Vec<T, Global> where
    &'a T: IntoVal, [src]

impl<'a, A, B, C> IntoVal for &'a mut (A, B, C) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal, [src]

impl IntoVal for i64[src]

impl<'a> IntoVal for &'a Ordering[src]

impl<'a, A, B, C, D> IntoVal for &'a mut (A, B, C, D) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal, [src]

impl IntoVal for OsString[src]

impl<'a, A, B, C, D, E> IntoVal for &'a (A, B, C, D, E) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal, [src]

impl<'a> IntoVal for &'a i16[src]

impl<'a, T> IntoVal for &'a Option<T> where
    &'a T: IntoVal, [src]

impl<'a> IntoVal for &'a mut bool[src]

impl<T> IntoVal for VecDeque<T> where
    T: IntoVal, [src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> IntoVal for &'a mut (A, B, C, D, E, F, G, H, I, J, K, L) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal,
    &'a mut C: IntoVal,
    &'a mut D: IntoVal,
    &'a mut E: IntoVal,
    &'a mut F: IntoVal,
    &'a mut G: IntoVal,
    &'a mut H: IntoVal,
    &'a mut I: IntoVal,
    &'a mut J: IntoVal,
    &'a mut K: IntoVal,
    &'a mut L: IntoVal, [src]

impl<'a, A, B> IntoVal for &'a mut (A, B) where
    &'a mut A: IntoVal,
    &'a mut B: IntoVal, [src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K> IntoVal for &'a (A, B, C, D, E, F, G, H, I, J, K) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal,
    &'a H: IntoVal,
    &'a I: IntoVal,
    &'a J: IntoVal,
    &'a K: IntoVal, [src]

impl<'a> IntoVal for &'a i8[src]

impl<A, B, C, D, E, F, G, H, I, J, K, L> IntoVal for (A, B, C, D, E, F, G, H, I, J, K, L) where
    C: IntoVal,
    E: IntoVal,
    F: IntoVal,
    B: IntoVal,
    I: IntoVal,
    A: IntoVal,
    K: IntoVal,
    G: IntoVal,
    H: IntoVal,
    D: IntoVal,
    J: IntoVal,
    L: IntoVal, [src]

impl<T, const N: usize> IntoVal for [T; N] where
    &'a T: for<'a> IntoVal, [src]

impl<'a> IntoVal for &'a mut Path[src]

impl<A> IntoVal for (A,) where
    A: IntoVal, [src]

impl<'a> IntoVal for &'a String[src]

impl<'a> IntoVal for &'a u16[src]

impl<'a, T> IntoVal for &'a mut Vec<T, Global> where
    &'a mut T: IntoVal, [src]

impl<'a, T> IntoVal for &'a mut Option<T> where
    &'a mut T: IntoVal, [src]

impl<'a, A, B, C, D, E, F, G, H, I, J, K, L> IntoVal for &'a (A, B, C, D, E, F, G, H, I, J, K, L) where
    &'a A: IntoVal,
    &'a B: IntoVal,
    &'a C: IntoVal,
    &'a D: IntoVal,
    &'a E: IntoVal,
    &'a F: IntoVal,
    &'a G: IntoVal,
    &'a H: IntoVal,
    &'a I: IntoVal,
    &'a J: IntoVal,
    &'a K: IntoVal,
    &'a L: IntoVal, [src]

impl IntoVal for u16[src]

impl<'a> IntoVal for &'a Path[src]

impl<'a> IntoVal for &'a ()[src]

impl<'a> IntoVal for &'a char[src]

impl<'a> IntoVal for &'a str[src]

impl<'a> IntoVal for &'a mut i8[src]

impl<'a, T> IntoVal for &'a mut [T] where
    &'a mut T: IntoVal, [src]

impl<'a, T> IntoVal for &'a VecDeque<T> where
    &'a T: IntoVal, [src]

impl<'a> IntoVal for &'a OsString[src]

Loading content...

Implementors

impl IntoVal for Callable[src]

impl IntoVal for Deque[src]

impl IntoVal for Expander[src]

impl IntoVal for GIterLen[src]

impl IntoVal for Iterable[src]

impl IntoVal for Num[src]

impl IntoVal for Val[src]

impl IntoVal for Root<Arr>[src]

impl IntoVal for Root<Class>[src]

impl IntoVal for Root<Coro>[src]

impl IntoVal for Root<GFn>[src]

impl IntoVal for Root<GIter>[src]

impl IntoVal for Root<Obj>[src]

impl IntoVal for Root<RData>[src]

impl IntoVal for Root<RFn>[src]

impl IntoVal for Root<Str>[src]

impl IntoVal for Root<Tab>[src]

impl IntoVal for Sym[src]

impl<'a> IntoVal for &'a Callable[src]

impl<'a> IntoVal for &'a Deque[src]

impl<'a> IntoVal for &'a Expander[src]

impl<'a> IntoVal for &'a GIterLen[src]

impl<'a> IntoVal for &'a Iterable[src]

impl<'a> IntoVal for &'a Val[src]

impl<'a> IntoVal for &'a Root<Arr>[src]

impl<'a> IntoVal for &'a Root<Class>[src]

impl<'a> IntoVal for &'a Root<Coro>[src]

impl<'a> IntoVal for &'a Root<GFn>[src]

impl<'a> IntoVal for &'a Root<GIter>[src]

impl<'a> IntoVal for &'a Root<Obj>[src]

impl<'a> IntoVal for &'a Root<RData>[src]

impl<'a> IntoVal for &'a Root<RFn>[src]

impl<'a> IntoVal for &'a Root<Str>[src]

impl<'a> IntoVal for &'a Root<Tab>[src]

impl<'a> IntoVal for &'a Sym[src]

impl<'a> IntoVal for &'a mut Callable[src]

impl<'a> IntoVal for &'a mut Deque[src]

impl<'a> IntoVal for &'a mut Expander[src]

impl<'a> IntoVal for &'a mut GIterLen[src]

impl<'a> IntoVal for &'a mut Iterable[src]

impl<'a> IntoVal for &'a mut Val[src]

impl<'a> IntoVal for &'a mut Root<Arr>[src]

impl<'a> IntoVal for &'a mut Root<Class>[src]

impl<'a> IntoVal for &'a mut Root<Coro>[src]

impl<'a> IntoVal for &'a mut Root<GFn>[src]

impl<'a> IntoVal for &'a mut Root<GIter>[src]

impl<'a> IntoVal for &'a mut Root<Obj>[src]

impl<'a> IntoVal for &'a mut Root<RData>[src]

impl<'a> IntoVal for &'a mut Root<RFn>[src]

impl<'a> IntoVal for &'a mut Root<Str>[src]

impl<'a> IntoVal for &'a mut Root<Tab>[src]

impl<'a> IntoVal for &'a mut Sym[src]

impl<'a, T> IntoVal for &'a RRoot<T>[src]

impl<'a, T> IntoVal for &'a mut RRoot<T>[src]

impl<T> IntoVal for RRoot<T>[src]

impl<T> IntoVal for T where
    T: StaticMarker, [src]

Loading content...