Throwing errors from Parser.map closure

[randomeizer]

Working with the throws implementation, it would be useful to be able to check multiple input from a parse for extra details before allowing the parse to complete. For example, I have documentation like this that I'm parsing:

--- foo.bar(a, b)
--- Function
--- Description of the function here.
--- 
--- Parameters:
---  * a - first parameter
---  * b - second parameter

I have a FunctionDoc structure I'm parsing the values into, and have the signature (first line) and Parameters: list parsed. Now, I want to check that the listed parameters actually match up to those in the signature.

One option is map:

let functionDoc = Parse {
  FunctionSignature.parser
  "Function"
  Description.parser
  Parameters.parser
  Returns.parser
}
.map { signature, description, parameters, returns in
  guard signature.parameters.count == parameters.count else {
    throw CustomError.expected("signature parameters count (\(signature.parameters.count)) to equal parameters count (\(parameters.count))"
  }
  return FunctionDoc(signature, description, parameters, returns)
}

Unfortunately, it doesn't allow throw in the transform function, so it's not much help. I chucked together a PR (which isn't merging, but is at #119 if you want to check it out) which adds throws to the signature. The main cost is that you have to try whenever doing a map.

Open to other ideas. I looked a filter, but I don't like the error message it produces - it's very undescriptive. I'd rather throw my own error and have that output.

Any thoughts?

[randomeizer]

So a suggestion from @stephencelis was implementing a throwing tryMap function in addition to map which does allow throwing.

Another option I've been implementing is a Verify parser, which works something like:

Verify {
  Int.parser()
} check: { result in
  guard result <= 42 else {
    throw ParsingError.expectedInput("of less than 42")
  }
}

This could also be implemented as:

Int.parser().verify { result in
  guard result <= 42 else {
    throw ParsingError.expectedInput("of less than 42")
  }
}

[kamcma]

I am also interested in a tryMap operator.

My use case is that I would like the concise Codable integration demonstrated by the JSON conversion, but for instances where I only have a Decodable implementation. Conversion's apply and unapply transforms are allowed to throw, but I don't want to provide both and imply the resulting parser is capable of printing. So I want to fall back to the one-way operation, Map, but need the ability to throw, so a TryMap implementation seems like the answer.

Here are the extensions I am currently using. Nothing special, just the Map parser but with a throwing transform:

extension Parser {
  func tryMap<NewOutput>(
    _ transform: @escaping (Output) throws -> NewOutput
  ) -> Parsers.TryMap<Self, NewOutput> {
    .init(upstream: self, transform: transform)
  }
}

extension Parsers {
  struct TryMap<Upstream: Parser, NewOutput>: Parser {
    let upstream: Upstream

    let transform: (Upstream.Output) throws -> NewOutput

    init(
      upstream: Upstream,
      transform: @escaping (Upstream.Output) throws -> NewOutput
    ) {
      self.upstream = upstream
      self.transform = transform
    }

    func parse(_ input: inout Upstream.Input) throws -> NewOutput {
      try self.transform(try self.upstream.parse(&input))
    }
  }
}

Then I can do something like the following:

extension MyDecodableType {
  static func parser() -> Parsers.TryMap<Rest<Data>, Self> {
    Rest()
      .tryMap { try JSONDecoder().decode(Self.self, from: $0) }
  }
}

You could finesse that API, make the decoder injectable, etc, but that's the idea.