Struct cfg::earley::BinarizedGrammar

pub struct BinarizedGrammar { /* fields omitted */ }

Drop-in replacement for cfg::BinarizedCfg.

Methods

impl BinarizedGrammar

pub fn new() -> Self

Creates a new BinarizedGrammar.

pub fn set_start(&mut self, start: Symbol)

pub fn start(&self) -> Symbol

impl BinarizedGrammar

pub fn wrap_start(&mut self)

pub fn original_start(&self) -> Option<Symbol>

pub fn eof(&self) -> Option<Symbol>

pub fn dot_before_eof(&self) -> Option<u32>

pub fn make_proper(self: BinarizedGrammar) -> BinarizedGrammar

pub fn eliminate_nulling(
    self: BinarizedGrammar
) -> (BinarizedGrammar, BinarizedGrammar)

pub fn remap_symbols(self: BinarizedGrammar) -> (BinarizedGrammar, Mapping)

pub fn is_empty(&self) -> bool

Methods from Deref<Target = BinarizedCfg<History>>

pub fn sort(&mut self)

Sorts the rule array.

pub fn sort_by<F>(&mut self, compare: F) where
    F: FnMut(&BinarizedRule<H>, &BinarizedRule<H>) -> Ordering, 

Sorts the rule array in place, using the argument to compare elements.

pub fn dedup(&mut self)

Removes consecutive duplicate rules.

pub fn sym<T>(&mut self) -> T where
    T: SymbolContainer, 

Returns generated symbols.

pub fn next_sym(&mut self) -> Symbol

Generates a new unique symbol.

pub fn num_syms(&self) -> usize

Returns the number of symbols in use.

pub fn eliminate_nulling_rules(&mut self) -> BinarizedCfg<H>

Eliminates all rules of the form A ::= epsilon.

In other words, this splits off the set of nulling rules.

The language represented by the grammar is preserved, except for the possible lack of the empty string. Unproductive rules aren't preserved.

Trait Implementations

impl ContextFree for BinarizedGrammar

fn rule(&mut self, lhs: Symbol) -> RuleBuilder<&mut Self>

Starts building a new rule.

fn precedenced_rule(&mut self, lhs: Symbol) -> PrecedencedRuleBuilder<&mut Self> where
    Self::History: AssignPrecedence + Default, 

Starts building a new precedenced rule.

impl<'a> ContextFreeRef<'a> for &'a BinarizedGrammar

type RuleRef = RuleRef<'a, History>

Immutable reference to a rule.

type Rules = BinarizedRules<'a, History>

Iterator over immutable references to the grammar's rules.

fn rules(self) -> Self::Rules

Returns an iterator over immutable references to the grammar's rules.

fn reverse(self) -> Self::Target where
    <Self::Target as RuleContainer>::History: Clone,
    Self::Target: EmptyRuleContainer, 

Reverses the grammar.

impl RuleContainer for BinarizedGrammar

type History = History

The type of history carried with the rule.

fn sym_source(&self) -> &SymbolSource

Returns an immutable reference to the grammar's symbol source.

fn sym_source_mut(&mut self) -> &mut SymbolSource

Returns a mutable reference to the grammar's symbol source.

fn retain<F>(&mut self, f: F) where
    F: FnMut(Symbol, &[Symbol], &History) -> bool, 

Retains only the rules specified by the predicate.

fn add_rule(&mut self, lhs: Symbol, rhs: &[Symbol], history: History)

Inserts a rule with lhs and rhs on its LHS and RHS. The rule carries history.

fn sym<T>(&mut self) -> T where
    T: SymbolContainer, 

Returns generated symbols.

fn next_sym(&mut self) -> Symbol

Generates a new unique symbol.

fn num_syms(&self) -> usize

Returns the number of symbols in use.

impl Clone for BinarizedGrammar

fn clone(&self) -> BinarizedGrammar

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for BinarizedGrammar

fn default() -> BinarizedGrammar

Returns the "default value" for a type.

impl Deref for BinarizedGrammar

type Target = BinarizedCfg<History>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for BinarizedGrammar

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.