content: {-# LANGUAGE CPP #-}
  -- |
  -- License: GPL-3.0-or-later
  -- Copyright: Oleg Grenrus
  --
  -- Fat-prelude.
  module CabalFmt.Prelude (
      -- * Control.Arrow
      (&&&),
      -- * Control.Monad
      when, unless, void,
      -- * Data.Bifunctor
      bimap,
      -- * Data.Char
      toLower,
      -- * Data.Either
      partitionEithers,
      -- * Data.Foldable
      toList, traverse_, asum, for_,
      -- * Data.Function
      on, (&),
      -- * Data.List
      intercalate, sortOn, sortBy, nub,
      -- * Data.Maybe
      catMaybes,
      fromMaybe,
      isJust,
      isNothing,
      -- * Packages
      -- ** bytestring
      ByteString,
      -- ** Cabal
      C.fromUTF8BS, C.toUTF8BS,
      pack', unpack',
      -- ** containers
      Set,
      -- ** directory
      dropExtension, splitDirectories,
      -- ** exceptions
      catchError, throwError,
      -- * Extras
      -- ** Lens
      traverseOf,
      over, view,
      _1,
      -- ** Tuples
      fstOf3,
      sndOf3,
      trdOf3,
      ) where
  
  import Control.Arrow               ((&&&))
  import Control.Monad               (unless, void, when)
  import Control.Monad.Except        (catchError, throwError)
  import Data.Bifunctor              (bimap)
  import Data.ByteString             (ByteString)
  import Data.Char                   (toLower)
  import Data.Either                 (partitionEithers)
  import Data.Foldable               (asum, for_, toList, traverse_)
  import Data.Function               (on, (&))
  import Data.List                   (intercalate, nub, sortBy, sortOn)
  import Data.Maybe                  (catMaybes, fromMaybe, isJust, isNothing)
  import Data.Set                    (Set)
  import Distribution.Compat.Lens    (over, view)
  import Distribution.Compat.Newtype (pack', unpack')
  import System.FilePath             (dropExtension, splitDirectories)
  
  import qualified Distribution.Utils.Generic as C
  
  #ifdef MIN_VERSION_base_orphans
  import Data.Orphans ()
  #endif
  
  traverseOf
      :: Applicative f
      => ((a -> f b) -> s ->  f t)
      -> (a -> f b) -> s ->  f t
  traverseOf = id
  
  _1 :: Functor f => (a -> f b) -> (a, c) -> f (b, c)
  _1 f (a, c) = (\b -> (b, c)) <$> f a
  
  fstOf3 :: (a,b,c) -> a
  fstOf3 (a,_,_) = a
  
  sndOf3 :: (a,b,c) -> b
  sndOf3 (_,b,_) = b
  
  trdOf3 :: (a,b,c) -> c
  trdOf3 (_,_,c) = c
  