Currently I have this as a workaround:

# @cache won't work
_seen = set()

def _leave_whitespace(element: ParserElement) -> ParserElement:
    if expression in _seen:
        return element

    _seen.add(element)

    if hasattr(element, 'expr'):
        _leave_whitespace(element.expr)
    elif hasattr(element, 'exprs'):
        for epxr in element.exprs:
            _leave_whitespace(expr)
    else:
        element.leave_whitespace()

    return element

Here is an alternative implementation of _leave_whitespace for you. It makes use of expr.recurse() which returns a list of the embedded expr or exprs (so you don't need the hasattr if/elif/else stuff). Also, it uses a deque to implement the recursion without having to actually write a recursive function. In my non-pyparsing Python work, I've shifted over to this style of recursion instead of actual recursive function calling.

from collections import deque

def _leave_whitespace(element: ParserElement) -> ParserElement:

    seen = set()

    # initialize queue of expressions to visit
    to_visit = deque([element])
    
    while to_visit:
        expr = to_visit.popleft()
        if expr in seen:
            continue
        seen.add(expr)

        # make the call on the current expr
        expr.leave_whitespace()

        # add child exprs to todo list
        to_visit.extend(expr.recurse())

    return element

@ptmcg Thanks. It would be nice if you document methods like this one so that we users know which ones are implementation details and which are not. Also, the method call should have recursive = False.