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 where

Methods

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

Instances

(~ * co ByteString, ~ * i Word8, ~ * o Word8) => CanMapFunc ByteString co i o

(~ * co Text, ~ * i Char, ~ * o Char) => CanMapFunc Text co i o

(~ * co LByteString, ~ * i Word8, ~ * o Word8) => CanMapFunc LByteString co i o

(~ * co LText, ~ * i Char, ~ * o Char) => CanMapFunc LText co i o

(~ * i a, ~ * co [b]) => CanMapFunc [a] co i b

(~ * i a, ~ * co (Vector b)) => CanMapFunc (Vector a) co i 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

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 where

Methods

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

Instances

(~ * co ByteString, ~ * i Word8, ~ * o ByteString) => CanConcatMapFunc ByteString co i o

(~ * co Text, ~ * i Char, ~ * o Text) => CanConcatMapFunc Text co i o

(~ * co LByteString, ~ * i Word8, ~ * o LByteString) => CanConcatMapFunc LByteString co i o

(~ * co LText, ~ * i Char, ~ * o LText) => CanConcatMapFunc LText co i o

(~ * i a, ~ * co [b]) => CanConcatMapFunc [a] co i [b]

(~ * i a, ~ * co (Vector b)) => CanConcatMapFunc (Vector a) co i (Vector b)

class CanFilter f a where

Methods

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

Instances

(~ * b c, CanFilterFunc b a) => CanFilter (b -> c) a

class CanFilterFunc c i | c -> i where

Methods

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

Instances

CanFilterFunc ByteString Word8

CanFilterFunc Text Char

CanFilterFunc LByteString Word8

CanFilterFunc LText Char

CanFilterFunc [a] a

CanFilterFunc (Vector a) a

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

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

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

class CanLength c i | c -> i where

Methods

length :: c -> i

Instances

CanLength ByteString Int

CanLength Text Int

CanLength LByteString Int64

CanLength [a] Int

CanLength (Set x) Int

CanLength (Vector a) Int

CanLength (Set x) Int

CanLength (Map k v) Int

CanLength (Map k v) Int

CanLength (Map k v) Int

class CanSingleton c i | c -> i where

Methods

singleton :: i -> c

Instances

CanSingleton ByteString Word8

CanSingleton Text Char

CanSingleton LByteString Word8

CanSingleton LText Char

CanSingleton [a] a

CanSingleton (Set x) x

CanSingleton (Vector a) a

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

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

class CanNull c where

Methods

null :: c -> Bool

Instances

CanNull ByteString

CanNull Text

CanNull LByteString

CanNull LText

CanNull [a]

CanNull (Set x)

CanNull (Vector a)

CanNull (Set x)

CanNull (Map k v)

CanNull (Map k v)

CanNull (Map k v)

class CanPack c i | c -> i where

Methods

pack :: [i] -> c

unpack :: c -> [i]

Instances

CanPack ByteString Word8

CanPack Text Char

CanPack FilePath Char

CanPack LByteString Word8

CanPack LText Char

CanPack [a] a

CanPack (Maybe a) a

Ord x => CanPack (Set x) x

CanPack (Vector a) a

(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)

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

class CanMapM f i o m where

Methods

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

Instances

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

class CanMapMFunc ci co i o m where

Methods

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

Instances

Monad m => CanMapMFunc [a] [b] a b m

Monad m => CanMapMFunc (Vector a) (Vector b) a b m

class CanMapM_ f i o m where

Methods

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

Instances

CanMapM_Func ci i o m => CanMapM_ (ci -> m ()) i o m

class CanMapM_Func ci i o m where

Methods

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

Instances

Monad m => CanMapM_Func [a] a b m

Monad m => CanMapM_Func (Vector a) a b m

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

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

class CanEmpty c where

Methods

empty :: c

Instances

CanEmpty ByteString

CanEmpty Text

CanEmpty LByteString

CanEmpty LText

CanEmpty [a]

CanEmpty (Set x)

CanEmpty (Vector a)

CanEmpty (Set x)

CanEmpty (Map k v)

CanEmpty (Map k v)

CanEmpty (Map k v)

class CanInsert f where

Methods

insert :: f

Instances

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

(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)

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

(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

(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

Ord x => CanMember (Set x) x

Eq x => CanMember (Vector 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

Instances

CanStripPrefix Text

CanStripPrefix FilePath

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 ByteString Word8

CanBreak Text Char

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 ByteString Word8

CanAny Text Char

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 ByteString Int

CanSplitAt Text Int

CanSplitAt LByteString Int64

CanSplitAt LText Int64

CanSplitAt [c] Int

CanSplitAt (Vector a) Int

class CanFold accum a f where

Methods

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

Strict left fold.

Instances

(~ * accum accum', CanFoldFunc c accum a) => CanFold accum a (c -> accum')

class CanFoldFunc c accum a | c -> a where

Methods

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

Instances

CanFoldFunc [a] accum a

CanFoldFunc (Vector a) accum a