Struct AssociatedTyDatum

pub struct AssociatedTyDatum<I: Interner> {
    pub trait_id: TraitId<I>,
    pub id: AssocTypeId<I>,
    pub name: I::Identifier,
    pub binders: Binders<AssociatedTyDatumBound<I>>,
}

Represents an associated type declaration found inside of a trait:

trait Foo<P1..Pn> { // P0 is Self
    type Bar<Pn..Pm>: [bounds]
    where
        [where_clauses];
}

The meaning of each of these parts:

• The parameters P0...Pm are all in scope for this associated type.
• The bounds bounds are things that the impl must prove to be true.
• The where clauses where_clauses are things that the impl can assume to be true (but which projectors must prove).

Fields

trait_id: TraitId<I>

The trait this associated type is defined in.

id: AssocTypeId<I>

The ID of this associated type

name: I::Identifier

Name of this associated type.

binders: Binders<AssociatedTyDatumBound<I>>

These binders represent the P0...Pm variables. The binders are in the order [Pn..Pm; P0..Pn]. That is, the variables from Bar come first (corresponding to the de bruijn concept that “inner” binders are lower indices, although within a given binder we do not have an ordering).

Implementations

impl<I: Interner> AssociatedTyDatum<I>

pub fn bounds_on_self(&self, interner: &I) -> Vec<QuantifiedWhereClause<I>>

Returns the associated ty’s bounds applied to the projection type, e.g.:

Implemented(<?0 as Foo>::Item<?1>: Sized)

these quantified where clauses are in the scope of the binders field.

Trait Implementations

impl<I: Clone + Interner> Clone for AssociatedTyDatum<I>

where I::Identifier: Clone,

fn clone(&self) -> AssociatedTyDatum<I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Interner> Debug for AssociatedTyDatum<I>

where I::Identifier: Debug,

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

Formats the value using the given formatter.

impl<I: Hash + Interner> Hash for AssociatedTyDatum<I>

where I::Identifier: Hash,

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: PartialEq + Interner> PartialEq for AssociatedTyDatum<I>

where I::Identifier: PartialEq,

fn eq(&self, other: &AssociatedTyDatum<I>) -> 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: Eq + Interner> Eq for AssociatedTyDatum<I>

where I::Identifier: Eq,

impl<I: Interner> StructuralPartialEq for AssociatedTyDatum<I>