module Universum
(
module X
, module Base
, identity
, map
, (&)
, uncons
, unsnoc
, applyN
, print
, throwIO
, throwTo
, foreach
, show
, LText
, LByteString
) where
import Applicative as X
import Bool as X
import Conv as X
import Debug as X
import Either as X
import Functor as X
import List as X
import Monad as X
import Panic as X
import Show as X
import Base as Base hiding (error, print, putStr, putStrLn,
show, showFloat, showList, showSigned,
showSignedFloat, showsPrec, undefined)
import qualified Base as PBase
import Data.String (String)
import Data.String as X (IsString)
import Safe as X (atDef, atMay, foldl1May, foldr1May,
headDef, headMay, initDef, initMay,
initSafe, lastDef, lastMay, tailDef,
tailMay, tailSafe)
import Control.Applicative as X (Alternative (..), Applicative (..),
Const (..), ZipList (..), liftA, liftA2,
liftA3, optional, (<**>))
import Data.Eq as X
import Data.Foldable as X hiding (foldl1, foldr1)
import Data.Functor.Identity as X
import Data.Ord as X
import Data.Traversable as X hiding (for)
import Semiring as X
#if ( __GLASGOW_HASKELL__ >= 800 )
import Data.Monoid as X hiding ((<>))
import Data.Semigroup as X (Semigroup (..))
#else
import Data.Monoid as X
#endif
#if (__GLASGOW_HASKELL__ >= 710)
import Data.Bifunctor as X (Bifunctor (..))
#else
import Bifunctor as X (Bifunctor (..))
#endif
import Control.DeepSeq as X (NFData (..), deepseq, force, ($!!))
import Data.List as X (break, cycle, drop, dropWhile, filter,
group, inits, intercalate, intersperse,
isPrefixOf, iterate, permutations, repeat,
replicate, reverse, scanl, scanr, sort,
sortBy, splitAt, subsequences, tails,
take, takeWhile, transpose, unfoldr, zip,
zipWith)
import Data.Tuple as X
import Data.HashMap.Strict as X (HashMap)
import Data.HashSet as X (HashSet)
import Data.IntMap.Strict as X (IntMap)
import Data.IntSet as X (IntSet)
import Data.Map.Strict as X (Map)
import Data.Sequence as X (Seq)
import Data.Set as X (Set)
#if ( __GLASGOW_HASKELL__ >= 710 )
import Data.Proxy as X (Proxy (..))
import Data.Typeable as X (Typeable)
import Data.Void as X (Void, absurd, vacuous)
#endif
import Control.Monad.State as X (MonadState, State, StateT, evalState,
evalStateT, execState, execStateT, gets,
modify, runState, runStateT, state,
withState)
import Control.Monad.Reader as X (MonadReader, Reader, ReaderT, ask, asks,
local, reader, runReader, runReaderT)
import Control.Monad.Except as X (Except, ExceptT, MonadError, catchError,
runExcept, runExceptT, throwError)
import Control.Monad.Trans as X (MonadIO, lift, liftIO)
import Data.Bits as X hiding (unsafeShiftL, unsafeShiftR)
import Data.Bool as X hiding (bool)
import Data.Char as X (chr)
import Data.Complex as X
import Data.Either as X
import Data.Int as X
import Data.Maybe as X hiding (fromJust)
import Data.Word as X
import Data.Function as X (const, fix, flip, on, ($), (.))
import GHC.Generics as X (Generic)
import Data.ByteString as X (ByteString)
import qualified Data.ByteString.Lazy
import Data.Text as X (Text)
import qualified Data.Text.Lazy
import Data.Text.IO as X (appendFile, getContents, getLine,
interact, readFile, writeFile)
import Data.Text.Lazy as X (fromStrict, toStrict)
import Data.Text.Encoding as X (decodeUtf8, decodeUtf8', decodeUtf8With,
encodeUtf8)
import System.Environment as X (getArgs)
import System.Exit as X
import System.IO as X (FilePath, Handle, IOMode (..), openFile,
stderr, stdin, stdout, withFile)
import Control.Monad.ST as X
import Control.Exception as X hiding (assert, displayException, throw,
throwIO, throwTo)
import qualified Control.Exception
import Control.Concurrent as X hiding (throwTo)
import Control.Concurrent.Async as X hiding (wait)
import Control.Monad.STM as X
import Foreign.Storable as X (Storable)
import Text.Read as X (Read, readEither, readMaybe, reads)
type LText = Data.Text.Lazy.Text
type LByteString = Data.ByteString.Lazy.ByteString
infixl 1 &
(&) :: a -> (a -> b) -> b
x & f = f x
identity :: a -> a
identity x = x
map :: Functor f => (a -> b) -> f a -> f b
map = fmap
uncons :: [a] -> Maybe (a, [a])
uncons [] = Nothing
uncons (x:xs) = Just (x, xs)
unsnoc :: [x] -> Maybe ([x],x)
unsnoc = foldr go Nothing
where
go x mxs = Just (case mxs of
Nothing -> ([], x)
Just (xs, e) -> (x:xs, e))
applyN :: Int -> (a -> a) -> a -> a
applyN n f = X.foldr (.) identity (X.replicate n f)
print :: (X.MonadIO m, PBase.Show a) => a -> m ()
print = liftIO . PBase.print
throwIO :: (X.MonadIO m, Exception e) => e -> m a
throwIO = liftIO . Control.Exception.throwIO
throwTo :: (X.MonadIO m, Exception e) => ThreadId -> e -> m ()
throwTo tid e = liftIO (Control.Exception.throwTo tid e)
foreach :: Functor f => f a -> (a -> b) -> f b
foreach = flip fmap
show :: (Show a, StringConv String b) => a -> b
show x = toS (PBase.show x)