fn push_initial_strands(&mut self, table: TableIndex) {
        // Instantiate the table goal with fresh inference variables.
        let table_goal = self.tables[table].table_goal.clone();
        self.context.clone().instantiate_ucanonical_goal(
            &table_goal,
            PushInitialStrandsInstantiated { table, this: self },
        );

        struct PushInitialStrandsInstantiated<'a, C: Context + 'a, CO: ContextOps<C> + 'a> {
            table: TableIndex,
            this: &'a mut Forest<C, CO>,
        }

        impl<C: Context, CO: ContextOps<C>> WithInstantiatedUCanonicalGoal<C>
                                                for PushInitialStrandsInstantiated<'a, C, CO> {
            type Output = ();

            fn with<I: Context>(
                self,
                infer: &mut dyn InferenceTable<C, I>,
                subst: I::Substitution,
                environment: I::Environment,
                goal: I::Goal,
            ) {
                let PushInitialStrandsInstantiated { table, this } = self;
                this.push_initial_strands_instantiated(table, infer, subst, environment, goal);
            }
        }
    }
/// When a table is first created, this function is invoked to
/// create the initial set of strands. If the table represents a
/// domain goal, these strands are created from the program
/// clauses as well as the clauses found in the environment.  If
/// the table represents a non-domain goal, such as `for<T> G`
/// etc, then `simplify_hh_goal` is invoked to create a strand
/// that breaks the goal down.
///
/// In terms of the NFTD paper, this corresponds to the *Program
/// Clause Resolution* step being applied eagerly, as many times
/// as possible.
When a table is first created, this function is invoked to
create the initial set of strands. If the table represents a
domain goal, these strands are created from the program
clauses as well as the clauses found in the environment.  If
the table represents a non-domain goal, such as `for G`
etc, then `simplify_hh_goal` is invoked to create a strand
that breaks the goal down.

In terms of the NFTD paper, this corresponds to the *Program
Clause Resolution* step being applied eagerly, as many times
as possible.
When a table is first created this function is invoked to create the initial set of strands . If the table represents a domain goal these strands are created from the program clauses as well as the clauses found in the environment . If the table represents a non - domain goal such as ` for G ` etc then ` simplify_hh_goal ` is invoked to create a strand that breaks the goal down . In terms of the NFTD paper this corresponds to the * Program Clause Resolution * step being applied eagerly as many times as possible .
fn push_initial_strands(&mut self, table: TableIndex) {
        // Instantiate the table goal with fresh inference variables.
        let table_goal = self.tables[table].table_goal.clone();
        self.context.clone().instantiate_ucanonical_goal(
            &table_goal,
            PushInitialStrandsInstantiated { table, this: self },
        );
        struct PushInitialStrandsInstantiated<'a, C: Context + 'a, CO: ContextOps<C> + 'a> {
            table: TableIndex,
            this: &'a mut Forest<C, CO>,
        }
        impl<C: Context, CO: ContextOps<C>> WithInstantiatedUCanonicalGoal<C>
                                                for PushInitialStrandsInstantiated<'a, C, CO> {
            type Output = ();
            fn with<I: Context>(
                self,
                infer: &mut dyn InferenceTable<C, I>,
                subst: I::Substitution,
                environment: I::Environment,
                goal: I::Goal,
            ) {
                let PushInitialStrandsInstantiated { table, this } = self;
                this.push_initial_strands_instantiated(table, infer, subst, environment, goal);
            }
        }
    }
fn push_initial_strands ( & mut self , table : TableIndex ) { // Instantiate the table goal with fresh inference variables. let table_goal = self . tables [ table ] . table_goal . clone ( ) ; self . context . clone ( ) . instantiate_ucanonical_goal ( & table_goal , PushInitialStrandsInstantiated { table , this : self } , ) ; struct PushInitialStrandsInstantiated < ' a , C : Context + ' a , CO : ContextOps < C > + ' a > { table : TableIndex , this : & ' a mut Forest < C , CO > , } impl < C : Context , CO : ContextOps < C > > WithInstantiatedUCanonicalGoal < C > for PushInitialStrandsInstantiated < ' a , C , CO > { type Output = ( ) ; fn with < I : Context > ( self , infer : & mut dyn InferenceTable < C , I > , subst : I :: Substitution , environment : I :: Environment , goal : I :: Goal , ) { let PushInitialStrandsInstantiated { table , this } = self ; this . push_initial_strands_instantiated ( table , infer , subst , environment , goal ) ; } } }
When a table is first created, this function is invoked to
create the initial set of strands.
When a table is first created this function is invoked to create the initial set of strands .
&mut self
table
TableIndex
&mut self
table
TableIndex