Trait glsp_engine::FromVal

pub trait FromVal: Sized + StaticMarker {
    pub fn from_val(val: &Val) -> GResult<Self>;
}

A type which can be converted from a GameLisp value.

Many functions in the glsp crate have a generic return value R: FromVal. They can automatically convert their return value to many different Rust types.

let numbers: Vec<u8> = glsp::global("numbers")?;
let text: Root<Str> = arr.pop()?;

Writing T::from_val(v)? is usually the most convenient way to destructure a Val. FromVal is part of the prelude, so there's usually no need to import it into scope.

let f = f64::from_val(val)?;

We provide FromVal implementations for many common types, including all of Rust's primitive integer and floating-point types; primitive Rust types like bool; most standard collections, including arrays, slices and tuples; Root and RRoot; type-erased enums like Deque and Callable; and owned string types, including PathBuf, OsString and CString.

You can also implement FromVal for your own types, which will enable them to take advantage of automatic conversions when they're bound as an RFn parameter.

Implementing FromVal 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 FromVal for Rgb {
	fn from_val(val: &Val) -> GResult<Rgb> {
		let (r, g, b) = <(u8, u8, u8)>::from_val(val)?; 
		Ok(Rgb(r, g, b))
	}
}

fn describe_rgb(rgb: Rgb) {
	let Rgb(r, g, b) = rgb;
	println!("Red: {}\nGreen: {}\nBlue: {}", r, g, b);
}

glsp::bind_rfn("describe-rgb", &describe_rgb)?;

//calling (describe-rgb '(32 178 178)) from a GameLisp script will
//automatically invoke Rgb::from_val, converting the array of three
//integers into an Rgb struct

Required methods

pub fn from_val(val: &Val) -> GResult<Self>

Loading content...

Implementations on Foreign Types

impl FromVal for i32

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for i64

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for i128

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for isize

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for char

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for bool

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for i8

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for i16

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for u8

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for u16

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for u32

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for u64

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for u128

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for usize

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for f32

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for f64

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Ordering

pub fn from_val(val: &Val) -> GResult<Self>

impl<T: FromVal> FromVal for Vec<T>

pub fn from_val(val: &Val) -> GResult<Self>

impl<T: FromVal> FromVal for VecDeque<T>

pub fn from_val(val: &Val) -> GResult<Self>

impl<A> FromVal for SmallVec<A> where
    A: Array + StaticMarker,
    A::Item: FromVal, 

pub fn from_val(val: &Val) -> GResult<Self>

impl<T: FromVal, const N: usize> FromVal for [T; N]

pub fn from_val(val: &Val) -> GResult<[T; N]>

impl<A> FromVal for (A,) where
    A: FromVal, 

pub fn from_val(val: &Val) -> GResult<(A,)>

impl<A, B> FromVal for (A, B) where
    A: FromVal,
    B: FromVal, 

pub fn from_val(val: &Val) -> GResult<(A, B)>

impl<A, B, C> FromVal for (A, B, C) where
    A: FromVal,
    B: FromVal,
    C: FromVal, 

pub fn from_val(val: &Val) -> GResult<(A, B, C)>

impl<A, B, C, D> FromVal for (A, B, C, D) where
    A: FromVal,
    B: FromVal,
    C: FromVal,
    D: FromVal, 

pub fn from_val(val: &Val) -> GResult<(A, B, C, D)>

impl<A, B, C, D, E> FromVal for (A, B, C, D, E) where
    A: FromVal,
    B: FromVal,
    C: FromVal,
    D: FromVal,
    E: FromVal, 

pub fn from_val(val: &Val) -> GResult<(A, B, C, D, E)>

impl<A, B, C, D, E, F> FromVal for (A, B, C, D, E, F) where
    A: FromVal,
    B: FromVal,
    C: FromVal,
    D: FromVal,
    E: FromVal,
    F: FromVal, 

pub fn from_val(val: &Val) -> GResult<(A, B, C, D, E, F)>

impl<A, B, C, D, E, F, G> FromVal for (A, B, C, D, E, F, G) where
    A: FromVal,
    B: FromVal,
    C: FromVal,
    D: FromVal,
    E: FromVal,
    F: FromVal,
    G: FromVal, 

pub fn from_val(val: &Val) -> GResult<(A, B, C, D, E, F, G)>

impl<A, B, C, D, E, F, G, H> FromVal for (A, B, C, D, E, F, G, H) where
    A: FromVal,
    B: FromVal,
    C: FromVal,
    D: FromVal,
    E: FromVal,
    F: FromVal,
    G: FromVal,
    H: FromVal, 

pub fn from_val(val: &Val) -> GResult<(A, B, C, D, E, F, G, H)>

impl<A, B, C, D, E, F, G, H, I> FromVal for (A, B, C, D, E, F, G, H, I) where
    A: FromVal,
    B: FromVal,
    C: FromVal,
    D: FromVal,
    E: FromVal,
    F: FromVal,
    G: FromVal,
    H: FromVal,
    I: FromVal, 

pub fn from_val(val: &Val) -> GResult<(A, B, C, D, E, F, G, H, I)>

impl<A, B, C, D, E, F, G, H, I, J> FromVal for (A, B, C, D, E, F, G, H, I, J) where
    A: FromVal,
    B: FromVal,
    C: FromVal,
    D: FromVal,
    E: FromVal,
    F: FromVal,
    G: FromVal,
    H: FromVal,
    I: FromVal,
    J: FromVal, 

pub fn from_val(val: &Val) -> GResult<(A, B, C, D, E, F, G, H, I, J)>

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

pub fn from_val(val: &Val) -> GResult<(A, B, C, D, E, F, G, H, I, J, K)>

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

pub fn from_val(val: &Val) -> GResult<(A, B, C, D, E, F, G, H, I, J, K, L)>

impl FromVal for String

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for CString

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for PathBuf

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for OsString

pub fn from_val(val: &Val) -> GResult<Self>

impl<K, V, S> FromVal for HashMap<K, V, S> where
    K: HashEqMarker + FromVal + StaticMarker,
    V: FromVal + StaticMarker,
    S: BuildHasherDefaultMarker + StaticMarker, 

pub fn from_val(val: &Val) -> GResult<Self>

impl<K, V> FromVal for BTreeMap<K, V> where
    K: OrdMarker + FromVal + StaticMarker,
    V: FromVal + StaticMarker, 

pub fn from_val(val: &Val) -> GResult<Self>

Loading content...

Implementors

impl FromVal for Callable

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Deque

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for EnvMode

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Expander

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Iterable

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Num

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Val

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Root<Arr>

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Root<Class>

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Root<Coro>

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Root<GFn>

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Root<GIter>

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Root<Obj>

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Root<RData>

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Root<RFn>

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Root<Str>

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Root<Tab>

pub fn from_val(val: &Val) -> GResult<Self>

impl FromVal for Sym

pub fn from_val(val: &Val) -> GResult<Self>

impl<T: StaticMarker> FromVal for RRoot<T>

pub fn from_val(val: &Val) -> GResult<RRoot<T>>

Loading content...