Struct transient::Inv

pub struct Inv<'a>(/* private fields */);

Used to declare an invariant relationship between a type and its lifetime parameter.

An invariant type is one for which the compiler cannot safely assume that its lifetime may be shortened or lengthened (e.g. 'b in &'a mut &'b T). Such a type must therefore match the expected lifetime exactly when passed to a function.

See the Transience documentation for more information.

Trait Implementations

impl<'a> Clone for Inv<'a>

fn clone(&self) -> Inv<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Inv<'a>

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

Formats the value using the given formatter.

impl<'a, R> CanRecoverFrom<(R,)> for Inv<'a>

where Inv<'a>: CanRecoverFrom<R>,

impl<'a, R1, R2> CanRecoverFrom<(R1, R2)> for Inv<'a>

where Inv<'a>: CanRecoverFrom<R1> + CanRecoverFrom<R2>,

impl<'a, R1, R2, R3> CanRecoverFrom<(R1, R2, R3)> for Inv<'a>

where Inv<'a>: CanRecoverFrom<R1> + CanRecoverFrom<R2> + CanRecoverFrom<R3>,

impl<'a, R1, R2, R3, R4> CanRecoverFrom<(R1, R2, R3, R4)> for Inv<'a>

where Inv<'a>: CanRecoverFrom<R1> + CanRecoverFrom<R2> + CanRecoverFrom<R3> + CanRecoverFrom<R4>,

impl<'a, 'b: 'a> CanRecoverFrom<Co<'b>> for Inv<'a>

impl<'a, 'b: 'a> CanRecoverFrom<Contra<'a>> for Inv<'b>

impl<'a, R> CanRecoverFrom<Inv<'a>> for (R,)

where R: CanRecoverFrom<Inv<'a>>,

impl<'a, R1, R2> CanRecoverFrom<Inv<'a>> for (R1, R2)

where R1: CanRecoverFrom<Inv<'a>>, R2: CanRecoverFrom<Inv<'a>>,

impl<'a, R1, R2, R3> CanRecoverFrom<Inv<'a>> for (R1, R2, R3)

where R1: CanRecoverFrom<Inv<'a>>, R2: CanRecoverFrom<Inv<'a>>, R3: CanRecoverFrom<Inv<'a>>,

impl<'a, R1, R2, R3, R4> CanRecoverFrom<Inv<'a>> for (R1, R2, R3, R4)

where R1: CanRecoverFrom<Inv<'a>>, R2: CanRecoverFrom<Inv<'a>>, R3: CanRecoverFrom<Inv<'a>>, R4: CanRecoverFrom<Inv<'a>>,

impl<'a> CanRecoverFrom<Inv<'a>> for Co<'a>

impl<'a> CanRecoverFrom<Inv<'a>> for Contra<'a>

impl<'a> CanRecoverFrom<Inv<'a>> for Inv<'a>

impl<'a, R> CanTranscendTo<(R,)> for Inv<'a>

where Inv<'a>: CanTranscendTo<R>,

impl<'a, R1, R2> CanTranscendTo<(R1, R2)> for Inv<'a>

where Inv<'a>: CanTranscendTo<R1> + CanTranscendTo<R2>,

impl<'a, R1, R2, R3> CanTranscendTo<(R1, R2, R3)> for Inv<'a>

where Inv<'a>: CanTranscendTo<R1> + CanTranscendTo<R2> + CanTranscendTo<R3>,

impl<'a, R1, R2, R3, R4> CanTranscendTo<(R1, R2, R3, R4)> for Inv<'a>

where Inv<'a>: CanTranscendTo<R1> + CanTranscendTo<R2> + CanTranscendTo<R3> + CanTranscendTo<R4>,

impl<'a, R> CanTranscendTo<Inv<'a>> for (R,)

where R: CanTranscendTo<Inv<'a>>,

impl<'a, R1, R2> CanTranscendTo<Inv<'a>> for (R1, R2)

where R1: CanTranscendTo<Inv<'a>>, R2: CanTranscendTo<Inv<'a>>,

impl<'a, R1, R2, R3> CanTranscendTo<Inv<'a>> for (R1, R2, R3)

where R1: CanTranscendTo<Inv<'a>>, R2: CanTranscendTo<Inv<'a>>, R3: CanTranscendTo<Inv<'a>>,

impl<'a, R1, R2, R3, R4> CanTranscendTo<Inv<'a>> for (R1, R2, R3, R4)

where R1: CanTranscendTo<Inv<'a>>, R2: CanTranscendTo<Inv<'a>>, R3: CanTranscendTo<Inv<'a>>, R4: CanTranscendTo<Inv<'a>>,

impl<'a, 'b: 'a> CanTranscendTo<Inv<'a>> for Co<'b>

impl<'a> CanTranscendTo<Inv<'a>> for Inv<'a>

impl<'a, 'b: 'a> CanTranscendTo<Inv<'b>> for Contra<'a>

impl<'a> Copy for Inv<'a>

impl<'a> Transience for Inv<'a>