Struct soroban_sdk::RawVal

#[repr(transparent)]
pub struct RawVal(_);

Raw value of the Soroban smart contract platform that types can be converted to and from for storing, or passing between contracts.

A 64-bit value encoding a bit-packed disjoint union between several different types (numbers, booleans, symbols, object handles, etc.)

RawVals divide up the space of 64 bits according to a 2-level tagging scheme. The first tag is a bit in the least-significant position, indicating whether the RawVal is a plain “u63” 63-bit unsigned integer, or some more-structured value with a second-level tag in the next most significant 3 bits. The 63-bit unsigned integer case can also be thought of as handling the complete range of non-negative signed 64-bit integers.

The remaining 3 bit tags are assigned to cases enumerated in [Tag], of which 7 are defined and one is currently reserved.

Schematically, the bit-assignment for RawVal looks like this:

   0x_NNNN_NNNN_NNNN_NNNX  - u63, for any even X
   0x_0000_000N_NNNN_NNN1  - u32
   0x_0000_000N_NNNN_NNN3  - i32
   0x_NNNN_NNNN_NNNN_NNN5  - static: void, true, false, ...
   0x_IIII_IIII_TTTT_TTT7  - object: 32-bit index I, 28-bit type code T
   0x_NNNN_NNNN_NNNN_NNN9  - symbol: up to 10 6-bit identifier characters
   0x_NNNN_NNNN_NNNN_NNNb  - bitset: up to 60 bits
   0x_CCCC_CCCC_TTTT_TTTd  - status: 32-bit code C, 28-bit type code T
   0x_NNNN_NNNN_NNNN_NNNf  - reserved

Implementations

impl RawVal

pub fn in_env<E>(self, env: &E) -> EnvVal<E, RawVal> where
    E: Env, 

pub const fn get_payload(self) -> u64

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

pub const fn is_u63(self) -> bool

pub const unsafe fn unchecked_as_u63(self) -> i64

pub const unsafe fn unchecked_from_u63(i: i64) -> RawVal

pub const fn get_tag(self) -> Tag

pub fn is<T>(self) -> bool where
    T: RawValConvertible, 

pub const fn from_void() -> RawVal

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

pub const fn from_other_static(st: ScStatic) -> RawVal

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

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

pub const fn is_i32_zero(self) -> bool

pub const fn is_u32_zero(self) -> bool

pub const fn is_void(self) -> bool

pub const fn is_true(self) -> bool

pub const fn is_false(self) -> bool

impl RawVal

pub const I32_ZERO: RawVal = RawVal::from_i32(0)

pub const I32_POSITIVE_ONE: RawVal = RawVal::from_i32(1)

pub const I32_NEGATIVE_ONE: RawVal = RawVal::from_i32(-1)

pub const I32_MIN: RawVal = RawVal::from_i32(i32::MIN)

pub const I32_MAX: RawVal = RawVal::from_i32(i32::MAX)

pub const U32_ZERO: RawVal = RawVal::from_u32(0)

pub const U32_ONE: RawVal = RawVal::from_u32(1)

pub const U32_MIN: RawVal = RawVal::from_u32(u32::MIN)

pub const U32_MAX: RawVal = RawVal::from_u32(u32::MAX)

pub const VOID: RawVal = RawVal::from_other_static(ScStatic::Void)

pub const TRUE: RawVal = RawVal::from_bool(true)

pub const FALSE: RawVal = RawVal::from_bool(false)

Trait Implementations

impl AsMut<RawVal> for BitSet

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

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

impl<E, V> AsMut<RawVal> for EnvVal<E, V> where
    E: Env,
    V: Val, 

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

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

impl AsMut<RawVal> for Object

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

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

impl AsMut<RawVal> for RawVal

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

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

impl AsMut<RawVal> for Static

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

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

impl AsMut<RawVal> for Status

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

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

impl AsMut<RawVal> for Symbol

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

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

impl AsRef<RawVal> for BitSet

fn as_ref(&self) -> &RawVal

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

impl<E, V> AsRef<RawVal> for EnvVal<E, V> where
    E: Env,
    V: Val, 

fn as_ref(&self) -> &RawVal

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

impl AsRef<RawVal> for Object

fn as_ref(&self) -> &RawVal

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

impl AsRef<RawVal> for RawVal

fn as_ref(&self) -> &RawVal

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

impl AsRef<RawVal> for Static

fn as_ref(&self) -> &RawVal

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

impl AsRef<RawVal> for Status

fn as_ref(&self) -> &RawVal

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

impl AsRef<RawVal> for Symbol

fn as_ref(&self) -> &RawVal

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

impl Clone for RawVal

fn clone(&self) -> RawVal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RawVal

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

Formats the value using the given formatter.

impl Default for RawVal

fn default() -> RawVal

Returns the “default value” for a type.

impl From<&()> for RawVal

fn from(&()) -> RawVal

Converts to this type from the input type.

impl From<&BigInt> for RawVal

fn from(b: &BigInt) -> Self

Converts to this type from the input type.

impl From<&ScStatus> for RawVal

fn from(st: &ScStatus) -> RawVal

Converts to this type from the input type.

impl From<&i32> for RawVal

fn from(i: &i32) -> RawVal

Converts to this type from the input type.

impl From<&u32> for RawVal

fn from(u: &u32) -> RawVal

Converts to this type from the input type.

impl From<()> for RawVal

fn from(()) -> RawVal

Converts to this type from the input type.

impl From<Account> for RawVal

fn from(a: Account) -> Self

Converts to this type from the input type.

impl From<BigInt> for RawVal

fn from(b: BigInt) -> Self

Converts to this type from the input type.

impl From<BitSet> for RawVal

fn from(b: BitSet) -> RawVal

Converts to this type from the input type.

impl From<Bytes> for RawVal

fn from(v: Bytes) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<E> From<EnvVal<E, BitSet>> for RawVal where
    E: Env, 

fn from(ev: EnvVal<E, BitSet>) -> RawVal

Converts to this type from the input type.

impl<E> From<EnvVal<E, Object>> for RawVal where
    E: Env, 

fn from(ev: EnvVal<E, Object>) -> RawVal

Converts to this type from the input type.

impl<E> From<EnvVal<E, RawVal>> for RawVal where
    E: Env, 

fn from(ev: EnvVal<E, RawVal>) -> RawVal

Converts to this type from the input type.

impl<E> From<EnvVal<E, Static>> for RawVal where
    E: Env, 

fn from(ev: EnvVal<E, Static>) -> RawVal

Converts to this type from the input type.

impl<E> From<EnvVal<E, Status>> for RawVal where
    E: Env, 

fn from(ev: EnvVal<E, Status>) -> RawVal

Converts to this type from the input type.

impl<E> From<EnvVal<E, Symbol>> for RawVal where
    E: Env, 

fn from(ev: EnvVal<E, Symbol>) -> RawVal

Converts to this type from the input type.

impl<K, V> From<Map<K, V>> for RawVal where
    K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
    V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>, 

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

Converts to this type from the input type.

impl From<Object> for RawVal

fn from(b: Object) -> RawVal

Converts to this type from the input type.

impl From<RawVal> for DebugArg

fn from(rv: RawVal) -> DebugArg

Converts to this type from the input type.

impl From<ScStatus> for RawVal

fn from(st: ScStatus) -> RawVal

Converts to this type from the input type.

impl From<Static> for RawVal

fn from(b: Static) -> RawVal

Converts to this type from the input type.

impl From<Status> for RawVal

fn from(b: Status) -> RawVal

Converts to this type from the input type.

impl From<Symbol> for RawVal

fn from(b: Symbol) -> RawVal

Converts to this type from the input type.

impl<T> From<Vec<T>> for RawVal where
    T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>, 

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

Converts to this type from the input type.

impl From<bool> for RawVal

fn from(b: bool) -> RawVal

Converts to this type from the input type.

impl From<i32> for RawVal

fn from(i: i32) -> RawVal

Converts to this type from the input type.

impl From<u32> for RawVal

fn from(u: u32) -> RawVal

Converts to this type from the input type.

impl<E> FromVal<E, RawVal> for RawVal where
    E: Env, 

fn from_val(_env: &E, val: RawVal) -> RawVal

impl FromValue for RawVal

fn from_value(val: Value) -> Option<RawVal>

Create a value of type Self from a given Value.

impl<E, const N: usize> IntoVal<E, RawVal> for &[u8; N] where
    E: Env, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &[u8] where
    E: Env, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &() where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IntoVal<E, RawVal> for &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>,
    &'a T2: for<'a> IntoVal<E, RawVal>,
    &'a T3: for<'a> IntoVal<E, RawVal>,
    &'a T4: for<'a> IntoVal<E, RawVal>,
    &'a T5: for<'a> IntoVal<E, RawVal>,
    &'a T6: for<'a> IntoVal<E, RawVal>,
    &'a T7: for<'a> IntoVal<E, RawVal>,
    &'a T8: for<'a> IntoVal<E, RawVal>,
    &'a T9: for<'a> IntoVal<E, RawVal>,
    &'a T10: for<'a> IntoVal<E, RawVal>,
    &'a T11: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IntoVal<E, RawVal> for &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>,
    &'a T2: for<'a> IntoVal<E, RawVal>,
    &'a T3: for<'a> IntoVal<E, RawVal>,
    &'a T4: for<'a> IntoVal<E, RawVal>,
    &'a T5: for<'a> IntoVal<E, RawVal>,
    &'a T6: for<'a> IntoVal<E, RawVal>,
    &'a T7: for<'a> IntoVal<E, RawVal>,
    &'a T8: for<'a> IntoVal<E, RawVal>,
    &'a T9: for<'a> IntoVal<E, RawVal>,
    &'a T10: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IntoVal<E, RawVal> for &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>,
    &'a T2: for<'a> IntoVal<E, RawVal>,
    &'a T3: for<'a> IntoVal<E, RawVal>,
    &'a T4: for<'a> IntoVal<E, RawVal>,
    &'a T5: for<'a> IntoVal<E, RawVal>,
    &'a T6: for<'a> IntoVal<E, RawVal>,
    &'a T7: for<'a> IntoVal<E, RawVal>,
    &'a T8: for<'a> IntoVal<E, RawVal>,
    &'a T9: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8> IntoVal<E, RawVal> for &(T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>,
    &'a T2: for<'a> IntoVal<E, RawVal>,
    &'a T3: for<'a> IntoVal<E, RawVal>,
    &'a T4: for<'a> IntoVal<E, RawVal>,
    &'a T5: for<'a> IntoVal<E, RawVal>,
    &'a T6: for<'a> IntoVal<E, RawVal>,
    &'a T7: for<'a> IntoVal<E, RawVal>,
    &'a T8: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7> IntoVal<E, RawVal> for &(T0, T1, T2, T3, T4, T5, T6, T7) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>,
    &'a T2: for<'a> IntoVal<E, RawVal>,
    &'a T3: for<'a> IntoVal<E, RawVal>,
    &'a T4: for<'a> IntoVal<E, RawVal>,
    &'a T5: for<'a> IntoVal<E, RawVal>,
    &'a T6: for<'a> IntoVal<E, RawVal>,
    &'a T7: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6> IntoVal<E, RawVal> for &(T0, T1, T2, T3, T4, T5, T6) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>,
    &'a T2: for<'a> IntoVal<E, RawVal>,
    &'a T3: for<'a> IntoVal<E, RawVal>,
    &'a T4: for<'a> IntoVal<E, RawVal>,
    &'a T5: for<'a> IntoVal<E, RawVal>,
    &'a T6: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5> IntoVal<E, RawVal> for &(T0, T1, T2, T3, T4, T5) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>,
    &'a T2: for<'a> IntoVal<E, RawVal>,
    &'a T3: for<'a> IntoVal<E, RawVal>,
    &'a T4: for<'a> IntoVal<E, RawVal>,
    &'a T5: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4> IntoVal<E, RawVal> for &(T0, T1, T2, T3, T4) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>,
    &'a T2: for<'a> IntoVal<E, RawVal>,
    &'a T3: for<'a> IntoVal<E, RawVal>,
    &'a T4: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3> IntoVal<E, RawVal> for &(T0, T1, T2, T3) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>,
    &'a T2: for<'a> IntoVal<E, RawVal>,
    &'a T3: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2> IntoVal<E, RawVal> for &(T0, T1, T2) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>,
    &'a T2: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1> IntoVal<E, RawVal> for &(T0, T1) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>,
    &'a T1: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0> IntoVal<E, RawVal> for &(T0,) where
    E: Env,
    &'a T0: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &BitSet where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &Object where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T> IntoVal<E, RawVal> for &Option<T> where
    E: Env,
    &'a T: for<'a> IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &Static where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &Status where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &Symbol where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &bool where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &i32 where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &i64 where
    E: Env, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &u32 where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for &u64 where
    E: Env, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, const N: usize> IntoVal<E, RawVal> for [u8; N] where
    E: Env, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for () where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> IntoVal<E, RawVal> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>,
    T2: IntoVal<E, RawVal>,
    T3: IntoVal<E, RawVal>,
    T4: IntoVal<E, RawVal>,
    T5: IntoVal<E, RawVal>,
    T6: IntoVal<E, RawVal>,
    T7: IntoVal<E, RawVal>,
    T8: IntoVal<E, RawVal>,
    T9: IntoVal<E, RawVal>,
    T10: IntoVal<E, RawVal>,
    T11: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> IntoVal<E, RawVal> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>,
    T2: IntoVal<E, RawVal>,
    T3: IntoVal<E, RawVal>,
    T4: IntoVal<E, RawVal>,
    T5: IntoVal<E, RawVal>,
    T6: IntoVal<E, RawVal>,
    T7: IntoVal<E, RawVal>,
    T8: IntoVal<E, RawVal>,
    T9: IntoVal<E, RawVal>,
    T10: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> IntoVal<E, RawVal> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>,
    T2: IntoVal<E, RawVal>,
    T3: IntoVal<E, RawVal>,
    T4: IntoVal<E, RawVal>,
    T5: IntoVal<E, RawVal>,
    T6: IntoVal<E, RawVal>,
    T7: IntoVal<E, RawVal>,
    T8: IntoVal<E, RawVal>,
    T9: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8> IntoVal<E, RawVal> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>,
    T2: IntoVal<E, RawVal>,
    T3: IntoVal<E, RawVal>,
    T4: IntoVal<E, RawVal>,
    T5: IntoVal<E, RawVal>,
    T6: IntoVal<E, RawVal>,
    T7: IntoVal<E, RawVal>,
    T8: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7> IntoVal<E, RawVal> for (T0, T1, T2, T3, T4, T5, T6, T7) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>,
    T2: IntoVal<E, RawVal>,
    T3: IntoVal<E, RawVal>,
    T4: IntoVal<E, RawVal>,
    T5: IntoVal<E, RawVal>,
    T6: IntoVal<E, RawVal>,
    T7: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5, T6> IntoVal<E, RawVal> for (T0, T1, T2, T3, T4, T5, T6) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>,
    T2: IntoVal<E, RawVal>,
    T3: IntoVal<E, RawVal>,
    T4: IntoVal<E, RawVal>,
    T5: IntoVal<E, RawVal>,
    T6: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4, T5> IntoVal<E, RawVal> for (T0, T1, T2, T3, T4, T5) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>,
    T2: IntoVal<E, RawVal>,
    T3: IntoVal<E, RawVal>,
    T4: IntoVal<E, RawVal>,
    T5: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3, T4> IntoVal<E, RawVal> for (T0, T1, T2, T3, T4) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>,
    T2: IntoVal<E, RawVal>,
    T3: IntoVal<E, RawVal>,
    T4: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2, T3> IntoVal<E, RawVal> for (T0, T1, T2, T3) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>,
    T2: IntoVal<E, RawVal>,
    T3: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1, T2> IntoVal<E, RawVal> for (T0, T1, T2) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>,
    T2: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0, T1> IntoVal<E, RawVal> for (T0, T1) where
    E: Env,
    T0: IntoVal<E, RawVal>,
    T1: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T0> IntoVal<E, RawVal> for (T0,) where
    E: Env,
    T0: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for BitSet where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for Object where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E, T> IntoVal<E, RawVal> for Option<T> where
    E: Env,
    T: IntoVal<E, RawVal>, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for RawVal where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for Static where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for Status where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for Symbol where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for bool where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for i32 where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for i64 where
    E: Env, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for u32 where
    E: Env, 

fn into_val(self, _env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<E> IntoVal<E, RawVal> for u64 where
    E: Env, 

fn into_val(self, env: &E) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, RawVal> for &BigInt

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, RawVal> for &Bytes

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, RawVal> for &BytesN<N>

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<K, V> IntoVal<Env, RawVal> for &Map<K, V> where
    K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
    V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>, 

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T> IntoVal<Env, RawVal> for &Vec<T> where
    T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>, 

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, RawVal> for BigInt

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl IntoVal<Env, RawVal> for Bytes

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<const N: usize> IntoVal<Env, RawVal> for BytesN<N>

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<K, V> IntoVal<Env, RawVal> for Map<K, V> where
    K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
    V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>, 

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl<T> IntoVal<Env, RawVal> for Vec<T> where
    T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>, 

fn into_val(self, _env: &Env) -> RawVal

fn into_env_val(self, env: &E) -> EnvVal<E, V>

impl TryFrom<&RawVal> for BitSet

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<&RawVal> for Object

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<&RawVal> for Static

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<&RawVal> for Status

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<&RawVal> for Symbol

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<RawVal> for BitSet

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<RawVal> for Object

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<RawVal> for Static

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<RawVal> for Status

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<RawVal> for Symbol

type Error = ConversionError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<E, const N: usize> TryFromVal<E, RawVal> for [u8; N] where
    E: Env, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for () where
    E: Env, 

type Error = ConversionError

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

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

type Error = ConversionError

fn try_from_val(
    env: &E,
    val: RawVal
) -> 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, RawVal>>::Error>

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

type Error = ConversionError

fn try_from_val(
    env: &E,
    val: RawVal
) -> 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, RawVal>>::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TryFromVal<E, RawVal> for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>,
    T6: TryFromVal<E, RawVal>,
    T7: TryFromVal<E, RawVal>,
    T8: TryFromVal<E, RawVal>,
    T9: TryFromVal<E, RawVal>, 

type Error = ConversionError

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

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8> TryFromVal<E, RawVal> for (T0, T1, T2, T3, T4, T5, T6, T7, T8) where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>,
    T6: TryFromVal<E, RawVal>,
    T7: TryFromVal<E, RawVal>,
    T8: TryFromVal<E, RawVal>, 

type Error = ConversionError

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

impl<E, T0, T1, T2, T3, T4, T5, T6, T7> TryFromVal<E, RawVal> for (T0, T1, T2, T3, T4, T5, T6, T7) where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>,
    T6: TryFromVal<E, RawVal>,
    T7: TryFromVal<E, RawVal>, 

type Error = ConversionError

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

impl<E, T0, T1, T2, T3, T4, T5, T6> TryFromVal<E, RawVal> for (T0, T1, T2, T3, T4, T5, T6) where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>,
    T6: TryFromVal<E, RawVal>, 

type Error = ConversionError

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

impl<E, T0, T1, T2, T3, T4, T5> TryFromVal<E, RawVal> for (T0, T1, T2, T3, T4, T5) where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>, 

type Error = ConversionError

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

impl<E, T0, T1, T2, T3, T4> TryFromVal<E, RawVal> for (T0, T1, T2, T3, T4) where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>, 

type Error = ConversionError

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

impl<E, T0, T1, T2, T3> TryFromVal<E, RawVal> for (T0, T1, T2, T3) where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>, 

type Error = ConversionError

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

impl<E, T0, T1, T2> TryFromVal<E, RawVal> for (T0, T1, T2) where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>, 

type Error = ConversionError

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

impl<E, T0, T1> TryFromVal<E, RawVal> for (T0, T1) where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>, 

type Error = ConversionError

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

impl<E, T0> TryFromVal<E, RawVal> for (T0,) where
    E: Env,
    T0: TryFromVal<E, RawVal>, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for BitSet where
    E: Env, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for Object where
    E: Env, 

type Error = ConversionError

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

impl<E, T> TryFromVal<E, RawVal> for Option<T> where
    E: Env,
    T: TryFromVal<E, RawVal>, 

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

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

impl<E> TryFromVal<E, RawVal> for RawVal where
    E: Env, 

type Error = Infallible

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

impl<E> TryFromVal<E, RawVal> for ScVal where
    E: Env,
    ScObject: TryFromVal<E, Object>, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for Static where
    E: Env, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for Status where
    E: Env, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for Symbol where
    E: Env, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for bool where
    E: Env, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for i32 where
    E: Env, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for i64 where
    E: Env, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for u32 where
    E: Env, 

type Error = ConversionError

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

impl<E> TryFromVal<E, RawVal> for u64 where
    E: Env, 

type Error = ConversionError

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

impl TryFromVal<Env, RawVal> for Account

type Error = <Account as TryFromVal<Env, Object>>::Error

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, RawVal> for BigInt

type Error = <BigInt as TryFromVal<Env, Object>>::Error

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl TryFromVal<Env, RawVal> for Bytes

type Error = <Bytes as TryFromVal<Env, Object>>::Error

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

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

type Error = ConversionError

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl<K, V> TryFromVal<Env, RawVal> for Map<K, V> where
    K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
    V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>, 

type Error = <Map<K, V> as TryFromVal<Env, Object>>::Error

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl<T> TryFromVal<Env, RawVal> for Vec<T> where
    T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>, 

type Error = <Vec<T> as TryFromVal<Env, Object>>::Error

fn try_from_val(env: &Env, val: RawVal) -> Result<Self, Self::Error>

impl<E, const N: usize> TryIntoVal<E, [u8; N]> for RawVal where
    E: Env, 

type Error = <[u8; N] as TryFromVal<E, RawVal>>::Error

fn try_into_val(
    self,
    env: &E
) -> Result<[u8; N], <RawVal as TryIntoVal<E, [u8; N]>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, ()> for RawVal where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(), <RawVal as TryIntoVal<E, ()>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>,
    T6: TryFromVal<E, RawVal>,
    T7: TryFromVal<E, RawVal>,
    T8: TryFromVal<E, RawVal>,
    T9: TryFromVal<E, RawVal>,
    T10: TryFromVal<E, RawVal>,
    T11: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), <RawVal as TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>,
    T6: TryFromVal<E, RawVal>,
    T7: TryFromVal<E, RawVal>,
    T8: TryFromVal<E, RawVal>,
    T9: TryFromVal<E, RawVal>,
    T10: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), <RawVal as TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>,
    T6: TryFromVal<E, RawVal>,
    T7: TryFromVal<E, RawVal>,
    T8: TryFromVal<E, RawVal>,
    T9: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), <RawVal as TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7, T8> TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>,
    T6: TryFromVal<E, RawVal>,
    T7: TryFromVal<E, RawVal>,
    T8: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), <RawVal as TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6, T7, T8)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6, T7> TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6, T7)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>,
    T6: TryFromVal<E, RawVal>,
    T7: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), <RawVal as TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6, T7)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1, T2, T3, T4, T5, T6> TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>,
    T6: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1, T2, T3, T4, T5, T6), <RawVal as TryIntoVal<E, (T0, T1, T2, T3, T4, T5, T6)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1, T2, T3, T4, T5> TryIntoVal<E, (T0, T1, T2, T3, T4, T5)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>,
    T5: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1, T2, T3, T4, T5), <RawVal as TryIntoVal<E, (T0, T1, T2, T3, T4, T5)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1, T2, T3, T4> TryIntoVal<E, (T0, T1, T2, T3, T4)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>,
    T4: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1, T2, T3, T4), <RawVal as TryIntoVal<E, (T0, T1, T2, T3, T4)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1, T2, T3> TryIntoVal<E, (T0, T1, T2, T3)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>,
    T3: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1, T2, T3), <RawVal as TryIntoVal<E, (T0, T1, T2, T3)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1, T2> TryIntoVal<E, (T0, T1, T2)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>,
    T2: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1, T2), <RawVal as TryIntoVal<E, (T0, T1, T2)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0, T1> TryIntoVal<E, (T0, T1)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>,
    T1: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0, T1), <RawVal as TryIntoVal<E, (T0, T1)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T0> TryIntoVal<E, (T0,)> for RawVal where
    E: Env,
    T0: TryFromVal<E, RawVal>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<(T0,), <RawVal as TryIntoVal<E, (T0,)>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, BitSet> for RawVal where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<BitSet, <RawVal as TryIntoVal<E, BitSet>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, Object> for RawVal where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<Object, <RawVal as TryIntoVal<E, Object>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E, T> TryIntoVal<E, Option<T>> for RawVal where
    E: Env,
    T: TryFromVal<E, RawVal>, 

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

fn try_into_val(
    self,
    env: &E
) -> Result<Option<T>, <RawVal as TryIntoVal<E, Option<T>>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for &ScVal where
    E: Env,
    &'a ScObject: for<'a> TryIntoVal<E, Object>, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<RawVal, <&ScVal as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for () where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    _env: &E
) -> Result<RawVal, <() as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for BitSet where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    _env: &E
) -> Result<RawVal, <BitSet as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for Object where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    _env: &E
) -> Result<RawVal, <Object as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for Static where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    _env: &E
) -> Result<RawVal, <Static as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for Status where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    _env: &E
) -> Result<RawVal, <Status as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for Symbol where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    _env: &E
) -> Result<RawVal, <Symbol as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for bool where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    _env: &E
) -> Result<RawVal, <bool as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for i32 where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    _env: &E
) -> Result<RawVal, <i32 as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for i64 where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<RawVal, <i64 as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for u32 where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    _env: &E
) -> Result<RawVal, <u32 as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, RawVal> for u64 where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<RawVal, <u64 as TryIntoVal<E, RawVal>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, Static> for RawVal where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<Static, <RawVal as TryIntoVal<E, Static>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, Status> for RawVal where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<Status, <RawVal as TryIntoVal<E, Status>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, Symbol> for RawVal where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<Symbol, <RawVal as TryIntoVal<E, Symbol>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, bool> for RawVal where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<bool, <RawVal as TryIntoVal<E, bool>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, i32> for RawVal where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<i32, <RawVal as TryIntoVal<E, i32>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, i64> for RawVal where
    E: Env, 

type Error = <i64 as TryFromVal<E, RawVal>>::Error

fn try_into_val(
    self,
    env: &E
) -> Result<i64, <RawVal as TryIntoVal<E, i64>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, u32> for RawVal where
    E: Env, 

type Error = ConversionError

fn try_into_val(
    self,
    env: &E
) -> Result<u32, <RawVal as TryIntoVal<E, u32>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<E> TryIntoVal<E, u64> for RawVal where
    E: Env, 

type Error = <u64 as TryFromVal<E, RawVal>>::Error

fn try_into_val(
    self,
    env: &E
) -> Result<u64, <RawVal as TryIntoVal<E, u64>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Env, BigInt> for RawVal

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<BigInt, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Env, Bytes> for RawVal

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Bytes, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<const N: usize> TryIntoVal<Env, BytesN<N>> for RawVal

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<BytesN<N>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<K, V> TryIntoVal<Env, Map<K, V>> for RawVal where
    K: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>,
    V: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>, 

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Map<K, V>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<T> TryIntoVal<Env, Vec<T>> for RawVal where
    T: IntoVal<Env, RawVal> + TryFromVal<Env, RawVal>, 

type Error = ConversionError

fn try_into_val(self, env: &Env) -> Result<Vec<T>, Self::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, AccountSignatures> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<AccountSignatures, <RawVal as TryIntoVal<Host, AccountSignatures>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, AllowanceDataKey> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<AllowanceDataKey, <RawVal as TryIntoVal<Host, AllowanceDataKey>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, BigInt> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<BigInt, <RawVal as TryIntoVal<Host, BigInt>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, Bytes> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<Bytes, <RawVal as TryIntoVal<Host, Bytes>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl<const N: u32> TryIntoVal<Host, BytesN<N>> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<BytesN<N>, <RawVal as TryIntoVal<Host, BytesN<N>>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, DataKey> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<DataKey, <RawVal as TryIntoVal<Host, DataKey>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, Ed25519Signature> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<Ed25519Signature, <RawVal as TryIntoVal<Host, Ed25519Signature>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, Identifier> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<Identifier, <RawVal as TryIntoVal<Host, Identifier>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, Map> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<Map, <RawVal as TryIntoVal<Host, Map>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, Signature> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<Signature, <RawVal as TryIntoVal<Host, Signature>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, SignaturePayload> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<SignaturePayload, <RawVal as TryIntoVal<Host, SignaturePayload>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, SignaturePayloadV0> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<SignaturePayloadV0, <RawVal as TryIntoVal<Host, SignaturePayloadV0>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl TryIntoVal<Host, Vec> for RawVal

type Error = HostError

fn try_into_val(
    self,
    env: &Host
) -> Result<Vec, <RawVal as TryIntoVal<Host, Vec>>::Error>

fn try_into_env_val(self, env: &E) -> Result<EnvVal<E, V>, Self::Error>

impl Copy for RawVal

impl Val for RawVal