Struct chalk_ir::InEnvironment

pub struct InEnvironment<G: HasInterner> {
    pub environment: Environment<G::Interner>,
    pub goal: G,
}

A goal with an environment to solve it in.

Fields

environment: Environment<G::Interner>

goal: G

Implementations

impl<G: HasInterner> InEnvironment<G>

pub fn new(environment: &Environment<G::Interner>, goal: G) -> Self

Creates a new environment/goal pair.

pub fn map<OP, H>(self, op: OP) -> InEnvironment<H>

where OP: FnOnce(G) -> H, H: HasInterner<Interner = G::Interner>,

Maps the goal without touching the environment.

Trait Implementations

impl<T, U, I> CastTo<InEnvironment<U>> for InEnvironment<T>

where T: HasInterner<Interner = I> + CastTo<U>, U: HasInterner<Interner = I>, I: Interner,

fn cast_to(self, interner: U::Interner) -> InEnvironment<U>

Cast a value to type T.

impl<G: Clone + HasInterner> Clone for InEnvironment<G>

where G::Interner: Clone,

fn clone(&self) -> InEnvironment<G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Debug + HasInterner> Debug for InEnvironment<G>

where G::Interner: Debug,

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

Formats the value using the given formatter.

impl<G: HasInterner> HasInterner for InEnvironment<G>

type Interner = <G as HasInterner>::Interner

The interner associated with the type.

impl<G: Hash + HasInterner> Hash for InEnvironment<G>

where G::Interner: 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<G: PartialEq + HasInterner> PartialEq for InEnvironment<G>

where G::Interner: PartialEq,

fn eq(&self, other: &InEnvironment<G>) -> bool

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

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

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

impl<G, _I> TypeFoldable<_I> for InEnvironment<G>

where _I: Interner, G: HasInterner<Interner = _I> + TypeFoldable<_I> + HasInterner,

fn try_fold_with<E>( self, folder: &mut dyn FallibleTypeFolder<_I, Error = E>, outer_binder: DebruijnIndex, ) -> Result<Self, E>

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.

fn fold_with( self, folder: &mut dyn TypeFolder<I>, outer_binder: DebruijnIndex, ) -> 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<G, _I> TypeVisitable<_I> for InEnvironment<G>

where _I: Interner, G: HasInterner<Interner = _I> + TypeVisitable<_I> + HasInterner,

fn visit_with<B>( &self, visitor: &mut dyn TypeVisitor<_I, BreakTy = B>, outer_binder: DebruijnIndex, ) -> ControlFlow<B>

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<T: HasInterner<Interner = I> + Zip<I>, I: Interner> Zip<I> for InEnvironment<T>

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

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

impl<G: HasInterner<Interner = I> + Copy, I: Interner> Copy for InEnvironment<G>

where I::InternedProgramClauses: Copy,

impl<G: Eq + HasInterner> Eq for InEnvironment<G>

where G::Interner: Eq,

impl<G: HasInterner> StructuralPartialEq for InEnvironment<G>