Struct Placeholder 

pub struct Placeholder<I, T>
where
    I: Interner,
{
    pub universe: UniverseIndex,
    pub bound: T,
    _tcx: PhantomData<fn() -> I>,
}

The “placeholder index” fully defines a placeholder region, type, or const. Placeholders are identified by both a universe, as well as a name residing within that universe. Distinct bound regions/types/consts within the same universe simply have an unknown relationship to one another.

Fields

universe: UniverseIndex

bound: T

_tcx: PhantomData<fn() -> I>

Implementations

impl<I, T> Placeholder<I, T>

where I: Interner,

pub fn new(universe: UniverseIndex, bound: T) -> Placeholder<I, T>

Trait Implementations

impl<I, T> Clone for Placeholder<I, T>

where I: Interner, T: Clone,

fn clone(&self) -> Placeholder<I, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I, T> Debug for Placeholder<I, T>

where I: Interner, T: Debug,

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

Formats the value using the given formatter.

impl<I, T, __D> Decodable<__D> for Placeholder<I, T>

where I: Interner, __D: Decoder, T: Decodable<__D>, PhantomData<fn() -> I>: Decodable<__D>,

fn decode(__decoder: &mut __D) -> Placeholder<I, T>

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

where I: Interner + IrPrint<Placeholder<I, T>>,

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

Formats the value using the given formatter.

impl<I, T, __E> Encodable<__E> for Placeholder<I, T>

where I: Interner, __E: Encoder, T: Encodable<__E>, PhantomData<fn() -> I>: Encodable<__E>,

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

impl<I, T> Hash for Placeholder<I, T>

where I: Interner, T: Hash,

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

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<I, T, __CTX> HashStable<__CTX> for Placeholder<I, T>

where I: Interner, T: HashStable<__CTX>, PhantomData<fn() -> I>: HashStable<__CTX>,

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

impl<I, U, T> Lift<U> for Placeholder<I, T>

where I: Interner, U: Interner, T: Lift<U>,

type Lifted = Placeholder<U, <T as Lift<U>>::Lifted>

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

impl<I, T> Ord for Placeholder<I, T>

where I: Interner, T: Ord,

fn cmp(&self, __other: &Placeholder<I, T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<I, T> PartialEq for Placeholder<I, T>

where I: Interner, T: PartialEq,

fn eq(&self, __other: &Placeholder<I, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<I, T> PartialOrd for Placeholder<I, T>

where I: Interner, T: Ord,

fn partial_cmp(&self, __other: &Placeholder<I, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'tcx> PlaceholderLike<TyCtxt<'tcx>> for Placeholder<TyCtxt<'tcx>, BoundConst>

type Bound = BoundConst

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

fn with_updated_universe( self, ui: UniverseIndex, ) -> Placeholder<TyCtxt<'tcx>, BoundConst>

fn new( ui: UniverseIndex, bound: BoundConst, ) -> Placeholder<TyCtxt<'tcx>, BoundConst>

fn new_anon( ui: UniverseIndex, var: BoundVar, ) -> Placeholder<TyCtxt<'tcx>, BoundConst>

impl<'tcx> PlaceholderLike<TyCtxt<'tcx>> for Placeholder<TyCtxt<'tcx>, BoundRegion>

type Bound = BoundRegion

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

fn with_updated_universe( self, ui: UniverseIndex, ) -> Placeholder<TyCtxt<'tcx>, BoundRegion>

fn new( ui: UniverseIndex, bound: BoundRegion, ) -> Placeholder<TyCtxt<'tcx>, BoundRegion>

fn new_anon( ui: UniverseIndex, var: BoundVar, ) -> Placeholder<TyCtxt<'tcx>, BoundRegion>

impl<'tcx> PlaceholderLike<TyCtxt<'tcx>> for Placeholder<TyCtxt<'tcx>, BoundTy>

type Bound = BoundTy

fn universe(self) -> UniverseIndex

fn var(self) -> BoundVar

fn with_updated_universe( self, ui: UniverseIndex, ) -> Placeholder<TyCtxt<'tcx>, BoundTy>

fn new(ui: UniverseIndex, bound: BoundTy) -> Placeholder<TyCtxt<'tcx>, BoundTy>

fn new_anon( ui: UniverseIndex, var: BoundVar, ) -> Placeholder<TyCtxt<'tcx>, BoundTy>

impl<'tcx, P> Print<'tcx, P> for Placeholder<TyCtxt<'tcx>, BoundTy>

where P: PrettyPrinter<'tcx>,

fn print(&self, p: &mut P) -> Result<(), Error>

impl<I, T> TypeFoldable<I> for Placeholder<I, T>

where I: Interner, T: TypeFoldable<I>,

fn try_fold_with<__F>( self, __folder: &mut __F, ) -> Result<Placeholder<I, T>, <__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).

fn fold_with<__F>(self, __folder: &mut __F) -> Placeholder<I, T>

where __F: TypeFolder<I>,

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<I, T> TypeVisitable<I> for Placeholder<I, T>

where I: Interner, T: TypeVisitable<I>,

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).

impl<I, T> Copy for Placeholder<I, T>

where I: Interner, T: Copy,

impl<I, T> Eq for Placeholder<I, T>

where I: Interner, T: 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.