Type Alias OutlivesPredicate

Source
pub type OutlivesPredicate<'tcx, T> = OutlivesPredicate<TyCtxt<'tcx>, T>;

Aliased Type§

struct OutlivesPredicate<'tcx, T>(pub T, pub Region<'tcx>);

Fields§

§0: T§1: Region<'tcx>

Trait Implementations§

Source§

impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<'tcx, P> for OutlivesPredicate<'tcx, T>
where T: Print<'tcx, P>,

Source§

impl<I, A> Clone for OutlivesPredicate<I, A>
where I: Interner, A: Clone,

Source§

fn clone(&self) -> OutlivesPredicate<I, A>

Returns a copy of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<I, A> Debug for OutlivesPredicate<I, A>
where I: Interner, A: Debug,

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<I, A, __D> Decodable<__D> for OutlivesPredicate<I, A>
where I: Interner, __D: TyDecoder<I = I>, A: Decodable<__D>, <I as Interner>::Region: Decodable<__D>,

Source§

fn decode(__decoder: &mut __D) -> OutlivesPredicate<I, A>

Source§

impl<I, T> Display for OutlivesPredicate<I, T>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<I, A, __E> Encodable<__E> for OutlivesPredicate<I, A>
where I: Interner, __E: TyEncoder<I = I>, A: Encodable<__E>, <I as Interner>::Region: Encodable<__E>,

Source§

fn encode(&self, __encoder: &mut __E)

Source§

impl<I, A> Hash for OutlivesPredicate<I, A>
where I: Interner, A: Hash,

Source§

fn hash<__H>(&self, __state: &mut __H)
where __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
Source§

impl<I, A, __CTX> HashStable<__CTX> for OutlivesPredicate<I, A>
where I: Interner, A: HashStable<__CTX>, <I as Interner>::Region: HashStable<__CTX>,

Source§

fn hash_stable( &self, __hcx: &mut __CTX, __hasher: &mut StableHasher<SipHasher128>, )

Source§

impl<I, U, A> Lift<U> for OutlivesPredicate<I, A>
where I: Interner, U: Interner, A: Lift<U>, <I as Interner>::Region: Lift<U, Lifted = <U as Interner>::Region>,

Source§

type Lifted = OutlivesPredicate<U, <A as Lift<U>>::Lifted>

Source§

fn lift_to_interner( self, cx: U, ) -> Option<OutlivesPredicate<U, <A as Lift<U>>::Lifted>>

Source§

impl<I, A> PartialEq for OutlivesPredicate<I, A>
where I: Interner, A: PartialEq,

Source§

fn eq(&self, __other: &OutlivesPredicate<I, A>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl<I, A> TypeFoldable<I> for OutlivesPredicate<I, A>
where I: Interner, A: TypeFoldable<I>, <I as Interner>::Region: TypeFoldable<I>,

Source§

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<OutlivesPredicate<I, A>, <__F as FallibleTypeFolder<I>>::Error>
where __F: FallibleTypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f). Read more
Source§

fn fold_with<F>(self, folder: &mut F) -> Self
where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.
Source§

impl<I, A> TypeVisitable<I> for OutlivesPredicate<I, A>
where I: Interner, A: TypeVisitable<I>, <I as Interner>::Region: TypeVisitable<I>,

Source§

fn visit_with<__V>( &self, __visitor: &mut __V, ) -> <__V as TypeVisitor<I>>::Result
where __V: TypeVisitor<I>,

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v). Read more
Source§

impl<I, A> Copy for OutlivesPredicate<I, A>
where I: Interner, A: Copy,

Source§

impl<I, A> Eq for OutlivesPredicate<I, A>
where I: Interner, A: Eq,

Layout§

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.