Struct Grammar

pub struct Grammar {
    pub name: Option<String>,
    /* private fields */
}

A compiled collection of rules ready for the building of a Matcher or for use in the definition of a new rule.

You do not build new Grammars directly. Rather, the grammar! macro compiles them for you.

Fields

name: Option<String>

Implementations

impl Grammar

pub fn matcher(&self) -> Result<Matcher, Error>

Compiles a Matcher based on the Grammar’s rules.

Examples

let m = grammar!{
	(?wbB)
	noun   => <person> | <place> | <thing>
	person => [["Moe", "Larry", "Curly", "Sade", "Diana Ross"]]
	place  => [["Brattleboro, Vermont"]]
	thing  => [["tiddly wink", "muffin", "kazoo"]]
}.matcher()?;

Errors

If the Grammar contains an ill-formed r(rx) or one with a named capture which is repeated, an error will be returned.

pub fn rule(&self, rule: &str) -> Option<Grammar>

Return a copy of one of the rules used by the grammar.

This is chiefly useful when combining grammars generated by the macro.

Examples

#[macro_use] extern crate pidgin;
let library = grammar!{
    books => <cat> | <dog> | <camel>
    cat   => [["persian", "siamese", "calico", "tabby"]]
    dog   => [["dachshund", "chihuahua", "corgi", "malamute"]]
    camel => [["bactrian", "dromedary"]]
};
let g = grammar!{
    seen -> ("I saw a") g(library.rule("cat").unwrap()) (".")
};
let matcher = g.matcher().unwrap();
assert!(matcher.is_match("I saw a calico."));

pub fn rx(&self) -> Result<Regex, Error>

Generates a non-capturing regex matching what the grammar matches.

Examples

let g = grammar!{
    foo -> r(r"\A") <bar> r(r"\z")
    bar => (?i) [["cat", "camel", "corn"]]
};
let rx = g.rx()?.to_string();
assert_eq!(r"\A(?i:\s*c(?:orn|a(?:t|mel)))\s*\z", rx);

let g = grammar!{
    sentence    -> <capitalized_word> <other_words>? <terminal_punctuation>
    other_words -> <other_word>+
    other_word  -> <non_terminal_punctuation>? <word>
    capitalized_word         => r(r"\b[A-Z]\w*\b")
    word                     => r(r"\b\w+\b")
    terminal_punctuation     => r(r"[.?!]")
    non_terminal_punctuation => r("(?:--?|[,;'\"])")
};
let rx = g.rule("word").unwrap().rx().unwrap();
let p = g
    .matcher()?
    .parse("John, don't forget to pick up chips.")
    .unwrap();
let other_words = p.name("other_words").unwrap().as_str();
let other_words = rx
    .find_iter(other_words)
    .map(|m| m.as_str())
    .collect::<Vec<_>>();
assert_eq!(
    vec!["don", "t", "forget", "to", "pick", "up", "chips"],
    other_words
);

Trait Implementations

impl Clone for Grammar

fn clone(&self) -> Grammar

Returns a duplicate of the value.

const 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 Display for Grammar

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

Formats the value using the given formatter.

impl Ord for Grammar

fn cmp(&self, other: &Grammar) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Grammar

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Grammar

fn partial_cmp(&self, other: &Grammar) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Grammar