[−][src]Trait glsp::FromVal

pub trait FromVal {
    fn from_val(val: &Val) -> Result<Self, GError>;
}

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()?;

Implementing the FromVal trait for your own types will also enable them to take advantage of automatic conversions for RFn arguments.

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 invert(src: Rgb) -> Rgb {
	let Rgb(r, g, b) = src;
	Rgb(255 - r, 255 - g, 255 - b)
}

glsp::bind_rfn("invert", rfn!(invert))?;

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

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

Required methods

`fn from_val(val: &Val) -> Result<Self, GError>`

Loading content...

Implementations on Foreign Types

`impl FromVal for Ordering`[src]

`fn from_val(val: &Val) -> Result<Ordering, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Ordering, GError>`[src]

`impl<T> FromVal for [T; 12] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 12], GError>`[src]

`impl FromVal for i128`[src]

`fn from_val(val: &Val) -> Result<i128, GError>`[src]

`fn from_slot(val: &Slot) -> Result<i128, GError>`[src]

`impl<T> FromVal for [T; 14] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 14], GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B), GError>`[src]

`impl<T> FromVal for [T; 3] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 3], GError>`[src]

`impl FromVal for usize`[src]

`fn from_val(val: &Val) -> Result<usize, GError>`[src]

`fn from_slot(val: &Slot) -> Result<usize, GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A,), GError>`[src]

`impl<T> FromVal for [T; 15] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 15], GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B, C, D), GError>`[src]

`impl<T> FromVal for [T; 1] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 1], GError>`[src]

`impl FromVal for i64`[src]

`fn from_val(val: &Val) -> Result<i64, GError>`[src]

`fn from_slot(val: &Slot) -> Result<i64, GError>`[src]

`impl FromVal for PathBuf`[src]

`fn from_val(val: &Val) -> Result<PathBuf, GError>`[src]

`impl<T> FromVal for [T; 5] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 5], GError>`[src]

`impl FromVal for u64`[src]

`fn from_val(val: &Val) -> Result<u64, GError>`[src]

`fn from_slot(val: &Slot) -> Result<u64, GError>`[src]

`impl<T> FromVal for [T; 8] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 8], GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B, C, D, E, F, G, H, I, J, K), GError>`[src]

`impl FromVal for char`[src]

`fn from_val(val: &Val) -> Result<char, GError>`[src]

`fn from_slot(val: &Slot) -> Result<char, GError>`[src]

`impl FromVal for i32`[src]

`fn from_val(val: &Val) -> Result<i32, GError>`[src]

`fn from_slot(val: &Slot) -> Result<i32, GError>`[src]

`impl<T> FromVal for [T; 6] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 6], GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), GError>`[src]

`impl FromVal for isize`[src]

`fn from_val(val: &Val) -> Result<isize, GError>`[src]

`fn from_slot(val: &Slot) -> Result<isize, GError>`[src]

`impl<T> FromVal for Vec<T> where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<Vec<T>, GError>`[src]

`impl<T> FromVal for [T; 10] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 10], GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B, C), GError>`[src]

`impl<T> FromVal for [T; 4] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 4], GError>`[src]

`impl FromVal for u8`[src]

`fn from_val(val: &Val) -> Result<u8, GError>`[src]

`fn from_slot(val: &Slot) -> Result<u8, GError>`[src]

`impl FromVal for bool`[src]

`fn from_val(val: &Val) -> Result<bool, GError>`[src]

`fn from_slot(val: &Slot) -> Result<bool, GError>`[src]

`impl<K, V, S> FromVal for HashMap<K, V, S> where K: Hash + Eq + FromVal, S: BuildHasher + Default, V: FromVal,` [src]

`fn from_val(val: &Val) -> Result<HashMap<K, V, S>, GError>`[src]

`impl<K, V> FromVal for BTreeMap<K, V> where K: FromVal + Ord, V: FromVal,` [src]

`fn from_val(val: &Val) -> Result<BTreeMap<K, V>, GError>`[src]

`impl<T> FromVal for [T; 2] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 2], GError>`[src]

`impl FromVal for f64`[src]

`fn from_val(val: &Val) -> Result<f64, GError>`[src]

`fn from_slot(val: &Slot) -> Result<f64, GError>`[src]

`impl FromVal for OsString`[src]

`fn from_val(val: &Val) -> Result<OsString, GError>`[src]

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

`fn from_val(val: &Val) -> Result<SmallVec<A>, GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B, C, D, E, F), GError>`[src]

`impl<T> FromVal for [T; 11] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 11], GError>`[src]

`impl FromVal for u16`[src]

`fn from_val(val: &Val) -> Result<u16, GError>`[src]

`fn from_slot(val: &Slot) -> Result<u16, GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B, C, D, E, F, G, H, I, J), GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B, C, D, E, F, G, H, I), GError>`[src]

`impl FromVal for f32`[src]

`fn from_val(val: &Val) -> Result<f32, GError>`[src]

`fn from_slot(val: &Slot) -> Result<f32, GError>`[src]

`impl<T> FromVal for [T; 13] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 13], GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B, C, D, E, F, G), GError>`[src]

`impl FromVal for i8`[src]

`fn from_val(val: &Val) -> Result<i8, GError>`[src]

`fn from_slot(val: &Slot) -> Result<i8, GError>`[src]

`impl FromVal for u32`[src]

`fn from_val(val: &Val) -> Result<u32, GError>`[src]

`fn from_slot(val: &Slot) -> Result<u32, GError>`[src]

`impl<T> FromVal for [T; 0] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 0], GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B, C, D, E), GError>`[src]

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

`fn from_val(val: &Val) -> Result<VecDeque<T>, GError>`[src]

`impl FromVal for CString`[src]

`fn from_val(val: &Val) -> Result<CString, GError>`[src]

`impl FromVal for i16`[src]

`fn from_val(val: &Val) -> Result<i16, GError>`[src]

`fn from_slot(val: &Slot) -> Result<i16, GError>`[src]

`impl<T> FromVal for [T; 16] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 16], GError>`[src]

`impl<T> FromVal for [T; 7] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 7], GError>`[src]

`impl FromVal for u128`[src]

`fn from_val(val: &Val) -> Result<u128, GError>`[src]

`fn from_slot(val: &Slot) -> Result<u128, GError>`[src]

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

`fn from_val(val: &Val) -> Result<(A, B, C, D, E, F, G, H), GError>`[src]

`impl<T> FromVal for [T; 9] where T: FromVal,` [src]

`fn from_val(val: &Val) -> Result<[T; 9], GError>`[src]

`impl FromVal for String`[src]

`fn from_val(val: &Val) -> Result<String, GError>`[src]

Loading content...

Implementors

`impl FromVal for Callable`[src]

`fn from_val(val: &Val) -> Result<Callable, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Callable, GError>`[src]

`impl FromVal for Deque`[src]

`fn from_val(val: &Val) -> Result<Deque, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Deque, GError>`[src]

`impl FromVal for EnvMode`[src]

`fn from_val(val: &Val) -> Result<EnvMode, GError>`[src]

`impl FromVal for Expander`[src]

`fn from_val(val: &Val) -> Result<Expander, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Expander, GError>`[src]

`impl FromVal for Iterable`[src]

`fn from_val(val: &Val) -> Result<Iterable, GError>`[src]

`fn from_slot(slot: &Slot) -> Result<Iterable, GError>`[src]

`impl FromVal for Num`[src]

`fn from_val(val: &Val) -> Result<Num, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Num, GError>`[src]

`impl FromVal for Val`[src]

`fn from_val(val: &Val) -> Result<Val, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Val, GError>`[src]

`impl FromVal for RFn`[src]

`fn from_val(val: &Val) -> Result<RFn, GError>`[src]

`fn from_slot(val: &Slot) -> Result<RFn, GError>`[src]

`impl FromVal for Root<Arr>`[src]

`fn from_val(val: &Val) -> Result<Root<Arr>, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Root<Arr>, GError>`[src]

`impl FromVal for Root<Class>`[src]

`fn from_val(val: &Val) -> Result<Root<Class>, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Root<Class>, GError>`[src]

`impl FromVal for Root<Coro>`[src]

`fn from_val(val: &Val) -> Result<Root<Coro>, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Root<Coro>, GError>`[src]

`impl FromVal for Root<GFn>`[src]

`fn from_val(val: &Val) -> Result<Root<GFn>, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Root<GFn>, GError>`[src]

`impl FromVal for Root<GIter>`[src]

`fn from_val(val: &Val) -> Result<Root<GIter>, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Root<GIter>, GError>`[src]

`impl FromVal for Root<Obj>`[src]

`fn from_val(val: &Val) -> Result<Root<Obj>, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Root<Obj>, GError>`[src]

`impl FromVal for Root<RData>`[src]

`fn from_val(val: &Val) -> Result<Root<RData>, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Root<RData>, GError>`[src]

`impl FromVal for Root<Str>`[src]

`fn from_val(val: &Val) -> Result<Root<Str>, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Root<Str>, GError>`[src]

`impl FromVal for Root<Tab>`[src]

`fn from_val(val: &Val) -> Result<Root<Tab>, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Root<Tab>, GError>`[src]

`impl FromVal for Sym`[src]

`fn from_val(val: &Val) -> Result<Sym, GError>`[src]

`fn from_slot(val: &Slot) -> Result<Sym, GError>`[src]

`impl<T> FromVal for RRoot<T> where T: RStore,` [src]

`fn from_val(val: &Val) -> Result<RRoot<T>, GError>`[src]

`fn from_slot(slot: &Slot) -> Result<RRoot<T>, GError>`[src]

Loading content...