Trait kas_core::cast::Conv

source ·

pub trait Conv<T>: Sized {
    // Required method
    fn try_conv(v: T) -> Result<Self, Error>;

    // Provided method
    fn conv(v: T) -> Self { ... }
}

Expand description

Like From, but supports fallible conversions

This trait is intented to be an extension over From, also supporting fallible conversions of numeric types. Since Rust does not yet have stable support for handling conflicting implementations (specialization or otherwise), only conversions between the most important numeric types are supported for now.

The sister-trait Cast supports “into” style usage.

Required Methods§

source

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

Try converting from T to Self

This method must fail on inexact conversions.

Provided Methods§

source

fn conv(v: T) -> Self

Convert from T to Self

This method must return the same result as Self::try_conv where that method succeeds, but differs in the handling of errors:

In debug builds the method panics on error
Otherwise, the method may panic or may return a different value, but like with the as keyword all results must be well-defined and safe.

Default implementations use Self::try_conv and panic on error. Implementations provided by this library will panic in debug builds or if the always_assert feature flag is used, and otherwise will behave identically to the as keyword.

This mirrors the behaviour of Rust’s overflow checks on integer arithmetic in that it is a tool for diagnosing logic errors where success is expected.

Object Safety§

This trait is not object safe.

Trait kas_core::cast::Conv

Required Methods§

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

Provided Methods§

fn conv(v: T) -> Self

Object Safety§

Implementations on Foreign Types§

impl Conv<f32> for f32

fn conv(x: f32) -> f32

fn try_conv(x: f32) -> Result<f32, Error>

impl Conv<f32> for f64

fn conv(x: f32) -> f64

fn try_conv(x: f32) -> Result<f64, Error>

impl Conv<f64> for f64

fn conv(x: f64) -> f64

fn try_conv(x: f64) -> Result<f64, Error>

impl Conv<i8> for f32

fn conv(x: i8) -> f32

fn try_conv(x: i8) -> Result<f32, Error>

impl Conv<i8> for f64

fn conv(x: i8) -> f64

fn try_conv(x: i8) -> Result<f64, Error>

impl Conv<i8> for i8

fn conv(x: i8) -> i8

fn try_conv(x: i8) -> Result<i8, Error>

impl Conv<i8> for i16

fn conv(x: i8) -> i16

fn try_conv(x: i8) -> Result<i16, Error>

impl Conv<i8> for i32

fn conv(x: i8) -> i32

fn try_conv(x: i8) -> Result<i32, Error>

impl Conv<i8> for i64

fn conv(x: i8) -> i64

fn try_conv(x: i8) -> Result<i64, Error>

impl Conv<i8> for i128

fn conv(x: i8) -> i128

fn try_conv(x: i8) -> Result<i128, Error>

impl Conv<i8> for isize

fn conv(x: i8) -> isize

fn try_conv(x: i8) -> Result<isize, Error>

impl Conv<i8> for u8

fn conv(x: i8) -> u8

fn try_conv(x: i8) -> Result<u8, Error>

impl Conv<i8> for u16

fn conv(x: i8) -> u16

fn try_conv(x: i8) -> Result<u16, Error>

impl Conv<i8> for u32

fn conv(x: i8) -> u32

fn try_conv(x: i8) -> Result<u32, Error>

impl Conv<i8> for u64

fn conv(x: i8) -> u64

fn try_conv(x: i8) -> Result<u64, Error>

impl Conv<i8> for u128

fn conv(x: i8) -> u128

fn try_conv(x: i8) -> Result<u128, Error>

impl Conv<i8> for usize

fn conv(x: i8) -> usize

fn try_conv(x: i8) -> Result<usize, Error>

impl Conv<i16> for f32

fn conv(x: i16) -> f32

fn try_conv(x: i16) -> Result<f32, Error>

impl Conv<i16> for f64

fn conv(x: i16) -> f64

fn try_conv(x: i16) -> Result<f64, Error>

impl Conv<i16> for i8

fn conv(x: i16) -> i8

fn try_conv(x: i16) -> Result<i8, Error>

impl Conv<i16> for i16

fn conv(x: i16) -> i16

fn try_conv(x: i16) -> Result<i16, Error>

impl Conv<i16> for i32

fn conv(x: i16) -> i32

fn try_conv(x: i16) -> Result<i32, Error>

impl Conv<i16> for i64

fn conv(x: i16) -> i64

fn try_conv(x: i16) -> Result<i64, Error>

impl Conv<i16> for i128

fn conv(x: i16) -> i128

fn try_conv(x: i16) -> Result<i128, Error>

impl Conv<i16> for isize