Module regex_syntax::ast 
                   
                       [−]
                   
               [src]
Defines an abstract syntax for regular expressions.
Modules
| parse | 
                                 This module provides a regular expression parser.  | 
                       
| 
                                 This module provides a regular expression printer.  | 
                       
Structs
| Alternation | 
                                 An alternation of regular expressions.  | 
                       
| Assertion | 
                                 A single zero-width assertion.  | 
                       
| CaptureName | 
                                 A capture name.  | 
                       
| ClassAscii | 
                                 An ASCII character class.  | 
                       
| ClassBracketed | 
                                 A bracketed character class, e.g.,   | 
                       
| ClassPerl | 
                                 A Perl character class.  | 
                       
| ClassSetBinaryOp | 
                                 A Unicode character class set operation.  | 
                       
| ClassSetRange | 
                                 A single character class range in a set.  | 
                       
| ClassSetUnion | 
                                 A union of items inside a character class set.  | 
                       
| ClassUnicode | 
                                 A Unicode character class.  | 
                       
| Comment | 
                                 A comment from a regular expression with an associated span.  | 
                       
| Concat | 
                                 A concatenation of regular expressions.  | 
                       
| Error | 
                                 An error that occurred while parsing a regular expression into an abstract syntax tree.  | 
                       
| Flags | 
                                 A group of flags.  | 
                       
| FlagsItem | 
                                 A single item in a group of flags.  | 
                       
| Group | 
                                 A grouped regular expression.  | 
                       
| Literal | 
                                 A single literal expression.  | 
                       
| Position | 
                                 A single position in a regular expression.  | 
                       
| Repetition | 
                                 A repetition operation applied to a regular expression.  | 
                       
| RepetitionOp | 
                                 The repetition operator itself.  | 
                       
| SetFlags | 
                                 A group of flags that is not applied to a particular regular expression.  | 
                       
| Span | 
                                 Span represents the position information of a single AST item.  | 
                       
| WithComments | 
                                 An abstract syntax tree for a singular expression along with comments found.  | 
                       
Enums
| AssertionKind | 
                                 An assertion kind.  | 
                       
| Ast | 
                                 An abstract syntax tree for a single regular expression.  | 
                       
| Class | 
                                 A single character class expression.  | 
                       
| ClassAsciiKind | 
                                 The available ASCII character classes.  | 
                       
| ClassPerlKind | 
                                 The available Perl character classes.  | 
                       
| ClassSet | 
                                 A character class set.  | 
                       
| ClassSetBinaryOpKind | 
                                 The type of a Unicode character class set operation.  | 
                       
| ClassSetItem | 
                                 A single component of a character class set.  | 
                       
| ClassUnicodeKind | 
                                 The available forms of Unicode character classes.  | 
                       
| ClassUnicodeOpKind | 
                                 The type of op used in a Unicode character class.  | 
                       
| ErrorKind | 
                                 The type of an error that occurred while building an AST.  | 
                       
| Flag | 
                                 A single flag.  | 
                       
| FlagsItemKind | 
                                 The kind of an item in a group of flags.  | 
                       
| GroupKind | 
                                 The kind of a group.  | 
                       
| HexLiteralKind | 
                                 The type of a Unicode hex literal.  | 
                       
| LiteralKind | 
                                 The kind of a single literal expression.  | 
                       
| RepetitionKind | 
                                 The kind of a repetition operator.  | 
                       
| RepetitionRange | 
                                 A range repetition operator.  | 
                       
| SpecialLiteralKind | 
                                 The type of a special literal.  | 
                       
Traits
| Visitor | 
                                 A trait for visiting an abstract syntax tree (AST) in depth first order.  | 
                       
Functions
| visit | 
                                 Executes an implementation of   |