Support alternative "letter-wise" smart case

[terrahornbeck378]

I'd like to do my matching using the following alternative "smart-case" algorithm, call it "letter-wise smart-case":
A capital letter in needle matches an upper case letter, while lower case letters match both upper- and lower-case letters. This essentially says "I want upper case letters to match upper case but don't care about the case of the rest".

Zsh supports this kind of matching with

zstyle ':completion:*' matcher-list 'm:{[:lower:]}={[:upper:]}'

This is slightly different to the currently implemented CaseMatching::Smart(call it "global smart-case") where a lower-case letter does not match an upper-case letter if there is a capital letter present in the search term.

Compare how different search terms match against fooBAR:

Algo	oba	oBA	oBa	OBa
global	yes	yes	no	no
letter-wise	yes	yes	yes	no

(the difference is for oBa)

Related:nushell/nushell#16105

[terrahornbeck378]

At a quick glance the following needs to be extended:

nucleo/matcher/src/lib.rs

Lines 722 to 728 in 5b74652

	let matched = if self.config.ignore_case {
	AsciiChar::cast(haystack)[start..end]
	.iter()
	.map(|c| c.normalize(&self.config))
	.eq(AsciiChar::cast(needle)
	.iter()
	.map(|c| c.normalize(&self.config)))

Instead of converting the letters to lower case and then comparing ("map inside if")

if ignore_case {
  haystack.map(|c| c.normalize()) == needle.map(|c| c.normalize())
} else
  haystack == needle
}

"letter-wise smart-case" needs a "if inside map"

allTrue(
  zip(needle,haystack).map(|h,n|  // iterate simultaneously over needle and haystack
    if ignore_case { // also set by "global smart case"
      h.normalize() == n.normalize()
    } else if letterwise_smart_case && !n.isUpper() {
      h.normalize() == n.normalize()
    } else {
      h == n
    }
  )
)

[pascalkuthe]

That seems useful but I don't think it's as easy to implement as you think. This would need to be supported directly in the matcher (and you are not looking at the right code for that). There are multiple different cases where casefolding happens and you need to catch them all (and also make sure this dosen't regress performance for other usecases)

I don't have the bandwidth to implement this but if someone made a PR with a good implementation I would be open to potentially accepting it.