Printing Not and Peek

[randomeizer]

Hi @stephencelis, continuing the discussion from PR #97, which is now closed. For context, we were discussing that Not and Peek are 'unprintable'.

Having had a chance to look at the printer-throws-2 branch, and I see what you mean with regards to it allowing "invalid" prints with code like this:

let uncommentedLine = Parse {
  Not { "//" }.printing("")
  Prefix { $0 != "\n" }
}

uncommentedLine.print("// hello from comment") // prints fine

I think the only solution would be to have Parse actually print to the input in reverse order. Not only Parse, but everything. Everything gets printed depth-first.

In that case, Not would attempt to parse the current printed value to check if it was valid against its internal upstream parser. If it parses successfully, it throws an error.

Printing backwards seems illogical, but if you think about it, we parse from outer to inner, so printing from inner to outer makes sense.

Example implementation of Not.print(...), if printing in reverse:

extension Not: Printer {
  func print(_ output: Void, to input: inout Substring) throws {
    do {
      var i = input
      let result = try upstream.parse(&i)
      throw PrintingError.expected("not to be \(result)", at: input)
    } catch {}
  }
}

This obviously won't work for uncommentedLine unless the Prefix parser has already printed. However, it would also let Prefix check that it is outputting correctly first. It's print could look like this:

extension Prefix: Printer where Input: RangeReplaceableCollection {
  @inlinable
  public func print(_ output: Input, to input: inout Input) throws {
    let count = output.count
    guard
      output.isEmpty || predicate(output.first!), // check that the existing `input` (aka printed value) is empty or begins by matching the predicate.
      count >= self.minLength,
      self.maxLength.map({ count <= $0 }) ?? true,
      self.predicate.map({ output.allSatisfy($0) }) ?? true
    else { throw PrintingError() }
    input.insert(contentsOf: output, at: output.startIndex) // note: inserting instead of appending
  }
}

Each of the ZipX parsers would then become something like:

extension Parsers.ZipOO: Printer
where
  P0: Printer,
  P1: Printer,
  P0.Input == P1.Input
{
  @inlinable public func print(
    _ output: (
      P0.Output,
      P1.Output
    ),
    to input: inout P0.Input
  ) rethrows {
    try p1.print(output.1, to: &input)  // first p1
    try p0.print(output.0, to: &input) // then p0
  }
}

Kind of unintuitive, but I think it would actually be more correct.

[randomeizer]

I've posted a PR in #145 as an implementation of this.

[mbrandonw]

Moved comment to PR #145

[mbrandonw]

I'm going to delete and repost my comment in the PR and we can continue any discussion over there.