-- |
-- SDPX-License-Identifier: GPL-2.0-or-later
-- Copyright: Oleg Grenrus <oleg.grenrus@iki.fi>
--
-- Collection of exports from the dependencies.
--
module Peura.Exports (
    module A,
    -- * Classes
    Alternative (..),
    Coercible,
    Generic,
    Generic1,
    MonadIO (..),
    MonadUnliftIO (..),
    MonadReader (..),
    MonadThrow (..),
    MonadCatch (..),
    MonadMask (..),
    NFData (..),
    IsString (..),
    Serialise,
    -- * Types
    ByteString,
    ExitCode (..),
    LazyByteString,
    Map,
    NonEmpty (..),
    PackageName,
    PackageId,
    Set,
    Text,
    Version,
    VersionRange,
    -- * Functors
    Proxy (..),
    Const (..),
    Identity (..),
    -- * Exceptions
    Exception (..),
    IOException,
    SomeException,
    -- * Individual functions
    -- * Control.DeepSeq
    force,
    -- ** Control.Monad
    ap,
    foldM,
    unless,
    when,
    (<$!>),
    -- ** Control.Monad.Catch
    handle,
    bracket,
    -- ** Data.Coercible
    coerce,
    -- ** Data.Foldable
    for_,
    traverse_,
    -- ** Data.Functor
    void,
    (<&>),
    -- ** Data.Maybe
    fromMaybe,
    mapMaybe,
    -- ** Data.List
    sortBy, sortOn,
    -- ** Data.List.NonEmpty
    head, last, groupBy,
    -- ** Data.Traversable
    for,
    -- * Cabal
    prettyShow,
    mkPackageName,
    mkVersion,
    -- ** UTF8
    fromUTF8BS, toUTF8BS,
    -- * Helpers from lens
    itraverse,
    itraverse_,
    ifor,
    ifor_,
    ix,
    at,
    -- * Lens operators
    (^?),
    ) where

-- to get all members of Foldable
import Data.Foldable as A (Foldable (..))
import Prelude       as A
       (Applicative (..), Bool (..), Bounded (..), Either (..), Enum (..),
       Eq (..), FilePath, Functor (..), IO, Maybe (..), Monad (..),
       Monoid (..), Ord (..), Semigroup (..), Show (..), String,
       Traversable (..), all, and, any, concat, concatMap, const, curry,
       dropWhile, either, filter, flip, fst, id, map, maybe, not, or,
       otherwise, replicate, return, reverse, snd, span, take, takeWhile,
       uncurry, unlines, unwords, zipWith, ($), ($!), (&&), (++), (.), (<$>),
       (||))

-- numerics
import Prelude as A
       (Double, Fractional (..), Int, Integer, Integral (..), Num (..),
       Rational, Real (..), RealFrac (..), Word, fromIntegral, realToFrac)

import Codec.Serialise                 (Serialise)
import Control.Applicative             (Alternative (..), Const (..))
import Control.DeepSeq                 (NFData (..), force)
import Control.Exception
       (Exception (..), IOException, SomeException)
import Control.Lens
       (at, ifor, ifor_, itraverse, itraverse_, ix, (^?))
import Control.Monad                   (ap, foldM, unless, when, (<$!>))
import Control.Monad.Catch
       (MonadCatch (..), MonadMask (..), MonadThrow (..), bracket, handle)
import Control.Monad.IO.Class          (MonadIO (..))
import Control.Monad.IO.Unlift         (MonadUnliftIO (withRunInIO))
import Control.Monad.Reader.Class      (MonadReader (ask, local))
import Data.ByteString                 (ByteString)
import Data.Coerce                     (Coercible, coerce)
import Data.Foldable                   (for_, traverse_)
import Data.Functor (void, (<&>))
import Data.Functor.Identity           (Identity (..))
import Data.List                       (sortBy, sortOn)
import Data.List.NonEmpty              (NonEmpty (..), groupBy, head, last)
import Data.Map.Strict                 (Map)
import Data.Maybe                      (fromMaybe, mapMaybe)
import Data.Proxy                      (Proxy (..))
import Data.Set                        (Set)
import Data.String                     (IsString (..))
import Data.Text                       (Text)
import Data.Traversable                (for)
import Distribution.Pretty             (prettyShow)
import Distribution.Simple.Utils       (fromUTF8BS, toUTF8BS)
import Distribution.Types.PackageId    (PackageId)
import Distribution.Types.PackageName  (PackageName, mkPackageName)
import Distribution.Types.Version      (Version, mkVersion)
import Distribution.Types.VersionRange (VersionRange)
import GHC.Generics                    (Generic, Generic1)
import System.Exit                     (ExitCode (..))

-- We use generic-lens with OverloadedLabels
import Data.Generics.Labels ()

import qualified Data.ByteString.Lazy as LBS

type LazyByteString = LBS.ByteString