How should nested parsing work?

[Tyler-Keith-Thompson]

Imagine a "simple" example where you're parsing anything between () and allow for nesting, so (nested (nested again (nested again again!)) is just as valid as (((nested))) or (some large amount of text).

I have had just a hell of a time doing this, I've tried a few things but this is probably the closest I got.

func parenParser() -> AnyParser<Substring, Substring> {
        Parse {
            "("
            Optionally { Lazy { self.parenParser() } }
            Prefix { $0 != ")" }
            ")"
        }
            .map { "\($0.0 ?? $0.1)" }
            .eraseToAnyParser()
    }

It works on use cases like (((nested))) but fails for (nested (nested again (nested again again!)).

I feel like maybe I'm missing something simple, but after struggling for a bit I figured maybe I'd just ask here.

[Tyler-Keith-Thompson]

Figured this out myself by looking at how string parsing worked in the JSON example. Ended up using Many for character-by-character iteration (not optimized at all):

func parenParser() -> AnyParser<Substring, Substring> {
    Parse {
        "("
        Many(into: Substring("")) { string, fragment in
            string += fragment
        } element: {
            OneOf {
                Prefix(1...) { $0 != "(" && $0 != ")" }

                Lazy { parenParser() }
            }
        } terminator: {
            ")"
        }
    }
    .eraseToAnyParser()
}