.hlint.yaml

- ignore: { name: "Use unless" }

- functions:
  - {name: unsafeDupablePerformIO, within: []} # Unsafe
  - {name: unsafeInterleaveIO, within: []} # Unsafe
  - {name: unsafeFixIO, within: []} # Unsafe
  - {name: unsafePerformIO, within: []} # Unsafe

  # _VERY_ hard to get right, use the async library instead.
  # See also https://github.com/informatikr/hedis/issues/165
  - {name: forkIO, within: []}
  # Mostly impossible to get right, rethink what you're doing entirely.
  # See also https://www.reddit.com/r/haskell/comments/jsap9r/how_dangerous_is_forkprocess/
  - {name: forkProcess, within: []}

  - {name: undefined, within: []} # Purposely fails. Deal with errors appropriately instead.
  - {name: throw, within: []} # Don't throw from pure code, use throwIO instead.
  - {name: Prelude.error, within: []}

  - {name: Data.List.head, within: []} # Partial, use `listToMaybe` instead.
  - {name: Data.List.tail, within: []} # Partial
  - {name: Data.List.init, within: []} # Partial
  - {name: Data.List.last, within: []} # Partial
  - {name: 'Data.List.!!', within: []} # Partial
  - {name: Data.List.genericIndex, within: []} # Partial

  # Same, but for Data.Text
  - {name: Data.Text.head, within: []}
  - {name: Data.Text.tail, within: []}
  - {name: Data.Text.init, within: []}
  - {name: Data.Text.last, within: []}

  - {name: minimum, within: []} # Partial
  - {name: minimumBy, within: []} # Partial
  - {name: maximum, within: []} # Partial
  - {name: maximumBy, within: []} # Partial

  # Same, but for Data.Text
  - {name: Data.Text.maximum, within: []}
  - {name: Data.Text.minimum, within: []}

  - {name: GHC.Enum.pred, within: []} # Partial
  - {name: GHC.Enum.suc, within: []} # Partial
  - {name: GHC.Enum.toEnum, within: []} # Partial
  - {name: GHC.Enum.fromEnum, within: []} # Does not do what you think it does.
  - {name: GHC.Enum.enumFrom, within: []} # Does not do what you think it does, depending on the type.
  - {name: GHC.Enum.enumFromThen, within: []} # Does not do what you think it does, depending on the type.
  - {name: GHC.Enum.enumFromTo, within: []} # Does not do what you think it does, depending on the type.
  - {name: GHC.Enum.enumFromThenTo, within: []} # Does not do what you think it does, depending on the type.

  - {name: unless, within: []} # Really confusing, use 'when' instead.
  # I've commented this out because, who hasn't memorized
  # `data Either a b = Left a | Right b`? Obviously it's left then right, so
  # the either function is `either handle_left handle_right either_value`
  # Just indent the 3 arguments so it resembles a case-match, like so:
  # a = either
  #       (handle_left foo)
  #       (handle_right bar)
  #       (qux either_value)
  # Unlike a case-match, this function lets me write point-free functions for
  # handle_left and handle_right
  #- {name: either, within: []} # Really confusing, just use a case-match.

  - {name: nub, within: []} # O(n^2)

  - {name: foldl, within: []} # Lazy. Use foldl' instead.
  - {name: sum, within: []} # Lazy accumulator
  - {name: product, within: []} # Lazy accumulator

  # Functions involving division
  - {name: Prelude.quot, within: []} # Partial, see https://github.com/NorfairKing/haskell-WAT#num-int
  - {name: Prelude.div, within: []}
  - {name: Prelude.rem, within: []}
  - {name: Prelude.mod, within: []}
  - {name: Prelude.quotRem, within: []}
  - {name: Prelude.divMod, within: []}

  # Does unexpected things, see
  # https://github.com/NorfairKing/haskell-WAT#real-double
  - {name: realToFrac, within: []}

  # Don't use string for command-line output.
  - {name: System.IO.putChar, within: []}
  - {name: System.IO.putStr, within: []}
  - {name: System.IO.putStrLn, within: []}
  - {name: System.IO.print, within: []}

  # Don't use string for command-line input either.
  - {name: System.IO.getChar, within: []}
  - {name: System.IO.getLine, within: []}
  - {name: System.IO.getContents, within: []} # Does lazy IO.
  - {name: System.IO.interact, within: []}
  - {name: System.IO.readIO, within: []}
  - {name: System.IO.readLn, within: []}

  # Don't use strings to interact with files
  - {name: System.IO.readFile, within: []}
  - {name: System.IO.writeFile, within: []}
  - {name: System.IO.appendFile, within: []}

  # Can succeed in dev, but fail in prod, because of encoding guessing
  # It's also Lazy IO.
  # See https://www.snoyman.com/blog/2016/12/beware-of-readfile/ for more info.
  - {name: Data.Text.IO.readFile, within: []}
  - {name: Data.Text.IO.Lazy.readFile, within: []}

  - {name: Data.Text.Encoding.decodeUtf8, within: []} # Throws on invalid UTF8

  - {name: fromJust, within: []} # Partial

  # Does silent truncation:
  # > fromIntegral (300 :: Word) :: Word8
  # 44
  - {name: fromIntegral, within: []}


  - {name: 'read', within: []} # Partial, use `Text.Read.readMaybe` instead.
  
  # Deprecated, use `pure` instead.
  # See https://gitlab.haskell.org/ghc/ghc/-/wikis/proposal/monad-of-no-return
  - {name: 'return', within: []}

- modules:
  - { name: Control.Lens, within: [] }

- extensions:
  - { name: DeriveAnyClass, within: [] } # Dangerous

  - { name: DuplicateRecordFields, within: [] }

  - { name: NamedFieldPuns, within: [] }
  - { name: TupleSections, within: [] }
  - { name: OverloadedLabels, within: [] }