Trait hdk::prelude::TryFrom

pub trait TryFrom<T> {
    type Error;
    pub fn try_from(value: T) -> Result<Self, Self::Error>;
}

Simple and safe type conversions that may fail in a controlled way under some circumstances. It is the reciprocal of TryInto.

This is useful when you are doing a type conversion that may trivially succeed but may also need special handling. For example, there is no way to convert an i64 into an i32 using the From trait, because an i64 may contain a value that an i32 cannot represent and so the conversion would lose data. This might be handled by truncating the i64 to an i32 (essentially giving the i64’s value modulo i32::MAX) or by simply returning i32::MAX, or by some other method. The From trait is intended for perfect conversions, so the TryFrom trait informs the programmer when a type conversion could go bad and lets them decide how to handle it.

Generic Implementations

• TryFrom<T> for U implies TryInto<U> for T
• try_from is reflexive, which means that TryFrom<T> for T is implemented and cannot fail – the associated Error type for calling T::try_from() on a value of type T is Infallible. When the ! type is stabilized Infallible and ! will be equivalent.

TryFrom<T> can be implemented as follows:

use std::convert::TryFrom;

struct GreaterThanZero(i32);

impl TryFrom<i32> for GreaterThanZero {
    type Error = &'static str;

    fn try_from(value: i32) -> Result<Self, Self::Error> {
        if value <= 0 {
            Err("GreaterThanZero only accepts value superior than zero!")
        } else {
            Ok(GreaterThanZero(value))
        }
    }
}

Examples

As described, i32 implements TryFrom<i64>:

use std::convert::TryFrom;

let big_number = 1_000_000_000_000i64;
// Silently truncates `big_number`, requires detecting
// and handling the truncation after the fact.
let smaller_number = big_number as i32;
assert_eq!(smaller_number, -727379968);

// Returns an error because `big_number` is too big to
// fit in an `i32`.
let try_smaller_number = i32::try_from(big_number);
assert!(try_smaller_number.is_err());

// Returns `Ok(3)`.
let try_successful_smaller_number = i32::try_from(3);
assert!(try_successful_smaller_number.is_ok());

Associated Types

type Error

The type returned in the event of a conversion error.

Loading content...

Required methods

pub fn try_from(value: T) -> Result<Self, Self::Error>

Performs the conversion.

Loading content...

Implementations on Foreign Types

impl TryFrom<u16> for u8

type Error = TryFromIntError

pub fn try_from(u: u16) -> Result<u8, <u8 as TryFrom<u16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroUsize> for NonZeroI8

Attempts to convert NonZeroUsize to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<usize> for i64

type Error = TryFromIntError

pub fn try_from(value: usize) -> Result<i64, <i64 as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i32> for u8

type Error = TryFromIntError

pub fn try_from(u: i32) -> Result<u8, <u8 as TryFrom<i32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u128> for i64

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<i64, <i64 as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI64> for NonZeroU8

Attempts to convert NonZeroI64 to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI64
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroI64>>::Error>

impl TryFrom<NonZeroUsize> for NonZeroU16

Attempts to convert NonZeroUsize to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<usize> for u64

type Error = TryFromIntError

pub fn try_from(value: usize) -> Result<u64, <u64 as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<usize> for u8

type Error = TryFromIntError

pub fn try_from(u: usize) -> Result<u8, <u8 as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU32> for NonZeroU8

Attempts to convert NonZeroU32 to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU32
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroU32>>::Error>

impl TryFrom<isize> for i128

type Error = TryFromIntError

pub fn try_from(value: isize) -> Result<i128, <i128 as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i64> for u16

type Error = TryFromIntError

pub fn try_from(u: i64) -> Result<u16, <u16 as TryFrom<i64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU128> for NonZeroU64

Attempts to convert NonZeroU128 to NonZeroU64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroU128>>::Error>

impl TryFrom<NonZeroI16> for NonZeroU16

Attempts to convert NonZeroI16 to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI16
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroI16>>::Error>

impl TryFrom<NonZeroU128> for NonZeroI8

Attempts to convert NonZeroU128 to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU128>>::Error>

impl TryFrom<usize> for u128

type Error = TryFromIntError

pub fn try_from(value: usize) -> Result<u128, <u128 as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI128> for NonZeroI64

Attempts to convert NonZeroI128 to NonZeroI64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroI64, <NonZeroI64 as TryFrom<NonZeroI128>>::Error>

impl TryFrom<i16> for i8

type Error = TryFromIntError

pub fn try_from(u: i16) -> Result<i8, <i8 as TryFrom<i16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i8> for NonZeroI8

Attempts to convert i8 to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: i8
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<i8>>::Error>

impl TryFrom<u32> for char

type Error = CharTryFromError

pub fn try_from(i: u32) -> Result<char, <char as TryFrom<u32>>::Error>

impl TryFrom<NonZeroI32> for NonZeroI8

Attempts to convert NonZeroI32 to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI32
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI32>>::Error>

impl TryFrom<NonZeroI8> for NonZeroU32

Attempts to convert NonZeroI8 to NonZeroU32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI8
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI8>>::Error>

impl TryFrom<i128> for usize

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<usize, <usize as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU128> for NonZeroIsize

Attempts to convert NonZeroU128 to NonZeroIsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroU128>>::Error>

impl TryFrom<NonZeroU128> for NonZeroI32

Attempts to convert NonZeroU128 to NonZeroI32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroU128>>::Error>

impl TryFrom<u32> for i8

type Error = TryFromIntError

pub fn try_from(u: u32) -> Result<i8, <i8 as TryFrom<u32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroUsize> for NonZeroU64

Attempts to convert NonZeroUsize to NonZeroU64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<isize> for NonZeroIsize

Attempts to convert isize to NonZeroIsize.

type Error = TryFromIntError

pub fn try_from(
    value: isize
) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<isize>>::Error>

impl TryFrom<isize> for u16

type Error = TryFromIntError

pub fn try_from(u: isize) -> Result<u16, <u16 as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u128> for u8

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<u8, <u8 as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u128> for NonZeroU128

Attempts to convert u128 to NonZeroU128.

type Error = TryFromIntError

pub fn try_from(
    value: u128
) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<u128>>::Error>

impl TryFrom<NonZeroI64> for NonZeroU16

Attempts to convert NonZeroI64 to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI64
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroI64>>::Error>

impl TryFrom<i128> for u32

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<u32, <u32 as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI128> for NonZeroU8

Attempts to convert NonZeroI128 to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroI128>>::Error>

impl TryFrom<isize> for u32

type Error = TryFromIntError

pub fn try_from(u: isize) -> Result<u32, <u32 as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u32> for u16

type Error = TryFromIntError

pub fn try_from(u: u32) -> Result<u16, <u16 as TryFrom<u32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u64> for u32

type Error = TryFromIntError

pub fn try_from(u: u64) -> Result<u32, <u32 as TryFrom<u64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU8> for NonZeroI8

Attempts to convert NonZeroU8 to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU8
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU8>>::Error>

impl TryFrom<NonZeroI128> for NonZeroU16

Attempts to convert NonZeroI128 to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroI128>>::Error>

impl TryFrom<u8> for i8

type Error = TryFromIntError

pub fn try_from(u: u8) -> Result<i8, <i8 as TryFrom<u8>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroUsize> for NonZeroI128

Attempts to convert NonZeroUsize to NonZeroI128.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroI128, <NonZeroI128 as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<u64> for i32

type Error = TryFromIntError

pub fn try_from(u: u64) -> Result<i32, <i32 as TryFrom<u64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI8> for NonZeroU64

Attempts to convert NonZeroI8 to NonZeroU64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI8
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroI8>>::Error>

impl TryFrom<i32> for i8

type Error = TryFromIntError

pub fn try_from(u: i32) -> Result<i8, <i8 as TryFrom<i32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u32> for i16

type Error = TryFromIntError

pub fn try_from(u: u32) -> Result<i16, <i16 as TryFrom<u32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU16> for NonZeroI8

Attempts to convert NonZeroU16 to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU16
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU16>>::Error>

impl TryFrom<i16> for u16

type Error = TryFromIntError

pub fn try_from(u: i16) -> Result<u16, <u16 as TryFrom<i16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI128> for NonZeroI8

Attempts to convert NonZeroI128 to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI128>>::Error>

impl TryFrom<NonZeroIsize> for NonZeroU128

Attempts to convert NonZeroIsize to NonZeroU128.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<i8> for u64

type Error = TryFromIntError

pub fn try_from(u: i8) -> Result<u64, <u64 as TryFrom<i8>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI128> for NonZeroI16

Attempts to convert NonZeroI128 to NonZeroI16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroI128>>::Error>

impl TryFrom<i32> for u32

type Error = TryFromIntError

pub fn try_from(u: i32) -> Result<u32, <u32 as TryFrom<i32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i128> for u8

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<u8, <u8 as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI32> for NonZeroU32

Attempts to convert NonZeroI32 to NonZeroU32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI32
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI32>>::Error>

impl TryFrom<NonZeroI64> for NonZeroI8

Attempts to convert NonZeroI64 to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI64
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI64>>::Error>

impl TryFrom<i64> for usize

type Error = TryFromIntError

pub fn try_from(u: i64) -> Result<usize, <usize as TryFrom<i64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i32> for u64

type Error = TryFromIntError

pub fn try_from(u: i32) -> Result<u64, <u64 as TryFrom<i32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU128> for NonZeroU32

Attempts to convert NonZeroU128 to NonZeroU32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroU128>>::Error>

impl TryFrom<isize> for i16

type Error = TryFromIntError

pub fn try_from(u: isize) -> Result<i16, <i16 as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl<'_, T, const N: usize> TryFrom<&'_ [T]> for [T; N] where
    T: Copy, 

type Error = TryFromSliceError

pub fn try_from(slice: &[T]) -> Result<[T; N], TryFromSliceError>

impl TryFrom<u128> for isize

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<isize, <isize as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU16> for NonZeroU8

Attempts to convert NonZeroU16 to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU16
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroU16>>::Error>

impl TryFrom<NonZeroI128> for NonZeroU64

Attempts to convert NonZeroI128 to NonZeroU64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroI128>>::Error>

impl TryFrom<NonZeroIsize> for NonZeroU32

Attempts to convert NonZeroIsize to NonZeroU32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<i128> for u128

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<u128, <u128 as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u32> for u8

type Error = TryFromIntError

pub fn try_from(u: u32) -> Result<u8, <u8 as TryFrom<u32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU16> for NonZeroIsize

Attempts to convert NonZeroU16 to NonZeroIsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU16
) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroU16>>::Error>

impl TryFrom<i64> for i8

type Error = TryFromIntError

pub fn try_from(u: i64) -> Result<i8, <i8 as TryFrom<i64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU128> for NonZeroU8

Attempts to convert NonZeroU128 to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroU128>>::Error>

impl TryFrom<NonZeroU32> for NonZeroU16

Attempts to convert NonZeroU32 to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU32
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroU32>>::Error>

impl TryFrom<isize> for u8

type Error = TryFromIntError

pub fn try_from(u: isize) -> Result<u8, <u8 as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI16> for NonZeroU64

Attempts to convert NonZeroI16 to NonZeroU64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI16
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroI16>>::Error>

impl TryFrom<i64> for i32

type Error = TryFromIntError

pub fn try_from(u: i64) -> Result<i32, <i32 as TryFrom<i64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI32> for NonZeroUsize

Attempts to convert NonZeroI32 to NonZeroUsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI32
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroI32>>::Error>

impl TryFrom<NonZeroI32> for NonZeroI16

Attempts to convert NonZeroI32 to NonZeroI16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI32
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroI32>>::Error>

impl TryFrom<NonZeroUsize> for NonZeroIsize

Attempts to convert NonZeroUsize to NonZeroIsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<u64> for isize

type Error = TryFromIntError

pub fn try_from(u: u64) -> Result<isize, <isize as TryFrom<u64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroIsize> for NonZeroI8

Attempts to convert NonZeroIsize to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<i128> for i16

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<i16, <i16 as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i64> for u64

type Error = TryFromIntError

pub fn try_from(u: i64) -> Result<u64, <u64 as TryFrom<i64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<usize> for u16

type Error = TryFromIntError

pub fn try_from(u: usize) -> Result<u16, <u16 as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<usize> for NonZeroUsize

Attempts to convert usize to NonZeroUsize.

type Error = TryFromIntError

pub fn try_from(
    value: usize
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<usize>>::Error>

impl TryFrom<NonZeroI32> for NonZeroU128

Attempts to convert NonZeroI32 to NonZeroU128.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI32
) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroI32>>::Error>

impl TryFrom<u8> for NonZeroU8

Attempts to convert u8 to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: u8
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<u8>>::Error>

impl TryFrom<NonZeroUsize> for NonZeroU128

Attempts to convert NonZeroUsize to NonZeroU128.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<i128> for isize

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<isize, <isize as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u128> for u64

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<u64, <u64 as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI32> for NonZeroIsize

Attempts to convert NonZeroI32 to NonZeroIsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI32
) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroI32>>::Error>

impl TryFrom<NonZeroU64> for NonZeroI64

Attempts to convert NonZeroU64 to NonZeroI64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU64
) -> Result<NonZeroI64, <NonZeroI64 as TryFrom<NonZeroU64>>::Error>

impl TryFrom<u64> for NonZeroU64

Attempts to convert u64 to NonZeroU64.

type Error = TryFromIntError

pub fn try_from(
    value: u64
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<u64>>::Error>

impl TryFrom<NonZeroI8> for NonZeroU128

Attempts to convert NonZeroI8 to NonZeroU128.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI8
) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroI8>>::Error>

impl TryFrom<u128> for i16

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<i16, <i16 as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u32> for NonZeroU32

Attempts to convert u32 to NonZeroU32.

type Error = TryFromIntError

pub fn try_from(
    value: u32
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<u32>>::Error>

impl TryFrom<i64> for NonZeroI64

Attempts to convert i64 to NonZeroI64.

type Error = TryFromIntError

pub fn try_from(
    value: i64
) -> Result<NonZeroI64, <NonZeroI64 as TryFrom<i64>>::Error>

impl TryFrom<NonZeroU64> for NonZeroI16

Attempts to convert NonZeroU64 to NonZeroI16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU64
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroU64>>::Error>

impl TryFrom<NonZeroUsize> for NonZeroI16

Attempts to convert NonZeroUsize to NonZeroI16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<NonZeroIsize> for NonZeroU8

Attempts to convert NonZeroIsize to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<NonZeroUsize> for NonZeroU8

Attempts to convert NonZeroUsize to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<NonZeroU64> for NonZeroUsize

Attempts to convert NonZeroU64 to NonZeroUsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU64
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroU64>>::Error>

impl TryFrom<i64> for u8

type Error = TryFromIntError

pub fn try_from(u: i64) -> Result<u8, <u8 as TryFrom<i64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroIsize> for NonZeroU64

Attempts to convert NonZeroIsize to NonZeroU64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<NonZeroIsize> for NonZeroU16

Attempts to convert NonZeroIsize to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<NonZeroU128> for NonZeroUsize

Attempts to convert NonZeroU128 to NonZeroUsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroU128>>::Error>

impl TryFrom<i64> for u128

type Error = TryFromIntError

pub fn try_from(u: i64) -> Result<u128, <u128 as TryFrom<i64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u64> for u8

type Error = TryFromIntError

pub fn try_from(u: u64) -> Result<u8, <u8 as TryFrom<u64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI8> for NonZeroU16

Attempts to convert NonZeroI8 to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI8
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroI8>>::Error>

impl TryFrom<u128> for usize

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<usize, <usize as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i64> for isize

type Error = TryFromIntError

pub fn try_from(u: i64) -> Result<isize, <isize as TryFrom<i64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u16> for NonZeroU16

Attempts to convert u16 to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: u16
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<u16>>::Error>

impl TryFrom<NonZeroI128> for NonZeroI32

Attempts to convert NonZeroI128 to NonZeroI32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroI128>>::Error>

impl TryFrom<i32> for i16

type Error = TryFromIntError

pub fn try_from(u: i32) -> Result<i16, <i16 as TryFrom<i32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU32> for NonZeroUsize

Attempts to convert NonZeroU32 to NonZeroUsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU32
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroU32>>::Error>

impl TryFrom<u16> for i16

type Error = TryFromIntError

pub fn try_from(u: u16) -> Result<i16, <i16 as TryFrom<u16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU64> for NonZeroI8

Attempts to convert NonZeroU64 to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU64
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU64>>::Error>

impl TryFrom<usize> for u32

type Error = TryFromIntError

pub fn try_from(value: usize) -> Result<u32, <u32 as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i32> for isize

type Error = TryFromIntError

pub fn try_from(value: i32) -> Result<isize, <isize as TryFrom<i32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u32> for usize

type Error = TryFromIntError

pub fn try_from(value: u32) -> Result<usize, <usize as TryFrom<u32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i8> for u128

type Error = TryFromIntError

pub fn try_from(u: i8) -> Result<u128, <u128 as TryFrom<i8>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u32> for isize

type Error = TryFromIntError

pub fn try_from(u: u32) -> Result<isize, <isize as TryFrom<u32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i32> for u16

type Error = TryFromIntError

pub fn try_from(u: i32) -> Result<u16, <u16 as TryFrom<i32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i64> for u32

type Error = TryFromIntError

pub fn try_from(u: i64) -> Result<u32, <u32 as TryFrom<i64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

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

type Error = TryFromSliceError

pub fn try_from(slice: &mut [T]) -> Result<&mut [T; N], TryFromSliceError>

impl TryFrom<i32> for NonZeroI32

Attempts to convert i32 to NonZeroI32.

type Error = TryFromIntError

pub fn try_from(
    value: i32
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<i32>>::Error>

impl TryFrom<i128> for u64

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<u64, <u64 as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<usize> for i128

type Error = TryFromIntError

pub fn try_from(value: usize) -> Result<i128, <i128 as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroUsize> for NonZeroU32

Attempts to convert NonZeroUsize to NonZeroU32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<NonZeroU32> for NonZeroIsize

Attempts to convert NonZeroU32 to NonZeroIsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU32
) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroU32>>::Error>

impl TryFrom<NonZeroI128> for NonZeroU128

Attempts to convert NonZeroI128 to NonZeroU128.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroI128>>::Error>

impl TryFrom<NonZeroU64> for NonZeroU32

Attempts to convert NonZeroU64 to NonZeroU32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU64
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroU64>>::Error>

impl TryFrom<u64> for i16

type Error = TryFromIntError

pub fn try_from(u: u64) -> Result<i16, <i16 as TryFrom<u64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI64> for NonZeroIsize

Attempts to convert NonZeroI64 to NonZeroIsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI64
) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroI64>>::Error>

impl TryFrom<i16> for u32

type Error = TryFromIntError

pub fn try_from(u: i16) -> Result<u32, <u32 as TryFrom<i16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI32> for NonZeroU64

Attempts to convert NonZeroI32 to NonZeroU64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI32
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroI32>>::Error>

impl TryFrom<NonZeroI32> for NonZeroU8

Attempts to convert NonZeroI32 to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI32
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroI32>>::Error>

impl TryFrom<isize> for i32

type Error = TryFromIntError

pub fn try_from(value: isize) -> Result<i32, <i32 as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i8> for u8

type Error = TryFromIntError

pub fn try_from(u: i8) -> Result<u8, <u8 as TryFrom<i8>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u128> for i128

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<i128, <i128 as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u64> for usize

type Error = TryFromIntError

pub fn try_from(u: u64) -> Result<usize, <usize as TryFrom<u64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u16> for i8

type Error = TryFromIntError

pub fn try_from(u: u16) -> Result<i8, <i8 as TryFrom<u16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI64> for NonZeroI32

Attempts to convert NonZeroI64 to NonZeroI32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI64
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroI64>>::Error>

impl TryFrom<NonZeroI64> for NonZeroU32

Attempts to convert NonZeroI64 to NonZeroU32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI64
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI64>>::Error>

impl TryFrom<NonZeroU64> for NonZeroI32

Attempts to convert NonZeroU64 to NonZeroI32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU64
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroU64>>::Error>

impl TryFrom<i8> for u16

type Error = TryFromIntError

pub fn try_from(u: i8) -> Result<u16, <u16 as TryFrom<i8>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u64> for u16

type Error = TryFromIntError

pub fn try_from(u: u64) -> Result<u16, <u16 as TryFrom<u64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i16> for u64

type Error = TryFromIntError

pub fn try_from(u: i16) -> Result<u64, <u64 as TryFrom<i16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i16> for usize

type Error = TryFromIntError

pub fn try_from(u: i16) -> Result<usize, <usize as TryFrom<i16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI16> for NonZeroU32

Attempts to convert NonZeroI16 to NonZeroU32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI16
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI16>>::Error>

impl TryFrom<NonZeroI8> for NonZeroU8

Attempts to convert NonZeroI8 to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI8
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroI8>>::Error>

impl TryFrom<u16> for isize

type Error = TryFromIntError

pub fn try_from(value: u16) -> Result<isize, <isize as TryFrom<u16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU128> for NonZeroU16

Attempts to convert NonZeroU128 to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroU128>>::Error>

impl TryFrom<usize> for i32

type Error = TryFromIntError

pub fn try_from(u: usize) -> Result<i32, <i32 as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroUsize> for NonZeroI32

Attempts to convert NonZeroUsize to NonZeroI32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<i32> for u128

type Error = TryFromIntError

pub fn try_from(u: i32) -> Result<u128, <u128 as TryFrom<i32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i128> for i64

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<i64, <i64 as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u128> for u16

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<u16, <u16 as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI64> for NonZeroUsize

Attempts to convert NonZeroI64 to NonZeroUsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI64
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroI64>>::Error>

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

type Error = TryFromSliceError

pub fn try_from(slice: &[T]) -> Result<&[T; N], TryFromSliceError>

impl TryFrom<i128> for i8

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<i8, <i8 as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u32> for i32

type Error = TryFromIntError

pub fn try_from(u: u32) -> Result<i32, <i32 as TryFrom<u32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU128> for NonZeroI128

Attempts to convert NonZeroU128 to NonZeroI128.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroI128, <NonZeroI128 as TryFrom<NonZeroU128>>::Error>

impl TryFrom<NonZeroIsize> for NonZeroI64

Attempts to convert NonZeroIsize to NonZeroI64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroI64, <NonZeroI64 as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<isize> for u128

type Error = TryFromIntError

pub fn try_from(u: isize) -> Result<u128, <u128 as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU32> for NonZeroI16

Attempts to convert NonZeroU32 to NonZeroI16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU32
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroU32>>::Error>

impl TryFrom<NonZeroIsize> for NonZeroI16

Attempts to convert NonZeroIsize to NonZeroI16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<NonZeroU128> for NonZeroI16

Attempts to convert NonZeroU128 to NonZeroI16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroU128>>::Error>

impl TryFrom<usize> for i8

type Error = TryFromIntError

pub fn try_from(u: usize) -> Result<i8, <i8 as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI8> for NonZeroUsize

Attempts to convert NonZeroI8 to NonZeroUsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI8
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroI8>>::Error>

impl TryFrom<isize> for u64

type Error = TryFromIntError

pub fn try_from(u: isize) -> Result<u64, <u64 as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroIsize> for NonZeroUsize

Attempts to convert NonZeroIsize to NonZeroUsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<u64> for i64

type Error = TryFromIntError

pub fn try_from(u: u64) -> Result<i64, <i64 as TryFrom<u64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI128> for NonZeroIsize

Attempts to convert NonZeroI128 to NonZeroIsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroI128>>::Error>

impl TryFrom<NonZeroI16> for NonZeroUsize

Attempts to convert NonZeroI16 to NonZeroUsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI16
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroI16>>::Error>

impl TryFrom<u128> for u32

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<u32, <u32 as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<isize> for i64

type Error = TryFromIntError

pub fn try_from(value: isize) -> Result<i64, <i64 as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i16> for u128

type Error = TryFromIntError

pub fn try_from(u: i16) -> Result<u128, <u128 as TryFrom<i16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u64> for i8

type Error = TryFromIntError

pub fn try_from(u: u64) -> Result<i8, <i8 as TryFrom<u64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i8> for usize

type Error = TryFromIntError

pub fn try_from(u: i8) -> Result<usize, <usize as TryFrom<i8>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI64> for NonZeroU128

Attempts to convert NonZeroI64 to NonZeroU128.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI64
) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroI64>>::Error>

impl TryFrom<NonZeroUsize> for NonZeroI64

Attempts to convert NonZeroUsize to NonZeroI64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroUsize
) -> Result<NonZeroI64, <NonZeroI64 as TryFrom<NonZeroUsize>>::Error>

impl TryFrom<usize> for isize

type Error = TryFromIntError

pub fn try_from(u: usize) -> Result<isize, <isize as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroIsize> for NonZeroI32

Attempts to convert NonZeroIsize to NonZeroI32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<NonZeroI32> for NonZeroU16

Attempts to convert NonZeroI32 to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI32
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroI32>>::Error>

impl TryFrom<NonZeroU16> for NonZeroI16

Attempts to convert NonZeroU16 to NonZeroI16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU16
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroU16>>::Error>

impl TryFrom<i16> for u8

type Error = TryFromIntError

pub fn try_from(u: i16) -> Result<u8, <u8 as TryFrom<i16>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI64> for NonZeroI16

Attempts to convert NonZeroI64 to NonZeroI16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI64
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<NonZeroI64>>::Error>

impl TryFrom<i16> for NonZeroI16

Attempts to convert i16 to NonZeroI16.

type Error = TryFromIntError

pub fn try_from(
    value: i16
) -> Result<NonZeroI16, <NonZeroI16 as TryFrom<i16>>::Error>

impl TryFrom<i128> for NonZeroI128

Attempts to convert i128 to NonZeroI128.

type Error = TryFromIntError

pub fn try_from(
    value: i128
) -> Result<NonZeroI128, <NonZeroI128 as TryFrom<i128>>::Error>

impl TryFrom<NonZeroI16> for NonZeroU8

Attempts to convert NonZeroI16 to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI16
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroI16>>::Error>

impl TryFrom<isize> for i8

type Error = TryFromIntError

pub fn try_from(u: isize) -> Result<i8, <i8 as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i32> for usize

type Error = TryFromIntError

pub fn try_from(u: i32) -> Result<usize, <usize as TryFrom<i32>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<isize> for usize

type Error = TryFromIntError

pub fn try_from(u: isize) -> Result<usize, <usize as TryFrom<isize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<u128> for i32

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<i32, <i32 as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI128> for NonZeroU32

Attempts to convert NonZeroI128 to NonZeroU32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroU32, <NonZeroU32 as TryFrom<NonZeroI128>>::Error>

impl TryFrom<NonZeroU128> for NonZeroI64

Attempts to convert NonZeroU128 to NonZeroI64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU128
) -> Result<NonZeroI64, <NonZeroI64 as TryFrom<NonZeroU128>>::Error>

impl TryFrom<NonZeroU64> for NonZeroU16

Attempts to convert NonZeroU64 to NonZeroU16.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU64
) -> Result<NonZeroU16, <NonZeroU16 as TryFrom<NonZeroU64>>::Error>

impl TryFrom<NonZeroI16> for NonZeroU128

Attempts to convert NonZeroI16 to NonZeroU128.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI16
) -> Result<NonZeroU128, <NonZeroU128 as TryFrom<NonZeroI16>>::Error>

impl TryFrom<NonZeroI16> for NonZeroI8

Attempts to convert NonZeroI16 to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI16
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroI16>>::Error>

impl TryFrom<i128> for u16

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<u16, <u16 as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroIsize> for NonZeroI128

Attempts to convert NonZeroIsize to NonZeroI128.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroIsize
) -> Result<NonZeroI128, <NonZeroI128 as TryFrom<NonZeroIsize>>::Error>

impl TryFrom<NonZeroI64> for NonZeroU64

Attempts to convert NonZeroI64 to NonZeroU64.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI64
) -> Result<NonZeroU64, <NonZeroU64 as TryFrom<NonZeroI64>>::Error>

impl TryFrom<i64> for i16

type Error = TryFromIntError

pub fn try_from(u: i64) -> Result<i16, <i16 as TryFrom<i64>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<i8> for u32

type Error = TryFromIntError

pub fn try_from(u: i8) -> Result<u32, <u32 as TryFrom<i8>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroI128> for NonZeroUsize

Attempts to convert NonZeroI128 to NonZeroUsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroI128
) -> Result<NonZeroUsize, <NonZeroUsize as TryFrom<NonZeroI128>>::Error>

impl TryFrom<NonZeroU64> for NonZeroU8

Attempts to convert NonZeroU64 to NonZeroU8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU64
) -> Result<NonZeroU8, <NonZeroU8 as TryFrom<NonZeroU64>>::Error>

impl TryFrom<NonZeroU32> for NonZeroI32

Attempts to convert NonZeroU32 to NonZeroI32.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU32
) -> Result<NonZeroI32, <NonZeroI32 as TryFrom<NonZeroU32>>::Error>

impl TryFrom<u128> for i8

type Error = TryFromIntError

pub fn try_from(u: u128) -> Result<i8, <i8 as TryFrom<u128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<NonZeroU32> for NonZeroI8

Attempts to convert NonZeroU32 to NonZeroI8.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU32
) -> Result<NonZeroI8, <NonZeroI8 as TryFrom<NonZeroU32>>::Error>

impl TryFrom<NonZeroU64> for NonZeroIsize

Attempts to convert NonZeroU64 to NonZeroIsize.

type Error = TryFromIntError

pub fn try_from(
    value: NonZeroU64
) -> Result<NonZeroIsize, <NonZeroIsize as TryFrom<NonZeroU64>>::Error>

impl TryFrom<i128> for i32

type Error = TryFromIntError

pub fn try_from(u: i128) -> Result<i32, <i32 as TryFrom<i128>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl TryFrom<usize> for i16

type Error = TryFromIntError

pub fn try_from(u: usize) -> Result<i16, <i16 as TryFrom<usize>>::Error>

Try to create the target number type from a source number type. This returns an error if the source value is outside of the range of the target type.

impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N] where
    A: Allocator, 

type Error = Vec<T, A>

pub fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>

Gets the entire contents of the Vec<T> as an array, if its size exactly matches that of the requested array.

Examples

use std::convert::TryInto;
assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
assert_eq!(<Vec<i32>>::new().try_into(), Ok([]));

If the length doesn’t match, the input comes back in Err:

use std::convert::TryInto;
let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));

If you’re fine with just getting a prefix of the Vec<T>, you can call .truncate(N) first.

use std::convert::TryInto;
let mut v = String::from("hello world").into_bytes();
v.sort();
v.truncate(2);
let [a, b]: [_; 2] = v.try_into().unwrap();
assert_eq!(a, b' ');
assert_eq!(b, b'd');

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

type Error = Arc<[T]>

pub fn try_from(
    boxed_slice: Arc<[T]>
) -> Result<Arc<[T; N]>, <Arc<[T; N]> as TryFrom<Arc<[T]>>>::Error>

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

type Error = Rc<[T]>

pub fn try_from(
    boxed_slice: Rc<[T]>
) -> Result<Rc<[T; N]>, <Rc<[T; N]> as TryFrom<Rc<[T]>>>::Error>

impl<T, const N: usize> TryFrom<Box<[T], Global>> for Box<[T; N], Global>

type Error = Box<[T], Global>

pub fn try_from(
    boxed_slice: Box<[T], Global>
) -> Result<Box<[T; N], Global>, <Box<[T; N], Global> as TryFrom<Box<[T], Global>>>::Error>

impl TryFrom<SerializedBytes> for ()

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<(), SerializedBytesError>

impl<'_> TryFrom<&'_ Timestamp> for DateTime<Utc>

type Error = TimestampError

pub fn try_from(
    t: &Timestamp
) -> Result<DateTime<Utc>, <DateTime<Utc> as TryFrom<&'_ Timestamp>>::Error>

impl TryFrom<Timestamp> for DateTime<Utc>

type Error = TimestampError

pub fn try_from(
    t: Timestamp
) -> Result<DateTime<Utc>, <DateTime<Utc> as TryFrom<Timestamp>>::Error>

impl<'_, A> TryFrom<&'_ [<A as Array>::Item]> for ArrayVec<A> where
    A: Array,
    <A as Array>::Item: Clone, 

Try to create an ArrayVec from a slice. This will return an error if the slice was too big to fit.

use arrayvec::ArrayVec;
use std::convert::TryInto as _;

let array: ArrayVec<[_; 4]> = (&[1, 2, 3] as &[_]).try_into().unwrap();
assert_eq!(array.len(), 3);
assert_eq!(array.capacity(), 4);

type Error = CapacityError<()>

pub fn try_from(
    slice: &[<A as Array>::Item]
) -> Result<ArrayVec<A>, <ArrayVec<A> as TryFrom<&'_ [<A as Array>::Item]>>::Error>

impl TryFrom<&'_ Component> for String

Restoring a String from a Component requires Vec<u8> to u32 to utf8 handling.

type Error = SerializedBytesError

fn try_from(component: &Component) -> Result<Self, Self::Error>

Loading content...

Implementors

impl TryFrom<&'_ Entry> for Anchor

type Error = WasmError

fn try_from(entry: &Entry) -> Result<Self, Self::Error>

impl TryFrom<&'_ Entry> for Path

type Error = WasmError

fn try_from(entry: &Entry) -> Result<Self, Self::Error>

impl TryFrom<&'_ Anchor> for Entry

type Error = WasmError

fn try_from(t: &Anchor) -> Result<Self, Self::Error>

impl TryFrom<&'_ Anchor> for EntryWithDefId where
    Anchor: EntryDefRegistration, 

type Error = WasmError

fn try_from(t: &Anchor) -> Result<Self, Self::Error>

impl TryFrom<&'_ Anchor> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &Anchor) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&'_ Path> for Entry

type Error = WasmError

fn try_from(t: &Path) -> Result<Self, Self::Error>

impl TryFrom<&'_ Path> for Anchor

Paths are more general than anchors so a path could be represented that is not a valid anchor. The obvious example would be a path of binary data that is not valid utf-8 strings or a path that is more than 2 levels deep.

type Error = SerializedBytesError

fn try_from(path: &Path) -> Result<Self, Self::Error>

impl TryFrom<&'_ Path> for EntryWithDefId where
    Path: EntryDefRegistration, 

type Error = WasmError

fn try_from(t: &Path) -> Result<Self, Self::Error>

impl TryFrom<&'_ Path> for LinkTag

type Error = SerializedBytesError

fn try_from(path: &Path) -> Result<Self, Self::Error>

impl TryFrom<&'_ Path> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: &Path) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<&'_ LinkTag> for Path

type Error = SerializedBytesError

fn try_from(link_tag: &LinkTag) -> Result<Self, Self::Error>

impl TryFrom<ActivityRequest> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ActivityRequest
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Details> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Details) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ElementEntry> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ElementEntry
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Entry> for Anchor

type Error = WasmError

fn try_from(entry: Entry) -> Result<Self, Self::Error>

impl TryFrom<Entry> for Path

type Error = WasmError

fn try_from(entry: Entry) -> Result<Self, Self::Error>

impl TryFrom<Entry> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Entry) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<EntryDefsCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: EntryDefsCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<EntryType> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: EntryType) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<EntryVisibility> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: EntryVisibility
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Header> for CreateLink

type Error = WrongHeaderError

pub fn try_from(
    value: Header
) -> Result<CreateLink, <CreateLink as TryFrom<Header>>::Error>

impl TryFrom<Header> for Delete

type Error = WrongHeaderError

pub fn try_from(
    value: Header
) -> Result<Delete, <Delete as TryFrom<Header>>::Error>

impl TryFrom<Header> for DeleteLink

type Error = WrongHeaderError

pub fn try_from(
    value: Header
) -> Result<DeleteLink, <DeleteLink as TryFrom<Header>>::Error>

impl TryFrom<Header> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Header) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Header> for Update

type Error = WrongHeaderError

pub fn try_from(
    value: Header
) -> Result<Update, <Update as TryFrom<Header>>::Error>

impl TryFrom<HeaderType> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: HeaderType) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<InitCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: InitCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<MigrateAgent> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: MigrateAgent
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<MigrateAgentCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: MigrateAgentCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<PostCommitCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: PostCommitCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ValidateCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ValidateCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ValidateLinkCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ValidateLinkCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ValidationPackageCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ValidationPackageCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<WasmError> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: WasmError) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ZomeCallResponse> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ZomeCallResponse
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<()> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: ()) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Anchor> for Entry

type Error = WasmError

fn try_from(t: Anchor) -> Result<Self, Self::Error>

impl TryFrom<Anchor> for EntryWithDefId

type Error = WasmError

fn try_from(t: Anchor) -> Result<Self, Self::Error>

impl TryFrom<Anchor> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: Anchor) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Path> for Entry

type Error = WasmError

fn try_from(t: Path) -> Result<Self, Self::Error>

impl TryFrom<Path> for EntryWithDefId

type Error = WasmError

fn try_from(t: Path) -> Result<Self, Self::Error>

impl TryFrom<Path> for SerializedBytes

type Error = SerializedBytesError

fn try_from(t: Path) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<AgentActivity> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: AgentActivity
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<AgentInfo> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: AgentInfo) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<AgentValidationPkg> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: AgentValidationPkg
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<AppEntryType> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: AppEntryType
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<CapClaim> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: CapClaim) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<CapSecret> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: CapSecret) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<CellId> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: CellId) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ChainQueryFilter> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ChainQueryFilter
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<CloseChain> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: CloseChain) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Create> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Create) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<CreateLink> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: CreateLink) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Delete> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Delete) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<DeleteHeader> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: DeleteHeader
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<DeleteLink> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: DeleteLink) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Dna> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Dna) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Element> for CreateLink

type Error = WrongHeaderError

pub fn try_from(
    value: Element
) -> Result<CreateLink, <CreateLink as TryFrom<Element>>::Error>

impl TryFrom<Element> for DeleteLink

type Error = WrongHeaderError

pub fn try_from(
    value: Element
) -> Result<DeleteLink, <DeleteLink as TryFrom<Element>>::Error>

impl TryFrom<Element> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Element) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ElementDetails> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ElementDetails
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<EntryDefIndex> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: EntryDefIndex
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<EntryDetails> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: EntryDetails
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<EntryHashes> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: EntryHashes) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<EntryWithDefId> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: EntryWithDefId
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<HeaderHashedVec> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: HeaderHashedVec
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<HeaderHashes> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: HeaderHashes
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<InitZomesComplete> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: InitZomesComplete
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Link> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Link) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<LinkDetails> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: LinkDetails) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<LinkTag> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: LinkTag) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Links> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Links) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<OpenChain> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: OpenChain) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<RemoteSignal> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: RemoteSignal
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<SerializedBytes> for ActivityRequest

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ActivityRequest, SerializedBytesError>

impl TryFrom<SerializedBytes> for Details

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Details, SerializedBytesError>

impl TryFrom<SerializedBytes> for ElementEntry

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ElementEntry, SerializedBytesError>

impl TryFrom<SerializedBytes> for Entry

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Entry, SerializedBytesError>

impl TryFrom<SerializedBytes> for EntryDefsCallbackResult

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<EntryDefsCallbackResult, SerializedBytesError>

impl TryFrom<SerializedBytes> for EntryType

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<EntryType, SerializedBytesError>

impl TryFrom<SerializedBytes> for EntryVisibility

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<EntryVisibility, SerializedBytesError>

impl TryFrom<SerializedBytes> for Header

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Header, SerializedBytesError>

impl TryFrom<SerializedBytes> for HeaderType

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<HeaderType, SerializedBytesError>

impl TryFrom<SerializedBytes> for InitCallbackResult

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<InitCallbackResult, SerializedBytesError>

impl TryFrom<SerializedBytes> for MigrateAgent

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<MigrateAgent, SerializedBytesError>

impl TryFrom<SerializedBytes> for MigrateAgentCallbackResult

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<MigrateAgentCallbackResult, SerializedBytesError>

impl TryFrom<SerializedBytes> for PostCommitCallbackResult

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<PostCommitCallbackResult, SerializedBytesError>

impl TryFrom<SerializedBytes> for ValidateCallbackResult

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ValidateCallbackResult, SerializedBytesError>

impl TryFrom<SerializedBytes> for ValidateLinkCallbackResult

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ValidateLinkCallbackResult, SerializedBytesError>

impl TryFrom<SerializedBytes> for ValidationPackageCallbackResult

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ValidationPackageCallbackResult, SerializedBytesError>

impl TryFrom<SerializedBytes> for WasmError

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<WasmError, SerializedBytesError>

impl TryFrom<SerializedBytes> for ZomeCallResponse

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ZomeCallResponse, SerializedBytesError>

impl TryFrom<SerializedBytes> for Anchor

type Error = SerializedBytesError

fn try_from(sb: SerializedBytes) -> Result<Anchor, SerializedBytesError>

impl TryFrom<SerializedBytes> for Path

type Error = SerializedBytesError

fn try_from(sb: SerializedBytes) -> Result<Path, SerializedBytesError>

impl TryFrom<SerializedBytes> for AgentActivity

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<AgentActivity, SerializedBytesError>

impl TryFrom<SerializedBytes> for AgentInfo

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<AgentInfo, SerializedBytesError>

impl TryFrom<SerializedBytes> for AgentValidationPkg

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<AgentValidationPkg, SerializedBytesError>

impl TryFrom<SerializedBytes> for AppEntryBytes

type Error = EntryError

pub fn try_from(sb: SerializedBytes) -> Result<AppEntryBytes, EntryError>

impl TryFrom<SerializedBytes> for AppEntryType

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<AppEntryType, SerializedBytesError>

impl TryFrom<SerializedBytes> for CapClaim

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<CapClaim, SerializedBytesError>

impl TryFrom<SerializedBytes> for CapSecret

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<CapSecret, SerializedBytesError>

impl TryFrom<SerializedBytes> for CellId

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<CellId, SerializedBytesError>

impl TryFrom<SerializedBytes> for ChainQueryFilter

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ChainQueryFilter, SerializedBytesError>

impl TryFrom<SerializedBytes> for CloseChain

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<CloseChain, SerializedBytesError>

impl TryFrom<SerializedBytes> for Create

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Create, SerializedBytesError>

impl TryFrom<SerializedBytes> for CreateLink

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<CreateLink, SerializedBytesError>

impl TryFrom<SerializedBytes> for Delete

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Delete, SerializedBytesError>

impl TryFrom<SerializedBytes> for DeleteHeader

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<DeleteHeader, SerializedBytesError>

impl TryFrom<SerializedBytes> for DeleteLink

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<DeleteLink, SerializedBytesError>

impl TryFrom<SerializedBytes> for Dna

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Dna, SerializedBytesError>

impl TryFrom<SerializedBytes> for Element

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Element, SerializedBytesError>

impl TryFrom<SerializedBytes> for ElementDetails

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ElementDetails, SerializedBytesError>

impl TryFrom<SerializedBytes> for EntryDefIndex

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<EntryDefIndex, SerializedBytesError>

impl TryFrom<SerializedBytes> for EntryDetails

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<EntryDetails, SerializedBytesError>

impl TryFrom<SerializedBytes> for EntryHashes

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<EntryHashes, SerializedBytesError>

impl TryFrom<SerializedBytes> for EntryWithDefId

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<EntryWithDefId, SerializedBytesError>

impl TryFrom<SerializedBytes> for HeaderHashedVec

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<HeaderHashedVec, SerializedBytesError>

impl TryFrom<SerializedBytes> for HeaderHashes

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<HeaderHashes, SerializedBytesError>

impl TryFrom<SerializedBytes> for InitZomesComplete

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<InitZomesComplete, SerializedBytesError>

impl TryFrom<SerializedBytes> for Link

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Link, SerializedBytesError>

impl TryFrom<SerializedBytes> for LinkDetails

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<LinkDetails, SerializedBytesError>

impl TryFrom<SerializedBytes> for LinkTag

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<LinkTag, SerializedBytesError>

impl TryFrom<SerializedBytes> for Links

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Links, SerializedBytesError>

impl TryFrom<SerializedBytes> for OpenChain

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<OpenChain, SerializedBytesError>

impl TryFrom<SerializedBytes> for RemoteSignal

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<RemoteSignal, SerializedBytesError>

impl TryFrom<SerializedBytes> for Sign

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Sign, SerializedBytesError>

impl TryFrom<SerializedBytes> for Signature

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Signature, SerializedBytesError>

impl TryFrom<SerializedBytes> for SignedHeader

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<SignedHeader, SerializedBytesError>

impl TryFrom<SerializedBytes> for Timestamp

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Timestamp, SerializedBytesError>

impl TryFrom<SerializedBytes> for Update

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Update, SerializedBytesError>

impl TryFrom<SerializedBytes> for UpdateHeader

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<UpdateHeader, SerializedBytesError>

impl TryFrom<SerializedBytes> for ValidateCreateLinkData

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ValidateCreateLinkData, SerializedBytesError>

impl TryFrom<SerializedBytes> for ValidateData

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ValidateData, SerializedBytesError>

impl TryFrom<SerializedBytes> for ValidateDeleteLinkData

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ValidateDeleteLinkData, SerializedBytesError>

impl TryFrom<SerializedBytes> for ValidationPackage

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<ValidationPackage, SerializedBytesError>

impl TryFrom<SerializedBytes> for VerifySignature

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<VerifySignature, SerializedBytesError>

impl TryFrom<SerializedBytes> for Warrant

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<Warrant, SerializedBytesError>

impl TryFrom<SerializedBytes> for X25519PubKey

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<X25519PubKey, SerializedBytesError>

impl TryFrom<SerializedBytes> for X25519XSalsa20Poly1305Decrypt

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<X25519XSalsa20Poly1305Decrypt, SerializedBytesError>

impl TryFrom<SerializedBytes> for X25519XSalsa20Poly1305Encrypt

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<X25519XSalsa20Poly1305Encrypt, SerializedBytesError>

impl TryFrom<SerializedBytes> for XSalsa20Poly1305Decrypt

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<XSalsa20Poly1305Decrypt, SerializedBytesError>

impl TryFrom<SerializedBytes> for XSalsa20Poly1305Encrypt

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<XSalsa20Poly1305Encrypt, SerializedBytesError>

impl TryFrom<SerializedBytes> for XSalsa20Poly1305KeyRef

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<XSalsa20Poly1305KeyRef, SerializedBytesError>

impl TryFrom<SerializedBytes> for ZomeId

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<ZomeId, SerializedBytesError>

impl TryFrom<SerializedBytes> for ZomeInfo

type Error = SerializedBytesError

pub fn try_from(sb: SerializedBytes) -> Result<ZomeInfo, SerializedBytesError>

impl TryFrom<SerializedBytes> for XSalsa20Poly1305Nonce

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<XSalsa20Poly1305Nonce, SerializedBytesError>

impl TryFrom<Sign> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Sign) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Signature> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Signature) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<SignedHeader> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: SignedHeader
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Timestamp> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Timestamp) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Update> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Update) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<UpdateHeader> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: UpdateHeader
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ValidateCreateLinkData> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ValidateCreateLinkData
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ValidateData> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ValidateData
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ValidateDeleteLinkData> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ValidateDeleteLinkData
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ValidationPackage> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: ValidationPackage
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<VerifySignature> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: VerifySignature
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<Warrant> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: Warrant) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<X25519PubKey> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: X25519PubKey
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<X25519XSalsa20Poly1305Decrypt> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: X25519XSalsa20Poly1305Decrypt
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<X25519XSalsa20Poly1305Encrypt> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: X25519XSalsa20Poly1305Encrypt
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<XSalsa20Poly1305Decrypt> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: XSalsa20Poly1305Decrypt
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<XSalsa20Poly1305Encrypt> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: XSalsa20Poly1305Encrypt
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<XSalsa20Poly1305KeyRef> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: XSalsa20Poly1305KeyRef
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ZomeId> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: ZomeId) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<ZomeInfo> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: ZomeInfo) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<XSalsa20Poly1305Nonce> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: XSalsa20Poly1305Nonce
) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<String> for Timestamp

type Error = TimestampError

pub fn try_from(
    t: String
) -> Result<Timestamp, <Timestamp as TryFrom<String>>::Error>

impl TryFrom<BoolWrap> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: BoolWrap) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<StringWrap> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: StringWrap) -> Result<SerializedBytes, SerializedBytesError>

impl TryFrom<U32Wrap> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: U32Wrap) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ActivityRequest> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ActivityRequest
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Details> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Details) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ElementEntry> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ElementEntry
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Entry> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Entry) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ EntryDefsCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &EntryDefsCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ EntryType> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &EntryType) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ EntryVisibility> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &EntryVisibility
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Header> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Header) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ HeaderType> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &HeaderType) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ InitCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &InitCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ MigrateAgent> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &MigrateAgent
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ MigrateAgentCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &MigrateAgentCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ PostCommitCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &PostCommitCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ValidateCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ValidateCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ValidateLinkCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ValidateLinkCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ValidationPackageCallbackResult> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ValidationPackageCallbackResult
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ WasmError> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &WasmError) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ZomeCallResponse> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ZomeCallResponse
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ str> for Timestamp

type Error = TimestampError

pub fn try_from(
    t: &str
) -> Result<Timestamp, <Timestamp as TryFrom<&'_ str>>::Error>

impl<'_> TryFrom<&'_ ()> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &()) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ AgentActivity> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &AgentActivity
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ AgentInfo> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &AgentInfo) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ AgentValidationPkg> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &AgentValidationPkg
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ AppEntryType> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &AppEntryType
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ CapClaim> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &CapClaim) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ CapSecret> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &CapSecret) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ CellId> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &CellId) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ChainQueryFilter> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ChainQueryFilter
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ CloseChain> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &CloseChain) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Create> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Create) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ CreateLink> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &CreateLink) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Delete> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Delete) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ DeleteHeader> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &DeleteHeader
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ DeleteLink> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &DeleteLink) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Dna> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Dna) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Element> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Element) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ElementDetails> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ElementDetails
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ EntryDefIndex> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &EntryDefIndex
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ EntryDetails> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &EntryDetails
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ EntryHashes> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &EntryHashes
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ EntryWithDefId> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &EntryWithDefId
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ HeaderHashedVec> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &HeaderHashedVec
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ HeaderHashes> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &HeaderHashes
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ InitZomesComplete> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &InitZomesComplete
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Link> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Link) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ LinkDetails> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &LinkDetails
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ LinkTag> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &LinkTag) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Links> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Links) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ OpenChain> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &OpenChain) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ RemoteSignal> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &RemoteSignal
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Sign> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Sign) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Signature> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Signature) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ SignedHeader> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &SignedHeader
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Timestamp> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Timestamp) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Update> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Update) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ UpdateHeader> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &UpdateHeader
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ValidateCreateLinkData> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ValidateCreateLinkData
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ValidateData> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ValidateData
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ValidateDeleteLinkData> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ValidateDeleteLinkData
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ValidationPackage> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &ValidationPackage
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ VerifySignature> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &VerifySignature
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ Warrant> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &Warrant) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ X25519PubKey> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &X25519PubKey
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ X25519XSalsa20Poly1305Decrypt> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &X25519XSalsa20Poly1305Decrypt
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ X25519XSalsa20Poly1305Encrypt> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &X25519XSalsa20Poly1305Encrypt
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ XSalsa20Poly1305Decrypt> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &XSalsa20Poly1305Decrypt
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ XSalsa20Poly1305Encrypt> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &XSalsa20Poly1305Encrypt
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ XSalsa20Poly1305KeyRef> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &XSalsa20Poly1305KeyRef
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ZomeId> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &ZomeId) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ ZomeInfo> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &ZomeInfo) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ XSalsa20Poly1305Nonce> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    t: &XSalsa20Poly1305Nonce
) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ String> for Timestamp

type Error = TimestampError

pub fn try_from(
    t: &String
) -> Result<Timestamp, <Timestamp as TryFrom<&'_ String>>::Error>

impl<'_> TryFrom<&'_ BoolWrap> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &BoolWrap) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ StringWrap> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &StringWrap) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ U32Wrap> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(t: &U32Wrap) -> Result<SerializedBytes, SerializedBytesError>

impl<'_> TryFrom<&'_ [u8]> for CapSecret

type Error = SecurePrimitiveError

pub fn try_from(
    slice: &[u8]
) -> Result<CapSecret, <CapSecret as TryFrom<&'_ [u8]>>::Error>

impl<'_> TryFrom<&'_ [u8]> for X25519PubKey

type Error = SecurePrimitiveError

pub fn try_from(
    slice: &[u8]
) -> Result<X25519PubKey, <X25519PubKey as TryFrom<&'_ [u8]>>::Error>

impl<'_> TryFrom<&'_ [u8]> for XSalsa20Poly1305KeyRef

type Error = SecurePrimitiveError

pub fn try_from(
    slice: &[u8]
) -> Result<XSalsa20Poly1305KeyRef, <XSalsa20Poly1305KeyRef as TryFrom<&'_ [u8]>>::Error>

impl<'_> TryFrom<&'_ [u8]> for XSalsa20Poly1305Nonce

type Error = SecurePrimitiveError

pub fn try_from(
    slice: &[u8]
) -> Result<XSalsa20Poly1305Nonce, <XSalsa20Poly1305Nonce as TryFrom<&'_ [u8]>>::Error>

impl<'_, P> TryFrom<&'_ str> for HoloHash<P> where
    P: PrimitiveHashType, 

type Error = HoloHashError

pub fn try_from(s: &str) -> Result<HoloHash<P>, HoloHashError>

impl<'_, P> TryFrom<&'_ String> for HoloHash<P> where
    P: PrimitiveHashType, 

type Error = HoloHashError

pub fn try_from(s: &String) -> Result<HoloHash<P>, HoloHashError>

impl<'_, T> TryFrom<&'_ HoloHash<T>> for SerializedBytes where
    T: HashType, 

type Error = SerializedBytesError

pub fn try_from(
    t: &HoloHash<T>
) -> Result<SerializedBytes, SerializedBytesError>

impl<'a> TryFrom<&'a Header> for &'a CreateLink

type Error = WrongHeaderError

pub fn try_from(
    value: &'a Header
) -> Result<&'a CreateLink, <&'a CreateLink as TryFrom<&'a Header>>::Error>

impl<'a> TryFrom<&'a Header> for &'a Delete

type Error = WrongHeaderError

pub fn try_from(
    value: &'a Header
) -> Result<&'a Delete, <&'a Delete as TryFrom<&'a Header>>::Error>

impl<'a> TryFrom<&'a Header> for &'a DeleteLink

type Error = WrongHeaderError

pub fn try_from(
    value: &'a Header
) -> Result<&'a DeleteLink, <&'a DeleteLink as TryFrom<&'a Header>>::Error>

impl<'a> TryFrom<&'a Header> for &'a Update

type Error = WrongHeaderError

pub fn try_from(
    value: &'a Header
) -> Result<&'a Update, <&'a Update as TryFrom<&'a Header>>::Error>

impl<'a> TryFrom<&'a SerializedBytes> for SerializedBytes

type Error = SerializedBytesError

pub fn try_from(
    s: &'a SerializedBytes
) -> Result<SerializedBytes, <SerializedBytes as TryFrom<&'a SerializedBytes>>::Error>

impl<P> TryFrom<String> for HoloHash<P> where
    P: PrimitiveHashType, 

type Error = HoloHashError

pub fn try_from(s: String) -> Result<HoloHash<P>, HoloHashError>

impl<T> TryFrom<HoloHash<T>> for SerializedBytes where
    T: HashType, 

type Error = SerializedBytesError

pub fn try_from(t: HoloHash<T>) -> Result<SerializedBytes, SerializedBytesError>

impl<T> TryFrom<SerializedBytes> for HoloHash<T> where
    T: HashType, 

type Error = SerializedBytesError

pub fn try_from(
    sb: SerializedBytes
) -> Result<HoloHash<T>, SerializedBytesError>

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Loading content...