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.

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

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

type Result = FlounderedSubgoal<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: Hash + Interner> Hash for FlounderedSubgoal<I>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub 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<FlounderedSubgoal<I>> 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: &FlounderedSubgoal<I>) -> bool

This method tests for !=.

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

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

impl<I: Interner> Visit<I> for FlounderedSubgoal<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.