Forbid using wildcard in pattern matching when it only replaces a single case

[jfmengels]

What the rule should do:

The rule should report an error when a pattern match contains a wildcard _ pattern match, when there is only a single case left to handle.

What problems does it solve:

Having a wildcard makes it tricky to add new cases to custom type declarations. In this case, having a wildcard adds unnecessary complexity

Example of things the rule would report:

a =
  case foo of
    True -> 1
    _ -> 2

type A = B | C | D

b =
  case foo of
    B -> 1
    C -> 2
    _ -> 3

Example of things the rule would not report:

a =
  case foo of
    True -> 1
    False -> 2

type A = B | C | D

b =
  case foo of
    B -> 1
    C -> 2
    D -> 3

{-| _ covers multiple cases, which is ok -}
b2 =
  case foo of
    B -> 1
    _ -> 2

c =
  case foo of
    1 -> 1
    _ -> 2
d =
  case foo of
    [] -> 1
    _ -> 2

** "Edge-case" **

So one thing where it can be a bit harder to detect, is for cases like the following

type Something = A | B
maybeSomething : Maybe Something
maybeSomething = Nothing
a = 
  case maybeSomething of
    Just A -> 1
    -- `_` covers both `Just B` and `Nothing`
    _ -> 2

We should technically have all the necessary knowledge to know how many cases are covered by _, but it will be hard work, especially when there is a lot of nested patterns.

Either we do the hard work of computing all of these, or the rule requires that you have a case for every custom type constructor, unless the _ covers two or more of them.

When (not) to enable this rule:

Except for the edge-case I mention above, I think it would always be useful, so always enable? 🤷

I am looking for:

• A good name
• To know in which package(s) this would fit best. I am thinking elm-review-common.
• General feedback: Is this a useful rule, or do you think it will be too often annoying, especially with regards to the edge case
• What do you think should happen for tuple pattern matching, like when you pattern match ( Msg, Model )?

[jfmengels]

hayleigh on Slack suggested NoRedundantWildCard as the rule name which I think would fit quite well.

[Janiczek]

I'd configure this rule to optionally be more strict about wildcards:

-when it only replaces a single case
+when it replaces a finite number of cases

So

case remoteData of
    Success data -> foo
    _ -> bar

would have to be rewritten to

case remoteData of
    Success data -> foo
    NotAsked -> bar
    Loading -> bar
    Failure _ -> bar

I'm not sure if that's possible though. Do we have access to type information in elm-review? Int, Char, String and Float can be considered infinite, and the rest of the types finite or defined recursively based on their type params?