OneOrMore parser

[randomeizer]

Not really a pitch for inclusion in the library, since it would require adding NonEmpty as a dependency, but I've been using NonEmpty in my data structures, and parsing them was a bit of a pain, so I added a OneOrMore parser. Not quite as flexible as Many in the library, it does the job for me, thought I'd share it:

import Parsing
import NonEmpty

/// Requires at least one match for the `Upstream` ``Parser``. If found, a ``NonEmpty`` array of the results is the `Output`.
struct OneOrMore<Upstream, Separator>: Parser
where Upstream: Parser,
      Separator: Parser,
      Upstream.Input == Separator.Input
{
    let upstream: Upstream
    let separator: Separator
    
    @inlinable
    init(
        @ParserBuilder _ build: () -> Upstream,
        @ParserBuilder separator: () -> Separator
    ) {
        self.upstream = build()
        self.separator = separator()
    }
    
    @inlinable
    func parse(_ input: inout Upstream.Input) -> NonEmpty<[Upstream.Output]>? {
        let original = input
        var rest = input

        var values = [Upstream.Output]()
        
        while let parsed = upstream.parse(&input) {
            values.append(parsed)
            rest = input
            if separator.parse(&input) == nil {
                break
            }
        }
        
        guard let result = NonEmpty(rawValue: values) else {
            input = original
            return nil
        }
        input = rest
        return result
    }
}

extension OneOrMore where Separator == Always<Input, Void> {    
    @inlinable
    init(@ParserBuilder _ builder: () -> Upstream) {
        self.upstream = builder()
        self.separator = .init(())
    }
}

[iampatbrown]

Another option is to use Many + CompactMap eg:

var input = "1,2,3,4,5"[...]

let oneOrMoreNumbers = Many {
  Int.parser()
} separator: {
  ","
}
.compactMap(NonEmpty.init)

oneOrMoreNumbers.parse(&input) // => [1, 2, 3, 4, 5]