You have a stable hierarchy of types — AST nodes, file system entries, shape primitives — and you keep needing to add new operations across all of them. Every new operation forces you to crack open every class and add another method. The Visitor pattern flips this: instead of putting operations on the types, you put the type-dispatch on the operation.

The mechanic is double dispatch. Each node exposes a single accept(visitor) method that calls back visitor.visitConcreteType(this). The runtime type of the node selects the accept implementation; the visitor's method overload selects the operation. Two dispatches, one for each axis.

Concrete example — a small expression evaluator:

• Node hierarchy: NumberLit, BinaryOp, VariableRef, FunctionCall
• Without Visitor: adding "pretty-print", "type-check", and "compile-to-bytecode" means three new methods on each of four classes — 12 places to touch, scattered across files.
• With Visitor: each operation is one class (PrettyPrinter, TypeChecker, Compiler) with four visit methods. The node classes stay frozen.

This is the core trade-off, often called the Expression Problem:

• Add a new operation? Visitor wins — write one new visitor class.
• Add a new node type? Visitor loses — you must update every existing visitor. The compiler will at least tell you where.

Rule of thumb: if your type hierarchy changes more than ~2× per year but operations rarely change, skip Visitor and use polymorphic methods. If the hierarchy is stable (think: language grammars, document formats, geometric primitives) but you keep inventing new things to do with it, Visitor pays for itself after roughly 3 operations × 4 types — about 12 dispatch sites.

Real-world sightings: Roslyn's C# compiler uses CSharpSyntaxVisitor<T> for analyzers and refactorings. Babel's AST traversal is essentially Visitor. ESLint rules are Visitors over the JS AST.

Practical pitfalls:

• Don't reach for it in dynamically-typed languages with pattern matching — Python's match or a dict-of-handlers is simpler and gives you the same separation without ceremony.
• Visitors break encapsulation — they need access to node internals. Keep node fields immutable so visitors can't corrupt state.
• Beware deep recursion on real ASTs; for production compilers, convert to an iterative worklist before you blow the stack on a 10,000-line generated file.