Trait TryFromSpecImpl 

pub trait TryFromSpecImpl<T>: Sized + TryFrom<T> {
    // Required methods
    exec fn obeys_try_from_spec() -> bool;
    exec fn try_from_spec(v: T) -> Result<Self, Self::Error>;
}

Required Methods

exec fn obeys_try_from_spec() -> bool

exec fn try_from_spec(v: T) -> Result<Self, Self::Error>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl TryFromSpecImpl<i8> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i8) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i8> for u16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i8) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i8> for u32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i8) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i8> for u64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i8) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i8> for u128

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i8) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u128) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i8> for usize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i8) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as usize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i16> for i8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i16) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i16> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i16) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i16> for u16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i16) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i16> for u32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i16) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i16> for u64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i16) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i16> for u128

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i16) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u128) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i16> for usize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i16) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as usize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i32> for i8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i32> for i16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i32> for isize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as isize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i32> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i32> for u16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i32> for u32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i32> for u64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i32> for u128

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u128) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i32> for usize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as usize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i64> for i8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i64> for i16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i64> for i32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i64> for isize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as isize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i64> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i64> for u16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i64> for u32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i64> for u64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i64> for u128

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u128) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i64> for usize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as usize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for i8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for i16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for i32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for i64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for isize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as isize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for u16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for u32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for u64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for u128

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u128) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<i128> for usize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: i128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as usize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for i8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for i16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for i32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for i64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for i128

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i128) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for u16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for u32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for u64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for u128

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u128) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<isize> for usize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: isize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as usize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u16> for i8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u16) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u16> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u16) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u32> for i8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u32> for i16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u32> for isize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as isize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u32> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u32> for u16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u32> for usize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u32) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as usize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u64> for i8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u64> for i16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u64> for i32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u64> for isize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as isize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u64> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u64> for u16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u64> for u32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u64> for usize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u64) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as usize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u128> for i8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u128> for i16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u128> for i32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u128> for i64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u128> for isize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as isize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u128> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u128> for u16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u128> for u32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u128> for u64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<u128> for usize

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: u128) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as usize) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<usize> for i8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: usize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<usize> for i16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: usize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<usize> for i32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: usize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<usize> for i64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: usize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as i64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<usize> for u8

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: usize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u8) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<usize> for u16

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: usize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u16) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<usize> for u32

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: usize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u32) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<usize> for u64

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: usize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u64) } else { Err(arbitrary()) } }

impl TryFromSpecImpl<usize> for u128

open spec fn obeys_try_from_spec() -> bool

{ true }

open spec fn try_from_spec(v: usize) -> Result<Self, Self::Error>

{ if Self::MIN <= v <= Self::MAX { Ok(v as u128) } else { Err(arbitrary()) } }

Implementors