module Internal.Prelude
  ( module X
  )
where

import Control.Applicative as X (Applicative (..), empty, (<|>))
import Control.Category as X ((>>>))
import Control.Exception as X (Exception, SomeException (..))
import Control.Exception.Annotated as X
  ( checkpointCallStack
  , throwWithCallStack
  )
import Control.Monad as X
  ( Monad (..)
  , guard
  , join
  , replicateM
  , replicateM_
  , unless
  , when
  , (<=<)
  , (=<<)
  , (>=>)
  )
import Control.Monad.Catch as X (MonadThrow, throwM)
import Control.Monad.Except as X (MonadError, throwError)
import Control.Monad.Fail as X (fail)
import Control.Monad.IO.Class as X (MonadIO (liftIO))
import Control.Monad.Reader as X (ReaderT)
import Control.Monad.Trans as X (MonadTrans (lift))
import Control.Monad.Trans.Identity as X (IdentityT (..))
import Data.Bifunctor as X (bimap)
import Data.Bool as X
import Data.ByteString as X (ByteString)
import Data.Char as X (Char)
import Data.Either as X (Either (..), either, fromRight)
import Data.Eq as X (Eq, (/=), (==))
import Data.Fixed as X (Fixed (MkFixed))
import Data.Foldable as X (all, foldMap, for_, toList, traverse_)
import Data.Function as X (const, flip, id, ($), (&), (.))
import Data.Functor as X (Functor, fmap, void, ($>), (<$>), (<&>))
import Data.Kind as X (Constraint, Type)
import Data.List as X (concat, concatMap, filter)
import Data.List.NonEmpty as X (nonEmpty)
import Data.Map as X (Map)
import Data.Maybe as X
  ( Maybe (..)
  , catMaybes
  , fromMaybe
  , isJust
  , isNothing
  , maybe
  )
import Data.Ord as X (Ord (..))
import Data.Semigroup as X (Min (..), (<>))
import Data.Sequence as X (Seq)
import Data.Set as X (Set)
import Data.String as X (String)
import Data.Text as X (Text)
import Data.Traversable as X (for)
import Data.Tuple as X (fst, snd, swap)
import Data.Type.Equality as X
import Data.Word as X (Word32)
import GHC.Generics as X (Generic)
import GHC.Stack as X (HasCallStack)
import Numeric.Natural as X (Natural)
import System.IO as X (IO)
import Test.QuickCheck as X (Arbitrary (arbitrary, shrink))
import Test.QuickCheck.Arbitrary.Generic as X
  ( GenericArbitrary
  , genericArbitrary
  , genericShrink
  )
import Text.Read as X (Read, readMaybe)
import Text.Show as X (Show, show)
import Prelude as X
  ( Bounded (..)
  , Enum
  , Int
  , Integer
  , Integral
  , Num
  , RealFrac (ceiling, floor)
  , fromInteger
  , fromIntegral
  , minimum
  , negate
  , pred
  , succ
  , toInteger
  , truncate
  , uncurry
  , ($!)
  , (*)
  , (+)
  , (-)
  , (/)
  )

{-# ANN module ("HLint: ignore Avoid restricted alias" :: String) #-}
{-# ANN module ("HLint: ignore Avoid restricted qualification" :: String) #-}