Struct pidgin::Matcher

pub struct Matcher {
    pub rx: Regex,
    // some fields omitted
}

This is functionally equivalent to a Regex: you can use it repeatedly to search a string. It cannot itself be used directly to split strings, but its regular expression is public and may be so used. It improves on regular expressions in that the Match object it returns is the root node in a parse tree, so its matches preserve parse structure.

Fields

rx: Regex

The Regex used for parsing.

Implementations

impl Matcher

pub fn parse<'t>(&self, s: &'t str) -> Option<Match<'t>>

Returns Some(Match) if the grammar can parse the string. Note that unless the grammar is string-bounded, this only means it can parse the string at some point.

Examples

let m = grammar!{

	(?bB)

	S -> r(r"\A") <subject> <VP> r(r"\.\z")

	subject           => [["Amy", "Bob", "Carter", "Dianne"]]
	VP                -> <verb_intransitive> | <verb_transitive> <object>
	verb_intransitive => [["naps", "doodles", "exercises", "meditates"]]
	verb_transitive   => [["eats", "programs", "sees", "throws"]]
	object            => (?w) [["a sandwich", "eggs", "the sunset"]]

}.matcher()?;

let parse_tree = m.parse("Amy programs the sunset.").unwrap();

println!("{}", parse_tree);

// S (0, 24): "Amy programs the sunset."
//   subject (0, 3): "Amy"
//   VP (4, 23): "programs the sunset"
//     verb_transitive (4, 12): "programs"
//     object (13, 23): "the sunset"

pub fn is_match(&self, text: &str) -> bool

Returns whether the grammar can parse the string. This is a cheaper operation than parsing.

Examples

let m = grammar!{

	(?bB)

	S -> r(r"\A") <subject> <VP> r(r"\.\z")

	subject           => [["Amy", "Bob", "Carter", "Dianne"]]
	VP                -> <verb_intransitive> | <verb_transitive> <object>
	verb_intransitive => [["naps", "doodles", "exercises", "meditates"]]
	verb_transitive   => [["eats", "programs", "sees", "throws"]]
	object            => (?w) [["a sandwich", "eggs", "the sunset"]]

}.matcher()?;

assert!(m.is_match("Bob doodles."));

Trait Implementations

impl Debug for Matcher

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Matcher

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

Deserialize this value from the given Serde deserializer.

impl Serialize for Matcher

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

Serialize this value into the given Serde serializer.