Trait FromRef

pub trait FromRef {
    type Ref;

    // Required method
    fn from_ref(ref_: &Self::Ref) -> Self;
}

Required Associated Types

type Ref

Required Methods

fn from_ref(ref_: &Self::Ref) -> Self

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl FromRef for bool

type Ref = bool

fn from_ref(ref_: &<bool as FromRef>::Ref) -> bool

impl FromRef for char

type Ref = char

fn from_ref(ref_: &<char as FromRef>::Ref) -> char

impl FromRef for f32

type Ref = f32

fn from_ref(ref_: &<f32 as FromRef>::Ref) -> f32

impl FromRef for f64

type Ref = f64

fn from_ref(ref_: &<f64 as FromRef>::Ref) -> f64

impl FromRef for i8

type Ref = i8

fn from_ref(ref_: &<i8 as FromRef>::Ref) -> i8

impl FromRef for i16

type Ref = i16

fn from_ref(ref_: &<i16 as FromRef>::Ref) -> i16

impl FromRef for i32

type Ref = i32

fn from_ref(ref_: &<i32 as FromRef>::Ref) -> i32

impl FromRef for i64

type Ref = i64

fn from_ref(ref_: &<i64 as FromRef>::Ref) -> i64

impl FromRef for isize

type Ref = isize

fn from_ref(ref_: &<isize as FromRef>::Ref) -> isize

impl FromRef for u8

type Ref = u8

fn from_ref(ref_: &<u8 as FromRef>::Ref) -> u8

impl FromRef for u16

type Ref = u16

fn from_ref(ref_: &<u16 as FromRef>::Ref) -> u16

impl FromRef for u32

type Ref = u32

fn from_ref(ref_: &<u32 as FromRef>::Ref) -> u32

impl FromRef for u64

type Ref = u64

fn from_ref(ref_: &<u64 as FromRef>::Ref) -> u64

impl FromRef for usize

type Ref = usize

fn from_ref(ref_: &<usize as FromRef>::Ref) -> usize

impl FromRef for String

type Ref = StringRef

fn from_ref(ref_: &<String as FromRef>::Ref) -> String

impl<T> FromRef for Vec<T>

where T: FromRef,

type Ref = ListRef

fn from_ref(ref_: &<Vec<T> as FromRef>::Ref) -> Vec<T>

Implementors