Struct jobrog::util::SPEC

pub struct SPEC { /* fields omitted */ }

Methods from Deref<Target = 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 Deref for SPEC

type Target = Grammar

The resulting type after dereferencing.

pub fn deref(&self) -> &Grammar

Dereferences the value.

impl LazyStatic for SPEC

pub fn initialize(lazy: &Self)