Best way to handle optional paths

[abear247]

Our backend has a lot of different URLs that represent the same thing, so my parsers end up kind of bloated. I often end up with something like

OneOf {
    Path { "assigned"; "item" }
    Path { "content" }
    Path { "item" }
    Path { "assigned" }
    ... and so on
}

My problems really tend to arise when I have an optional path component. So in addition to the above OneOf I may have part of the path that may or may not exist

example.com/1234/assigned
example.com/optionalPath/1234/assigned

Which should be equivalent. I can solve something like this with separate parsers, but due to the bloating of URLs this can result in a lot of different parsers and reduces maintainability. Is there a way to effectively handle the case where I have an optional path parameter succinctly?

[kamcma]

I think the tool for this is the Optionally parser. It'll take some thinking from you to decide exactly where in the composed parser that optionality belongs. Eg: is parsing the "optionalPath" component the job of the assigned parser, or should that be in a higher up parser? And if you need printability, but the optional path has no representation in your route model, then the router will have to be opinionated about whether to print the optional piece etc etc. But look at the Optionally documentation; you'll see it mentions in some cases it's easier to use .replaceError(with:) to achieve the same thing.

enum FooRoute {
  case assigned(Int)
}

struct FooRouter: ParserPrinter {
  
  var body: some Router<FooRoute> {
    OneOf {
      Route(.case(FooRoute.assigned)) {
        Path {
          "optionalPath".replaceError(with: ())
          Digits()
          "assigned"
        }
      }
    }
  }
}