module Protolude (
module X,
identity,
bool,
(&),
uncons,
applyN,
print,
LText,
LByteString,
) where
import qualified Prelude as P
import qualified List as X
import qualified Show as X
import qualified Bool as X
import qualified Debug as X
import qualified Monad as X
import qualified Applicative as X
import Safe as X (
headMay
, initMay
, tailMay
)
import Control.Applicative as X (
Applicative(..)
, Alternative(..)
, Const(..)
, ZipList(..)
, (<**>)
, liftA
, liftA2
, liftA3
, optional
)
import Data.Eq as X
import Data.Ord as X
import Data.Monoid as X
import Data.Traversable as X
import Data.Foldable as X hiding (
foldr1
, foldl1
, maximum
, maximumBy
, minimum
, minimumBy
)
import Data.Semiring as X
import Data.Functor.Identity as X
import Data.Functor as X (
Functor(..)
, ($>)
, (<$>)
, void
)
import Control.DeepSeq as X (
NFData(..)
, ($!!)
, deepseq
, force
)
import Data.Tuple as X
import Data.List as X (
splitAt
, break
, intercalate
, isPrefixOf
, drop
, filter
, reverse
, replicate
)
import Data.Map as X (Map)
import Data.Set as X (Set)
import Data.Sequence as X (Seq)
import Data.IntMap as X (IntMap)
import Data.IntSet as X (IntSet)
import Control.Monad.State as X (
MonadState
, State
, StateT
, put
, get
, gets
, modify
, withState
, runStateT
, execStateT
, evalStateT
)
import Control.Monad.Reader as X (
MonadReader
, Reader
, ReaderT
, ask
, asks
, local
, runReader
, runReaderT
)
import Control.Monad.Except as X (
MonadError
, Except
, ExceptT
, throwError
, catchError
, runExcept
, runExceptT
)
import Control.Monad.Trans as X (
MonadIO
, lift
, liftIO
)
import Data.Int as X
import Data.Bits as X
import Data.Word as X
import Data.Bool as X hiding (bool)
import Data.Char as X (Char)
import Data.Maybe as X hiding (fromJust)
import Data.Either as X
import Data.Complex as X
import Data.Function as X (
id
, const
, (.)
, flip
, fix
, on
)
import GHC.IO as X (IO)
import GHC.Num as X
import GHC.Real as X
import GHC.Float as X
import GHC.Show as X
import GHC.Exts as X (
Constraint
, Ptr
, FunPtr
, the
)
import GHC.Generics (
Generic(..)
, Rep
, K1(..)
, M1(..)
, U1(..)
, V1
, D1
, C1
, S1
, (:+:)
, (:*:)
, NoSelector
, Rec0
, Par0
, Constructor(..)
, Selector(..)
, Arity(..)
, Fixity(..)
)
import qualified Data.ByteString.Lazy
import qualified Data.ByteString as X (ByteString)
import Data.Text as X (Text)
import qualified Data.Text.Lazy
import qualified Data.Text.IO
import Text.Printf as X (printf)
import Data.Text.Lazy (
toStrict
, fromStrict
)
import Data.String.Conv as X (
strConv
, toS
, toSL
, Leniency(..)
)
import Text.Printf as Exports (
PrintfArg
, printf
, hPrintf
)
import System.Exit as X
import System.Environment as X (getArgs)
import System.IO as X (
Handle
, hClose
)
import Control.Monad.ST as ST
import Control.Exception as X
import Control.Concurrent as X
import Control.Concurrent.Async as X
import Foreign.Storable as Exports (Storable)
import Text.Read as X (
Read
, reads
, readMaybe
, readEither
)
type LText = Data.Text.Lazy.Text
type LByteString = Data.ByteString.Lazy.ByteString
infixl 1 &
(&) :: a -> (a -> b) -> b
x & f = f x
bool :: a -> a -> Bool -> a
bool f t b = if b then t else f
identity :: a -> a
identity x = x
uncons :: [a] -> Maybe (a, [a])
uncons [] = Nothing
uncons (x:xs) = Just (x, xs)
applyN :: Int -> (a -> a) -> a -> a
applyN n f = X.foldr (.) id (X.replicate n f)
print :: (X.MonadIO m, P.Show a) => a -> m ()
print = liftIO . P.print