# `Predicator.Visitor`
[🔗](https://github.com/riddler/predicator-ex/blob/v9.5.0/lib/predicator/visitor.ex#L1)

Behaviour for AST visitors.

Visitors implement the visitor pattern to traverse and transform
Abstract Syntax Trees into various representations.

## Examples

    defmodule MyVisitor do
      @behaviour Predicator.Visitor

      @impl true
      def visit({:literal, value, _slot}, _opts) do
        value
      end

      @impl true
      def visit({:identifier, name, _slot}, _opts) do
        name
      end

      @impl true
      def visit({:comparison, op, left, right, _slot}, opts) do
        left_result = visit(left, opts)
        right_result = visit(right, opts)
        {op, left_result, right_result}
      end
    end

# `visit`

```elixir
@callback visit(ast_node :: Predicator.Parser.visitable(), opts :: keyword()) :: term()
```

Visits an AST node and returns the transformed result.

## Parameters

- `ast_node` - The AST node to visit
- `opts` - Optional visitor-specific options

## Returns

The transformed representation (type depends on visitor implementation)

## Source positions

The contract is a positioned AST: every node carries a trailing slot holding
a position, a span, or `nil`. Implementations match on that shape directly -
there is no position-free variant and no normalization on the way in.

# `accept`

```elixir
@spec accept(Predicator.Parser.visitable(), module(), keyword()) :: term()
```

Utility function to accept a visitor and process an AST.

This provides a convenient interface for applying visitors to AST nodes.

## Examples

    iex> ast = {:literal, 42, nil}
    iex> Predicator.Visitor.accept(ast, MyVisitor)
    42

---

*Consult [api-reference.md](api-reference.md) for complete listing*