ModularPrelude.Classy

This module provides the core type classes from ClassyPrelude necessary to conveniently interact with the standard modules provided with modular-prelude-classy.

It is recommended that you always import this module -- *as well as ModularPrelude* -- when using other modules from modular-prelude-classy.

Documentation

class CanMap f i o

Instances

CanMapFunc ci co i o => CanMap (ci -> co) i o

class CanConcatMap f i o

Instances

CanConcatMapFunc ci co i o => CanConcatMap (ci -> co) i o

class CanFilter f i

Instances

CanFilterFunc ci co i => CanFilter (ci -> co) i

class CanLength c len | c -> len

Instances

CanLength Text Int

CanLength ByteString Int

CanLength LText Int64

CanLength LByteString Int64

CanLength [a] Int

CanLength (Vector a) Int

CanLength (Set x) Int

CanLength (Set x) Int

CanLength (Map k v) Int

CanLength (Map k v) Int

class CanSingleton c i | c -> i

Instances

CanSingleton Text Char

CanSingleton ByteString Word8

CanSingleton LText Char

CanSingleton LByteString Word8

CanSingleton [a] a

CanSingleton (Vector a) a

CanSingleton (Set x) x

Hashable x => CanSingleton (Set x) x

~ * v' v => CanSingleton (v' -> Map k v) k

(Eq k, Hashable k, ~ * v' v) => CanSingleton (v' -> Map k v) k

class CanNull c

Instances

CanNull Text

CanNull ByteString

CanNull LText

CanNull LByteString

CanNull [a]

CanNull (Vector a)

CanNull (Set x)

CanNull (Set x)

CanNull (Map k v)

CanNull (Map k v)

class CanPack c i | c -> i

Instances

CanPack FilePath Char

CanPack Text Char

CanPack ByteString Word8

CanPack LText Char

CanPack LByteString Word8

CanPack [a] a

CanPack (Maybe a) a

CanPack (Vector a) a

Ord x => CanPack (Set x) x

(Hashable x, Eq x) => CanPack (Set x) x

Ord k => CanPack (Map k v) (k, v)

(Eq k, Hashable k) => CanPack (Map k v) (k, v)

class Monad m => CanMapM f m i o

Instances

CanMapMFunc ci mco m i o => CanMapM (ci -> mco) m i o

class Monad m => CanMapM_ f m i

Instances

(Monad m, CanMapM_Func ci i, ~ * r (m ())) => CanMapM_ (ci -> r) m i

class CanLookup c k v | c -> k v

Instances

Eq k => CanLookup [(k, v)] k v

Ord k => CanLookup (Map k v) k v

(Eq k, Hashable k) => CanLookup (Map k v) k v

class CanInsert f

Instances

(Ord x, ~ * (Set x) s, ~ * x x') => CanInsert (x' -> s -> Set x)

(Eq x, Hashable x, ~ * (Set x) s, ~ * x x') => CanInsert (x' -> s -> Set x)

(CanInsertVal c' k v, ~ * c c') => CanInsert (k -> v -> c -> c')

class CanDelete c k | c -> k

Instances

Eq k => CanDelete [(k, v)] k

Ord k => CanDelete (Map k v) k

(Eq k, Hashable k) => CanDelete (Map k v) k

class CanMember c k | c -> k

Instances

Eq x => CanMember [x] x

Eq x => CanMember (Vector x) x

Ord x => CanMember (Set x) x

(Eq x, Hashable x) => CanMember (Set x) x

class CanReadFile a

Instances

MonadIO m => CanReadFile (m LByteString)

MonadIO m => CanReadFile (m ByteString)

class CanWriteFile a

Instances

(MonadIO m, ~ * b (), CanWriteFileFunc a) => CanWriteFile (a -> m b)

class CanStripPrefix a

Instances

CanStripPrefix FilePath

CanStripPrefix Text

CanStripPrefix LText

Eq a => CanStripPrefix [a]

class CanBreak c i | c -> i

Instances

CanBreak Text Char

CanBreak ByteString Word8

CanBreak LText Char

CanBreak LByteString Word8

CanBreak [a] a

CanBreak (Vector a) a

class CanAny c i | c -> i

Instances

CanAny Text Char

CanAny ByteString Word8

CanAny LText Char

CanAny LByteString Word8

CanAny [a] a

CanAny (Vector a) a

class CanSplitAt c i | c -> i

Instances

CanSplitAt Text Int

CanSplitAt ByteString Int

CanSplitAt LText Int64

CanSplitAt LByteString Int64

CanSplitAt [c] Int

CanSplitAt (Vector a) Int

class CanFold f i accum

Instances

(CanFoldFunc c i accum, ~ * accum result) => CanFold (c -> result) i accum

class CanWords t

Instances

CanWords Text

CanWords LText

~ * c Char => CanWords [c]

class CanSplit c i | c -> i

Instances

CanSplit Text Char

CanSplit LText Char

class CanStripSuffix a

Instances

CanStripSuffix Text

CanStripSuffix LText

class CanIsInfixOf a

Instances

CanIsInfixOf Text

CanIsInfixOf LText

Eq a => CanIsInfixOf [a]

class CanReverse a

Instances

CanReverse Text

CanReverse ByteString

CanReverse LText

CanReverse LByteString

CanReverse [a]

CanReverse (Vector a)

class CanReplicate a i len | a -> i len

Instances

CanReplicate Text Text Int

CanReplicate ByteString Word8 Int

CanReplicate LText LText Int64

CanReplicate LByteString Word8 Int64

CanReplicate [i] i Int

CanReplicate (Vector a) a Int