Whitespace parser since 0.12

[JaapWijnen]

I'm trying to update to the latest version but can't get the Whitespace parser to work.

var source = " (x)"[...]
let result = try Whitespace().parse(&source) // '&' used with non-inout argument of type 'String.SubSequence' (aka 'Substring')
print(result, source)

When looking at Whitespace's initialisers it seems like you can only initialise it with a InputToBytes == Conversions.Identity<C> which I don't fully understand. Then what use are the conversions? Or is this an oversight?

It's failing because it's using the disfavoured overload:

@_disfavoredOverload
  @inlinable
  public func parse<S: StringProtocol>(_ input: S) rethrows -> Output
  where Input == S.SubSequence.UTF8View {
    var input = input[...].utf8
    return try Parse {
      self
      End<Input>()
    }.parse(&input)
  }

Not sure how to get around this!

[JaapWijnen]

After looking at it a little more. Is there simply no way to user the Whitespace parser on Substring input anymore?

[mbrandonw]

Yes it is possible:

func testTrimsAllWhitespace() {
  let parser = Parse(input: Substring.self) {
    Whitespace()
  }
  var input = "    \r \t\t \r\n \n\r    Hello, world!"[...]
  XCTAssertNotNil(try parser.parse(&input))
  XCTAssertEqual("Hello, world!", input)
}

You just may need to give Swift a little more type information due to how type inference works in builder contexts. How are you using Whitespace?

[JaapWijnen]

Was trying to upgrade one of our packages that was using the following parser to use swift-parsing with regexp

private struct RegexParser: Parser {
    enum Error: Swift.Error {
        case failed(String)
    }

    let pattern: String

    @inlinable
    init(_ pattern: String) {
        self.pattern = pattern
    }

    @inlinable
    func parse(_ input: inout Substring) throws -> String {
        // TODO: there has to be a cleaner implementation
        let regex = try NSRegularExpression(pattern: self.pattern)
        let inputString = String(input)
        guard let matchResult = regex.firstMatch(
            in: inputString, options: .anchored, range: NSRange(location: 0, length: inputString.count)
        ) else {
            throw Self.Error.failed("remaining input does not match regular expression \(self.pattern): \(input)")
        }

        assert(matchResult.range.lowerBound == 0) // guaranteed by `options: .anchored`

        let matchedSubstring = inputString.prefix(matchResult.range.upperBound)
        input.removeFirst(matchResult.range.upperBound)

        Whitespace().parse(&input) // '&' used with non-inout argument of type 'Substring'

        return String(matchedSubstring)
    }
}

That Whitespace line is trying to run the following disfavoured overload in the swift-parsing library:

 @_disfavoredOverload
  @inlinable
  public func parse<S: StringProtocol>(_ input: S) rethrows -> Output
  where Input == S.SubSequence.UTF8View {
    var input = input[...].utf8
    return try Parse {
      self
      End<Input>()
    }.parse(&input)
  }

I was able to get around it by wrapping it with From(.utf8) { Whitespace() }.parse(&input) was just suprised it didn't work and had a hard time passing the correct type information to the Whitespace() parser itself.