module Language.Haskell.Brittany.Internal.Prelude
  ( module E
  ) where

import Control.Applicative as E (Alternative(..), Applicative(..))
import Control.Arrow as E ((&&&), (***), (<<<), (>>>), first, second)
import Control.Concurrent as E (forkIO, forkOS, threadDelay)
import Control.Concurrent.Chan as E (Chan)
import Control.Concurrent.MVar as E
  (MVar, newEmptyMVar, newMVar, putMVar, readMVar, swapMVar, takeMVar)
import Control.Exception as E (assert, bracket, evaluate)
import Control.Monad as E
  ( (<$!>)
  , (<=<)
  , (=<<)
  , (>=>)
  , Functor(..)
  , Monad(..)
  , MonadPlus(..)
  , filterM
  , forM
  , forM_
  , forever
  , guard
  , join
  , liftM
  , liftM2
  , liftM3
  , liftM4
  , liftM5
  , mapM
  , mapM_
  , replicateM
  , replicateM_
  , sequence
  , sequence_
  , unless
  , void
  , when
  )
import Control.Monad.Extra as E
  (allM, andM, anyM, ifM, notM, orM, unlessM, whenM)
import Control.Monad.IO.Class as E (MonadIO(..))
import Control.Monad.ST as E (ST)
import Control.Monad.Trans.Class as E (lift)
import Control.Monad.Trans.Maybe as E (MaybeT(..))
import Control.Monad.Trans.MultiRWS as E
  (MonadMultiReader(..), MonadMultiState(..), MonadMultiWriter(..), mGet)
import Data.Bifunctor as E (bimap)
import Data.Bool as E (Bool(..))
import Data.Char as E (Char, chr, ord)
import Data.Data as E (toConstr)
import Data.Either as E (Either(..), either)
import Data.Foldable as E (asum, fold, foldl', foldr')
import Data.Function as E ((&), fix)
import Data.Functor as E (($>))
import Data.Functor.Identity as E (Identity(..))
import Data.IORef as E (IORef)
import Data.Int as E (Int)
import Data.List as E
  ( all
  , break
  , drop
  , dropWhile
  , elem
  , filter
  , find
  , intercalate
  , intersperse
  , isPrefixOf
  , isSuffixOf
  , iterate
  , length
  , mapAccumL
  , mapAccumR
  , maximum
  , minimum
  , notElem
  , nub
  , null
  , partition
  , repeat
  , replicate
  , sortBy
  , sum
  , take
  , takeWhile
  , transpose
  , uncons
  , unzip
  , zip
  , zip3
  , zipWith
  )
import Data.List.Extra as E (nubOrd, stripSuffix)
import Data.List.NonEmpty as E (NonEmpty(..), nonEmpty)
import Data.Map as E (Map)
import Data.Maybe as E
  (Maybe(..), catMaybes, fromMaybe, listToMaybe, maybe, maybeToList)
import Data.Monoid as E
  ( All(..)
  , Alt(..)
  , Any(..)
  , Endo(..)
  , Monoid(..)
  , Product(..)
  , Sum(..)
  , mconcat
  )
import Data.Ord as E (Down(..), Ordering(..), comparing)
import Data.Proxy as E (Proxy(..))
import Data.Ratio as E ((%), Ratio, Rational, denominator, numerator)
import Data.Semigroup as E ((<>), Semigroup(..))
import Data.Sequence as E (Seq)
import Data.Set as E (Set)
import Data.String as E (String)
import Data.Text as E (Text)
import Data.Tree as E (Tree(..))
import Data.Tuple as E (swap)
import Data.Typeable as E (Typeable)
import Data.Version as E (showVersion)
import Data.Void as E (Void)
import Data.Word as E (Word, Word32)
import Debug.Trace as E
  ( trace
  , traceIO
  , traceId
  , traceM
  , traceShow
  , traceShowId
  , traceShowM
  , traceStack
  )
import Foreign.ForeignPtr as E (ForeignPtr)
import Foreign.Storable as E (Storable)
import GHC.Exts as E (Constraint)
import GHC.Hs.Extension as E (GhcPs)
import GHC.Types.Name.Reader as E (RdrName)
import Prelude as E
  ( ($)
  , ($!)
  , (&&)
  , (++)
  , (.)
  , (<$>)
  , Bounded(..)
  , Double
  , Enum(..)
  , Eq(..)
  , Float
  , Floating(..)
  , Foldable
  , Fractional(..)
  , Integer
  , Integral(..)
  , Num(..)
  , Ord(..)
  , RealFloat(..)
  , RealFrac(..)
  , Show(..)
  , Traversable
  , (^)
  , and
  , any
  , const
  , curry
  , error
  , flip
  , foldl
  , foldr
  , foldr1
  , fromIntegral
  , fst
  , head
  , id
  , map
  , not
  , or
  , otherwise
  , print
  , putStr
  , putStrLn
  , realToFrac
  , reverse
  , seq
  , snd
  , subtract
  , traverse
  , uncurry
  , undefined
  , (||)
  )
import System.IO as E (IO, hFlush, stdout)
import Text.Read as E (readMaybe)