Add fixes for genericity

gearley-recognizer/src/perf_hint.rs

···
 
 pub trait PerfHint {
     const LOOKAHEAD: bool;
+    const LEO: bool;
     type Symbol;
-    fn completion_capacity(&self) -> usize;
-    fn medial_capacity(&self) -> Vec2dCapacity;
+
+    fn completion_capacity(&self) -> usize {
+        32
+    }
+
+    fn medial_capacity(&self) -> Vec2dCapacity {
+        Vec2dCapacity {
+            chart_capacity: 512,
+            indices_capacity: 128,
+        }
+    }
 }
 
 pub struct DefaultPerfHint {
···
 
 impl PerfHint for DefaultPerfHint {
     const LOOKAHEAD: bool = true;
+    const LEO: bool = true;
     type Symbol = Symbol;
 
     fn completion_capacity(&self) -> usize {

gearley-recognizer/src/recognizer.rs

···
 
     pub fn begin_earleme(&mut self) {
         self.medial.next_set();
-        self.leo.next_set();
+        if P::LEO {
+            self.leo.next_set();
+        }
         if cfg!(feature = "log") {
             let earleme = self.earleme();
             let rows = format!("{:?}", self.predicted.sub_matrix(earleme..earleme + 1));
···
     pub fn advance_after_completion(&mut self) {
         self.sort_medial_items();
         self.remove_unreachable_sets();
+        if P::LEO {
+            self.add_leo_items();
+        }
         trace!("recognizer.medial: Vec {:?}", self.medial.last());
         // `earleme` is now at least 1.
         // Prediction pass.
···
             });
     }
 
+    fn add_leo_items(&mut self) {
+        let medial = self.medial.last();
+        for idx in 0 .. medial.len() {
+            let rhs1 = self.grammar.get_rhs1(medial[idx].dot).unwrap();
+            let last = self.grammar.get_rhs1(medial[idx.saturating_sub(1)].dot).unwrap();
+            let next = self.grammar.get_rhs1(medial[idx + (idx != medial.len() - 1) as usize].dot).unwrap();
+            if (rhs1 != last || idx == 0) && (rhs1 != next || idx == medial.len() - 1) {
+                // this item is unique
+                // this item has a node
+                let item = medial[idx];
+                if self.grammar.is_right_recursive(rhs1) {
+                    let leo_set = &self.leo[item.origin as usize];
+                    let leo_idx = leo_set.binary_search_by_key(&rhs1, |&leo_item| self.grammar.get_rhs1(leo_item.dot).unwrap());
+                    match leo_idx {
+                        Err(_) => {
+                            self.leo.push_item(item);
+                        }
+                        Ok(idx) => {
+                            let mut new_leo_item = leo_set[idx];
+                            new_leo_item.node = self.forest.leo_product(new_leo_item.node, item.node);
+                            self.leo.push_item(new_leo_item);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     fn remove_unreachable_sets(&mut self) {
         let origin = |item: &Item<F::NodeRef>| item.origin as usize;
         let max_origin = self
···
             // ------------------------------
             self.predicted.truncate(new_earleme + 1);
             self.medial.truncate(new_earleme + 1);
+            self.leo.truncate(new_earleme + 1);
             debug_assert_eq!(self.medial.len(), new_earleme + 2);
             debug_assert_eq!(self.earleme(), new_earleme);
         }
···
             // to   A ::=   g42 • c
             self.complete_generated_binary_predictions(set_id, sym, rhs_link);
         } else if self.predicted[set_id as usize].get(sym.usize()) {
-            // New item, either completed or medial.
+            // New item, completed.
             // from A ::=   B • C
             // to   A ::=   B   C •
-            self.complete_medial_items(set_id, sym, rhs_link);
-            // New item, either completed or medial.
-            // from A ::= • B   c
-            // to   A ::=   B • c
-            self.complete_predictions(set_id, sym, rhs_link);
+            if !P::LEO || !self.complete_leo(set_id, sym, rhs_link) {
+                // New item, completed.
+                // from A ::=   B • C
+                // to   A ::=   B   C •
+                self.complete_medial_items(set_id, sym, rhs_link);
+                // New item, either completed or medial.
+                // from A ::= • B   c
+                // to   A ::=   B • c
+                self.complete_predictions(set_id, sym, rhs_link);
+            }
         }
     }
 
···
         }
         self.medial
             .truncate_chart(self.medial.item_count() - (self.medial.last().len() - binary));
+    }
+
+    fn complete_leo(&mut self, set_id: Origin, sym: Symbol, rhs_link: F::NodeRef) -> bool {
+        if !self.grammar.is_right_recursive(sym) {
+            return false;
+        }
+        let leo_set = &self.leo[set_id as usize];
+        let maybe_found = leo_set.binary_search_by_key(&Some(sym), |ei| {
+            self.grammar.get_rhs1(ei.dot)
+        });
+        if let Ok(idx) = maybe_found {
+            // let medial_set = &self.medial[set_id as usize];
+            // let medial_idx = medial_set.binary_search_by_key(&sym, |ei| {
+            //     self.grammar.get_rhs1(ei.dot).unwrap()
+            // }).unwrap();
+            // medial_set[medial_idx].node
+            // LEO node
+            // rep • ----rr--
+            //       rep --rr--
+            //             rep • rr
+            //                 rep
+            // 
+            let mut leo_item = leo_set[idx];
+            leo_item.node = self.forest.leo_product(leo_item.node, rhs_link);
+            self.complete.heap_push(leo_item);
+            true
+        } else {
+            false
+        }
     }
 
     /// Attempt to complete a predicted item with a postdot gensym.

gearley-utils/src/parse.rs

···
 use gearley_forest::Forest;
 use gearley_forest::NullForest;
 use gearley_grammar::Grammar;
-use gearley_recognizer::{Recognizer, lookahead::Lookahead};
+use gearley_recognizer::{lookahead::Lookahead, perf_hint::PerfHint, Recognizer};
 
 pub trait RecognizerParseExt {
     fn parse(&mut self, tokens: &[Symbol]) -> Result<bool, ParseError>;
···
     }
 }
 
-impl<G, F> RecognizerParseExt for Recognizer<G, F>
+impl<G, F, P> RecognizerParseExt for Recognizer<G, F, P>
 where
     Self: Debug,
     G: Grammar,
     F: Forest,
+    P: PerfHint,
 {
     #[inline]
     fn parse(&mut self, tokens: &[Symbol]) -> Result<bool, ParseError> {

gearley-wasm/src/lib.rs

···
 use cfg_grammar::SymbolBitSet;
 use cfg_load::advanced::{AdvancedGrammar, LexerMap};
 
-use std::cell::RefCell;wrapping_sub
+use std::cell::RefCell;
 use std::sync::LazyLock;
 use std::sync::mpsc;
 use std::panic;