How to perform case insensitive matching?

[finestructure]

I think I know how to solve this in principle by writing a whole new lower level parser (which will take me considerable time to wrap my head around 😅) but I'm hoping there's an easier way I don't see. What I'm trying to do get the last test case to pass:

    func test_repo() throws {
        XCTAssertEqual(try Github.repo.parse("foo.git"), "foo")
        XCTAssertEqual(try Github.repo.parse("foo.swift.git"), "foo.swift")
        XCTAssertEqual(try Github.repo.parse("Foo.git"), "Foo")
        // This needs fixing
        //        XCTAssertEqual(try Github.repo.parse("foo.GIT"), "foo")
    }

with an updated parser:

enum Github {
    static let repo = Parse {
        OneOf {
            Parse {
                PrefixUpTo(".git")
                Skip { ".git" }
            }
            Rest()
        }
    }
}

Of course, I could stack a

            Parse {
                PrefixUpTo(".GIT")
                Skip { ".GIT" }
            }

in there.

That is, until Git comes along 🤪. There must be a better way?

[tgrapperon]

You can configure your PrefixUpTo with what you mean by being equivalent chars. You can use it to compare lowercased versions for example.

enum Github {
  static let repo = Parse {
    OneOf {
      Parse {
        PrefixUpTo<Substring>(".git") { $0.lowercased() == $1.lowercased() }
        StartsWith<Substring>(".git") { $0.lowercased() == $1.lowercased() }
      }
      Rest()
    }
  }
}

Because you want to discard what's coming next, you should also use the same trick for StartsWith (but you can't use the literal anymore, and you lose the inference it provided, so you need to specify generics for your parser). Also your Skip was useless as you were already parsing ".git" into Void. Skip { ".git" } and ".git" (aka StartsWith(".git")) produce the same results, they succeed with Void if the string starts with ".git".

Fortunately, the input is likely not in German, so in this case, it should be enough to compare chars by chars using .lowercase().

[tgrapperon]

A few comments if someone has the same issue and finds this discussion:

• The new version of the library likely doesn't need the <Substring> generics to be specified;
• This method will not work in languages where the number of characters can change between cases, for example in German where "ß" is often uppercased as "SS" for example. In this case, you can't work chars by chars and a more subtle treatment is required;
• You should ideally try to build your parser out of built-in parsers because most of them are also ParserPrinters, and you may end up with a ParserPrinter "for free". If you decide to implement your own "low-level" parsing logic, you will also need to implement manually the "print" side if you want a ParserPrinter.

[finestructure]

Oh interesting, I had no idea Prefix had that closure syntax. Thanks a lot, Thomas! And yes, that Skip was totally redundant :)

Does your snippet compile for you? I'm getting the following error and I can't quite figure out how to provide the Input generic. I'll need to dig out the video, I know I've seen it somewhere...

[finestructure]

Ah, I see you noticed. It's working now :)

[tgrapperon]

Indeed, I edited while you were responding!

[finestructure]

Closing this then - merci beaucoup Thomas!

[tgrapperon]

Almost anything that compares things in the library has a parameter where you can specify what you mean by being equal. The trailing closure syntax is a little unfortunate in this case, because you're actually parsing PrefixUpto(".git", by: { $0.lowercased() == $1.lowercased() }) which is more clear.

[stephencelis]

Gonna convert this to a discussion so others may find it 😄

[tgrapperon]

BTW, I was a little surprised that I had to specify the Input generics twice, once for each parser. I was under the assumption that the first one would lock the Input of ZipOV and the following would compile:

Parse {
  PrefixUpTo<Substring>(".git")
  StartsWith(".git")
}

Is it expected that both generics are required, or is this a regression, as I'm using Xcode 14?

[stephencelis]

I think it's just that StartsWith isn't super ergonomic and may be missing initializer overloads.

FWIW this compiles fine:

Parse {
  PrefixUpTo(".git")
  ".git"
}

So yeah, maybe StartsWith needs overloads for Substring and Substring.UTF8View for when you need the element comparator.

[tgrapperon]

Ah ok, that's StartWith because it builds fine with two PrefixUpTo. Do you think it's worth a PR?

[stephencelis]

@tgrapperon Definitely down for a PR if you want to take it on! It's not a parser people reach for often but obviously has its uses as you show in this discussion 😄

[tgrapperon]

No problem, I'll prepare one later.
BTW, I've checked with Swift 5.7 builders, but it doesn't help in this case unfortunately.