pub fn solve_multiple(
        &mut self,
        program: &dyn RustIrDatabase<I>,
        goal: &UCanonical<InEnvironment<Goal<I>>>,
        f: impl FnMut(SubstitutionResult<Canonical<ConstrainedSubst<I>>>, bool) -> bool,
    ) -> bool {
        let ops = self.forest.context().ops(program);
        self.forest.solve_multiple(&ops, goal, f)
    }
/// Attempts to solve the given goal, which must be in canonical
/// form. Provides multiple solutions to function `f`.  This will do
/// only as much work towards `goal` as it has to (and that work
/// is cached for future attempts).
///
/// # 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
/// - `f` -- function to proceed solution. New solutions will be generated
/// while function returns `true`.
///   - first argument is solution found
///   - second argument is ther next solution present
///   - returns true if next solution should be handled
///
/// # Returns
///
/// - `true` all solutions were processed with the function.
/// - `false` the function returned `false` and solutions were interrupted.
Attempts to solve the given goal, which must be in canonical
form. Provides multiple solutions to function `f`.  This will do
only as much work towards `goal` as it has to (and that work
is cached for future attempts).
Attempts to solve the given goal which must be in canonical form . Provides multiple solutions to function ` f ` . This will do only as much work towards ` goal ` as it has to ( and that work is cached for future attempts ) .
pub fn solve_multiple(
        &mut self,
        program: &dyn RustIrDatabase<I>,
        goal: &UCanonical<InEnvironment<Goal<I>>>,
        f: impl FnMut(SubstitutionResult<Canonical<ConstrainedSubst<I>>>, bool) -> bool,
    ) -> bool {
        let ops = self.forest.context().ops(program);
        self.forest.solve_multiple(&ops, goal, f)
    }
pub fn solve_multiple ( & mut self , program : & dyn RustIrDatabase < I > , goal : & UCanonical < InEnvironment < Goal < I > > > , f : impl FnMut ( SubstitutionResult < Canonical < ConstrainedSubst < I > > > , bool ) -> bool , ) -> bool { let ops = self . forest . context ( ) . ops ( program ) ; self . forest . solve_multiple ( & ops , goal , f ) }
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>>>
f
impl FnMut(SubstitutionResult<Canonical<ConstrainedSubst<I>>>, bool) -> bool
all solutions were processed with the function.
all solutions were processed with the function .
ru
the function returned `false` and solutions were interrupted.
the function returned ` false ` and solutions were interrupted .
als
&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
f
impl FnMut(SubstitutionResult<Canonical<ConstrainedSubst<I>>>, bool) -> bool
function to proceed solution. New solutions will be generated
while function returns `true`.
first argument is solution found
second argument is ther next solution present
returns true if next solution should be handled
function to proceed solution . New solutions will be generated while function returns ` true ` . first argument is solution found second argument is ther next solution present returns true if next solution should be handled