Grammar is a Backus-Naur form grammar, extended by regular expressions, embedded in Haskell, with combinators:

• pattern matching >?, >?<
• alternation <|>
• sequencing >*<, >*, *<
• Kleene quantifiers optionalP, manyP, someP
• any character anyToken
• regular predicates inClass, notInClass, inCategory, notInCategory
• nonregular predicate satisfy
• terminal strings tokens, fromString and -XOverloadedStrings
• nonterminal rules rule, ruleRec
• and more.

To see an example of a Grammar, look at the source of regexGrammar.

A Grammarr is just a function of Grammars, useful for expressing one in terms of another Grammar. The arr is for arrow; and it should be pronounced like a pirate.

One can create new generators from a Grammar by defining instances of Grammatical. For instance, one could create generators for Parsec style parsers, and use rule for labeling of parse errors.

A Grammatical Profunctor is a partial distributor, being an Alternator & Filtrator. It is also Tokenized with Char input & output tokens, and IsString with the property:

fromString = tokens

Grammatical has defaults for methods inClass, notInClass, inCategory, notInCategory in terms of satisfy; and rule & ruleRec in terms of id & fix.

Generate a ReadS parser from a Grammar.

Use a Grammar to parse a String.

Generate ShowS printers from a Grammar.

Use a Grammar to print Strings.

Generate a RegEx from a Grammar. This will infinite loop if your Grammar includes a ruleRec, otherwise it will inline all rules and produce a regular expression.

Generate a context free grammar, consisting of "start" & named RegEx rules, from a Grammar.

Print a Grammar.

A version of regular expressions extended by nonterminals.

Normalize a RegEx.

>>> regexNorm (Sequence (Terminal "abc") (Terminal "xyz"))
Terminal "abcxyz"

Parse a RegEx from a String.

>>> let str = "xy|z+"
>>> regexParse str
Alternate (Terminal "xy") (KleenePlus (Terminal "z"))

Fail if the String is not a valid regular expression.

>>> let bad = ")("
>>> regexParse bad
Fail

The RegEx String.

>>> let rex = Alternate (Terminal "xy") (KleenePlus (Terminal "z"))
>>> putStrLn (regexString rex)
xy|z+

regexGrammar provides an important example of a Grammar. Take a look at the source to see its definition.

>>> printGrammar regexGrammar
start = \q{regex}
alternate = \q{sequence}(\|\q{sequence})*
any = \.
atom = \q{nonterminal}|\q{fail}|\q{class-in}|\q{class-not-in}|\q{category-in}|\q{category-not-in}|\q{char}|\q{any}|\q{parenthesized}
category = Ll|Lu|Lt|Lm|Lo|Mn|Mc|Me|Nd|Nl|No|Pc|Pd|Ps|Pe|Pi|Pf|Po|Sm|Sc|Sk|So|Zs|Zl|Zp|Cc|Cf|Cs|Co|Cn
category-in = \\p\{\q{category}\}
category-not-in = \\P\{\q{category}\}
char = \q{char-literal}|\q{char-escaped}
char-escaped = \\[\$\(\)\*\+\.\?\[\\\]\^\{\|\}]
char-literal = [^\$\(\)\*\+\.\?\[\\\]\^\{\|\}]
class-in = \[\q{char}*\]
class-not-in = \[\^\q{char}*\]
expression = \q{terminal}|\q{kleene-optional}|\q{kleene-star}|\q{kleene-plus}|\q{atom}
fail = \\q
kleene-optional = \q{atom}\?
kleene-plus = \q{atom}\+
kleene-star = \q{atom}\*
nonterminal = \\q\{\q{char}*\}
parenthesized = \(\q{regex}\)
regex = \q{alternate}
sequence = \q{expression}*
terminal = \q{char}+