{-# LANGUAGE BangPatterns #-}
module Pregame (module P) where

import Control.Applicative as P
import Control.Concurrent as P
import Control.Concurrent.Chan as P
import Control.Concurrent.STM as P
import Control.Exception as P
import Control.Parallel as P
import Control.Parallel.Strategies as P
import Control.Monad.IO.Class as P
import Control.Lens as P
import Data.Default as P
import Data.Functor as P
import Data.Either as P
import Data.Function as P
import Data.Maybe as P
import Data.Tuple as P
import Data.Tuple.All as P hiding (only)
import GHC.Base as P hiding (coerce, lazy)
import GHC.Enum as P
import GHC.Num as P
import GHC.Real as P
import GHC.Float as P
import GHC.Show as P
import System.IO as P
import System.IO.Error as P
import Safe as P hiding (at)
import Safe.Exact as P

import Control.Monad.Trans.Cont as P (Cont, ContT)
import Control.Monad.Trans.Error as P (Error, ErrorT)
import Control.Monad.Trans.Identity as P (IdentityT)
import Control.Monad.Trans.State as P (State, StateT)
import Control.Monad.Trans.List as P (ListT)
import Control.Monad.Trans.Maybe as P (MaybeT)
import Control.Monad.Trans.Reader as P (Reader, ReaderT)
import Control.Monad.Trans.RWS as P (RWS, RWST)
import Control.Monad.Trans.Writer as P (Writer, WriterT)
import Data.Map as P (Map)
import Data.Sequence as P (Seq)
import Data.Set as P (Set)
import Data.Text as P (Text)
import Data.Tree as P (Tree(..), Forest(..))
import Data.ByteString as P (ByteString)
import Data.Vector as P (Vector)


infixr 0 $!
($!) :: (a -> b) -> a -> b
f $! x = let !vx = x in f vx

fi :: (Num b, Integral a) => a -> b
fi = fromIntegral

io :: MonadIO m => IO a -> m a
io = liftIO