Struct ExistentialProjection

pub struct ExistentialProjection<I: Interner> {
    pub def_id: I::DefId,
    pub args: I::GenericArgs,
    pub term: I::Term,
    use_existential_projection_new_instead: (),
}

A ProjectionPredicate for an ExistentialTraitRef.

Fields

def_id: I::DefId

args: I::GenericArgs

term: I::Term

use_existential_projection_new_instead: ()

This field exists to prevent the creation of ExistentialProjection without using ExistentialProjection::new_from_args.

Implementations

impl<I: Interner> ExistentialProjection<I>

pub fn new_from_args( interner: I, def_id: I::DefId, args: I::GenericArgs, term: I::Term, ) -> ExistentialProjection<I>

pub fn new( interner: I, def_id: I::DefId, args: impl IntoIterator<Item: Into<I::GenericArg>>, term: I::Term, ) -> ExistentialProjection<I>

pub fn trait_ref(&self, interner: I) -> ExistentialTraitRef<I>

Extracts the underlying existential trait reference from this projection. For example, if this is a projection of exists T. <T as Iterator>::Item == X, then this function would return an exists T. T: Iterator existential trait reference.

pub fn with_self_ty( &self, interner: I, self_ty: I::Ty, ) -> ProjectionPredicate<I>

pub fn erase_self_ty( interner: I, projection_predicate: ProjectionPredicate<I>, ) -> Self

Trait Implementations

impl<I> Clone for ExistentialProjection<I>

where I: Interner,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I: Interner> Debug for ExistentialProjection<I>

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

Formats the value using the given formatter.

impl<I: Interner, __D: TyDecoder<I = I>> Decodable<__D> for ExistentialProjection<I>

where I::DefId: Decodable<__D>, I::GenericArgs: Decodable<__D>, I::Term: Decodable<__D>,

fn decode(__decoder: &mut __D) -> Self

impl<I: Interner> Display for ExistentialProjection<I>

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

Formats the value using the given formatter.

impl<I: Interner, __E: TyEncoder<I = I>> Encodable<__E> for ExistentialProjection<I>

where I::DefId: Encodable<__E>, I::GenericArgs: Encodable<__E>, I::Term: Encodable<__E>,

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

impl<I> Hash for ExistentialProjection<I>

where I: Interner,

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

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: Interner, __CTX> HashStable<__CTX> for ExistentialProjection<I>

where I::DefId: HashStable<__CTX>, I::GenericArgs: HashStable<__CTX>, I::Term: HashStable<__CTX>,

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

impl<I, J> Lift<J> for ExistentialProjection<I>

where I: Interner, J: Interner, I::DefId: Lift<J, Lifted = J::DefId>, I::GenericArgs: Lift<J, Lifted = J::GenericArgs>, I::Term: Lift<J, Lifted = J::Term>, (): Lift<J, Lifted = ()>,

type Lifted = ExistentialProjection<J>

fn lift_to_interner(self, interner: J) -> Option<Self::Lifted>

impl<I> PartialEq for ExistentialProjection<I>

where I: Interner,

fn eq(&self, __other: &Self) -> 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: Interner> Relate<I> for ExistentialProjection<I>

fn relate<R: TypeRelation<I>>( relation: &mut R, a: ExistentialProjection<I>, b: ExistentialProjection<I>, ) -> RelateResult<I, ExistentialProjection<I>>

impl<I> TypeFoldable<I> for ExistentialProjection<I>

where I: Interner, I::DefId: TypeFoldable<I>, I::GenericArgs: TypeFoldable<I>, I::Term: TypeFoldable<I>,

fn try_fold_with<__F: FallibleTypeFolder<I>>( self, __folder: &mut __F, ) -> Result<Self, __F::Error>

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

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

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

impl<I> TypeVisitable<I> for ExistentialProjection<I>

where I: Interner, I::DefId: TypeVisitable<I>, I::GenericArgs: TypeVisitable<I>, I::Term: TypeVisitable<I>,

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

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

impl<I> Copy for ExistentialProjection<I>

where I: Interner,

impl<I> Eq for ExistentialProjection<I>

where I: Interner,

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.