Struct Val 

pub struct Val(/* private fields */);

Implementations

impl Val

pub const fn can_represent_scval_type(scv_ty: ScValType) -> bool

Some ScVals are not representable as Vals at all, and only exist in the XDR to serve as special storage system key or value payloads managed by the Host.

pub fn can_represent_scval(scv: &ScVal) -> bool

Non-recursively checks whether ScVal can be represented as Val. Since conversions from ScVal are recursive themselves, this should be called at every recursion level during conversion.

pub fn can_represent_scval_recursive(scv: &ScVal) -> bool

Recursively checks whether ScVal can be represented as Val. This should only be used once per top-level ScVal.

pub fn is_good(self) -> bool

We define a “good” Val as one that has one of the allowed tag values, all the defined body-bits for its case set to valid values, and all the undefined body-bits set to zero.

pub const fn get_payload(self) -> u64

pub const fn from_payload(x: u64) -> Val

pub const fn shallow_eq(&self, other: &Val) -> bool

pub const fn get_tag(self) -> Tag

pub const fn is_object(self) -> bool

pub const fn from_void() -> Void

pub const fn from_bool(b: bool) -> Bool

pub const fn is_void(self) -> bool

pub const fn is_true(self) -> bool

pub const fn is_false(self) -> bool

impl Val

pub const I32_ZERO: I32Val

pub const I32_MIN: I32Val

pub const I32_MAX: I32Val

pub const U32_ZERO: U32Val

pub const U32_ONE: U32Val

pub const U32_MIN: U32Val

pub const U32_MAX: U32Val

pub const VOID: Void

pub const TRUE: Bool

pub const FALSE: Bool

impl Val

pub const fn from_u32(u: u32) -> U32Val

pub const fn from_i32(i: i32) -> I32Val

Trait Implementations

impl AsMut<Val> for Error

fn as_mut(&mut self) -> &mut Val

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Val> for MapObject

fn as_mut(&mut self) -> &mut Val

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Val> for Val

fn as_mut(&mut self) -> &mut Val

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsMut<Val> for VecObject

fn as_mut(&mut self) -> &mut Val

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Val> for Error

fn as_ref(&self) -> &Val

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Val> for MapObject

fn as_ref(&self) -> &Val

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Val> for Val

fn as_ref(&self) -> &Val

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Val> for VecObject

fn as_ref(&self) -> &Val

Converts this type into a shared reference of the (usually inferred) input type.

impl CheckedEnvArg for Val

fn check_env_arg<E>(self, e: &E) -> Result<Val, <E as EnvBase>::Error>

where E: Env,

impl Clone for Val

fn clone(&self) -> Val

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Val

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

Formats the value using the given formatter.

impl Default for Val

fn default() -> Val

Returns the “default value” for a type.

impl From<&()> for Val

fn from(_: &()) -> Val

Converts to this type from the input type.

impl From<&AddressObject> for Val

fn from(b: &AddressObject) -> Val

Converts to this type from the input type.

impl From<&Bool> for Val

fn from(b: &Bool) -> Val

Converts to this type from the input type.

impl From<&BytesObject> for Val

fn from(b: &BytesObject) -> Val

Converts to this type from the input type.

impl From<&DurationObject> for Val

fn from(b: &DurationObject) -> Val

Converts to this type from the input type.

impl From<&DurationSmall> for Val

fn from(b: &DurationSmall) -> Val

Converts to this type from the input type.

impl From<&DurationVal> for Val

fn from(b: &DurationVal) -> Val

Converts to this type from the input type.

impl From<&Error> for Val

fn from(b: &Error) -> Val

Converts to this type from the input type.

impl From<&I128Object> for Val

fn from(b: &I128Object) -> Val

Converts to this type from the input type.

impl From<&I128Small> for Val

fn from(b: &I128Small) -> Val

Converts to this type from the input type.

impl From<&I128Val> for Val

fn from(b: &I128Val) -> Val

Converts to this type from the input type.

impl From<&I256Object> for Val

fn from(b: &I256Object) -> Val

Converts to this type from the input type.

impl From<&I256Small> for Val

fn from(b: &I256Small) -> Val

Converts to this type from the input type.

impl From<&I256Val> for Val

fn from(b: &I256Val) -> Val

Converts to this type from the input type.

impl From<&I32Val> for Val

fn from(b: &I32Val) -> Val

Converts to this type from the input type.

impl From<&I64Object> for Val

fn from(b: &I64Object) -> Val

Converts to this type from the input type.

impl From<&I64Small> for Val

fn from(b: &I64Small) -> Val

Converts to this type from the input type.

impl From<&I64Val> for Val

fn from(b: &I64Val) -> Val

Converts to this type from the input type.

impl From<&MapObject> for Val

fn from(b: &MapObject) -> Val

Converts to this type from the input type.

impl From<&MuxedAddressObject> for Val

fn from(b: &MuxedAddressObject) -> Val

Converts to this type from the input type.

impl From<&Object> for Val

fn from(b: &Object) -> Val

Converts to this type from the input type.

impl From<&ScError> for Val

fn from(er: &ScError) -> Val

Converts to this type from the input type.

impl From<&StringObject> for Val

fn from(b: &StringObject) -> Val

Converts to this type from the input type.

impl From<&Symbol> for Val

fn from(b: &Symbol) -> Val

Converts to this type from the input type.

impl From<&SymbolObject> for Val

fn from(b: &SymbolObject) -> Val

Converts to this type from the input type.

impl From<&SymbolSmall> for Val

fn from(b: &SymbolSmall) -> Val

Converts to this type from the input type.

impl From<&TimepointObject> for Val

fn from(b: &TimepointObject) -> Val

Converts to this type from the input type.

impl From<&TimepointSmall> for Val

fn from(b: &TimepointSmall) -> Val

Converts to this type from the input type.

impl From<&TimepointVal> for Val

fn from(b: &TimepointVal) -> Val

Converts to this type from the input type.

impl From<&U128Object> for Val

fn from(b: &U128Object) -> Val

Converts to this type from the input type.

impl From<&U128Small> for Val

fn from(b: &U128Small) -> Val

Converts to this type from the input type.

impl From<&U128Val> for Val

fn from(b: &U128Val) -> Val

Converts to this type from the input type.

impl From<&U256Object> for Val

fn from(b: &U256Object) -> Val

Converts to this type from the input type.

impl From<&U256Small> for Val

fn from(b: &U256Small) -> Val

Converts to this type from the input type.

impl From<&U256Val> for Val

fn from(b: &U256Val) -> Val

Converts to this type from the input type.

impl From<&U32Val> for Val

fn from(b: &U32Val) -> Val

Converts to this type from the input type.

impl From<&U64Object> for Val

fn from(b: &U64Object) -> Val

Converts to this type from the input type.

impl From<&U64Small> for Val

fn from(b: &U64Small) -> Val

Converts to this type from the input type.

impl From<&U64Val> for Val

fn from(b: &U64Val) -> Val

Converts to this type from the input type.

impl From<&VecObject> for Val

fn from(b: &VecObject) -> Val

Converts to this type from the input type.

impl From<&Void> for Val

fn from(b: &Void) -> Val

Converts to this type from the input type.

impl From<&i32> for Val

fn from(i: &i32) -> Val

Converts to this type from the input type.

impl From<&u32> for Val

fn from(u: &u32) -> Val

Converts to this type from the input type.

impl From<()> for Val

fn from(_: ()) -> Val

Converts to this type from the input type.

impl From<AddressObject> for Val

fn from(b: AddressObject) -> Val

Converts to this type from the input type.

impl From<Bool> for Val

fn from(b: Bool) -> Val

Converts to this type from the input type.

impl From<Bytes> for Val

fn from(v: Bytes) -> Val

Converts to this type from the input type.

impl<const N: usize> From<BytesN<N>> for Val

fn from(v: BytesN<N>) -> Val

Converts to this type from the input type.

impl<const N: usize> From<BytesN<N>> for Val

fn from(val: BytesN<N>) -> Val

Converts to this type from the input type.

impl From<BytesObject> for Val

fn from(b: BytesObject) -> Val

Converts to this type from the input type.

impl From<DurationObject> for Val

fn from(b: DurationObject) -> Val

Converts to this type from the input type.

impl From<DurationSmall> for Val

fn from(b: DurationSmall) -> Val

Converts to this type from the input type.

impl From<DurationVal> for Val

fn from(b: DurationVal) -> Val

Converts to this type from the input type.

impl From<Error> for Val

fn from(b: Error) -> Val

Converts to this type from the input type.

impl From<I128Object> for Val

fn from(b: I128Object) -> Val

Converts to this type from the input type.

impl From<I128Small> for Val

fn from(b: I128Small) -> Val

Converts to this type from the input type.

impl From<I128Val> for Val

fn from(b: I128Val) -> Val

Converts to this type from the input type.

impl From<I256Object> for Val

fn from(b: I256Object) -> Val

Converts to this type from the input type.

impl From<I256Small> for Val

fn from(b: I256Small) -> Val

Converts to this type from the input type.

impl From<I256Val> for Val

fn from(b: I256Val) -> Val

Converts to this type from the input type.

impl From<I32Val> for Val

fn from(b: I32Val) -> Val

Converts to this type from the input type.

impl From<I64Object> for Val

fn from(b: I64Object) -> Val

Converts to this type from the input type.

impl From<I64Small> for Val

fn from(b: I64Small) -> Val

Converts to this type from the input type.

impl From<I64Val> for Val

fn from(b: I64Val) -> Val

Converts to this type from the input type.

impl<K, V> From<Map<K, V>> for Val

where K: IntoVal<Env, Val> + TryFromVal<Env, Val>, V: IntoVal<Env, Val> + TryFromVal<Env, Val>,

fn from(m: Map<K, V>) -> Val

Converts to this type from the input type.

impl From<MapObject> for Val

fn from(b: MapObject) -> Val

Converts to this type from the input type.

impl From<MuxedAddressObject> for Val

fn from(b: MuxedAddressObject) -> Val

Converts to this type from the input type.

impl From<Object> for Val

fn from(b: Object) -> Val

Converts to this type from the input type.

impl From<ScError> for Val

fn from(er: ScError) -> Val

Converts to this type from the input type.

impl From<String> for Val

fn from(v: String) -> Val

Converts to this type from the input type.

impl From<StringObject> for Val

fn from(b: StringObject) -> Val

Converts to this type from the input type.

impl From<Symbol> for Val

fn from(b: Symbol) -> Val

Converts to this type from the input type.

impl From<SymbolObject> for Val

fn from(b: SymbolObject) -> Val

Converts to this type from the input type.

impl From<SymbolSmall> for Val

fn from(b: SymbolSmall) -> Val

Converts to this type from the input type.

impl From<TimepointObject> for Val

fn from(b: TimepointObject) -> Val

Converts to this type from the input type.

impl From<TimepointSmall> for Val

fn from(b: TimepointSmall) -> Val

Converts to this type from the input type.

impl From<TimepointVal> for Val

fn from(b: TimepointVal) -> Val

Converts to this type from the input type.

impl From<U128Object> for Val

fn from(b: U128Object) -> Val

Converts to this type from the input type.

impl From<U128Small> for Val

fn from(b: U128Small) -> Val

Converts to this type from the input type.

impl From<U128Val> for Val

fn from(b: U128Val) -> Val

Converts to this type from the input type.

impl From<U256Object> for Val

fn from(b: U256Object) -> Val

Converts to this type from the input type.

impl From<U256Small> for Val

fn from(b: U256Small) -> Val

Converts to this type from the input type.

impl From<U256Val> for Val

fn from(b: U256Val) -> Val

Converts to this type from the input type.

impl From<U32Val> for Val

fn from(b: U32Val) -> Val

Converts to this type from the input type.

impl From<U64Object> for Val

fn from(b: U64Object) -> Val

Converts to this type from the input type.

impl From<U64Small> for Val

fn from(b: U64Small) -> Val

Converts to this type from the input type.

impl From<U64Val> for Val

fn from(b: U64Val) -> Val

Converts to this type from the input type.

impl<T> From<Vec<T>> for Val

where T: IntoVal<Env, Val> + TryFromVal<Env, Val>,

fn from(v: Vec<T>) -> Val

Converts to this type from the input type.

impl From<Vec> for Val

fn from(val: Vec) -> Val

Converts to this type from the input type.

impl From<VecObject> for Val

fn from(b: VecObject) -> Val

Converts to this type from the input type.

impl From<Void> for Val

fn from(b: Void) -> Val

Converts to this type from the input type.

impl From<bool> for Val

fn from(b: bool) -> Val

Converts to this type from the input type.

impl From<i32> for Val

fn from(i: i32) -> Val

Converts to this type from the input type.

impl From<u32> for Val

fn from(u: u32) -> Val

Converts to this type from the input type.

impl Hash for Val

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize> IntoVal<Env, Val> for Hash<N>

fn into_val(&self, e: &Env) -> Val

impl TryFrom<&Val> for Error

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(v: &Val) -> Result<Error, <Error as TryFrom<&Val>>::Error>

Performs the conversion.

impl TryFrom<&Val> for MapObject

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(v: &Val) -> Result<MapObject, <MapObject as TryFrom<&Val>>::Error>

Performs the conversion.

impl TryFrom<&Val> for VecObject

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(v: &Val) -> Result<VecObject, <VecObject as TryFrom<&Val>>::Error>

Performs the conversion.

impl TryFrom<Val> for Error

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(v: Val) -> Result<Error, <Error as TryFrom<Val>>::Error>

Performs the conversion.

impl TryFrom<Val> for MapObject

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(v: Val) -> Result<MapObject, <MapObject as TryFrom<Val>>::Error>

Performs the conversion.

impl TryFrom<Val> for VecObject

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(v: Val) -> Result<VecObject, <VecObject as TryFrom<Val>>::Error>

Performs the conversion.

impl<E> TryFromVal<E, &[u8]> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &&[u8], ) -> Result<Val, <Val as TryFromVal<E, &[u8]>>::Error>

impl<E> TryFromVal<E, &()> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&(), ) -> Result<Val, <Val as TryFromVal<E, &()>>::Error>

impl<E, T0> TryFromVal<E, &(T0,)> for Val

where E: Env, T0: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0,), ) -> Result<Val, <Val as TryFromVal<E, &(T0,)>>::Error>

impl<E, T0, T1> TryFromVal<E, &(T0, T1)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1)>>::Error>

impl<E, T0, T1, T2> TryFromVal<E, &(T0, T1, T2)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2)>>::Error>

impl<E, T0, T1, T2, T3> TryFromVal<E, &(T0, T1, T2, T3)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2, T3), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2, T3)>>::Error>

impl<E, T0, T1, T2, T3, T4> TryFromVal<E, &(T0, T1, T2, T3, T4)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2, T3, T4), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2, T3, T4)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5> TryFromVal<E, &(T0, T1, T2, T3, T4, T5)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2, T3, T4, T5), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2, T3, T4, T5)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6> TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2, T3, T4, T5, T6), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7> TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2, T3, T4, T5, T6, T7), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8> TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>, T8: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2, T3, T4, T5, T6, T7, T8), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>, T8: TryIntoVal<E, Val>, T9: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>, T8: TryIntoVal<E, Val>, T9: TryIntoVal<E, Val>, T10: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>, T8: TryIntoVal<E, Val>, T9: TryIntoVal<E, Val>, T10: TryIntoVal<E, Val>, T11: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>, T8: TryIntoVal<E, Val>, T9: TryIntoVal<E, Val>, T10: TryIntoVal<E, Val>, T11: TryIntoVal<E, Val>, T12: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), ) -> Result<Val, <Val as TryFromVal<E, &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Error>

impl<E> TryFromVal<E, &AddressObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&AddressObject, ) -> Result<Val, <Val as TryFromVal<E, &AddressObject>>::Error>

impl<E> TryFromVal<E, &Bool> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&Bool, ) -> Result<Val, <Val as TryFromVal<E, &Bool>>::Error>

impl<E> TryFromVal<E, &BytesObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&BytesObject, ) -> Result<Val, <Val as TryFromVal<E, &BytesObject>>::Error>

impl<E> TryFromVal<E, &DurationObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&DurationObject, ) -> Result<Val, <Val as TryFromVal<E, &DurationObject>>::Error>

impl<E> TryFromVal<E, &DurationSmall> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&DurationSmall, ) -> Result<Val, <Val as TryFromVal<E, &DurationSmall>>::Error>

impl<E> TryFromVal<E, &DurationVal> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&DurationVal, ) -> Result<Val, <Val as TryFromVal<E, &DurationVal>>::Error>

impl<E> TryFromVal<E, &Error> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&Error, ) -> Result<Val, <Val as TryFromVal<E, &Error>>::Error>

impl<E> TryFromVal<E, &I128Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&I128Object, ) -> Result<Val, <Val as TryFromVal<E, &I128Object>>::Error>

impl<E> TryFromVal<E, &I128Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&I128Small, ) -> Result<Val, <Val as TryFromVal<E, &I128Small>>::Error>

impl<E> TryFromVal<E, &I128Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&I128Val, ) -> Result<Val, <Val as TryFromVal<E, &I128Val>>::Error>

impl<E> TryFromVal<E, &I256> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &&I256, ) -> Result<Val, <Val as TryFromVal<E, &I256>>::Error>

impl<E> TryFromVal<E, &I256Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&I256Object, ) -> Result<Val, <Val as TryFromVal<E, &I256Object>>::Error>

impl<E> TryFromVal<E, &I256Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&I256Small, ) -> Result<Val, <Val as TryFromVal<E, &I256Small>>::Error>

impl<E> TryFromVal<E, &I256Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&I256Val, ) -> Result<Val, <Val as TryFromVal<E, &I256Val>>::Error>

impl<E> TryFromVal<E, &I32Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&I32Val, ) -> Result<Val, <Val as TryFromVal<E, &I32Val>>::Error>

impl<E> TryFromVal<E, &I64Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&I64Object, ) -> Result<Val, <Val as TryFromVal<E, &I64Object>>::Error>

impl<E> TryFromVal<E, &I64Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&I64Small, ) -> Result<Val, <Val as TryFromVal<E, &I64Small>>::Error>

impl<E> TryFromVal<E, &I64Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&I64Val, ) -> Result<Val, <Val as TryFromVal<E, &I64Val>>::Error>

impl<E> TryFromVal<E, &MapObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&MapObject, ) -> Result<Val, <Val as TryFromVal<E, &MapObject>>::Error>

impl<E> TryFromVal<E, &MuxedAddressObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&MuxedAddressObject, ) -> Result<Val, <Val as TryFromVal<E, &MuxedAddressObject>>::Error>

impl<E> TryFromVal<E, &Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&Object, ) -> Result<Val, <Val as TryFromVal<E, &Object>>::Error>

impl<E, T> TryFromVal<E, &Option<T>> for Val

where E: Env, T: TryIntoVal<E, Val>,

type Error = <T as TryIntoVal<E, Val>>::Error

fn try_from_val( env: &E, v: &&Option<T>, ) -> Result<Val, <Val as TryFromVal<E, &Option<T>>>::Error>

impl<E> TryFromVal<E, &ScVal> for Val

where E: Env, Object: for<'a> TryFromVal<E, ScValObjRef<'a>>, <Object as TryFromVal<E, ScValObjRef<'a>>>::Error: for<'a> Into<Error>,

Available on crate feature std only.

type Error = Error

fn try_from_val( env: &E, val: &&ScVal, ) -> Result<Val, <Val as TryFromVal<E, &ScVal>>::Error>

impl<E> TryFromVal<E, &StringObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&StringObject, ) -> Result<Val, <Val as TryFromVal<E, &StringObject>>::Error>

impl<E> TryFromVal<E, &Symbol> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&Symbol, ) -> Result<Val, <Val as TryFromVal<E, &Symbol>>::Error>

impl<E> TryFromVal<E, &SymbolObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&SymbolObject, ) -> Result<Val, <Val as TryFromVal<E, &SymbolObject>>::Error>

impl<E> TryFromVal<E, &SymbolSmall> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&SymbolSmall, ) -> Result<Val, <Val as TryFromVal<E, &SymbolSmall>>::Error>

impl<E> TryFromVal<E, &TimepointObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&TimepointObject, ) -> Result<Val, <Val as TryFromVal<E, &TimepointObject>>::Error>

impl<E> TryFromVal<E, &TimepointSmall> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&TimepointSmall, ) -> Result<Val, <Val as TryFromVal<E, &TimepointSmall>>::Error>

impl<E> TryFromVal<E, &TimepointVal> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&TimepointVal, ) -> Result<Val, <Val as TryFromVal<E, &TimepointVal>>::Error>

impl<E> TryFromVal<E, &U128Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&U128Object, ) -> Result<Val, <Val as TryFromVal<E, &U128Object>>::Error>

impl<E> TryFromVal<E, &U128Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&U128Small, ) -> Result<Val, <Val as TryFromVal<E, &U128Small>>::Error>

impl<E> TryFromVal<E, &U128Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&U128Val, ) -> Result<Val, <Val as TryFromVal<E, &U128Val>>::Error>

impl<E> TryFromVal<E, &U256> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &&U256, ) -> Result<Val, <Val as TryFromVal<E, &U256>>::Error>

impl<E> TryFromVal<E, &U256Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&U256Object, ) -> Result<Val, <Val as TryFromVal<E, &U256Object>>::Error>

impl<E> TryFromVal<E, &U256Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&U256Small, ) -> Result<Val, <Val as TryFromVal<E, &U256Small>>::Error>

impl<E> TryFromVal<E, &U256Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&U256Val, ) -> Result<Val, <Val as TryFromVal<E, &U256Val>>::Error>

impl<E> TryFromVal<E, &U32Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&U32Val, ) -> Result<Val, <Val as TryFromVal<E, &U32Val>>::Error>

impl<E> TryFromVal<E, &U64Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&U64Object, ) -> Result<Val, <Val as TryFromVal<E, &U64Object>>::Error>

impl<E> TryFromVal<E, &U64Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&U64Small, ) -> Result<Val, <Val as TryFromVal<E, &U64Small>>::Error>

impl<E> TryFromVal<E, &U64Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&U64Val, ) -> Result<Val, <Val as TryFromVal<E, &U64Val>>::Error>

impl<E> TryFromVal<E, &Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&Val, ) -> Result<Val, <Val as TryFromVal<E, &Val>>::Error>

impl<E> TryFromVal<E, &VecObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&VecObject, ) -> Result<Val, <Val as TryFromVal<E, &VecObject>>::Error>

impl<E> TryFromVal<E, &Void> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&Void, ) -> Result<Val, <Val as TryFromVal<E, &Void>>::Error>

impl<E> TryFromVal<E, &bool> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&bool, ) -> Result<Val, <Val as TryFromVal<E, &bool>>::Error>

impl<E> TryFromVal<E, &i128> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &&i128, ) -> Result<Val, <Val as TryFromVal<E, &i128>>::Error>

impl<E> TryFromVal<E, &i32> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&i32, ) -> Result<Val, <Val as TryFromVal<E, &i32>>::Error>

impl<E> TryFromVal<E, &i64> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &&i64, ) -> Result<Val, <Val as TryFromVal<E, &i64>>::Error>

impl<E> TryFromVal<E, &str> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, val: &&str, ) -> Result<Val, <Val as TryFromVal<E, &str>>::Error>

impl<E> TryFromVal<E, &u128> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &&u128, ) -> Result<Val, <Val as TryFromVal<E, &u128>>::Error>

impl<E> TryFromVal<E, &u32> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &&u32, ) -> Result<Val, <Val as TryFromVal<E, &u32>>::Error>

impl<E> TryFromVal<E, &u64> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &&u64, ) -> Result<Val, <Val as TryFromVal<E, &u64>>::Error>

impl<E, const N: usize> TryFromVal<E, [u8; N]> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &[u8; N], ) -> Result<Val, <Val as TryFromVal<E, [u8; N]>>::Error>

impl<E> TryFromVal<E, ()> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &(), ) -> Result<Val, <Val as TryFromVal<E, ()>>::Error>

impl<E, T0> TryFromVal<E, (T0,)> for Val

where E: Env, T0: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0,), ) -> Result<Val, <Val as TryFromVal<E, (T0,)>>::Error>

impl<E, T0, T1> TryFromVal<E, (T0, T1)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1)>>::Error>

impl<E, T0, T1, T2> TryFromVal<E, (T0, T1, T2)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2)>>::Error>

impl<E, T0, T1, T2, T3> TryFromVal<E, (T0, T1, T2, T3)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2, T3), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2, T3)>>::Error>

impl<E, T0, T1, T2, T3, T4> TryFromVal<E, (T0, T1, T2, T3, T4)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2, T3, T4), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2, T3, T4)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5> TryFromVal<E, (T0, T1, T2, T3, T4, T5)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2, T3, T4, T5), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2, T3, T4, T5)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6> TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2, T3, T4, T5, T6), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7> TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2, T3, T4, T5, T6, T7), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8> TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>, T8: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2, T3, T4, T5, T6, T7, T8), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>, T8: TryIntoVal<E, Val>, T9: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>, T8: TryIntoVal<E, Val>, T9: TryIntoVal<E, Val>, T10: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>, T8: TryIntoVal<E, Val>, T9: TryIntoVal<E, Val>, T10: TryIntoVal<E, Val>, T11: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> for Val

where E: Env, T0: TryIntoVal<E, Val>, T1: TryIntoVal<E, Val>, T2: TryIntoVal<E, Val>, T3: TryIntoVal<E, Val>, T4: TryIntoVal<E, Val>, T5: TryIntoVal<E, Val>, T6: TryIntoVal<E, Val>, T7: TryIntoVal<E, Val>, T8: TryIntoVal<E, Val>, T9: TryIntoVal<E, Val>, T10: TryIntoVal<E, Val>, T11: TryIntoVal<E, Val>, T12: TryIntoVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, v: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), ) -> Result<Val, <Val as TryFromVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>>::Error>

impl<E> TryFromVal<E, AddressObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &AddressObject, ) -> Result<Val, <Val as TryFromVal<E, AddressObject>>::Error>

impl<E> TryFromVal<E, Bool> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Bool, ) -> Result<Val, <Val as TryFromVal<E, Bool>>::Error>

impl<E> TryFromVal<E, BytesObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &BytesObject, ) -> Result<Val, <Val as TryFromVal<E, BytesObject>>::Error>

impl<E> TryFromVal<E, DurationObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &DurationObject, ) -> Result<Val, <Val as TryFromVal<E, DurationObject>>::Error>

impl<E> TryFromVal<E, DurationSmall> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &DurationSmall, ) -> Result<Val, <Val as TryFromVal<E, DurationSmall>>::Error>

impl<E> TryFromVal<E, DurationVal> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &DurationVal, ) -> Result<Val, <Val as TryFromVal<E, DurationVal>>::Error>

impl<E> TryFromVal<E, Error> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Error, ) -> Result<Val, <Val as TryFromVal<E, Error>>::Error>

impl<E> TryFromVal<E, I128Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &I128Object, ) -> Result<Val, <Val as TryFromVal<E, I128Object>>::Error>

impl<E> TryFromVal<E, I128Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &I128Small, ) -> Result<Val, <Val as TryFromVal<E, I128Small>>::Error>

impl<E> TryFromVal<E, I128Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &I128Val, ) -> Result<Val, <Val as TryFromVal<E, I128Val>>::Error>

impl<E> TryFromVal<E, I256> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &I256, ) -> Result<Val, <Val as TryFromVal<E, I256>>::Error>

impl<E> TryFromVal<E, I256Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &I256Object, ) -> Result<Val, <Val as TryFromVal<E, I256Object>>::Error>

impl<E> TryFromVal<E, I256Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &I256Small, ) -> Result<Val, <Val as TryFromVal<E, I256Small>>::Error>

impl<E> TryFromVal<E, I256Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &I256Val, ) -> Result<Val, <Val as TryFromVal<E, I256Val>>::Error>

impl<E> TryFromVal<E, I32Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &I32Val, ) -> Result<Val, <Val as TryFromVal<E, I32Val>>::Error>

impl<E> TryFromVal<E, I64Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &I64Object, ) -> Result<Val, <Val as TryFromVal<E, I64Object>>::Error>

impl<E> TryFromVal<E, I64Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &I64Small, ) -> Result<Val, <Val as TryFromVal<E, I64Small>>::Error>

impl<E> TryFromVal<E, I64Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &I64Val, ) -> Result<Val, <Val as TryFromVal<E, I64Val>>::Error>

impl<E> TryFromVal<E, MapObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &MapObject, ) -> Result<Val, <Val as TryFromVal<E, MapObject>>::Error>

impl<E> TryFromVal<E, MuxedAddressObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &MuxedAddressObject, ) -> Result<Val, <Val as TryFromVal<E, MuxedAddressObject>>::Error>

impl<E> TryFromVal<E, Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Object, ) -> Result<Val, <Val as TryFromVal<E, Object>>::Error>

impl<E, T> TryFromVal<E, Option<T>> for Val

where E: Env, T: TryIntoVal<E, Val>,

type Error = <T as TryIntoVal<E, Val>>::Error

fn try_from_val( env: &E, v: &Option<T>, ) -> Result<Val, <Val as TryFromVal<E, Option<T>>>::Error>

impl<E, T, R> TryFromVal<E, Result<T, R>> for Val

where E: Env, Val: TryFromVal<E, T>, &'a R: for<'a> TryInto<Error>, <&'a R as TryInto<Error>>::Error: for<'a> Into<Error>,

type Error = Error

fn try_from_val( env: &E, v: &Result<T, R>, ) -> Result<Val, <Val as TryFromVal<E, Result<T, R>>>::Error>

impl<E> TryFromVal<E, ScVal> for Val

where E: Env, Object: for<'a> TryFromVal<E, ScValObjRef<'a>>, <Object as TryFromVal<E, ScValObjRef<'a>>>::Error: for<'a> Into<Error>,

Available on crate feature std only.

type Error = Error

fn try_from_val( env: &E, val: &ScVal, ) -> Result<Val, <Val as TryFromVal<E, ScVal>>::Error>

impl<E> TryFromVal<E, String> for Val

where E: Env,

Available on crate feature std only.

type Error = Error

fn try_from_val( env: &E, v: &String, ) -> Result<Val, <Val as TryFromVal<E, String>>::Error>

impl<E> TryFromVal<E, StringObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &StringObject, ) -> Result<Val, <Val as TryFromVal<E, StringObject>>::Error>

impl<E> TryFromVal<E, Symbol> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Symbol, ) -> Result<Val, <Val as TryFromVal<E, Symbol>>::Error>

impl<E> TryFromVal<E, SymbolObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &SymbolObject, ) -> Result<Val, <Val as TryFromVal<E, SymbolObject>>::Error>

impl<E> TryFromVal<E, SymbolSmall> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &SymbolSmall, ) -> Result<Val, <Val as TryFromVal<E, SymbolSmall>>::Error>

impl<E> TryFromVal<E, TimepointObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &TimepointObject, ) -> Result<Val, <Val as TryFromVal<E, TimepointObject>>::Error>

impl<E> TryFromVal<E, TimepointSmall> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &TimepointSmall, ) -> Result<Val, <Val as TryFromVal<E, TimepointSmall>>::Error>

impl<E> TryFromVal<E, TimepointVal> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &TimepointVal, ) -> Result<Val, <Val as TryFromVal<E, TimepointVal>>::Error>

impl<E> TryFromVal<E, U128Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &U128Object, ) -> Result<Val, <Val as TryFromVal<E, U128Object>>::Error>

impl<E> TryFromVal<E, U128Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &U128Small, ) -> Result<Val, <Val as TryFromVal<E, U128Small>>::Error>

impl<E> TryFromVal<E, U128Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &U128Val, ) -> Result<Val, <Val as TryFromVal<E, U128Val>>::Error>

impl<E> TryFromVal<E, U256> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &U256, ) -> Result<Val, <Val as TryFromVal<E, U256>>::Error>

impl<E> TryFromVal<E, U256Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &U256Object, ) -> Result<Val, <Val as TryFromVal<E, U256Object>>::Error>

impl<E> TryFromVal<E, U256Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &U256Small, ) -> Result<Val, <Val as TryFromVal<E, U256Small>>::Error>

impl<E> TryFromVal<E, U256Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &U256Val, ) -> Result<Val, <Val as TryFromVal<E, U256Val>>::Error>

impl<E> TryFromVal<E, U32Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &U32Val, ) -> Result<Val, <Val as TryFromVal<E, U32Val>>::Error>

impl<E> TryFromVal<E, U64Object> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &U64Object, ) -> Result<Val, <Val as TryFromVal<E, U64Object>>::Error>

impl<E> TryFromVal<E, U64Small> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &U64Small, ) -> Result<Val, <Val as TryFromVal<E, U64Small>>::Error>

impl<E> TryFromVal<E, U64Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &U64Val, ) -> Result<Val, <Val as TryFromVal<E, U64Val>>::Error>

impl<E, const N: usize> TryFromVal<E, Val> for [u8; N]

where E: Env,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<[u8; N], <[u8; N] as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for ()

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<(), <() as TryFromVal<E, Val>>::Error>

impl<E, T0> TryFromVal<E, Val> for (T0,)

where E: Env, T0: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0,), <(T0,) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1> TryFromVal<E, Val> for (T0, T1)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1), <(T0, T1) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2> TryFromVal<E, Val> for (T0, T1, T2)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2), <(T0, T1, T2) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2, T3> TryFromVal<E, Val> for (T0, T1, T2, T3)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>, T3: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2, T3), <(T0, T1, T2, T3) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2, T3, T4> TryFromVal<E, Val> for (T0, T1, T2, T3, T4)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>, T3: TryFromVal<E, Val>, T4: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2, T3, T4), <(T0, T1, T2, T3, T4) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2, T3, T4, T5> TryFromVal<E, Val> for (T0, T1, T2, T3, T4, T5)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>, T3: TryFromVal<E, Val>, T4: TryFromVal<E, Val>, T5: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2, T3, T4, T5), <(T0, T1, T2, T3, T4, T5) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6> TryFromVal<E, Val> for (T0, T1, T2, T3, T4, T5, T6)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>, T3: TryFromVal<E, Val>, T4: TryFromVal<E, Val>, T5: TryFromVal<E, Val>, T6: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2, T3, T4, T5, T6), <(T0, T1, T2, T3, T4, T5, T6) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7> TryFromVal<E, Val> for (T0, T1, T2, T3, T4, T5, T6, T7)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>, T3: TryFromVal<E, Val>, T4: TryFromVal<E, Val>, T5: TryFromVal<E, Val>, T6: TryFromVal<E, Val>, T7: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), <(T0, T1, T2, T3, T4, T5, T6, T7) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8> TryFromVal<E, Val> for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>, T3: TryFromVal<E, Val>, T4: TryFromVal<E, Val>, T5: TryFromVal<E, Val>, T6: TryFromVal<E, Val>, T7: TryFromVal<E, Val>, T8: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), <(T0, T1, T2, T3, T4, T5, T6, T7, T8) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TryFromVal<E, Val> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>, T3: TryFromVal<E, Val>, T4: TryFromVal<E, Val>, T5: TryFromVal<E, Val>, T6: TryFromVal<E, Val>, T7: TryFromVal<E, Val>, T8: TryFromVal<E, Val>, T9: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> TryFromVal<E, Val> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>, T3: TryFromVal<E, Val>, T4: TryFromVal<E, Val>, T5: TryFromVal<E, Val>, T6: TryFromVal<E, Val>, T7: TryFromVal<E, Val>, T8: TryFromVal<E, Val>, T9: TryFromVal<E, Val>, T10: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> TryFromVal<E, Val> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>, T3: TryFromVal<E, Val>, T4: TryFromVal<E, Val>, T5: TryFromVal<E, Val>, T6: TryFromVal<E, Val>, T7: TryFromVal<E, Val>, T8: TryFromVal<E, Val>, T9: TryFromVal<E, Val>, T10: TryFromVal<E, Val>, T11: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as TryFromVal<E, Val>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> TryFromVal<E, Val> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where E: Env, T0: TryFromVal<E, Val>, T1: TryFromVal<E, Val>, T2: TryFromVal<E, Val>, T3: TryFromVal<E, Val>, T4: TryFromVal<E, Val>, T5: TryFromVal<E, Val>, T6: TryFromVal<E, Val>, T7: TryFromVal<E, Val>, T8: TryFromVal<E, Val>, T9: TryFromVal<E, Val>, T10: TryFromVal<E, Val>, T11: TryFromVal<E, Val>, T12: TryFromVal<E, Val>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), <(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for AddressObject

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<AddressObject, <AddressObject as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for Bool

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<Bool, <Bool as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for BytesObject

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<BytesObject, <BytesObject as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for DurationObject

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<DurationObject, <DurationObject as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for DurationSmall

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<DurationSmall, <DurationSmall as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for DurationVal

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<DurationVal, <DurationVal as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for Error

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<Error, <Error as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I128Object

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<I128Object, <I128Object as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I128Small

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<I128Small, <I128Small as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I128Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<I128Val, <I128Val as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I256

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &Val, ) -> Result<I256, <I256 as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I256Object

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<I256Object, <I256Object as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I256Small

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<I256Small, <I256Small as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I256Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<I256Val, <I256Val as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I32Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<I32Val, <I32Val as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I64Object

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<I64Object, <I64Object as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I64Small

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<I64Small, <I64Small as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for I64Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<I64Val, <I64Val as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for MapObject

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<MapObject, <MapObject as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for MuxedAddressObject

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<MuxedAddressObject, <MuxedAddressObject as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for Object

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<Object, <Object as TryFromVal<E, Val>>::Error>

impl<E, T> TryFromVal<E, Val> for Option<T>

where E: Env, T: TryFromVal<E, Val>,

type Error = <T as TryFromVal<E, Val>>::Error

fn try_from_val( env: &E, val: &Val, ) -> Result<Option<T>, <Option<T> as TryFromVal<E, Val>>::Error>

impl<E, T, R> TryFromVal<E, Val> for Result<T, R>

where E: Env, T: TryFromVal<E, Val>, R: TryFrom<Error>, <R as TryFrom<Error>>::Error: Into<Error>,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<Result<T, R>, <Result<T, R> as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for ScVal

where E: Env, ScValObject: TryFromVal<E, Object>, <ScValObject as TryFromVal<E, Object>>::Error: Into<Error>,

Available on crate feature std only.

type Error = Error

fn try_from_val(env: &E, val: &Val) -> Result<ScVal, Error>

impl<E> TryFromVal<E, Val> for String

where E: Env,

Available on crate feature std only.

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<String, <String as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for StringObject

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<StringObject, <StringObject as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for Symbol

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<Symbol, <Symbol as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for SymbolObject

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<SymbolObject, <SymbolObject as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for SymbolSmall

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<SymbolSmall, <SymbolSmall as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for TimepointObject

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<TimepointObject, <TimepointObject as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for TimepointSmall

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<TimepointSmall, <TimepointSmall as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for TimepointVal

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<TimepointVal, <TimepointVal as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U128Object

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<U128Object, <U128Object as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U128Small

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<U128Small, <U128Small as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U128Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<U128Val, <U128Val as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U256

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &Val, ) -> Result<U256, <U256 as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U256Object

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<U256Object, <U256Object as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U256Small

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<U256Small, <U256Small as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U256Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<U256Val, <U256Val as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U32Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<U32Val, <U32Val as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U64Object

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<U64Object, <U64Object as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U64Small

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<U64Small, <U64Small as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for U64Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<U64Val, <U64Val as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<Val, <Val as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for Vec<u8>

where E: Env,

Available on crate feature std only.

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<Vec<u8>, <Vec<u8> as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for VecObject

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<VecObject, <VecObject as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for Void

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<Void, <Void as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for bool

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<bool, <bool as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for i128

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &Val, ) -> Result<i128, <i128 as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for i32

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<i32, <i32 as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for i64

where E: Env,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<i64, <i64 as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for u128

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &Val, ) -> Result<u128, <u128 as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for u32

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Val, ) -> Result<u32, <u32 as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Val> for u64

where E: Env,

type Error = Error

fn try_from_val( env: &E, val: &Val, ) -> Result<u64, <u64 as TryFromVal<E, Val>>::Error>

impl<E> TryFromVal<E, Vec<u8>> for Val

where E: Env,

Available on crate feature std only.

type Error = Error

fn try_from_val( env: &E, v: &Vec<u8>, ) -> Result<Val, <Val as TryFromVal<E, Vec<u8>>>::Error>

impl<E> TryFromVal<E, VecObject> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &VecObject, ) -> Result<Val, <Val as TryFromVal<E, VecObject>>::Error>

impl<E> TryFromVal<E, Void> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &Void, ) -> Result<Val, <Val as TryFromVal<E, Void>>::Error>

impl<E> TryFromVal<E, bool> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &bool, ) -> Result<Val, <Val as TryFromVal<E, bool>>::Error>

impl<E> TryFromVal<E, i128> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &i128, ) -> Result<Val, <Val as TryFromVal<E, i128>>::Error>

impl<E> TryFromVal<E, i32> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &i32, ) -> Result<Val, <Val as TryFromVal<E, i32>>::Error>

impl<E> TryFromVal<E, i64> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &i64, ) -> Result<Val, <Val as TryFromVal<E, i64>>::Error>

impl<E> TryFromVal<E, u128> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &u128, ) -> Result<Val, <Val as TryFromVal<E, u128>>::Error>

impl<E> TryFromVal<E, u32> for Val

where E: Env,

type Error = ConversionError

fn try_from_val( _env: &E, val: &u32, ) -> Result<Val, <Val as TryFromVal<E, u32>>::Error>

impl<E> TryFromVal<E, u64> for Val

where E: Env,

type Error = Error

fn try_from_val( env: &E, v: &u64, ) -> Result<Val, <Val as TryFromVal<E, u64>>::Error>

impl TryFromVal<Env, &Address> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&Address, ) -> Result<Val, <Val as TryFromVal<Env, &Address>>::Error>

impl TryFromVal<Env, &Bls12381Fp> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &&Bls12381Fp, ) -> Result<Val, <Val as TryFromVal<Env, &Bls12381Fp>>::Error>

impl TryFromVal<Env, &Bls12381Fp2> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &&Bls12381Fp2, ) -> Result<Val, <Val as TryFromVal<Env, &Bls12381Fp2>>::Error>

impl TryFromVal<Env, &Bls12381G1Affine> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &&Bls12381G1Affine, ) -> Result<Val, <Val as TryFromVal<Env, &Bls12381G1Affine>>::Error>

impl TryFromVal<Env, &Bls12381G2Affine> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &&Bls12381G2Affine, ) -> Result<Val, <Val as TryFromVal<Env, &Bls12381G2Affine>>::Error>

impl TryFromVal<Env, &Bn254Fp> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &&Bn254Fp, ) -> Result<Val, <Val as TryFromVal<Env, &Bn254Fp>>::Error>

impl TryFromVal<Env, &Bn254G1Affine> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &&Bn254G1Affine, ) -> Result<Val, <Val as TryFromVal<Env, &Bn254G1Affine>>::Error>

impl TryFromVal<Env, &Bn254G2Affine> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &&Bn254G2Affine, ) -> Result<Val, <Val as TryFromVal<Env, &Bn254G2Affine>>::Error>

impl TryFromVal<Env, &Fr> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, fr: &&Fr, ) -> Result<Val, <Val as TryFromVal<Env, &Fr>>::Error>

impl TryFromVal<Env, &Bytes> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&Bytes, ) -> Result<Val, <Val as TryFromVal<Env, &Bytes>>::Error>

impl<const N: usize> TryFromVal<Env, &BytesN<N>> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&BytesN<N>, ) -> Result<Val, <Val as TryFromVal<Env, &BytesN<N>>>::Error>

impl TryFromVal<Env, &Context> for Val

type Error = ConversionError

fn try_from_val(env: &Env, val: &&Context) -> Result<Val, ConversionError>

impl TryFromVal<Env, &ContractContext> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &&ContractContext, ) -> Result<Val, ConversionError>

impl TryFromVal<Env, &ContractExecutable> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &&ContractExecutable, ) -> Result<Val, ConversionError>

impl TryFromVal<Env, &CreateContractHostFnContext> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &&CreateContractHostFnContext, ) -> Result<Val, ConversionError>

impl TryFromVal<Env, &CreateContractWithConstructorHostFnContext> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &&CreateContractWithConstructorHostFnContext, ) -> Result<Val, ConversionError>

impl TryFromVal<Env, &Duration> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&Duration, ) -> Result<Val, <Val as TryFromVal<Env, &Duration>>::Error>

impl TryFromVal<Env, &Executable> for Val

type Error = ConversionError

fn try_from_val(env: &Env, val: &&Executable) -> Result<Val, ConversionError>

impl TryFromVal<Env, &Fr> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, fr: &&Fr, ) -> Result<Val, <Val as TryFromVal<Env, &Fr>>::Error>

impl TryFromVal<Env, &I256> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&I256, ) -> Result<Val, <Val as TryFromVal<Env, &I256>>::Error>

impl TryFromVal<Env, &InvokerContractAuthEntry> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &&InvokerContractAuthEntry, ) -> Result<Val, ConversionError>

impl<K, V> TryFromVal<Env, &Map<K, V>> for Val

where K: IntoVal<Env, Val> + TryFromVal<Env, Val>, V: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = Infallible

fn try_from_val( _env: &Env, v: &&Map<K, V>, ) -> Result<Val, <Val as TryFromVal<Env, &Map<K, V>>>::Error>

impl TryFromVal<Env, &MuxedAddress> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&MuxedAddress, ) -> Result<Val, <Val as TryFromVal<Env, &MuxedAddress>>::Error>

impl TryFromVal<Env, &String> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&String, ) -> Result<Val, <Val as TryFromVal<Env, &String>>::Error>

impl TryFromVal<Env, &SubContractInvocation> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &&SubContractInvocation, ) -> Result<Val, ConversionError>

impl TryFromVal<Env, &Symbol> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&Symbol, ) -> Result<Val, <Val as TryFromVal<Env, &Symbol>>::Error>

impl TryFromVal<Env, &Timepoint> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&Timepoint, ) -> Result<Val, <Val as TryFromVal<Env, &Timepoint>>::Error>

impl TryFromVal<Env, &Token> for Val

type Error = ConversionError

fn try_from_val(env: &Env, val: &&Token) -> Result<Self, ConversionError>

impl TryFromVal<Env, &U256> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&U256, ) -> Result<Val, <Val as TryFromVal<Env, &U256>>::Error>

impl<T> TryFromVal<Env, &Vec<T>> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &&Vec<T>, ) -> Result<Val, <Val as TryFromVal<Env, &Vec<T>>>::Error>

impl TryFromVal<Env, Address> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &Address, ) -> Result<Val, <Val as TryFromVal<Env, Address>>::Error>

impl TryFromVal<Env, Bls12381Fp> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &Bls12381Fp, ) -> Result<Val, <Val as TryFromVal<Env, Bls12381Fp>>::Error>

impl TryFromVal<Env, Bls12381Fp2> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &Bls12381Fp2, ) -> Result<Val, <Val as TryFromVal<Env, Bls12381Fp2>>::Error>

impl TryFromVal<Env, Bls12381G1Affine> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &Bls12381G1Affine, ) -> Result<Val, <Val as TryFromVal<Env, Bls12381G1Affine>>::Error>

impl TryFromVal<Env, Bls12381G2Affine> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &Bls12381G2Affine, ) -> Result<Val, <Val as TryFromVal<Env, Bls12381G2Affine>>::Error>

impl TryFromVal<Env, Bn254Fp> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &Bn254Fp, ) -> Result<Val, <Val as TryFromVal<Env, Bn254Fp>>::Error>

impl TryFromVal<Env, Bn254G1Affine> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &Bn254G1Affine, ) -> Result<Val, <Val as TryFromVal<Env, Bn254G1Affine>>::Error>

impl TryFromVal<Env, Bn254G2Affine> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, elt: &Bn254G2Affine, ) -> Result<Val, <Val as TryFromVal<Env, Bn254G2Affine>>::Error>

impl TryFromVal<Env, Fr> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, fr: &Fr, ) -> Result<Val, <Val as TryFromVal<Env, Fr>>::Error>

impl TryFromVal<Env, Bytes> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &Bytes, ) -> Result<Val, <Val as TryFromVal<Env, Bytes>>::Error>

impl<const N: usize> TryFromVal<Env, BytesN<N>> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &BytesN<N>, ) -> Result<Val, <Val as TryFromVal<Env, BytesN<N>>>::Error>

impl TryFromVal<Env, Context> for Val

type Error = ConversionError

fn try_from_val(env: &Env, val: &Context) -> Result<Val, ConversionError>

impl TryFromVal<Env, ContractContext> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &ContractContext, ) -> Result<Val, ConversionError>

impl TryFromVal<Env, ContractExecutable> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &ContractExecutable, ) -> Result<Val, ConversionError>

impl TryFromVal<Env, CreateContractHostFnContext> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &CreateContractHostFnContext, ) -> Result<Val, ConversionError>

impl TryFromVal<Env, CreateContractWithConstructorHostFnContext> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &CreateContractWithConstructorHostFnContext, ) -> Result<Val, ConversionError>

impl TryFromVal<Env, Duration> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &Duration, ) -> Result<Val, <Val as TryFromVal<Env, Duration>>::Error>

impl TryFromVal<Env, Executable> for Val

type Error = ConversionError

fn try_from_val(env: &Env, val: &Executable) -> Result<Val, ConversionError>

impl TryFromVal<Env, Fr> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, fr: &Fr, ) -> Result<Val, <Val as TryFromVal<Env, Fr>>::Error>

impl TryFromVal<Env, I256> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &I256, ) -> Result<Val, <Val as TryFromVal<Env, I256>>::Error>

impl TryFromVal<Env, InvokerContractAuthEntry> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &InvokerContractAuthEntry, ) -> Result<Val, ConversionError>

impl<K, V> TryFromVal<Env, Map<K, V>> for Val

where K: IntoVal<Env, Val> + TryFromVal<Env, Val>, V: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = Infallible

fn try_from_val( _env: &Env, v: &Map<K, V>, ) -> Result<Val, <Val as TryFromVal<Env, Map<K, V>>>::Error>

impl TryFromVal<Env, MuxedAddress> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &MuxedAddress, ) -> Result<Val, <Val as TryFromVal<Env, MuxedAddress>>::Error>

impl TryFromVal<Env, String> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &String, ) -> Result<Val, <Val as TryFromVal<Env, String>>::Error>

impl TryFromVal<Env, SubContractInvocation> for Val

type Error = ConversionError

fn try_from_val( env: &Env, val: &SubContractInvocation, ) -> Result<Val, ConversionError>

impl TryFromVal<Env, Symbol> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &Symbol, ) -> Result<Val, <Val as TryFromVal<Env, Symbol>>::Error>

impl TryFromVal<Env, Timepoint> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &Timepoint, ) -> Result<Val, <Val as TryFromVal<Env, Timepoint>>::Error>

impl TryFromVal<Env, Token> for Val

type Error = ConversionError

fn try_from_val(env: &Env, val: &Token) -> Result<Self, ConversionError>

impl TryFromVal<Env, U256> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &U256, ) -> Result<Val, <Val as TryFromVal<Env, U256>>::Error>

impl TryFromVal<Env, Val> for Address

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Address, <Address as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Bls12381Fp

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Bls12381Fp, <Bls12381Fp as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Bls12381Fp2

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Bls12381Fp2, <Bls12381Fp2 as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Bls12381G1Affine

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Bls12381G1Affine, <Bls12381G1Affine as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Bls12381G2Affine

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Bls12381G2Affine, <Bls12381G2Affine as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Bn254Fp

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Bn254Fp, <Bn254Fp as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Bn254G1Affine

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Bn254G1Affine, <Bn254G1Affine as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Bn254G2Affine

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Bn254G2Affine, <Bn254G2Affine as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Fr

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Fr, <Fr as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Bytes

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Bytes, <Bytes as TryFromVal<Env, Val>>::Error>

impl<const N: usize> TryFromVal<Env, Val> for BytesN<N>

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<BytesN<N>, <BytesN<N> as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Context

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Context, ConversionError>

impl TryFromVal<Env, Val> for ContractContext

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<ContractContext, ConversionError>

impl TryFromVal<Env, Val> for ContractExecutable

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<ContractExecutable, ConversionError>

impl TryFromVal<Env, Val> for CreateContractHostFnContext

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<CreateContractHostFnContext, ConversionError>

impl TryFromVal<Env, Val> for CreateContractWithConstructorHostFnContext

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<CreateContractWithConstructorHostFnContext, ConversionError>

impl TryFromVal<Env, Val> for Duration

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Duration, <Duration as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Executable

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Executable, ConversionError>

impl TryFromVal<Env, Val> for Fr

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Fr, <Fr as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for I256

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<I256, <I256 as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for InvokerContractAuthEntry

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<InvokerContractAuthEntry, ConversionError>

impl<K, V> TryFromVal<Env, Val> for Map<K, V>

where K: IntoVal<Env, Val> + TryFromVal<Env, Val>, V: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Map<K, V>, <Map<K, V> as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for MuxedAddress

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<MuxedAddress, <MuxedAddress as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for String

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<String, <String as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for SubContractInvocation

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<SubContractInvocation, ConversionError>

impl TryFromVal<Env, Val> for Symbol

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Symbol, <Symbol as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Timepoint

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Timepoint, <Timepoint as TryFromVal<Env, Val>>::Error>

impl TryFromVal<Env, Val> for Token

type Error = ConversionError

fn try_from_val(env: &Env, val: &Val) -> Result<Self, ConversionError>

impl TryFromVal<Env, Val> for U256

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<U256, <U256 as TryFromVal<Env, Val>>::Error>

impl<T> TryFromVal<Env, Val> for Vec<T>

where T: IntoVal<Env, Val> + TryFromVal<Env, Val>,

type Error = ConversionError

fn try_from_val( env: &Env, val: &Val, ) -> Result<Vec<T>, <Vec<T> as TryFromVal<Env, Val>>::Error>

impl<T> TryFromVal<Env, Vec<T>> for Val

type Error = ConversionError

fn try_from_val( _env: &Env, v: &Vec<T>, ) -> Result<Val, <Val as TryFromVal<Env, Vec<T>>>::Error>

impl TryFromVal<Host, AccountEd25519Signature> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &AccountEd25519Signature, ) -> Result<Val, <Val as TryFromVal<Host, AccountEd25519Signature>>::Error>

impl TryFromVal<Host, Address> for Val

type Error = HostError

fn try_from_val( _env: &Host, val: &Address, ) -> Result<Val, <Val as TryFromVal<Host, Address>>::Error>

impl TryFromVal<Host, AddressExecutable> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &AddressExecutable, ) -> Result<Val, <Val as TryFromVal<Host, AddressExecutable>>::Error>

impl TryFromVal<Host, AllowanceDataKey> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &AllowanceDataKey, ) -> Result<Val, <Val as TryFromVal<Host, AllowanceDataKey>>::Error>

impl TryFromVal<Host, AllowanceValue> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &AllowanceValue, ) -> Result<Val, <Val as TryFromVal<Host, AllowanceValue>>::Error>

impl TryFromVal<Host, AlphaNum12AssetInfo> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &AlphaNum12AssetInfo, ) -> Result<Val, <Val as TryFromVal<Host, AlphaNum12AssetInfo>>::Error>

impl TryFromVal<Host, AlphaNum4AssetInfo> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &AlphaNum4AssetInfo, ) -> Result<Val, <Val as TryFromVal<Host, AlphaNum4AssetInfo>>::Error>

impl TryFromVal<Host, AssetInfo> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &AssetInfo, ) -> Result<Val, <Val as TryFromVal<Host, AssetInfo>>::Error>

impl TryFromVal<Host, AuthorizationContext> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &AuthorizationContext, ) -> Result<Val, <Val as TryFromVal<Host, AuthorizationContext>>::Error>

impl TryFromVal<Host, BalanceValue> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &BalanceValue, ) -> Result<Val, <Val as TryFromVal<Host, BalanceValue>>::Error>

impl<const N: usize> TryFromVal<Host, BytesN<N>> for Val

type Error = HostError

fn try_from_val( _env: &Host, val: &BytesN<N>, ) -> Result<Val, <Val as TryFromVal<Host, BytesN<N>>>::Error>

impl TryFromVal<Host, ContractAuthorizationContext> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &ContractAuthorizationContext, ) -> Result<Val, <Val as TryFromVal<Host, ContractAuthorizationContext>>::Error>

impl TryFromVal<Host, ContractExecutable> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &ContractExecutable, ) -> Result<Val, <Val as TryFromVal<Host, ContractExecutable>>::Error>

impl TryFromVal<Host, CreateContractHostFnContext> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &CreateContractHostFnContext, ) -> Result<Val, <Val as TryFromVal<Host, CreateContractHostFnContext>>::Error>

impl TryFromVal<Host, CreateContractWithConstructorHostFnContext> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &CreateContractWithConstructorHostFnContext, ) -> Result<Val, <Val as TryFromVal<Host, CreateContractWithConstructorHostFnContext>>::Error>

impl TryFromVal<Host, DataKey> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &DataKey, ) -> Result<Val, <Val as TryFromVal<Host, DataKey>>::Error>

impl TryFromVal<Host, InstanceDataKey> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &InstanceDataKey, ) -> Result<Val, <Val as TryFromVal<Host, InstanceDataKey>>::Error>

impl TryFromVal<Host, InvokerContractAuthEntry> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &InvokerContractAuthEntry, ) -> Result<Val, <Val as TryFromVal<Host, InvokerContractAuthEntry>>::Error>

impl TryFromVal<Host, MuxedAddress> for Val

type Error = HostError

fn try_from_val( _env: &Host, address: &MuxedAddress, ) -> Result<Val, <Val as TryFromVal<Host, MuxedAddress>>::Error>

impl TryFromVal<Host, StellarAssetContractMetadata> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &StellarAssetContractMetadata, ) -> Result<Val, <Val as TryFromVal<Host, StellarAssetContractMetadata>>::Error>

impl TryFromVal<Host, String> for Val

type Error = HostError

fn try_from_val( _env: &Host, val: &String, ) -> Result<Val, <Val as TryFromVal<Host, String>>::Error>

impl TryFromVal<Host, SubContractInvocation> for Val

type Error = HostError

fn try_from_val( env: &Host, val: &SubContractInvocation, ) -> Result<Val, <Val as TryFromVal<Host, SubContractInvocation>>::Error>

impl TryFromVal<Host, Vec> for Val

type Error = HostError

fn try_from_val( _env: &Host, val: &Vec, ) -> Result<Val, <Val as TryFromVal<Host, Vec>>::Error>

impl WasmiMarshal for Val

Available on crate feature wasmi only.

fn try_marshal_from_value(v: Value) -> Option<Val>

fn marshal_from_self(self) -> Value

impl Copy for Val