Struct chalk_engine::FlounderedSubgoal

pub struct FlounderedSubgoal<C: Context> {
    pub floundered_literal: Literal<C>,
    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<C>

Literal that floundered.

floundered_time: TimeStamp

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

Trait Implementations

impl<C: Clone + Context> Clone for FlounderedSubgoal<C>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug + Context> Debug for FlounderedSubgoal<C>

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

Formats the value using the given formatter.

impl<C: Eq + Context> Eq for FlounderedSubgoal<C>

impl<C: Hash + Context> Hash for FlounderedSubgoal<C>

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, 

Feeds a slice of this type into the given [Hasher].

impl<C: PartialEq + Context> PartialEq<FlounderedSubgoal<C>> for FlounderedSubgoal<C>

fn eq(&self, other: &FlounderedSubgoal<C>) -> bool

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

fn ne(&self, other: &FlounderedSubgoal<C>) -> bool

This method tests for !=.

impl<C: Context> StructuralEq for FlounderedSubgoal<C>

impl<C: Context> StructuralPartialEq for FlounderedSubgoal<C>