Currently, NoUnused.Variables does not report functions that call themselves, even if they are never used elsewhere

module A exposing (a)

a = 1

foo list =
  case list of
    [] -> 1
    _ :: rest -> 1 + foo rest

Here, we would like foo to be reported, since no other functions uses it and it's not exposed.

NoUnused.Variables does not report pattern variables. This means that in the following example, b will not get reported.

foo =
  let
    (a, b) = bar
  in
  a

This is on purpose because there can be value in giving b a name.

The improvement here, would be to report the whole pattern, when none of the pattern variables are used.

foo =
  let
    (a, b) = bar
    ^^^^^^
  in
  1

This is valid for other types of patterns obviously, like {a, b}.

This rule would report unused imported custom type constructors.

For instance:

import A exposing (B(..))

where none of B's constructors are used in the file.

This could be autofixed by removing the (..) part.

This requires additional work in the elm-lint package to load the Elm interface files, so that we know what the constructors of B are.

This rule would report unused parameters in custom type constructors.

For instance:

type MyType
  = A
  | B String

where B's String parameter is always ignored (B _ -> ...) or just not used (B notUsed -> ...).

B "" ->, B Nothing ->, etc. should make B's argument considered.

A has no parameters, and should thus not be reported.

Having MyType's constructors exposed should ignore reporting B.