Enum ProbeStep

pub enum ProbeStep<I: Interner> {
    AddGoal(GoalSource, CanonicalState<I, Goal<I, I::Predicate>>),
    NestedProbe(Probe<I>),
    RecordImplArgs {
        impl_args: CanonicalState<I, I::GenericArgs>,
    },
    MakeCanonicalResponse {
        shallow_certainty: Certainty,
    },
}

Variants

AddGoal(GoalSource, CanonicalState<I, Goal<I, I::Predicate>>)

We added a goal to the EvalCtxt which will get proven the next time EvalCtxt::try_evaluate_added_goals is called.

NestedProbe(Probe<I>)

A call to probe while proving the current goal. This is used whenever there are multiple candidates to prove the current goal.

RecordImplArgs

A trait goal was satisfied by an impl candidate.

Fields

impl_args: CanonicalState<I, I::GenericArgs>

MakeCanonicalResponse

A call to EvalCtxt::evaluate_added_goals_make_canonical_response with Certainty was made. This is the certainty passed in, so it’s not unified with the certainty of the try_evaluate_added_goals that is done within; if it’s Certainty::Yes, then we can trust that the candidate is “finished” and we didn’t force ambiguity for some reason.

Fields

shallow_certainty: Certainty

Trait Implementations

impl<I> Debug for ProbeStep<I>

where I: Interner,

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

Formats the value using the given formatter.

impl<I> Hash for ProbeStep<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> PartialEq for ProbeStep<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> Eq for ProbeStep<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.