ClassyPrelude

CorePrelude

module CorePrelude

data Seq a

General-purpose finite sequences.

Instances

Monad Seq

Functor Seq

Typeable1 Seq

MonadPlus Seq

Foldable Seq

Traversable Seq

Eq a => Eq (Seq a)

Data a => Data (Seq a)

Ord a => Ord (Seq a)

Read a => Read (Seq a)

Show a => Show (Seq a)

Monoid (Seq a)

NFData a => NFData (Seq a)

CanReverse (Seq a)

Eq a => CanStripSuffix (Seq a)

Eq a => CanStripPrefix (Seq a)

CanNull (Seq a)

CanUncons (Seq a) a

CanCons (Seq a) a

Ord a => CanSort (Seq a) a

CanSortBy (Seq a) a

CanPartition (Seq a) a

Monoid m => CanConcat (Seq m) m

CanFind (Seq a) a

CanSplitAt (Seq a) Int

CanAny (Seq a) a

CanBreak (Seq a) a

Eq x => CanMember (Seq x) x

CanMapM_ (Seq a) a

CanIntersperse (Seq a) a

CanPack (Seq a) a

CanSingleton (Seq a) a

CanLength (Seq a) Int

CanFilterM (Seq a) a

CanFilter (Seq a) a

CanReplicate (Seq a) a Int

CanFold (Seq a) a accum

CanReplicateM (Seq a) a Int

CanMap (Seq a) (Seq b) a b

Monad m => CanMapM (Seq i) (m (Seq o)) m i o

CanConcatMap (Seq a) (Seq b) a (Seq b)

Standard

Monoid

empty :: Monoid m => m

append :: Monoid m => m -> m -> m

(++) :: Monoid m => m -> m -> m

Monad

module Control.Monad

Mutable references

module Control.Concurrent.MVar.Lifted

module Data.IORef.Lifted

Non-standard

List-like classes

map :: CanMap ci co i o => (i -> o) -> ci -> co

concat :: CanConcat c i => c -> i

concatMap :: CanConcatMap ci co i o => (i -> o) -> ci -> co

filter :: CanFilter c i => (i -> Bool) -> c -> c

find :: CanFind c i => (i -> Bool) -> c -> Maybe i

length :: CanLength c len => c -> len

singleton :: CanSingleton c i => i -> c

null :: CanNull c => c -> Bool

pack :: CanPack c i => [i] -> c

unpack :: CanPack c i => c -> [i]

repack :: (CanPack a i, CanPack b i) => a -> b

Repack from one type to another, dropping to a list in the middle.

repack = pack . unpack.

fromList :: CanPack c i => [i] -> c

toList :: CanPack c i => c -> [i]

mapM :: CanMapM ci mco m i o => (i -> m o) -> ci -> mco

mapM_ :: (CanMapM_ ci i, Monad m) => (i -> m o) -> ci -> m ()

forM :: CanMapM ci mco m i o => ci -> (i -> m o) -> mco

forM_ :: (Monad m, CanMapM_ ci i) => ci -> (i -> m o) -> m ()

replicateM :: (CanReplicateM c i len, Monad m) => len -> m i -> m c

stripPrefix :: CanStripPrefix a => a -> a -> Maybe a

isPrefixOf :: CanStripPrefix a => a -> a -> Bool

stripSuffix :: CanStripSuffix a => a -> a -> Maybe a

isSuffixOf :: CanStripSuffix a => a -> a -> Bool

isInfixOf :: CanIsInfixOf a => a -> a -> Bool

break :: CanBreak c i => (i -> Bool) -> c -> (c, c)

span :: CanBreak c i => (i -> Bool) -> c -> (c, c)

dropWhile :: CanBreak c i => (i -> Bool) -> c -> c

takeWhile :: CanBreak c i => (i -> Bool) -> c -> c

any :: CanAny c i => (i -> Bool) -> c -> Bool

all :: CanAny c i => (i -> Bool) -> c -> Bool

splitAt :: CanSplitAt c i => i -> c -> (c, c)

take :: CanSplitAt c i => i -> c -> c

drop :: CanSplitAt c i => i -> c -> c

fold :: CanFold c i accum => (accum -> i -> accum) -> accum -> c -> accum

Strict left fold.

words :: CanWords t => t -> [t]

unwords :: CanWords t => [t] -> t

lines :: CanLines t => t -> [t]

unlines :: CanUnlines t => [t] -> t

split :: CanSplit c i => (i -> Bool) -> c -> [c]

reverse :: CanReverse a => a -> a

readMay :: (Read b, CanPack a Char) => a -> Maybe b

replicate :: CanReplicate a i len => len -> i -> a

intercalate :: (CanConcat c i, CanIntersperse c i) => i -> c -> i

intersperse :: CanIntersperse c i => i -> c -> c

encodeUtf8 :: CanEncodeUtf8 ci co => ci -> co

decodeUtf8 :: CanDecodeUtf8 ci co => ci -> co

subsequences :: CanPack c i => c -> [c]

permutations :: CanPack c i => c -> [c]

partition :: CanPartition c i => (i -> Bool) -> c -> (c, c)

nub :: (CanNubBy c i, Ord i, CanNubBy c i) => c -> c

nubBy :: CanNubBy c i => (i -> i -> Bool) -> c -> c

sort :: CanSort c a => c -> c

sortBy :: CanSortBy c a => (a -> a -> Ordering) -> c -> c

sortWith :: (CanSortBy c a, Ord b) => (a -> b) -> c -> c

Sort elements using the user supplied function to project something out of each element. Inspired by http://hackage.haskell.org/packages/archive/base/latest/doc/html/GHC-Exts.html#v:sortWith.

group :: CanGroup c a => c -> [c]

groupBy :: CanGroupBy c a => (a -> a -> Bool) -> c -> [c]

groupWith :: (CanGroupBy c a, Eq b) => (a -> b) -> c -> [c]

The groupWith function uses the user supplied function which projects an element out of every list element in order to first sort the input list and then to form groups by equality on these projected elements

Inspired by http://hackage.haskell.org/packages/archive/base/latest/doc/html/GHC-Exts.html#v:groupWith

cons :: CanCons c a => a -> c -> c

uncons :: CanUncons c a => c -> Maybe (a, c)

compareLength :: (CanCompareLength c, Integral l) => c -> l -> Ordering

This is a more effective alternative to statements like i >= length xs for types having an O(n) complexity of length operation like list or Text. It does not traverse the whole data structure if the value being compared to is lesser.

sum :: (Foldable t, Num a) => t a -> a

The sum function computes the sum of the numbers of a structure.

product :: (Foldable t, Num a) => t a -> a

The product function computes the product of the numbers of a structure.

repeat :: CanRepeat c a => a -> c

Map-like

lookup :: CanLookup c k v => k -> c -> Maybe v

insert :: CanInsert f => f

delete :: CanDelete f => f

Set-like

member :: CanMember c k => k -> c -> Bool

notMember :: CanMember c k => k -> c -> Bool

elem :: CanMember c k => k -> c -> Bool

An alias for member

notElem :: CanMember c k => k -> c -> Bool

An alias for notMember

union :: CanUnion c => c -> c -> c

difference :: CanDifference c => c -> c -> c

(\\) :: CanDifference c => c -> c -> c

An alias for difference.

intersection :: CanIntersection c => c -> c -> c

intersect :: CanIntersection c => c -> c -> c

An alias for intersection.

unions :: (Foldable cc, Monoid c, CanUnion c) => cc c -> c

Text-like

show :: (Show a, CanPack c Char) => a -> c

toLower :: CanToLower a => a -> a

toUpper :: CanToUpper a => a -> a

toCaseFold :: CanToCaseFold a => a -> a

toStrict :: CanToStrict a b => a -> b

fromStrict :: CanToStrict a b => b -> a

IO

readFile :: (CanReadFile a, MonadIO m) => FilePath -> m a

writeFile :: (CanWriteFile a, MonadIO m) => FilePath -> a -> m ()

getLine :: CanGetLine a => a

print :: (Show a, MonadIO m) => a -> m ()

Chunking

toChunks :: CanToChunks c i => c -> [i]

fromChunks :: CanToChunks c i => [i] -> c

Force types

Helper functions for situations where type inferer gets confused.

asByteString :: ByteString -> ByteString

asLByteString :: LByteString -> LByteString

asHashMap :: HashMap k v -> HashMap k v

asHashSet :: HashSet a -> HashSet a

asText :: Text -> Text

asLText :: LText -> LText

asList :: [a] -> [a]

asMap :: Map k v -> Map k v

asMaybe :: Maybe a -> Maybe a

asSet :: Set a -> Set a

asVector :: Vector a -> Vector a