Enum chalk_ir::WhereClause

pub enum WhereClause<I: Interner> {
    Implemented(TraitRef<I>),
    AliasEq(AliasEq<I>),
    LifetimeOutlives(LifetimeOutlives<I>),
    TypeOutlives(TypeOutlives<I>),
}

Where clauses that can be written by a Rust programmer.

Variants

Implemented(TraitRef<I>)

Type implements a trait.

AliasEq(AliasEq<I>)

Type is equal to an alias.

LifetimeOutlives(LifetimeOutlives<I>)

One lifetime outlives another.

TypeOutlives(TypeOutlives<I>)

Type outlives a lifetime.

Implementations

impl<I: Interner> WhereClause<I>

pub fn into_well_formed_goal(self, interner: &I) -> DomainGoal<I>

Turn a where clause into the WF version of it i.e.:

• Implemented(T: Trait) maps to WellFormed(T: Trait)
• ProjectionEq(<T as Trait>::Item = Foo) maps to WellFormed(<T as Trait>::Item = Foo)
• any other clause maps to itself

pub fn into_from_env_goal(self, interner: &I) -> DomainGoal<I>

Same as into_well_formed_goal but with the FromEnv predicate instead of WellFormed.

pub fn trait_id(&self) -> Option<TraitId<I>>

If where clause is a TraitRef, returns its trait id.

Trait Implementations

impl<I: Interner> CastTo<WhereClause<I>> for WhereClause<I>

fn cast_to(
    self,
    _interner: &<WhereClause<I> as HasInterner>::Interner
) -> WhereClause<I>

Cast a value to type T.

impl<I: Interner> CastTo<WhereClause<I>> for TraitRef<I>

fn cast_to(self, _interner: &I) -> WhereClause<I>

Cast a value to type T.

impl<I: Interner> CastTo<WhereClause<I>> for AliasEq<I>

fn cast_to(self, _interner: &I) -> WhereClause<I>

Cast a value to type T.

impl<I: Interner> CastTo<WhereClause<I>> for LifetimeOutlives<I>

fn cast_to(self, _interner: &I) -> WhereClause<I>

Cast a value to type T.

impl<I: Interner> CastTo<WhereClause<I>> for TypeOutlives<I>

fn cast_to(self, _interner: &I) -> WhereClause<I>

Cast a value to type T.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<I: Interner> Fold<I> for WhereClause<I>

type Result = WhereClause<I>

The type of value that will be produced once folding is done. Typically this is Self, unless Self contains borrowed values, in which case owned values are produced (for example, one can fold over a &T value where T: Fold, in which case you get back a T, not a &T).

fn fold_with<'i>(
    self,
    folder: &mut dyn Folder<'i, I>,
    outer_binder: DebruijnIndex
) -> Fallible<Self::Result> where
    I: 'i, 

Apply the given folder folder to self; binders is the number of binders that are in scope when beginning the folder. Typically binders starts as 0, but is adjusted when we encounter Binders<T> in the IR or other similar constructs.

impl<I: Interner> HasInterner for WhereClause<I>

type Interner = I

The interner associated with the type.

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

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, 

Feeds a slice of this type into the given Hasher.

impl<I: PartialEq + Interner> PartialEq<WhereClause<I>> for WhereClause<I>

fn eq(&self, other: &WhereClause<I>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &WhereClause<I>) -> bool

This method tests for !=.

impl<I: Interner> SuperVisit<I> for WhereClause<I>

fn super_visit_with<'i, B>(
    &self,
    visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
    outer_binder: DebruijnIndex
) -> ControlFlow<B> where
    I: 'i, 

Recursively visits the type contents.

impl<I: Interner> Visit<I> for WhereClause<I>

fn visit_with<'i, B>(
    &self,
    visitor: &mut dyn Visitor<'i, I, BreakTy = B>,
    outer_binder: DebruijnIndex
) -> ControlFlow<B> where
    I: 'i, 

Apply the given visitor visitor to self; binders is the number of binders that are in scope when beginning the visitor. Typically binders starts as 0, but is adjusted when we encounter Binders<T> in the IR or other similar constructs.

impl<I: Interner> Zip<I> for WhereClause<I>

fn zip_with<'i, Z: Zipper<'i, I>>(
    zipper: &mut Z,
    variance: Variance,
    a: &Self,
    b: &Self
) -> Fallible<()> where
    I: 'i, 

Uses the zipper to walk through two values, ensuring that they match.

impl<I: Interner> Copy for WhereClause<I> where
    I::InternedSubstitution: Copy,
    I::InternedLifetime: Copy,
    I::InternedType: Copy, 

impl<I: Eq + Interner> Eq for WhereClause<I>

impl<I: Interner> StructuralEq for WhereClause<I>

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