fn new_clause(
        &mut self,
        goal_depth: StackIndex,
        mut ex_clause: ExClause, // Contains both A and G together.
        minimums: &mut Minimums,
    ) -> ExplorationResult {
        debug_heading!(
            "new_clause(goal_depth={:?}, ex_clause={:?}, minimums={:?}",
            goal_depth,
            self.infer.normalize_deep(&ex_clause),
            minimums
        );

        maybe_grow_stack(|| {
            self.snapshotted(|this| {
                match ex_clause.subgoals.pop() {
                    // No goals left to prove: this is an answer.
                    None => this.answer(goal_depth, ex_clause, minimums),

                    // Positive goal.
                    Some(Literal::Positive(selected_goal)) => {
                        this.positive(goal_depth, ex_clause, selected_goal, minimums)
                    }

                    // Negative goal. EWFS checks for whether `selected_goal`
                    // is ground here. We push this check into `negative`.
                    Some(Literal::Negative(selected_goal)) => {
                        this.negative(goal_depth, ex_clause, selected_goal, minimums)
                    }
                }
            })
        })
    }
/// Pop off the next subgoal from `ex_clause` and try to solve
/// it. Invoked when we have either just started a fresh goal (and
/// selected a program clause) or when we have a new answer to a
/// blocked goal that has just been incorporated.
Pop off the next subgoal from `ex_clause` and try to solve
it. Invoked when we have either just started a fresh goal (and
selected a program clause) or when we have a new answer to a
blocked goal that has just been incorporated.
Pop off the next subgoal from ` ex_clause ` and try to solve it . Invoked when we have either just started a fresh goal ( and selected a program clause ) or when we have a new answer to a blocked goal that has just been incorporated .
fn new_clause(
        &mut self,
        goal_depth: StackIndex,
        mut ex_clause: ExClause, // Contains both A and G together.
        minimums: &mut Minimums,
    ) -> ExplorationResult {
        debug_heading!(
            "new_clause(goal_depth={:?}, ex_clause={:?}, minimums={:?}",
            goal_depth,
            self.infer.normalize_deep(&ex_clause),
            minimums
        );
        maybe_grow_stack(|| {
            self.snapshotted(|this| {
                match ex_clause.subgoals.pop() {
                    // No goals left to prove: this is an answer.
                    None => this.answer(goal_depth, ex_clause, minimums),
                    // Positive goal.
                    Some(Literal::Positive(selected_goal)) => {
                        this.positive(goal_depth, ex_clause, selected_goal, minimums)
                    }
                    // Negative goal. EWFS checks for whether `selected_goal`
                    // is ground here. We push this check into `negative`.
                    Some(Literal::Negative(selected_goal)) => {
                        this.negative(goal_depth, ex_clause, selected_goal, minimums)
                    }
                }
            })
        })
    }
fn new_clause ( & mut self , goal_depth : StackIndex , mut ex_clause : ExClause , // Contains both A and G together. minimums : & mut Minimums , ) -> ExplorationResult { debug_heading ! ( " " goal_depth self infer normalize_deep ( ex_clause ) minimums ) ; maybe_grow_stack ( | | { self . snapshotted ( | this | { match ex_clause . subgoals . pop ( ) { // No goals left to prove: this is an answer. None => this . answer ( goal_depth , ex_clause , minimums ) , // Positive goal. Some ( Literal :: Positive ( selected_goal ) ) => { this . positive ( goal_depth , ex_clause , selected_goal , minimums ) } // Negative goal. EWFS checks for whether `selected_goal` // is ground here. We push this check into `negative`. Some ( Literal :: Negative ( selected_goal ) ) => { this . negative ( goal_depth , ex_clause , selected_goal , minimums ) } } } ) } ) }
Pop off the next subgoal from `ex_clause` and try to solve
it.
Pop off the next subgoal from ` ex_clause ` and try to solve it .
&mut self
goal_depth
StackIndex
ex_clause
ExClause
minimums
&mut Minimums