{-# LANGUAGE BangPatterns #-}
module Pregame.Base
  ( module X
  , done
  , ($!)
  ) where

import Control.Category as X
  ( Category(id, (.))
  , (<<<)
  , (>>>)
  )
import Data.Function as X
  ( ($)
  , (&)
  , const
  , flip
  , fix
  )
import Data.Bool as X
  ( Bool(True, False)
  , (&&)
  , (||)
  , not
  , otherwise
  )
import Data.Bifunctor as X
  ( Bifunctor(bimap, first, second)
  )
import Data.Bits as X
  ( Bits
  )
import Data.Int as X
  ( Int8
  , Int16
  , Int32
  , Int64
  )
import Data.Char as X
  ( isSpace
  , isLower
  , isUpper
  , isAlpha
  , isAlphaNum
  , isDigit
  , isOctDigit
  , isHexDigit
  , isLetter
  , toLower
  , toUpper
  )
import Data.Word as X
  ( Word8
  , Word16
  , Word32
  , Word64
  )
import Data.String as X
  ( String
  , IsString
  )
import Foreign.C.Types as X
  ( CChar(CChar)
  , CSChar(CSChar)
  , CUChar(CUChar)
  , CShort(CShort)
  , CUShort(CUShort)
  , CInt(CInt)
  , CUInt(CUInt)
  , CLong(CLong)
  , CULong(CULong)
  , CPtrdiff(CPtrdiff)
  , CSize(CSize)
  , CWchar(CWchar)
  , CSigAtomic(CSigAtomic)
  , CLLong(CLLong)
  , CULLong(CULLong)
  , CIntPtr(CIntPtr)
  , CUIntPtr(CUIntPtr)
  , CIntMax(CIntMax)
  , CUIntMax(CUIntMax)
  , CClock(CClock)
  , CTime(CTime)
  , CUSeconds(CUSeconds)
  , CSUSeconds(CSUSeconds)
  , CFloat(CFloat)
  , CDouble(CDouble)
  , CFile
  , CFpos
  , CJmpBuf
  )
import Foreign.Ptr as X
  ( Ptr
  , nullPtr
  , castPtr
  , plusPtr
  , alignPtr
  , minusPtr
  , FunPtr
  , nullFunPtr
  , castFunPtr
  , castFunPtrToPtr
  , castPtrToFunPtr
  , IntPtr
  , ptrToIntPtr
  , intPtrToPtr
  , WordPtr
  , ptrToWordPtr
  , wordPtrToPtr
  )
import Foreign.Storable as X
  ( Storable
  , sizeOf
  , alignment
  , peekElemOff
  , pokeElemOff
  , peekByteOff
  , pokeByteOff
  , peek
  , poke
  )
import Data.Void as X
  ( Void
  )
import Data.Ord as X
  ( Ord
  , compare
  , (<=)
  , (>=)
  , (<)
  , (>)
  )
import Data.Proxy as X
  ( Proxy(Proxy)
  )
import GHC.Enum as X
  ( Enum
  , Bounded(minBound, maxBound)
  )
import GHC.Num as X
  ( Num(..)
  )
import Data.Fixed as X
  ( div'
  , mod'
  , divMod'
  , Fixed(MkFixed)
  , HasResolution
  )
import GHC.Real as X
  ( Real(..)
  , Integral(..)
  , Fractional(..)
  , Ratio(..)
  , (^)
  , (^^)
  , fromIntegral
  , realToFrac
  )
import Data.Eq as X
  ( Eq((==), (/=))
  )
import Data.Monoid as X
  ( Monoid
  , mempty
  , mappend
  , mconcat
  , Dual(Dual)
  , Endo(Endo)
  , All(All)
  , Any(Any)
  , Sum(Sum)
  , Product(Product)
  , First(First)
  , Last(Last)
  , Alt(Alt)
  )
import Data.Semigroup as X
  ( Semigroup
  , (<>)
  , sconcat
  )
import Data.Functor as X
  ( Functor
  , fmap
  , ($>)
  , (<$>)
  , void
  )
import Data.Foldable as X
  ( Foldable
  , foldMap
  , foldr
  , foldl'
  , null
  , length
  , elem
  , foldrM
  , foldlM
  , traverse_
  , for_
  , sequenceA_
  , asum
  , mapM_
  , forM_
  , sequence_
  , msum
  , concat
  , concatMap
  , and
  , or
  , any
  , all
  , notElem
  , find
  )
import Data.Tuple as X
  ( fst
  , snd
  )
import GHC.List as X
  ( map
  , (++)
  , filter
  , cycle
  , replicate
  , repeat
  , iterate
  , drop
  , take
  )
import Data.List.NonEmpty as X
  ( NonEmpty((:|))
  , nonEmpty
  )
import Control.Applicative as X
  ( Applicative
  , pure
  , (<*>)
  , Alternative
  , (<|>)
  , some
  , many
  )
import Control.Exception as X
  ( SomeException
  , IOException
  )
import Data.Maybe as X
  ( Maybe(Just, Nothing)
  , maybe
  , fromMaybe
  , isJust
  , isNothing
  , catMaybes
  )
import Data.Either as X
  ( Either(Left, Right)
  , either
  , lefts
  , rights
  , isLeft
  , isRight
  , partitionEithers
  )
import Data.Traversable as X
  ( Traversable
  , traverse
  , sequenceA
  , mapM
  , sequence
  , for
  , forM
  , mapAccumL
  , mapAccumR
  )
import Control.Monad as X
  ( Monad
  , return
  , (>>=)
  , MonadPlus
  , mzero
  , mplus
  , join
  , (>>)
  , (=<<)
  , (>=>)
  , (<=<)
  , forever
  , guard
  , when
  , unless
  )
import Control.Monad.Fix as X
  ( MonadFix
  , mfix
  )
import GHC.IORef as X
  ( IORef
  , newIORef
  , readIORef
  , writeIORef
  , atomicModifyIORef
  )
import Control.Concurrent.MVar as X
  ( MVar
  , newMVar
  , newEmptyMVar
  , readMVar
  , putMVar
  , takeMVar
  , modifyMVar
  )
import Control.Concurrent.Chan as X
  ( Chan
  , newChan
  , readChan
  , writeChan
  , dupChan
  )
import System.Posix.Types
  ( CDev(CDev)
  , CIno(CIno)
  , CMode(CMode)
  , COff(COff)
  , CPid(CPid)
  , CSsize(CSsize)
  , CGid(CGid)
  , CNlink(CNlink)
  , CUid(CUid)
  , CCc(CCc)
  , CSpeed(CSpeed)
  , CTcflag(CTcflag)
  , CRLim(CRLim)
  , Fd(Fd)
  , LinkCount
  , UserID
  , GroupID
  , ByteCount
  , ClockTick
  , EpochTime
  , FileOffset
  , ProcessID
  , DeviceID
  , FileID
  , FileMode
  , Limit
  )
import System.IO as X
  ( fixIO
  , FilePath
  , Handle
  , stdin
  , stdout
  , stderr
  , withFile
  , openFile
  , IOMode(ReadMode, WriteMode, AppendMode, ReadWriteMode)
  , hClose
  , hIsOpen
  , hIsClosed
  , hIsReadable
  , hIsWritable
  )
import Text.Read as X
  ( Read
  )
import Text.Show as X
  ( Show(show)
  )
import GHC.Generics as X
  ( Generic
  )

done :: Monad m => m ()
done = return ()

infixr 0 $!
($!) :: (a -> b) -> a -> b
x $! y = let !y' = y in x y'