.hlint.yaml

# HLint configuration file
# https://github.com/ndmitchell/hlint

# Optional rules
- warn: { name: Use DerivingStrategies }

# Custom warning hints
- warn: { note: Prefer pure to reduce Monad constraint
        , lhs: return x
        , rhs: pure x
        }
- warn: { note: Use more general Foldable typeclass instance
        , lhs: maybeToList x
        , rhs: toList x
        }
- warn: { name: Use generalized indexing
        , note: Use more general Indexable typeclass instance
        , lhs: (!!)
        , rhs: (!)
        }
- warn: { note: Use more general custom parmap function
        , lhs: parMap
        , rhs: parmap
        }
- warn: { name: fromList
        , note: Use fromList' over fromList for correct vector allocation
        , lhs: V.fromList
        , rhs: V.fromList'
        }
- warn: { name: Prefer fold to mconcat
        , lhs: mconcat
        , rhs: fold
        }
- warn: { name: Prefer fold1 to sconcat
        , lhs: sconcat
        , rhs: fold1
        }

# Custom suggestion hints

# Replace a $ b $ c with a . b $ c
- group: { name: dollar, enabled: true }

# Generalise map to fmap, ++ to <>
- group: { name: generalise, enabled: true }

# Generalise Maybe, Either functions to fold, foldMap
- group: { name: generalise-for-conciseness, enabled: true }

# The TupleSections language extension's syntax can be confusing, so we will ignore the hints
- ignore: { name: Use tuple-section }

# Reports language extensions that ARE used, but are implied by other langauge
# extensions. Since this whole implied extension idea is dodgy, we don't eschew
# the extra information regarding what extensions are currently enabled.
- ignore: { name: Unused LANGUAGE pragma }


# Ignore some builtin hint in test modules where we need to test the hint.
# These hints are inapplicable within test modules since the test-suites are
# testing the properties that the hint assumes to be true.
- ignore: { name: Evaluate
          , within:
            [ Bio.Character.Encodable.Dynamic.Test
            , Bio.Character.Encodable.Static.Test
            , Data.BitMatrix.Test
            , Numeric.Extended.Natural.Test
            , Numeric.Extended.Real.Test
            ]
          }
- ignore: { name: Redundant id
          , within:
            [ Bio.Character.Encodable.Dynamic.Test
            , Bio.Character.Encodable.Static.Test
            , Data.BitMatrix.Test
            , Numeric.Extended.Natural.Test
            , Numeric.Extended.Real.Test
            ]
          }
- ignore: { name: Use /=
          , within:
            [ Control.Evaluation.Test
            , Control.Monad.Trans.Validation.Test
            , System.ErrorPhase.Test
            , Numeric.Cost.Test
            ]
          }

- ignore: { name: Use >=>
          , within:
            [ Control.Evaluation.Test
            , Control.Monad.Trans.Validation.Test
            ]
          }

- ignore: { name: Use <$>
          , within:
            [ Control.Evaluation.Test
            , Control.Monad.Trans.Validation.Test
            ]
          }

- ignore: { name: Use =<<
          , within:
            [ Control.Evaluation.Test
            , Control.Monad.Trans.Validation.Test
            ]
          }

- ignore: { name: "Functor law"
          , within:
            [ Control.Evaluation.Test
            , Control.Monad.Trans.Validation.Test
            ]
          }

- ignore: { name: Strict sum
          , within:
              [ Data.MutualExclusionSet.Internal
              , File.Format.Nexus.Parser
              , Control.Evaluation.Test
              , Control.Monad.Trans.Validation.Test
              ]
          }

- ignore: { name: Use null
          , within:
            [ Control.Evaluation.Test
            , Control.Monad.Trans.Validation.Test
            ]
          }

- ignore: { name: "Monoid law, left identity"
          , within:
            [ Data.MutualExclusionSet.Test
            , Numeric.Cost.Test
            ]
          }

- ignore: { name: "Monoid law, right identity"
          , within:
            [ Data.MutualExclusionSet.Test
            , Numeric.Cost.Test
            ]
          }

- ignore: { name: "Use generalized indexing"
          , within:
            [ Data.BitMatrix.Test
            ]
          }


# unsafePerformIO can only appear in FFI modules
- functions:
  - { name: unsafePerformIO
    , within:
      [ Analysis.Parsimony.Dynamic.SequentialAlign.FFI
      , Analysis.Parsimony.Dynamic.DirectOptimization.Pairwise.FFI
      , Data.Hashable.Memoize
      , Data.TCM.Memoized.FFI
      , PCG.Command.Build.Evaluate
      ]
    }

# Ignore . re-write suggestion in PCG.Command.Unification.Master
- ignore: { name: Use .
          , within: PCG.Command.Read.Unification.Master
          }

# Ignore if instead of case statement
- ignore: { name: Use if
          , within: Data.Binary.Utility
          }

# Ignore const rename suggestion
- ignore: { name: Use const
          , within: Bio.Metadata.Discrete.Class
          }

- ignore: { name: Reduce duplication
          , within:
             [ Bio.Graph.ReferenceDAG.Traversal
             , Data.Alphabet.Test
             ]
          }

- ignore: { name: Reduce duplication
          , within: Bio.Graph.ReferenceDAG.Utility
          }

- ignore: { name: Use <$>
          , within: Bio.Graph.ReferenceDAG.Utility
          }

- ignore: { name: Use camelCase
          , within: TestSuite.ScriptTests
          }