Error in spec/data-model-errors.json

[mihnita]

The last test case is

    {
      "src": ".local $star = {star :string} .match $star |*| {{Literal star}} * {{The default}}",
      "exp": "The default"
    }

I think this is an error.

Why?

Because there is no difference between |*| and *.
So there should be a data model error,

It is the same as the test a bit above:

    {
      "src": ".input {$var :string} .match $var * {{The first default}} * {{The second default}}",
      "expErrors": [
        {
          "type": "duplicate-variant"
        }
      ]
    },

And the fact that it is included in data-model-errors.json also seems to confirm that the intention was for this to be an error, and the missing "expErrors": [{ "type": "duplicate-variant" }] is just an unintentional mistake.

[eemeli]

Because there is no difference between |*| and *.

There is a difference: * is the catch-all selector which is handled specially in Pattern Selection, while |*| represents a literal key. With the default functions, the latter would only match something like {|*| :string}, and not e.g. {star :string}.

[mihnita]

And I argue that it is wrong to have that difference.

Everything is a string, we refused again and again to allow for any kind of types:

|a| = string
a = string
|1| = string
1 = string
|*| = string
* = NOT A STRING

It also has the side-effects that the keys in a "selector map", or the "cases in a switch" (however we want to think about the selection) end up being different types.
Which is not a problem for programming languages with a dynamic typing, but introduces unnecessary friction for static typing languages.

---

In ABNF the * looks like a string:

key               = literal / "*"

By this logic the _ are also different:

".match $var
   _   {{The first default}}
   |_| {{The first default}}
   *   {{The second default}}",

Because

name-start = ALPHA / "_"

I mean, "_" is "the keyword _".

---

Looks like * is different because we use "catch-all key '*'" 3 times without even explaining what it means.

[mihnita]

The description of Key in the data model (syntax.md):

#### Key

A **_<dfn>key</dfn>_** is a value in a _variant_ for use by a _selector_ when ranking
or excluding _variants_ during the _matcher_ process.
A _key_ can be either a _literal_ value or the "catch-all" key `*`.

The **_<dfn>catch-all key</dfn>_** is a special key, represented by `*`,
that matches all values for a given _selector_.

The value of each _key_ MUST be treated as if it were in [Unicode Normalization Form C](https://unicode.org/reports/tr15/) ("NFC").
Two _keys_ are considered equal if they are canonically equivalent strings,
that is, if they consist of the same sequence of Unicode code points after
Unicode Normalization Form C has been applied to both.

So:

• |*| is a key
• * is "catch-all" key, but it is also a key, right?
• Two _keys_ are considered equal if they are canonically equivalent strings

So the "*" (key, literal) and "*" (catch-all key) are not "canonically equivalent strings"?

[eemeli]

Ah, good catch! The key equality text is a bit misleading, so I filed #996 to improve the text.