Simpler description of the matching algorithm

[macchiati]

I think we can have a simpler exposition of the matching algorithm. Here is my take

Implementing the algorithm for matching requires two capabilities of functions. I think of these in terms of objects, but of course it can be done in a non-OO language.

Given a bound selector BS consisting of a value, a function, and a set of options, we need two operations.

1. BS.matches(Locale locale, String matchKey)
   1. Returns FAILURE or SUCCESS
   2. “*” as a matchKey is always success
   3. Example: suppose BV is {1 :number maximumFractionDigits=0}, and the locale is ‘en’
      1. If the matchKey is either 1 or one, there is a match. If it is any other plural value or numeric value, it fails.
      2. If the locale is ‘fr’, then there is a match if the matchKey is 0, 1, or one.
2. BS.compare(Locale locale, String matchKey1, matchKey2)
   1. Only to be called if both matchKey1 and matchKey2 have passed the ‘matches’ test.
   2. Returns WORSE if matchKey1 is worse than matchKey2, similarly for SAME, and BETTER.
   3. Must be a total order.
   4. Example:
      1. For the BV above, “*” is worse than “one” is worse than “1”

Here is how the matching can be performed. Each variant has a list of keys plus a message.

1. Let bestVariant be empty
2. For each variant V
   1. For each bound selector X[i]
      1. If X.matches(locale, V.key[i]) == FAILURE, continue to the next variant
   2. // Now we know that all of the keys match
   3. If bestVariant is empty, let bestVariant be V, continue to the next variant
   4. Let possibleBetter = false
   5. For each bound selector X[i]
      1. Let comparison = X.compare(locale, V.key[i], bestVariant.key[i])
      2. If comparison == WORSE, continue to the next variant
      3. If comparison == BETTER, let possibleBetter = true
   6. If possibleBetter == true, then let bestVariant be V
3. Return bestVariant

Note: there are various further optimizations that can be done without changing the result. For example, it is possible to combine the two calls on matches and compare (but at the expense of complicating the algorithm a bit).