Type Alias InEnvironment

pub type InEnvironment<T> = InEnvironment<T>;

Aliased Type

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

Fields

environment: Environment<<T as HasInterner>::Interner>

goal: T

Implementations

impl<G> InEnvironment<G>

where G: HasInterner,

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

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 as HasInterner>::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 as HasInterner>::Interner) -> InEnvironment<U>

Cast a value to type T.

impl<G> Clone for InEnvironment<G>

where G: Clone + HasInterner, <G as HasInterner>::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 for InEnvironment<G>

where G: Debug + HasInterner, <G as HasInterner>::Interner: Debug,

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

Formats the value using the given formatter.

impl<G> HasInterner for InEnvironment<G>

where G: HasInterner,

type Interner = <G as HasInterner>::Interner

The interner associated with the type.

impl<G> Hash for InEnvironment<G>

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

where G: PartialEq + HasInterner, <G as HasInterner>::Interner: PartialEq,

fn eq(&self, other: &InEnvironment<G>) -> 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<G, _I> TypeFoldable<_I> for InEnvironment<G>

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

fn try_fold_with<E>( self, folder: &mut dyn FallibleTypeFolder<_I, Error = E>, outer_binder: DebruijnIndex, ) -> Result<InEnvironment<G>, 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, Error = Infallible>, 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 G: HasInterner<Interner = _I> + HasInterner + TypeVisitable<_I>, _I: Interner,

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, I> Zip<I> for InEnvironment<T>

where T: HasInterner<Interner = I> + Zip<I>, I: Interner,

fn zip_with<Z>( zipper: &mut Z, variance: Variance, a: &InEnvironment<T>, b: &InEnvironment<T>, ) -> Result<(), NoSolution>

where Z: Zipper<I>,

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

impl<G, I> Copy for InEnvironment<G>

where G: HasInterner<Interner = I> + Copy, I: Interner, <I as Interner>::InternedProgramClauses: Copy,

impl<G> Eq for InEnvironment<G>

where G: Eq + HasInterner, <G as HasInterner>::Interner: Eq,

impl<G> StructuralPartialEq for InEnvironment<G>

where G: HasInterner,