{-# LANGUAGE BangPatterns #-}
module Pregame 
    ( module Control.Applicative 
    , module Control.Concurrent 
    , module Control.Concurrent.Chan 
    , module Control.Concurrent.STM 
    , module Control.Exception 
    , module Control.Parallel 
    , module Control.Parallel.Strategies 
    , module Control.Monad
    , module Control.Monad.IO.Class 
    , module Control.Lens 
    , module Data.Char
    , module Data.Default 
    , module Data.Functor 
    , module Data.Either 
    , module Data.Function 
    , module Data.Maybe 
    , module Data.Monoid
    , module Data.List
    , module Data.String
    , module Data.Tuple 
    , module Data.Tuple.All
    , module GHC.Base
    , module GHC.Enum 
    , module GHC.Num 
    , module GHC.Real 
    , module GHC.Float 
    , module GHC.Show 
    , module System.IO 
    , module System.IO.Error 
    , module Safe 
    , module Safe.Exact 
    , Cont, ContT
    --
    , Error, ErrorT
    , IdentityT
    , State, StateT
    , ListT
    , MaybeT
    , Reader, ReaderT
    , RWS, RWST
    , Writer, WriterT
    , Map
    , Seq
    , Set
    , Text
    , Tree(..), Forest(..)
    , ByteString
    , Vector
    --
    , ($!)
    , fi
    , io
    , done
    ) where

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

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


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

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

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

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