Struct bnf::Grammar

pub struct Grammar { /* fields omitted */ }

A Grammar is comprised of any number of Productions

Implementations

impl Grammar

pub fn new() -> Grammar

Construct a new Grammar

pub fn from_parts(v: Vec<Production>) -> Grammar

Construct an Grammar from Productions

pub fn add_production(&mut self, prod: Production)

Add Production to the Grammar

pub fn remove_production(&mut self, prod: &Production) -> Option<Production>

Remove Production from the Grammar

pub fn productions_iter(&self) -> Iter<'_>

Get iterator of the Grammar’s Productions

pub fn productions_iter_mut(&mut self) -> IterMut<'_>

Get mutable iterator of the Grammar’s Productions

pub fn generate_seeded(&self, rng: &mut StdRng) -> Result<String, Error>

Generate a random sentence from self and seed for random. Use if interested in reproducing the output generated. Begins from lhs of first production.

Example

extern crate bnf;
extern crate rand;
use rand::{SeedableRng, rngs::StdRng};
use bnf::Grammar;

fn main() {
    let input =
        "<dna> ::= <base> | <base> <dna>
        <base> ::= \"A\" | \"C\" | \"G\" | \"T\"";
    let grammar: Grammar = input.parse().unwrap();
    let seed: [u8; 32] = [0; 32];
    let mut rng: StdRng = SeedableRng::from_seed(seed);
    let sentence = grammar.generate_seeded(&mut rng);
    match sentence {
        Ok(s) => println!("random sentence: {}", s),
        Err(e) => println!("something went wrong: {}!", e)
    }

}

pub fn generate_seeded_callback(
    &self,
    rng: &mut StdRng,
    f: impl Fn(&str, &str) -> bool
) -> Result<String, Error>

Does the same as [generate_seeded], except it takes a callback which is executed on every production that is generated to check if it is okay. When the callback returns true, the generation continues as normal, but when the callback returns false, a new random option is tried.

The first parameter to the callback is the current production name, and the second parameter is the value that was attempted to be generated, but may be rejected.

pub fn generate(&self) -> Result<String, Error>

Generate a random sentence from self. Begins from lhs of first production.

Example

extern crate bnf;
use bnf::Grammar;

fn main() {
    let input =
        "<dna> ::= <base> | <base> <dna>
        <base> ::= \"A\" | \"C\" | \"G\" | \"T\"";
    let grammar: Grammar = input.parse().unwrap();
    let sentence = grammar.generate();
    match sentence {
        Ok(s) => println!("random sentence: {}", s),
        Err(e) => println!("something went wrong: {}!", e)
    }

}

pub fn generate_callback(
    &self,
    f: impl Fn(&str, &str) -> bool
) -> Result<String, Error>

Does the same as [generate], except it takes a callback which is executed on every production that is generated to check if it is okay. When the callback returns true, the generation continues as normal, but when the callback returns false, a new random option is tried.

The first parameter to the callback is the current production name, and the second parameter is the value that was attempted to be generated, but may be rejected.

Trait Implementations

impl Clone for Grammar

fn clone(&self) -> Grammar

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Grammar

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Grammar

fn default() -> Grammar

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Grammar

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Grammar

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for Grammar

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Grammar

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<Grammar> for Grammar

fn eq(&self, other: &Grammar) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Grammar) -> bool

This method tests for !=.

impl Serialize for Grammar

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl Eq for Grammar

impl StructuralEq for Grammar

impl StructuralPartialEq for Grammar