classy-prelude-0.1.0.0: A typeclass-based Prelude.

Safe HaskellSafe-Infered

ClassyPrelude.Classes

Documentation

class CanMap f i o whereSource

Methods

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

Instances

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

class CanMapFunc ci co i o whereSource

Methods

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

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 whereSource

Methods

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

Instances

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

class CanConcatMapFunc ci co i o whereSource

Methods

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

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 whereSource

Methods

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

Instances

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

class CanFilterFunc c i | c -> i whereSource

Methods

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

Instances

class CanLength c i | c -> i whereSource

Methods

length :: c -> iSource

Instances

class CanSingleton c i | c -> i whereSource

Methods

singleton :: i -> cSource

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 whereSource

Methods

null :: c -> BoolSource

Instances

class CanPack c i | c -> i whereSource

Methods

pack :: [i] -> cSource

unpack :: c -> [i]Source

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 whereSource

Methods

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

Instances

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

class CanMapMFunc ci co i o m whereSource

Methods

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

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 whereSource

Methods

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

Instances

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

class CanMapM_Func ci i o m whereSource

Methods

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

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 whereSource

Methods

lookup :: k -> c -> Maybe vSource

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 whereSource

Methods

empty :: cSource

Instances

class CanInsert f whereSource

Methods

insert :: fSource

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 whereSource

Methods

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

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 whereSource

Methods

delete :: k -> c -> cSource

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 whereSource

Methods

member :: k -> c -> BoolSource

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 whereSource

Methods

readFile :: FilePath -> aSource

Instances

class CanWriteFile a whereSource

Methods

writeFile :: FilePath -> aSource

Instances

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

class CanWriteFileFunc a whereSource

Methods

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

Instances

class CanStripPrefix a whereSource

Methods

stripPrefix :: a -> a -> Maybe aSource

Instances

class CanBreak c i | c -> i whereSource

Methods

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

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

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

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

Instances

class CanAny c i | c -> i whereSource

Methods

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

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

Instances

class CanSplitAt c i | c -> i whereSource

Methods

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

Instances

class CanFold accum a f whereSource

Methods

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

Strict left fold.

Instances

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

class CanFoldFunc c accum a | c -> a whereSource

Methods

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

Instances

CanFoldFunc [a] accum a 
CanFoldFunc (Vector a) accum a