Does the visitor pattern prevent the need to modify existing code when adding new data types?

Question

From what I understand, the visitor pattern is supposed to solve the expression problem (described here), where a program needs to support performing multiple operations on multiple types, ideally allowing adding new operations and new types without touching existing code.

• OOP languages can define a method for each operation on each type of object; this makes it easy to add new objects without modifying existing code, but adding a new operation requires modifying all existing objects.
• FP languages with pattern matching have the opposite issue; adding a new operation is self-contained, but adding a new data type requires modifying all existing functions to support the new type.

The visitor pattern, as I understand it, just changes the OOP style to the FP style; adding a new operation just means adding a new type of visitor, but adding a new data type means adding a method to all existing visitors. Is my understanding correct? If so, what's the benefit of the visitor pattern, if it doesn't fully solve the expression problem?

Answer 1

I'm not sure that the visitor solves the "expression problem". But your understanding is correct:

• You can derive new visitors based on the abstract visitor. This allows to define new operations that will work on all visited elements.
• But if you add to the visited's object structure an element of a new type, you'll need to update the abstract visitor and all its concrete derivations in order to add a member function for coping with the new type of elements.

The visitor is designed to perform an operation on a complex structure with substructures (typically on a tree-like composite), and allow to add new operations without changing the visited classes.

Not related: I would be careful in opposing OOP and FP. You have FP languages that allow their functions to get immutable objects as input and produce objects as result, and you have OOP languages that have introduced FP features, allowing to implement FP logic if the programmer wants to).