Transforming parsing errors

[randomeizer]

So, I've been building out my parser here, and have found it useful to have a way of transforming possible errors from a parsing block into something specific to that context. For example, something like this:

/// Parses a single return signature value.
let returnSignature = Prefix(1...) { !",\n".contains($0) }.map(ReturnSignature.init)

This doesn't give a particularly illuminating error message. So I cooked up a Require parser, which you use like so:

/// Parses a single return signature value.
let returnSignature = Require {
    Prefix(1...) { !",\n".contains($0) }
} orThrow: { error, input in
    LintError.expected("a return type")
}
.map(ReturnSignature.init)

Now at least it will give an idea of what it might be. The message could be more specific as well if desired (LintError is just temporary until ParsingError is public).

Currently, the closure gets passed the error that came from the upstream Parser, along with the Input in whatever state the failed parser left it.

Not sure this is quite the right shape for it. Another possibility would be a Parser extension, something along the lines of:

extension Parser {
    func orThrow(error thrower: (Error, inout Input) -> Error) -> Require<Input,Output> {
        Require(upstream: self, orThrow: thrower)
    }
}

Which would then let you do this instead:

let returnSignature = Prefix(1...) { !",\n".contains($0) }
    .orThrow { error, input in LintError.expected("a return type") }
    .map(ReturnSignature.init)

Thoughts?

[tgrapperon]

Ah sorry, I've PR #135 without seeing this discussion.