pub fn solve_limited(
        &mut self,
        program: &dyn RustIrDatabase<I>,
        goal: &UCanonical<InEnvironment<Goal<I>>>,
        should_continue: impl std::ops::Fn() -> bool,
    ) -> Option<Solution<I>> {
        let ops = self.forest.context().ops(program);
        self.forest.solve(&ops, goal, should_continue)
    }
/// Attempts to solve the given goal, which must be in canonical
/// form. Returns a unique solution (if one exists).  This will do
/// only as much work towards `goal` as it has to (and that work
/// is cached for future attempts). In addition, the solving of the
/// goal can be limited by returning `false` from `should_continue`.
///
/// # Parameters
///
/// - `program` -- defines the program clauses in scope.
///   - **Important:** You must supply the same set of program clauses
///     each time you invoke `solve`, as otherwise the cached data may be
///     invalid.
/// - `goal` the goal to solve
/// - `should_continue` if `false` is returned, the no further solving
///   will be done. A `Guidance(Suggested(...))` will be returned a
///   `Solution`, using any answers that were generated up to that point.
///
/// # Returns
///
/// - `None` is the goal cannot be proven.
/// - `Some(solution)` if we succeeded in finding *some* answers,
///   although `solution` may reflect ambiguity and unknowns.
Attempts to solve the given goal, which must be in canonical
form. Returns a unique solution (if one exists).  This will do
only as much work towards `goal` as it has to (and that work
is cached for future attempts). In addition, the solving of the
goal can be limited by returning `false` from `should_continue`.
Attempts to solve the given goal which must be in canonical form . Returns a unique solution ( if one exists ) . This will do only as much work towards ` goal ` as it has to ( and that work is cached for future attempts ) . In addition the solving of the goal can be limited by returning ` false ` from ` should_continue ` .
pub fn solve_limited(
        &mut self,
        program: &dyn RustIrDatabase<I>,
        goal: &UCanonical<InEnvironment<Goal<I>>>,
        should_continue: impl std::ops::Fn() -> bool,
    ) -> Option<Solution<I>> {
        let ops = self.forest.context().ops(program);
        self.forest.solve(&ops, goal, should_continue)
    }
pub fn solve_limited ( & mut self , program : & dyn RustIrDatabase < I > , goal : & UCanonical < InEnvironment < Goal < I > > > , should_continue : impl std :: ops :: Fn ( ) -> bool , ) -> Option < Solution < I > > { let ops = self . forest . context ( ) . ops ( program ) ; self . forest . solve ( & ops , goal , should_continue ) }
Attempts to solve the given goal, which must be in canonical
form.
Attempts to solve the given goal which must be in canonical form .
&mut self
program
&dyn RustIrDatabase<I>
goal
&UCanonical<InEnvironment<Goal<I>>>
should_continue
impl std::ops::Fn() -> bool
None
on
if we succeeded in finding *some* answers,
although `solution` may reflect ambiguity and unknowns.
if we succeeded in finding * some * answers although ` solution ` may reflect ambiguity and unknowns .
ome(solution
&mut self
program
&dyn RustIrDatabase<I>
defines the program clauses in scope.
Important:** You must supply the same set of program clauses
each time you invoke `solve`, as otherwise the cached data may be
invalid.
defines the program clauses in scope . Important : ** You must supply the same set of program clauses each time you invoke ` solve ` as otherwise the cached data may be invalid .
goal
&UCanonical<InEnvironment<Goal<I>>>
the goal to solve
the goal to solve
should_continue
impl std::ops::Fn() -> bool
if `false` is returned, the no further solving
will be done. A `Guidance(Suggested(...))` will be returned a
`Solution`, using any answers that were generated up to that point.
if ` false ` is returned the no further solving will be done . A ` Guidance ( Suggested ( ... )) ` will be returned a ` Solution ` using any answers that were generated up to that point .