The ? operator from regex

[alexbbrown]

I'm trying to parse a fragment of Dotty syntax from Graphviz

Discarding the boilerplate digraph G {}, a node looks like this:

A

two nodes look like this

A
B

A node has an optional attribute list, like this

A [width=1.0]
B

In a regex, I would use the ? operator to indicate that there are ZERO or ONE attribute lists.

What's the equivalent of ? in this parser? I can see the Optional.parser type, but that appears to expect the parser to return an optional value. I can see the OneOf type, but I don't know what the alternative case should be... Fail?

I can see a workaround:

OneOf(node, node.take(attributeList))

But I'd prefer something like

node.thenMaybe(attributeList)

which avoids parsing node twice.

[alexbbrown]

Experimenting, I find the answer is: Use the Optional.parser

Here's a worked example of a parser that can accept [1,2,3] or [1,3]:

typealias Input = ArraySlice<Int>

let n = { (v: Int) in
    Prefix<Input>(minLength: 1) {
        $0 == v
    }.map { $0.first! }
}

let data: Input = [1,3]

let parser = n(1)
    .take(Optional.parser(of: n(2)))
    .take(n(3))

let parsed = parser.parse(data)

XCTAssertNotNil(parsed.output)

print(parsed) // output: Optional((1, nil, 3)), rest: ArraySlice([]))

output: does not fail, Optional((1, nil, 3)), rest: ArraySlice([])

---

feel free to copy this code.

[stephencelis]

Ah, yup! You can also use orElse and Always to cascade failure to some default value:

StartsWith("[")
  .take(Many(attributeParser, atLeast: 1))
  .skip(StartsWith("]")
  .orElse(Always([]))

This is sometimes a bit nicer to deal with than optionality.

[alexbbrown]

This is great! Please can you add it to the documentation for orElse and Optional, so the next person groks this from the start?

[stephencelis]

Absolutely! Looks like we don't have any docs for Optional.parser 😅

[alexbbrown]

What would have been neat for me: coming from a regex world but dearly wanting to learn parser combinators, is a map from one to the other!

regex name          op  Parser
Alternation,        |   OrElse()
Match-Zero-Or-One   ?   Optional.parser(of:)
Match-Zero-Or-More  *   Many

etc

[stephencelis]

What would have been neat for me: coming from a regex world but dearly wanting to learn parser combinators, is a map from one to the other!

That'd be awesome! If you end up exploring a way of documenting this we'd love to take a guide to this effect. DocC should make it really nice to have a page that compares regular expressions to combinators.