pub fn solve(mut self) -> FlowAnalysis {
        while let Some(implication) = self.pop() {
            let validity = self.try_prove(&implication.preconditions);

            if let Validity::Trivial = validity {
                self.insert_fact(implication.consequent);
            } else {
                self.queue.push_back(implication);
            }

            if let Validity::Trivial | Validity::Progress = validity {
                self.progress = 0;
            }
        }

        FlowAnalysis {
            passable: self.passable,
            haltable: self.haltable,
        }
    }
/// Run the full flow analysis algorithm and return a solution.
Run the full flow analysis algorithm and return a solution.
Run the full flow analysis algorithm and return a solution .
pub fn solve(mut self) -> FlowAnalysis {
        while let Some(implication) = self.pop() {
            let validity = self.try_prove(&implication.preconditions);
            if let Validity::Trivial = validity {
                self.insert_fact(implication.consequent);
            } else {
                self.queue.push_back(implication);
            }
            if let Validity::Trivial | Validity::Progress = validity {
                self.progress = 0;
            }
        }
        FlowAnalysis {
            passable: self.passable,
            haltable: self.haltable,
        }
    }
pub fn solve ( mut self ) -> FlowAnalysis { while let Some ( implication ) = self . pop ( ) { let validity = self . try_prove ( & implication . preconditions ) ; if let Validity :: Trivial = validity { self . insert_fact ( implication . consequent ) ; } else { self . queue . push_back ( implication ) ; } if let Validity :: Trivial | Validity :: Progress = validity { self . progress = 0 ; } } FlowAnalysis { passable : self . passable , haltable : self . haltable , } }
Run the full flow analysis algorithm and return a solution.
Run the full flow analysis algorithm and return a solution .
mut self