    {-# LANGUAGE NoImplicitPrelude #-}
    {-# LANGUAGE CPP #-}

    module CorePrelude
        ( -- * Standard
          -- ** Operators
          (Prelude.$)
        , (Prelude.$!)
        , (Prelude.&&)
        , (Prelude.||)
        , (Control.Category..)
          -- ** Functions
        , Prelude.not
        , Prelude.otherwise
        , Prelude.fst
        , Prelude.snd
        , Control.Category.id
        , Prelude.maybe
        , Prelude.either
        , Prelude.flip
        , Prelude.const
        , Prelude.error
        , putStr
        , putStrLn
        , print
        , getArgs
        , terror
        , Prelude.odd
        , Prelude.even
        , Prelude.uncurry
        , Prelude.curry
        , Data.Tuple.swap
        , Prelude.until
        , Prelude.asTypeOf
        , Prelude.undefined
        , Prelude.seq
          -- ** Type classes
        , Prelude.Ord (..)
        , Prelude.Eq (..)
        , Prelude.Bounded (..)
        , Prelude.Enum (..)
        , Prelude.Show
        , Prelude.Read
        , Prelude.Functor (..)
        , Prelude.Monad (..)
        , (Control.Monad.=<<)
        , Data.String.IsString (..)
          -- ** Numeric type classes
        , Prelude.Num (..)
        , Prelude.Real (..)
        , Prelude.Integral (..)
        , Prelude.Fractional (..)
        , Prelude.Floating (..)
        , Prelude.RealFrac (..)
        , Prelude.RealFloat(..)
          -- ** Data types
        , Prelude.Maybe (..)
        , Prelude.Ordering (..)
        , Prelude.Bool (..)
        , Prelude.Char
        , Prelude.IO
        , Prelude.Either (..)
          -- * Re-exports
          -- ** Packed reps
        , ByteString
        , LByteString
        , Text
        , LText
          -- ** Containers
        , Map
        , HashMap
        , IntMap
        , Set
        , HashSet
        , IntSet
        , Seq
        , Vector
        , UVector
        , Unbox
        , SVector
        , Data.Vector.Storable.Storable
        , Hashable
          -- ** Numbers
        , Word
        , Word8
        , Word32
        , Word64
        , Prelude.Int
        , Int32
        , Int64
        , Prelude.Integer
        , Prelude.Rational
        , Prelude.Float
        , Prelude.Double
          -- ** Numeric functions
        , (Prelude.^)
        , (Prelude.^^)
        , Prelude.subtract
        , Prelude.fromIntegral
        , Prelude.realToFrac
          -- ** Monoids
        , Monoid (..)
        , (<>)
          -- ** Folds and traversals
        , Data.Foldable.Foldable
        , Data.Foldable.asum
        , Data.Traversable.Traversable
          -- ** arrow
        , Control.Arrow.first
        , Control.Arrow.second
        , (Control.Arrow.***)
        , (Control.Arrow.&&&)
          -- ** Bool
        , bool
          -- ** Maybe
        , Data.Maybe.mapMaybe
        , Data.Maybe.catMaybes
        , Data.Maybe.fromMaybe
        , Data.Maybe.isJust
        , Data.Maybe.isNothing
        , Data.Maybe.listToMaybe
        , Data.Maybe.maybeToList
          -- ** Either
        , Data.Either.partitionEithers
        , Data.Either.lefts
        , Data.Either.rights
          -- ** Ord
        , Data.Function.on
        , Data.Ord.comparing
        , equating
        , GHC.Exts.Down (..)
          -- ** Applicative
        , Control.Applicative.Applicative (..)
        , (Control.Applicative.<$>)
        , (Control.Applicative.<|>)
          -- ** Monad
        , (Control.Monad.>=>)
          -- ** Transformers
        , Control.Monad.Trans.Class.lift
        , Control.Monad.IO.Class.MonadIO
        , Control.Monad.IO.Class.liftIO
          -- ** Exceptions
        , Control.Exception.Exception (..)
        , Data.Typeable.Typeable (..)
        , Control.Exception.SomeException
        , Control.Exception.IOException
        , module System.IO.Error
          -- ** Files
        , Prelude.FilePath
        , (F.</>)
        , (F.<.>)
          -- ** Strings
        , Prelude.String
          -- ** Hashing
        , hash
        , hashWithSalt
        ) where

    import qualified Prelude
    import Prelude (Char, (.), Eq, Bool)

    import Data.Hashable (Hashable, hash, hashWithSalt)
    import Data.Vector.Unboxed (Unbox)

    import Data.Monoid (Monoid (..))
    import qualified Control.Arrow
    import Control.Applicative
    import qualified Control.Category
    import qualified Control.Monad
    import qualified Control.Exception
    import qualified Data.Typeable

    import qualified Data.Foldable
    import qualified Data.Traversable

    import Data.Word (Word8, Word32, Word64, Word)
    import Data.Int (Int32, Int64)

    import qualified Data.Text.IO

    import qualified Data.Maybe
    import qualified Data.Either
    import qualified Data.Ord
    import qualified Data.Function
    import qualified Data.Tuple
    import qualified Data.String

    import qualified Control.Monad.Trans.Class
    import qualified Control.Monad.IO.Class
    import Control.Monad.IO.Class (MonadIO (liftIO))

    import Data.ByteString (ByteString)
    import qualified Data.ByteString.Lazy
    import Data.Text (Text)
    import qualified Data.Text.Lazy
    import Data.Vector (Vector)
    import qualified Data.Vector.Unboxed
    import qualified Data.Vector.Storable
    import Data.Map (Map)
    import Data.Set (Set)
    import Data.IntMap (IntMap)
    import Data.IntSet (IntSet)
    import Data.Sequence (Seq)
    import Data.HashMap.Strict (HashMap)
    import Data.HashSet (HashSet)
    import qualified System.FilePath as F

    import qualified System.Environment
    import qualified Data.Text
    import qualified Data.List
    import System.IO.Error hiding (catch, try)
    import qualified GHC.Exts

    #if MIN_VERSION_base(4,7,0)
    import Data.Bool (bool)
    #endif

    #if MIN_VERSION_base(4,5,0)
    import Data.Monoid ((<>))
    #endif

    #if MIN_VERSION_base(4,9,0)
    import GHC.Stack (HasCallStack)
    #endif

    type LText = Data.Text.Lazy.Text
    type LByteString = Data.ByteString.Lazy.ByteString
    type UVector = Data.Vector.Unboxed.Vector
    type SVector = Data.Vector.Storable.Vector

    #if !MIN_VERSION_base(4,7,0)
    bool :: a -> a -> Bool -> a
    bool f t b = if b then t else f
    #endif

    #if !MIN_VERSION_base(4,5,0)

    infixr 6 <>
    (<>) :: Monoid w => w -> w -> w
    (<>) = mappend
    {-# INLINE (<>) #-}

    #endif

    equating :: Eq a => (b -> a) -> b -> b -> Bool
    equating :: forall a b. Eq a => (b -> a) -> b -> b -> Bool
    equating = (a -> a -> Bool) -> (b -> a) -> b -> b -> Bool
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    Data.Function.on a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    (Prelude.==)

    getArgs :: MonadIO m => m [Text]
    getArgs :: forall (m :: * -> *). MonadIO m => m [Text]
    getArgs = IO [Text] -> m [Text]
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO ((String -> Text) -> [String] -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    Data.List.map String -> Text
    Data.Text.pack ([String] -> [Text]) -> IO [String] -> IO [Text]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IO [String]
    System.Environment.getArgs)

    putStr :: MonadIO m => Text -> m ()
    putStr :: forall (m :: * -> *). MonadIO m => Text -> m ()
    putStr = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (Text -> IO ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> IO ()
    Data.Text.IO.putStr

    putStrLn :: MonadIO m => Text -> m ()
    putStrLn :: forall (m :: * -> *). MonadIO m => Text -> m ()
    putStrLn = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (Text -> IO ()) -> Text -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> IO ()
    Data.Text.IO.putStrLn

    print :: (MonadIO m, Prelude.Show a) => a -> m ()
    print :: forall (m :: * -> *) a. (MonadIO m, Show a) => a -> m ()
    print = IO () -> m ()
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> (a -> IO ()) -> a -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> IO ()
    forall a. Show a => a -> IO ()
    Prelude.print

    -- | @error@ applied to @Text@
    --
    -- Since 0.4.1
    #if MIN_VERSION_base(4,9,0)
    terror :: HasCallStack => Text -> a
    #else
    terror :: Text -> a
    #endif
    terror :: forall a. HasCallStack => Text -> a
    terror = String -> a
    forall a. HasCallStack => String -> a
    Prelude.error (String -> a) -> (Text -> String) -> Text -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> String
    Data.Text.unpack