Many that ignores errors?

[elfenlaid]

Hello 👋 Hope all is well

During logs parsing I've stumbled upon malformed entries that sorta break Many.
In my case it was okay to skip such entries and continue parsing. We can simulate such scenario by the following example:

struct User: Equatable {
    var id: Int
    var name: String
    var isAdmin: Bool
}

let user = Parse(User.init(id:name:isAdmin:)) {
    Int.parser()
    ","
    Prefix { $0 != "," }.map(String.init)
    ","
    Bool.parser()
}

let users = Many {
    user
} separator: {
    "\n"
}

// The second line contains a broken entry
var input = """
1,Blob,true
2,Blob Jr.,f
3,Blob Sr.,true
"""[...]

let output = try users.parse(&input)
output.count // 1

As you can see, we stopped parsing at the second line and produced out only one element, which is totally expected.

Let's see what it takes to come up with such Many that ignores malformed entries and continues with parsing:

Many(into: []) { users, user in
    user.map { users.append($0) }
} element: {
    Optionally { user }
} separator: {
    PrefixThrough("\n") // Notice the replacement of `"\n"` with `PrefixThrough("\n")` as we need to consume the malformed line
}

Let's generalize it a bit by cooking up a small helper

struct ProbablyMany<Element: Parser, Separator: Parser>: Parser
    where Separator.Input == Element.Input
{
    let element: Element
    let separator: Separator
    
    init(
        @ParserBuilder element: () -> Element,
        @ParserBuilder separator: () -> Separator
    ) {
        self.element = element()
        self.separator = separator()
    }
    
    func parse(_ input: inout Element.Input) throws -> [Element.Output] {
        try Many(into: []) { accumulator, item in
            item.map { accumulator.append($0) }
        } element: {
            Optionally { element }
        } separator: {
            separator
        }
        .parse(&input)
    }
}

and its usage looks like this:

let users = ProbablyMany {
    user
} separator: {
    PrefixThrough("\n")
}

There are certain downsides to it. Like one needs to be extremely mindful while constructing a separator parser. But overall I think it looks okay-ish 🤔

Maybe I'm reinventing the wheel here and there are more simple ways of baking a "graceful" Many?

[iampatbrown]

Hey @elfenlaid one option could be to use Many + Not inside your separator. eg:

let linesToUser = Many(1...) {
  PrefixThrough("\n")
} separator: {
  Not { user }
}

let users = Many {
  user
} separator: {
  linesToUser
}

I'm not sure if this works for all of your use cases but it should work for the example above.

[elfenlaid]

Oh, that's really clever. Many thanks, will try it out 🙇