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

Safe HaskellNone

ClassyPrelude.Classes

Synopsis

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 | ci -> i, co -> o, ci o -> co, co i -> ci whereSource

Methods

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

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 whereSource

Methods

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

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 whereSource

Methods

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

Instances

class CanFilter f i whereSource

Methods

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

Instances

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

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

Methods

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

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 whereSource

Methods

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

Instances

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

class CanFilterMFunc c i | c -> i whereSource

Methods

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

Instances

class CanLength c len | c -> len whereSource

Methods

length :: c -> lenSource

class CanSingleton c i | c -> i whereSource

Methods

singleton :: i -> cSource

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 whereSource

Methods

null :: c -> BoolSource

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 whereSource

Methods

pack :: [i] -> cSource

unpack :: c -> [i]Source

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 whereSource

Methods

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

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 whereSource

Methods

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

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 whereSource

Methods

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

Instances

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

class CanMapM_Func ci i | ci -> i whereSource

Methods

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

Instances

CanMapM_Func [a] a 
CanMapM_Func (Vector a) a 
(Eq a, Hashable a) => CanMapM_Func (HashSet a) a 
Ord a => CanMapM_Func (Set a) a 

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

Methods

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

Instances

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 

class CanInsert f whereSource

Methods

insert :: fSource

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

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 

class CanMember c k | c -> k whereSource

Methods

member :: k -> c -> BoolSource

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 whereSource

Methods

readFile :: FilePath -> aSource

Instances

MonadIO m => CanReadFile (m ByteString) 
MonadIO m => CanReadFile (m LByteString) 

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

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

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

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

class CanFold f i accum whereSource

Methods

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

Strict left fold.

Instances

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

class CanFoldFunc c i accum | c -> i whereSource

Methods

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

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 whereSource

Methods

words :: t -> [t]Source

unwords :: [t] -> tSource

Instances

CanWords Text 
CanWords LText 
~ * c Char => CanWords [c] 

class CanLines f whereSource

Methods

lines :: fSource

Instances

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

class CanLinesFunc t whereSource

Methods

linesFunc :: t -> [t]Source

Instances

class CanUnlines t whereSource

Methods

unlines :: [t] -> tSource

Instances

CanUnlines Text 
CanUnlines LText 
~ * c Char => CanUnlines [c] 

class CanSplit c i | c -> i whereSource

Methods

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

Instances

class CanStripSuffix a whereSource

Methods

stripSuffix :: a -> a -> Maybe aSource

isSuffixOf :: a -> a -> BoolSource

class CanIsInfixOf a whereSource

Methods

isInfixOf :: a -> a -> BoolSource

Instances

class CanReverse a whereSource

Methods

reverse :: a -> aSource

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

Methods

replicate :: len -> i -> aSource

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

Methods

toChunks :: c -> [i]Source

fromChunks :: [i] -> cSource

Instances

CanToChunks LByteString ByteString 
CanToChunks LText Text 

class CanEncodeUtf8 f whereSource

Methods

encodeUtf8 :: fSource

Instances

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

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

Methods

encodeUtf8Func :: ci -> coSource

class CanDecodeUtf8 f whereSource

Methods

decodeUtf8 :: fSource

Instances

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

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

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 -> coSource