ClassyPrelude.Classes

Documentation

class CanMap f i o where

Methods

map :: (i -> o) -> f

Instances

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

class CanMapFunc ci co i o | ci -> i, co -> o, ci o -> co, co i -> ci where

Methods

mapFunc :: (i -> o) -> ci -> co

Instances

CanMapFunc Text Text Char Char

CanMapFunc ByteString ByteString Word8 Word8

CanMapFunc LByteString LByteString Word8 Word8

CanMapFunc LText LText Char Char

CanMapFunc [a] [b] a b

CanMapFunc (Vector a) (Vector b) a b

(Ord a, Ord b) => CanMapFunc (Set a) (Set b) a b

(Eq b, Hashable b) => CanMapFunc (Set a) (Set b) a b

CanMapFunc (Map k v1) (Map k v2) v1 v2

CanMapFunc (Map k v1) (Map k v2) v1 v2

class CanConcatMap f i o where

Methods

concatMap :: (i -> o) -> f

Instances

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

class CanConcatMapFunc ci co i o | ci -> i, co -> o, ci o -> co, co i -> ci where

Methods

concatMapFunc :: (i -> o) -> ci -> co

Instances

CanConcatMapFunc Text Text Char Text

CanConcatMapFunc ByteString ByteString Word8 ByteString

CanConcatMapFunc LByteString LByteString Word8 LByteString

CanConcatMapFunc LText LText Char LText

CanConcatMapFunc [a] [b] a [b]

CanConcatMapFunc (Vector a) (Vector b) a (Vector b)

class CanFilter f i where

Methods

filter :: (i -> Bool) -> f

Instances

(CanFilterFunc ci co i, ~ * ci co) => CanFilter (ci -> co) i

class CanFilterFunc ci co i | ci -> i co where

Methods

filterFunc :: (i -> Bool) -> ci -> co

Instances

CanFilterFunc Text Text Char

CanFilterFunc ByteString ByteString Word8

CanFilterFunc LByteString LByteString Word8

CanFilterFunc LText LText Char

CanFilterFunc [a] [a] a

CanFilterFunc (Vector a) (Vector a) a

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

Hashable k => CanFilterFunc (Map k v) (Map k v) (k, v)

class CanFilterM f m i where

Methods

filterM :: (i -> m Bool) -> f

Instances

(CanFilterMFunc ci i, ~ * (m ci) mco, Monad m) => CanFilterM (ci -> mco) m i

class CanFilterMFunc c i | c -> i where

Methods

filterMFunc :: Monad m => (i -> m Bool) -> c -> m c

Instances

CanFilterMFunc [a] a

CanFilterMFunc (Vector a) a

class CanLength c len | c -> len where

Methods

length :: c -> len

Instances

CanLength Text Int

CanLength ByteString Int

CanLength LByteString Int64

CanLength LText 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 where

Methods

singleton :: i -> c

Instances

CanSingleton Text Char

CanSingleton ByteString Word8

CanSingleton LByteString Word8

CanSingleton LText Char

CanSingleton [a] a

CanSingleton (Vector a) a

CanSingleton (Set x) x

Hashable x => CanSingleton (Set x) x

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

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

class CanNull c where

Methods

null :: c -> Bool

Instances

CanNull Text

CanNull ByteString

CanNull LByteString

CanNull LText

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 where

Methods

pack :: [i] -> c

unpack :: c -> [i]

Instances

CanPack FilePath Char

CanPack Text Char

CanPack ByteString Word8

CanPack LByteString Word8

CanPack LText Char

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 where

Methods

mapM :: (i -> m o) -> f

Instances

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

class Monad m => CanMapMFunc ci mco m i o | ci -> i, mco -> m o, ci o m -> mco, mco i -> ci where

Methods

mapMFunc :: (i -> m o) -> ci -> mco

Instances

Monad m => CanMapMFunc [i] (m [o]) m i o

Monad m => CanMapMFunc (Vector i) (m (Vector o)) m i o

class Monad m => CanMapM_ f m i where

Methods

mapM_ :: (i -> m o) -> f

Instances

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

class CanMapM_Func ci i | ci -> i where

Methods

mapM_Func :: Monad m => (i -> m o) -> ci -> m ()

Instances

CanMapM_Func [a] a

CanMapM_Func (Vector a) a

class CanReplicateM c i len | c -> i len where

Methods

replicateM :: Monad m => len -> m i -> m c

Instances

CanReplicateM [a] a Int

CanReplicateM (Vector a) a Int

class CanLookup c k v | c -> k v where

Methods

lookup :: k -> c -> Maybe 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 where

Methods

insert :: f

Instances

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

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

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

class CanInsertVal c k v | c -> k v where

Methods

insertVal :: k -> v -> c -> c

Instances

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

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

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

class CanDelete c k | c -> k where

Methods

delete :: k -> c -> c

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 where

Methods

member :: k -> c -> Bool

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 where

Methods

readFile :: FilePath -> a

Instances

MonadIO m => CanReadFile (m ByteString)

MonadIO m => CanReadFile (m LByteString)

class CanWriteFile a where

Methods

writeFile :: FilePath -> a

Instances

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

class CanWriteFileFunc a where

Methods

writeFileFunc :: MonadIO m => FilePath -> a -> m ()

Instances

CanWriteFileFunc ByteString

CanWriteFileFunc LByteString

class CanStripPrefix a where

Methods

stripPrefix :: a -> a -> Maybe a

isPrefixOf :: a -> a -> Bool

Instances

CanStripPrefix FilePath

CanStripPrefix Text

CanStripPrefix LText

Eq a => CanStripPrefix [a]

class CanBreak c i | c -> i where

Methods

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

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

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

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

Instances

CanBreak Text Char

CanBreak ByteString Word8

CanBreak LByteString Word8

CanBreak LText Char

CanBreak [a] a

CanBreak (Vector a) a

class CanAny c i | c -> i where

Methods

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

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

Instances

CanAny Text Char

CanAny ByteString Word8

CanAny LByteString Word8

CanAny LText Char

CanAny [a] a

CanAny (Vector a) a

class CanSplitAt c i | c -> i where

Methods

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

Instances

CanSplitAt Text Int

CanSplitAt ByteString Int

CanSplitAt LByteString Int64

CanSplitAt LText Int64

CanSplitAt [c] Int

CanSplitAt (Vector a) Int

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

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

class CanFold f i accum where

Methods

fold :: (accum -> i -> accum) -> accum -> f

Strict left fold.

Instances

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

class CanFoldFunc c i accum | c -> i where

Methods

foldFunc :: (accum -> i -> accum) -> accum -> c -> accum

Strict left fold.

Instances

CanFoldFunc Text Char accum

CanFoldFunc ByteString Word8 accum

CanFoldFunc LByteString Word8 accum

CanFoldFunc LText Char accum

CanFoldFunc [a] a accum

CanFoldFunc (Vector a) a accum

CanFoldFunc (Set a) a accum

CanFoldFunc (Set a) a accum

class CanWords t where

Methods

words :: t -> [t]

unwords :: [t] -> t

Instances

CanWords Text

CanWords LText

~ * c Char => CanWords [c]

class CanLines f where

Methods

lines :: f

Instances

(CanLinesFunc t, ~ * out [t]) => CanLines (t -> out)

class CanLinesFunc t where

Methods

linesFunc :: t -> [t]

Instances

CanLinesFunc Text

CanLinesFunc LText

~ * c Char => CanLinesFunc [c]

class CanUnlines t where

Methods

unlines :: [t] -> t

Instances

CanUnlines Text

CanUnlines LText

~ * c Char => CanUnlines [c]

class CanSplit c i | c -> i where

Methods

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

Instances

CanSplit Text Char

CanSplit LText Char

class CanStripSuffix a where

Methods

stripSuffix :: a -> a -> Maybe a

isSuffixOf :: a -> a -> Bool

Instances

CanStripSuffix Text

CanStripSuffix ByteString

CanStripSuffix LByteString

CanStripSuffix LText

class CanIsInfixOf a where

Methods

isInfixOf :: a -> a -> Bool

Instances

CanIsInfixOf Text

CanIsInfixOf LText

Eq a => CanIsInfixOf [a]

class CanReverse a where

Methods

reverse :: a -> a

Instances

CanReverse Text

CanReverse ByteString

CanReverse LByteString

CanReverse LText

CanReverse [a]

CanReverse (Vector a)

class CanReplicate a i len | a -> i len where

Methods

replicate :: len -> i -> a

Instances

CanReplicate Text Text Int

CanReplicate ByteString Word8 Int

CanReplicate LByteString Word8 Int64

CanReplicate LText LText Int64

CanReplicate [i] i Int

CanReplicate (Vector a) a Int

class CanToChunks c i | c -> i, i -> c where

Methods

toChunks :: c -> [i]

fromChunks :: [i] -> c

Instances

CanToChunks LByteString ByteString

CanToChunks LText Text

class CanEncodeUtf8 f where

Methods

encodeUtf8 :: f

Instances

CanEncodeUtf8Func ci co => CanEncodeUtf8 (ci -> co)

class CanEncodeUtf8Func ci co | co -> ci, ci -> co where

Methods

encodeUtf8Func :: ci -> co

Instances

CanEncodeUtf8Func Text ByteString

CanEncodeUtf8Func LText ByteString

class CanDecodeUtf8 f where

Methods

decodeUtf8 :: f

Instances

CanDecodeUtf8Func ci co => CanDecodeUtf8 (ci -> co)

class CanDecodeUtf8Func ci co | co -> ci, ci -> co where

Note: implementations should ensure that decodeUtf8Func is a total function. As such, the standard decodeUtf8 provided by the text package should not be used, but instead decodeUtf8With lenientDecode.

Methods

decodeUtf8Func :: ci -> co

Instances

CanDecodeUtf8Func ByteString Text

CanDecodeUtf8Func ByteString LText