module ClassyPrelude
(
module CorePrelude
, undefined
, (++)
, Semigroup (..)
, WrappedMonoid
, module Control.Monad
, module Control.Concurrent.MVar.Lifted
, module Data.IORef.Lifted
, trace
, traceShow
, traceId
, traceM
, traceShowId
, traceShowM
, assert
, module Data.Foldable
, module Data.Traversable
, module Data.MonoTraversable
, module Data.Sequences
, module Data.Containers
, Handle
, stdin
, stdout
, stderr
, map
, concat
, concatMap
, length
, null
, pack
, unpack
, repack
, toList
, Traversable.mapM
, mapM_
, Traversable.forM
, forM_
, any
, all
, foldl'
, foldr
, foldM
, readMay
, intercalate
, zip, zip3, zip4, zip5, zip6, zip7
, unzip, unzip3, unzip4, unzip5, unzip6, unzip7
, zipWith, zipWith3, zipWith4, zipWith5, zipWith6, zipWith7
, sortWith
, compareLength
, sum
, product
, Prelude.repeat
, (\\)
, intersect
, unions
, Show (..)
, tshow
, tlshow
, IOData (..)
, print
, hClose
, fpToString
, fpFromString
, fpToText
, fpFromText
, catchAny
, handleAny
, tryAny
, catchAnyDeep
, handleAnyDeep
, tryAnyDeep
, catchIO
, handleIO
, tryIO
, asByteString
, asLByteString
, asHashMap
, asHashSet
, asText
, asLText
, asList
, asMap
, asMaybe
, asSet
, asVector
, asUVector
, asIOException
, asSomeException
) where
import qualified Prelude
import Control.Exception (assert)
import Control.Monad (when, unless, void, liftM, ap, forever, join, sequence, sequence_, replicateM_)
import Control.Monad.Trans.Control (MonadBaseControl, liftBaseWith, restoreM)
import Control.Concurrent.Async (withAsync, waitCatch)
import Control.Concurrent.MVar.Lifted
import Data.IORef.Lifted
import qualified Data.Monoid as Monoid
import qualified Data.Traversable as Traversable
import Data.Traversable (Traversable)
import Data.Foldable (Foldable)
import Control.DeepSeq (NFData, ($!!))
import Data.Vector.Instances ()
import CorePrelude hiding (print, undefined, (<>))
import ClassyPrelude.Classes
import Data.Sequences
import Data.MonoTraversable
import Data.Containers
import qualified Filesystem.Path.CurrentOS as F
import System.IO (Handle, stdin, stdout, stderr, hClose)
import Debug.Trace (trace, traceShow)
import Data.Semigroup (Semigroup (..), WrappedMonoid (..))
import Prelude (Show (..))
tshow :: Show a => a -> Text
tshow = fromList . Prelude.show
tlshow :: Show a => a -> LText
tlshow = fromList . Prelude.show
pack :: IsSequence c => [Element c] -> c
pack = fromList
unpack, toList :: MonoFoldable c => c -> [Element c]
unpack = otoList
toList = otoList
null :: MonoFoldable c => c -> Bool
null = onull
compareLength :: (Integral i, MonoFoldable c) => c -> i -> Ordering
compareLength = ocompareLength
sum :: (MonoFoldable c, Num (Element c)) => c -> Element c
sum = osum
product :: (MonoFoldable c, Num (Element c)) => c -> Element c
product = oproduct
all :: MonoFoldable c => (Element c -> Bool) -> c -> Bool
all = oall
any :: MonoFoldable c => (Element c -> Bool) -> c -> Bool
any = oany
length :: MonoFoldable c => c -> Int
length = olength
mapM_ :: (Monad m, MonoFoldable c) => (Element c -> m a) -> c -> m ()
mapM_ = omapM_
forM_ :: (Monad m, MonoFoldable c) => c -> (Element c -> m a) -> m ()
forM_ = oforM_
concatMap :: (Monoid m, MonoFoldable c) => (Element c -> m) -> c -> m
concatMap = ofoldMap
foldr :: MonoFoldable c => (Element c -> b -> b) -> b -> c -> b
foldr = ofoldr
foldl' :: MonoFoldable c => (a -> Element c -> a) -> a -> c -> a
foldl' = ofoldl'
foldM :: (Monad m, MonoFoldable c) => (a -> Element c -> m a) -> a -> c -> m a
foldM = ofoldlM
concat :: (MonoFoldable c, Monoid (Element c)) => c -> Element c
concat = ofoldMap id
readMay :: (Element c ~ Char, MonoFoldable c, Read a) => c -> Maybe a
readMay a =
case [x | (x, t) <- Prelude.reads (otoList a :: String), onull t] of
[x] -> Just x
_ -> Nothing
repack :: (MonoFoldable a, IsSequence b, Element a ~ Element b) => a -> b
repack = fromList . toList
map :: Functor f => (a -> b) -> f a -> f b
map = fmap
infixr 5 ++
(++) :: Monoid m => m -> m -> m
(++) = mappend
infixl 9 \\
(\\) :: Container a => a -> a -> a
(\\) = difference
intersect :: Container a => a -> a -> a
intersect = intersection
unions :: (MonoFoldable c, Container (Element c)) => c -> Element c
unions = ofoldl' union Monoid.mempty
intercalate :: (Monoid (Element c), IsSequence c) => Element c -> c -> Element c
intercalate xs xss = concat (intersperse xs xss)
asByteString :: ByteString -> ByteString
asByteString = id
asLByteString :: LByteString -> LByteString
asLByteString = id
asHashMap :: HashMap k v -> HashMap k v
asHashMap = id
asHashSet :: HashSet a -> HashSet a
asHashSet = id
asText :: Text -> Text
asText = id
asLText :: LText -> LText
asLText = id
asList :: [a] -> [a]
asList = id
asMap :: Map k v -> Map k v
asMap = id
asMaybe :: Maybe a -> Maybe a
asMaybe = id
asSet :: Set a -> Set a
asSet = id
asVector :: Vector a -> Vector a
asVector = id
asUVector :: UVector a -> UVector a
asUVector = id
print :: (Show a, MonadIO m) => a -> m ()
print = liftIO . Prelude.print
sortWith :: (Ord a, IsSequence c) => (Element c -> a) -> c -> c
sortWith f = sortBy $ comparing f
undefined :: a
undefined = error "ClassyPrelude.undefined"
catchAny :: MonadBaseControl IO m => m a -> (SomeException -> m a) -> m a
catchAny action onE = tryAny action >>= either onE return
handleAny :: MonadBaseControl IO m => (SomeException -> m a) -> m a -> m a
handleAny = flip catchAny
tryAny :: MonadBaseControl IO m => m a -> m (Either SomeException a)
tryAny m =
liftBaseWith (\runInIO -> withAsync (runInIO m) waitCatch) >>=
either (return . Left) (liftM Right . restoreM)
catchAnyDeep :: (NFData a, MonadBaseControl IO m) => m a -> (SomeException -> m a) -> m a
catchAnyDeep action onE = tryAnyDeep action >>= either onE return
handleAnyDeep :: (NFData a, MonadBaseControl IO m) => (SomeException -> m a) -> m a -> m a
handleAnyDeep = flip catchAnyDeep
tryAnyDeep :: (NFData a, MonadBaseControl IO m)
=> m a
-> m (Either SomeException a)
tryAnyDeep m = tryAny $ do
x <- m
return $!! x
catchIO :: MonadBaseControl IO m => m a -> (IOException -> m a) -> m a
catchIO = catch
handleIO :: MonadBaseControl IO m => (IOException -> m a) -> m a -> m a
handleIO = handle
tryIO :: MonadBaseControl IO m => m a -> m (Either IOException a)
tryIO = try
asSomeException :: SomeException -> SomeException
asSomeException = id
asIOException :: IOException -> IOException
asIOException = id
traceId :: String -> String
traceId a = trace a a
traceM :: (Monad m) => String -> m ()
traceM string = trace string $ return ()
traceShowId :: (Show a) => a -> a
traceShowId a = trace (show a) a
traceShowM :: (Show a, Monad m) => a -> m ()
traceShowM = traceM . show
fpToString :: FilePath -> String
fpToString = F.encodeString
fpFromString :: String -> FilePath
fpFromString = F.decodeString
fpToText :: FilePath -> Text
fpToText = either id id . F.toText
fpFromText :: Text -> FilePath
fpFromText = F.fromText