Struct chalk_engine::FlounderedSubgoal

pub struct FlounderedSubgoal<I: Interner> {
    pub floundered_literal: Literal<I>,
    pub floundered_time: TimeStamp,
}

A “floundered” subgoal is one that contains unbound existential variables for which it cannot produce a value. The classic example of floundering is a negative subgoal:

not { Implemented(?T: Foo) }

The way the prolog solver works, it basically enumerates all the ways that a given goal can be true. But we can’t use this technique to find all the ways that ?T: Foo can be false – so we call it floundered. In other words, we can evaluate a negative goal, but only if we know what ?T is – we can’t use the negative goal to help us figuring out ?T.

In addition to negative goals, we use floundering to prevent the trait solver from trying to enumerate very large goals with tons of answers. For example, we consider a goal like ?T: Sized to “flounder”, since we can’t hope to enumerate all types that are Sized. The same is true for other special traits like Clone.

Floundering can also occur indirectly. For example:

trait Foo { }
impl<T> Foo for T { }

trying to solve ?T: Foo would immediately require solving ?T: Sized, and hence would flounder.

Fields

floundered_literal: Literal<I>

Literal that floundered.

floundered_time: TimeStamp

Current value of the strand’s clock at the time of floundering.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<I: Hash + Interner> Hash for FlounderedSubgoal<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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

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

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, 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<I: Interner> TypeVisitable<I> for FlounderedSubgoal<I>

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<I: Eq + Interner> Eq for FlounderedSubgoal<I>

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