# [−] [src] Trait regex_syntax::ast::Visitor

    pub trait Visitor {
        type Output;
        type Err;
        fn finish(self) -> Result<Self::Output, Self::Err>;

        fn start(&mut self) { ... }
        fn visit_pre(&mut self, _ast: &Ast) -> Result<(), Self::Err> { ... }
        fn visit_post(&mut self, _ast: &Ast) -> Result<(), Self::Err> { ... }
        fn visit_alternation_in(&mut self) -> Result<(), Self::Err> { ... }
        fn visit_class_set_item_pre(
            &mut self,
            _ast: &ClassSetItem
        ) -> Result<(), Self::Err> { ... }
        fn visit_class_set_item_post(
            &mut self,
            _ast: &ClassSetItem
        ) -> Result<(), Self::Err> { ... }
        fn visit_class_set_binary_op_pre(
            &mut self,
            _ast: &ClassSetBinaryOp
        ) -> Result<(), Self::Err> { ... }
        fn visit_class_set_binary_op_post(
            &mut self,
            _ast: &ClassSetBinaryOp
        ) -> Result<(), Self::Err> { ... }
        fn visit_class_set_binary_op_in(
            &mut self,
            _ast: &ClassSetBinaryOp
        ) -> Result<(), Self::Err> { ... }
    }

A trait for visiting an abstract syntax tree (AST) in depth first order.

The principle aim of this trait is to enable callers to perform case analysis on an abstract syntax tree without necessarily using recursion. In particular, this permits callers to do case analysis with constant stack usage, which can be important since the size of an abstract syntax tree may be proportional to end user input.

Typical usage of this trait involves providing an implementation and then running it using the `visit` function.

Note that the abstract syntax tree for a regular expression is quite complex. Unless you specifically need it, you might be able to use the much simpler high-level intermediate representation and its corresponding `Visitor` trait instead.

## Associated Types

### `type Output`

The result of visiting an AST.

### `type Err`

An error that visiting an AST might return.

Loading content...

## Required methods

### `fn finish(self) -> Result<Self::Output, Self::Err>`

All implementors of `Visitor` must provide a `finish` method, which yields the result of visiting the AST or an error.

Loading content...

## Provided methods

### `fn start(&mut self)`

This method is called before beginning traversal of the AST.

### `fn visit_pre(&mut self, _ast: &Ast) -> Result<(), Self::Err>`

This method is called on an `Ast` before descending into child `Ast` nodes.

### `fn visit_post(&mut self, _ast: &Ast) -> Result<(), Self::Err>`

This method is called on an `Ast` after descending all of its child `Ast` nodes.

### `fn visit_alternation_in(&mut self) -> Result<(), Self::Err>`

This method is called between child nodes of an `Alternation`.

### `fn visit_class_set_item_pre(
&mut self,
_ast: &ClassSetItem
) -> Result<(), Self::Err>`

This method is called on every `ClassSetItem` before descending into child nodes.

### `fn visit_class_set_item_post(
&mut self,
_ast: &ClassSetItem
) -> Result<(), Self::Err>`

This method is called on every `ClassSetItem` after descending into child nodes.

### `fn visit_class_set_binary_op_pre(
&mut self,
_ast: &ClassSetBinaryOp
) -> Result<(), Self::Err>`

This method is called on every `ClassSetBinaryOp` before descending into child nodes.

### `fn visit_class_set_binary_op_post(
&mut self,
_ast: &ClassSetBinaryOp
) -> Result<(), Self::Err>`

This method is called on every `ClassSetBinaryOp` after descending into child nodes.

### `fn visit_class_set_binary_op_in(
&mut self,
_ast: &ClassSetBinaryOp
) -> Result<(), Self::Err>`

This method is called between the left hand and right hand child nodes of a `ClassSetBinaryOp`.

Loading content...

## Implementors

Loading content...

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)