Consistent repetition boundaries for Prefix/Many/etc

[randomeizer]

I've been playing in the "result builder" branch (not sure I'm actually using the latest one though, which would that be now?), and noticed that Prefix uses Ranges to limit the number of repetitions, while Many uses atLeast/atMost parameters instead.

Could these be unified? Not sure which I prefer, but Ranges are definitely more concise. I think it would work for Many also:

let lines = Many(1...) {
    Prefix { $0 != "\n" }
} separatedBy: {
    "\n"
}

[mbrandonw]

It definitely looks nicer to use Many(1...) instead of Many(atLeast: 1), but our overloads are really starting to explode. Just recently we explored adding a new parameter to Prefix for some behavior we were experimenting with, but it meant that we needed many additional overloads to support all of the various ways of customizing the max/min length.

We'd like to find a way to minimize the overloads, possibly even removing the range initializers from Prefix. 😬

But we'd be happy to hear of any potential solutions to rein in this problem though.

[randomeizer]

Yeah, I had been wondering about that. Personally, I'd prefer consistency over a neater syntax in one situation only. I could live with atLeast:atMost: in Prefix, even though it's probably used there more than in Many.

[tgrapperon]

but it meant that we needed many additional overloads to support all of the various ways of customizing the max/min length

One way to advance in this direction would be to bundle all non-generic and defaultable parameters as chainable modifier methods of this parser instance, and remove them from the initializer. This would create an API similar to the one described in #77: parser.atLeast(10). Thus, we will only have to define overloads for generics or parameters without defaults.

[randomeizer]

Yeah, although bouncing between result builder style and fluent style feels a bit... awkward?

Another possibility I was wondering about was perhaps coming up with an AnyRange which could represent enough of the open/closed range for Int values at least, along with some operator overloads to have all possible range descriptions for this purpose in a single type, rather many in raw Swift?

Is it possible to create an overload for Int like 1... that would resolve to a custom AnyRange and another for 1...10 which also resolves to anAnyRange?

[tgrapperon]

Yeah, although bouncing between result builder style and fluent style feels a bit... awkward?

That's what's happening in SwiftUI. You use builders to compose views, and methods to configure them.

[randomeizer]

True that. Although generally they don't go from singular to plural via a configuration method, from memory. Could be a configurator on Many I guess, if that was an issue.