elm-review-no-single-pattern-case

Provides elm-review rules to disallow single-pattern case expressions.

Provided rules

🔧 NoSinglePatternCase - Reports case...of expressions that match only a single pattern. Such case expressions typically are either unnecessary or may be written more concisely.

Configuration

module ReviewConfig exposing (config)

import NoSinglePatternCase
import Review.Rule exposing (Rule)

config : List Rule
config =
    [ NoSinglePatternCase.rule
        NoSinglePatternCase.fixInArgument
    ]

Try it out

You can try the example configuration above out by running the following command:

elm-review --template SiriusStarr/elm-review-no-single-pattern-case/example/fix-in-argument --rules NoSinglePatternCase

Changelog

2.1.2
- ⚡️ Improve performance when dealing with ignored files (~10% in one real-world test case).
- 🐛 Bump elm-review to v2.12.1 for upstream bugfix.
2.1.1 -- Bump elm-review to v2.11.1 and mark rule as providing fixes.

2.1.0

New features:

✨ Non-wrapped types are now ignored by default. By default, only constructors whose names are identical to their type are reported, along with types imported from dependencies (since those aren't expected to be iterated on).

-- import the constructor `OutsideConstructor` from some other package
import SomeOutsidePackage exposing (OutsideType(..))

type Date =
      -- Constructor has same name as type
      Date Int

type Msg =
      -- Constructor has different name than type
      ThingieClicked

update1 : Date -> Int -> Int
update1 date i =
    case date of
        -- THIS CASE IS ALWAYS FLAGGED
        Date j ->
            i + j

update2 : Msg -> Int -> Int
update2 msg i =
    case msg of
        -- THIS CASE IS NOT FLAGGED BY DEFAULT, IS FLAGGED WITH `reportAllCustomTypes`
        ThingieClicked ->
            i + 1

update3 : OutsideType -> Int -> Int
update3 oType i =
    case oType of
        -- THIS CASE IS ALWAYS FLAGGED
        OutsideConstructor j ->
            i + j

To revert to version 2.0.2 behavior and before, use reportAllCustomTypes

✨ replaceUnusedBindings now replaces bindings with more specific patterns. For example,

type Date = Date Int

type CreateThing = CreateThing

foo : ( Date, CreateThing ) -> Bool
foo x =
    case x of
        ( Date i, CreateThing ) ->
            True

will be fixed to

type Date = Date Int

type CreateThing = CreateThing

foo : ( Date, CreateThing ) -> Bool
foo ( Date _, CreateThing ) =
    True

Since some IDEs do not recognize

pointless CreateNewLet =
    foo

as valid Elm (even though it is), you can use replaceUnusedBindingsWithWildcard to revert to version 2.0.2 behavior and before.

2.0.2
- New features:
  - ✨ The rule is now capable of reducing the expressions and patterns of a single-pattern case to find the original binding sites to reduce expressions at. The following improvements have been added:
    - Reduce parenthesized expressions:
```
unpack o =
    case (o) of
        Opaque i -> i
-->
unpack (Opaque i) =
    i
```
    - Reduce constructed tupled expressions
```
add a b =
    case ( a, b ) of
        ( Opaque i1, Opaque i2 ) ->
            Opaque <| i1 + i2
-->
add (Opaque i1) (Opaque i2) =
    Opaque <| i1 + i2
```
    - Reduce constructed record expressions
```
pointless a b c =
    case { d = a, e = b, f = c } of
        { d, e, f } -> e
-->
pointless _ e _ =
    e
```
    - Reduce unnecessary as patterns
```
unpack o =
    case o of
        ((Opaque i) as a) -> i
-->
unpack (Opaque i) =
    i
```
    - Reduce function application/named patterns
```
multWrap a b =
    case (Tuple a b) of
        Tuple i1 i2 ->
            Opaque <| i1 * i2
-->
multWrap i1 i2 =
    Opaque <| i1 * i2
```
  - ✨ With replaceUnusedBindings, unit patterns are now fixed to () instead of _ to be more explicit. (There is an elm-review rule to enforce this in your code, should you so desire.)
  - 🚸 The error range reported by the rule now flags just the pattern, instead of the entire case, for less cluttered errors (especially with tooling). No more red-underlining large sections of code!
- Bugfixes:
  - 🐛 Fixed a bug where name clashes were only checked for expressions, not patterns, when generating fixes, leading to the generation of uncompilable code. This probably rarely happened in practice, but for instance this incorrect fix used to be generated:
```
unpack o =
    let
        foo i =
            0
    in
    case o of
        Opaque i -> i
-->
unpack (Opaque i) =
    let
        foo i = -- THIS IS A NAME CLASH FOR `i`
            0
    in
    i
```
  - 🐛 Fixed a bug where both subexpressions of a single-pattern case were not actually checked by this rule. This means that nested single-pattern cases are now detected properly (previously, only the outermost one would be flagged). This applies to both those nested following the pattern or within the case...of.
- Documentation changes:
  - 📝 Added a recommendation to add NoUnused.Patterns to one's config, as the fixes from this rule can sometimes generate nested as patterns, which will be detected by that rule.
  - 🔥 Removed some references to old v1.0 configs
2.0.1 -- Bump elm-syntax to v7.2.8, fixing issued with lambda ranges. Unlikely to affect this rule in practice, however.
2.0.0 -- Add fixes, with option to destructure in the argument or in a let
1.0.1 -- Fix minor documentation issue
1.0.0 -- Initial release

Modules

NoSinglePatternCase