Safe Haskell	None

ClassyPrelude.Classes

Synopsis

class CanMap ci co i o | ci -> i, co -> o, ci o -> co, co i -> ci where
- map :: (i -> o) -> ci -> co
class CanConcatMap ci co i o | ci -> i, co -> o, ci o -> co, co i -> ci where
- concatMap :: (i -> o) -> ci -> co
class CanFilter c i | c -> i where
- filter :: (i -> Bool) -> c -> c
class CanFilterM c i | c -> i where
- filterM :: Monad m => (i -> m Bool) -> c -> m c
class CanLength c len | c -> len where
- length :: c -> len
class CanSingleton c i | c -> i where
- singleton :: i -> c
class CanNull c where
- null :: c -> Bool
class CanPack c i | c -> i where
- pack :: [i] -> c
- unpack :: c -> [i]
- subsequences :: c -> [c]
- permutations :: c -> [c]
class CanIntersperse c i | c -> i where
- intersperse :: i -> c -> c
class Monad m => CanMapM ci mco m i o | ci -> i, mco -> m o, ci o m -> mco, mco i -> ci where
- mapM :: (i -> m o) -> ci -> mco
class CanMapM_ ci i | ci -> i where
- mapM_ :: Monad m => (i -> m o) -> ci -> m ()
class CanReplicateM c i len | c -> i len where
- replicateM :: Monad m => len -> m i -> m c
class CanReplicateM_ i len where
- replicateM_ :: Monad m => len -> m i -> m ()
class CanLookup c k v | c -> k v where
- lookup :: k -> c -> Maybe v
class CanInsert f where
- insert :: f
class CanInsertVal c k v | c -> k v where
- insertVal :: k -> v -> c -> c
class CanDelete f where
- delete :: f
class CanDeleteVal c k | c -> k where
- deleteVal :: k -> c -> c
class CanMember c k | c -> k where
- member :: k -> c -> Bool
- notMember :: k -> c -> Bool
class CanReadFile a where
- readFile :: MonadIO m => FilePath -> m a
class CanWriteFile a where
- writeFile :: MonadIO m => FilePath -> a -> m ()
class CanStripPrefix a where
- stripPrefix :: a -> a -> Maybe a
- isPrefixOf :: a -> a -> Bool
class CanBreak c i | c -> i where
- break :: (i -> Bool) -> c -> (c, c)
- span :: (i -> Bool) -> c -> (c, c)
- dropWhile :: (i -> Bool) -> c -> c
- takeWhile :: (i -> Bool) -> c -> c
class CanAny c i | c -> i where
- any :: (i -> Bool) -> c -> Bool
- all :: (i -> Bool) -> c -> Bool
class CanSplitAt c i | c -> i where
- splitAt :: i -> c -> (c, c)
class CanFold c i accum | c -> i where
- fold :: (accum -> i -> accum) -> accum -> c -> accum
class CanWords t where
- words :: t -> [t]
- unwords :: [t] -> t
class CanLines t where
- lines :: t -> [t]
class CanUnlines t where
- unlines :: [t] -> t
class CanSplit c i | c -> i where
- split :: (i -> Bool) -> c -> [c]
class CanStripSuffix a where
- stripSuffix :: a -> a -> Maybe a
- isSuffixOf :: a -> a -> Bool
class CanIsInfixOf a where
- isInfixOf :: a -> a -> Bool
class CanReverse a where
- reverse :: a -> a
class CanReplicate a i len | a -> i len where
- replicate :: len -> i -> a
class CanToChunks c i | c -> i, i -> c where
- toChunks :: c -> [i]
- fromChunks :: [i] -> c
class CanEncodeUtf8 ci co | co -> ci, ci -> co where
- encodeUtf8 :: ci -> co
class CanDecodeUtf8 ci co | co -> ci, ci -> co where
- decodeUtf8 :: ci -> co
class CanToStrict a b where
- toStrict :: a -> b
- fromStrict :: b -> a
class CanGetLine a where
- getLine :: a
class CanToLower a where
- toLower :: a -> a
class CanToUpper a where
- toUpper :: a -> a
class CanToCaseFold a where
- toCaseFold :: a -> a
class CanFind c i | c -> i where
- find :: (i -> Bool) -> c -> Maybe i
class CanConcat c i | c -> i where
- concat :: c -> i
class CanPartition c i | c -> i where
- partition :: (i -> Bool) -> c -> (c, c)
class CanNubBy c i | c -> i where
- nubBy :: (i -> i -> Bool) -> c -> c
- nub :: (Ord i, CanNubBy c i) => c -> c
class CanUnion c where
- union :: c -> c -> c
class CanDifference c where
- difference :: c -> c -> c
class CanIntersection c where
- intersection :: c -> c -> c
class CanSortBy c a | c -> a where
- sortBy :: (a -> a -> Ordering) -> c -> c
class Ord a => CanSort c a | c -> a where
- sort :: c -> c
class CanCons c a where
- cons :: a -> c -> c
class CanUncons c a where
- uncons :: c -> Maybe (a, c)
class CanCompareLength c where
- compareLength :: Integral l => c -> l -> Ordering
class CanGroupBy c a | c -> a where
- groupBy :: (a -> a -> Bool) -> c -> [c]
class CanGroup c a | c -> a where
- group :: c -> [c]
class CanRepeat c a | c -> a where
- repeat :: a -> c
class CanZipWith c1 i1 c2 i2 c3 i3 | c1 -> i1, c2 -> i2, c3 -> i3 where
- zipWith :: (i1 -> i2 -> i3) -> c1 -> c2 -> c3
class CanZipWith3 c1 i1 c2 i2 c3 i3 c4 i4 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4 where
- zipWith3 :: (i1 -> i2 -> i3 -> i4) -> c1 -> c2 -> c3 -> c4
class CanZipWith4 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5 where
- zipWith4 :: (i1 -> i2 -> i3 -> i4 -> i5) -> c1 -> c2 -> c3 -> c4 -> c5
class CanZipWith5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6 where
- zipWith5 :: (i1 -> i2 -> i3 -> i4 -> i5 -> i6) -> c1 -> c2 -> c3 -> c4 -> c5 -> c6
class CanZipWith6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6, c7 -> i7 where
- zipWith6 :: (i1 -> i2 -> i3 -> i4 -> i5 -> i6 -> i7) -> c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> c7
class CanZipWith7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 c8 i8 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6, c7 -> i7, c8 -> i8 where
- zipWith7 :: (i1 -> i2 -> i3 -> i4 -> i5 -> i6 -> i7 -> i8) -> c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> c7 -> c8
class CanZip c1 i1 c2 i2 t | c1 -> i1, c2 -> i2 where
- zip :: c1 -> c2 -> t (i1, i2)
class CanZip3 c1 i1 c2 i2 c3 i3 t | c1 -> i1, c2 -> i2, c3 -> i3 where
- zip3 :: c1 -> c2 -> c3 -> t (i1, i2, i3)
class CanZip4 c1 i1 c2 i2 c3 i3 c4 i4 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4 where
- zip4 :: c1 -> c2 -> c3 -> c4 -> t (i1, i2, i3, i4)
class CanZip5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5 where
- zip5 :: c1 -> c2 -> c3 -> c4 -> c5 -> t (i1, i2, i3, i4, i5)
class CanZip6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6 where
- zip6 :: c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> t (i1, i2, i3, i4, i5, i6)
class CanZip7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6, c7 -> i7 where
- zip7 :: c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> c7 -> t (i1, i2, i3, i4, i5, i6, i7)
class CanUnzip c1 i1 c2 i2 t | c1 -> i1, c2 -> i2 where
- unzip :: t (i1, i2) -> (c1, c2)
class CanUnzip3 c1 i1 c2 i2 c3 i3 t | c1 -> i1, c2 -> i2, c3 -> i3 where
- unzip3 :: t (i1, i2, i3) -> (c1, c2, c3)
class CanUnzip4 c1 i1 c2 i2 c3 i3 c4 i4 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4 where
- unzip4 :: t (i1, i2, i3, i4) -> (c1, c2, c3, c4)
class CanUnzip5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5 where
- unzip5 :: t (i1, i2, i3, i4, i5) -> (c1, c2, c3, c4, c5)
class CanUnzip6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6 where
- unzip6 :: t (i1, i2, i3, i4, i5, i6) -> (c1, c2, c3, c4, c5, c6)
class CanUnzip7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6, c7 -> i7 where
- unzip7 :: t (i1, i2, i3, i4, i5, i6, i7) -> (c1, c2, c3, c4, c5, c6, c7)
class CanEmpty a where
- empty :: a

Documentation

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

Methods

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

Instances

CanMap LText LText Char Char
CanMap LByteString LByteString Word8 Word8
CanMap Text Text Char Char
CanMap ByteString ByteString Word8 Word8
CanMap [a] [b] a b
CanMap (Maybe a) (Maybe b) a b
CanMap (Vector a) (Vector b) a b
(Eq b, Hashable b) => CanMap (HashSet a) (HashSet b) a b
(Ord a, Ord b) => CanMap (Set a) (Set b) a b
CanMap (Seq a) (Seq b) a b
CanMap (HashMap k v1) (HashMap k v2) v1 v2
CanMap (Map k v1) (Map k v2) v1 v2

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

Methods

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

Instances

CanConcatMap LText LText Char LText
CanConcatMap LByteString LByteString Word8 LByteString
CanConcatMap Text Text Char Text
CanConcatMap ByteString ByteString Word8 ByteString
CanConcatMap [a] [b] a [b]
CanConcatMap (Maybe a) (Maybe b) a (Maybe b)
CanConcatMap (Vector a) (Vector b) a (Vector b)
CanConcatMap (Seq a) (Seq b) a (Seq b)

class CanFilter c i | c -> i where

Methods

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

Instances

CanFilter LText Char
CanFilter LByteString Word8
CanFilter Text Char
CanFilter ByteString Word8
CanFilter [a] a
CanFilter (Maybe a) a
CanFilter (Vector a) a
Ord a => CanFilter (Set a) a
CanFilter (Seq a) a
Hashable k => CanFilter (HashMap k v) (k, v)
Ord k => CanFilter (Map k v) (k, v)

class CanFilterM c i | c -> i where

Methods

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

Instances

CanFilterM [a] a
CanFilterM (Vector a) a
CanFilterM (Seq a) a

class CanLength c len | c -> len where

Methods

length :: c -> len

Instances

CanLength LText Int64
CanLength LByteString Int64
CanLength Text Int
CanLength ByteString Int
CanLength [a] Int
CanLength (Maybe a) Int
CanLength (Vector a) Int
CanLength (HashSet x) Int
CanLength (Set x) Int
CanLength (Seq a) Int
CanLength (HashMap k v) Int
CanLength (Map k v) Int

class CanSingleton c i | c -> i where

Methods

singleton :: i -> c

Instances

CanSingleton LText Char
CanSingleton LByteString Word8
CanSingleton Text Char
CanSingleton ByteString Word8
CanSingleton [a] a
CanSingleton (Maybe a) a
CanSingleton (Vector a) a
Hashable x => CanSingleton (HashSet x) x
CanSingleton (Set x) x
CanSingleton (Seq a) a
(Eq k, Hashable k, ~ * v' v) => CanSingleton (v' -> HashMap k v) k
~ * v' v => CanSingleton (v' -> Map k v) k

class CanNull c where

Methods

null :: c -> Bool

Instances

CanNull LText
CanNull LByteString
CanNull Text
CanNull ByteString
CanNull [a]
CanNull (Maybe a)
CanNull (Vector a)
CanNull (HashSet x)
CanNull (Set x)
CanNull (Seq a)
CanNull (HashMap k v)
CanNull (Map k v)

class CanPack c i | c -> i where

Methods

pack :: [i] -> c

unpack :: c -> [i]

subsequences :: c -> [c]

permutations :: c -> [c]

Instances

CanPack LText Char
CanPack LByteString Word8
CanPack FilePath Char
CanPack Text Char
CanPack ByteString Word8
CanPack [a] a
CanPack (Maybe a) a
CanPack (Vector a) a
(Hashable x, Eq x) => CanPack (HashSet x) x
Ord x => CanPack (Set x) x
CanPack (Seq a) a
(Eq k, Hashable k) => CanPack (HashMap k v) (k, v)
Ord k => CanPack (Map k v) (k, v)

class CanIntersperse c i | c -> i where

Methods

intersperse :: i -> c -> c

Instances

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

Methods

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

Instances

Monad m => CanMapM [i] (m [o]) m i o
Monad m => CanMapM (Maybe i) (m (Maybe o)) m i o
Monad m => CanMapM (Vector i) (m (Vector o)) m i o
Monad m => CanMapM (Seq i) (m (Seq o)) m i o

class CanMapM_ ci i | ci -> i where

Methods

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

Instances

CanMapM_ [a] a
CanMapM_ (Maybe a) a
CanMapM_ (Vector a) a
(Eq a, Hashable a) => CanMapM_ (HashSet a) a
Ord a => CanMapM_ (Set a) a
CanMapM_ (Seq 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
CanReplicateM (Seq a) a Int

class CanReplicateM_ i len where

Methods

replicateM_ :: Monad m => len -> m i -> m ()

Instances

CanReplicateM_ 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
(Eq k, Hashable k) => CanLookup (HashMap k v) k v
Ord 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, ~ * (HashSet x) s, ~ * x x') => CanInsert (x' -> s -> HashSet 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
(Eq k, Hashable k) => CanInsertVal (HashMap k v) k v
Ord k => CanInsertVal (Map k v) k v

class CanDelete f where

Methods

delete :: f

Instances

(CanDeleteVal c' k, ~ * c c') => CanDelete (k -> c -> c')

class CanDeleteVal c k | c -> k where

Methods

deleteVal :: k -> c -> c

Instances

Eq k => CanDeleteVal [(k, v)] k
Ord x => CanDeleteVal (Set x) x
(Eq k, Hashable k) => CanDeleteVal (HashMap k v) k
Ord k => CanDeleteVal (Map k v) k

class CanMember c k | c -> k where

Methods

member :: k -> c -> Bool

notMember :: k -> c -> Bool

Instances

Eq x => CanMember [x] x
Eq x => CanMember (Maybe x) x
Eq x => CanMember (Vector x) x
(Eq x, Hashable x) => CanMember (HashSet x) x
Ord x => CanMember (Set x) x
Eq x => CanMember (Seq x) x

class CanReadFile a where

Methods

readFile :: MonadIO m => FilePath -> m a

Instances

CanReadFile LByteString
CanReadFile ByteString

class CanWriteFile a where

Methods

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

Instances

CanWriteFile LByteString
CanWriteFile ByteString

class CanStripPrefix a where

Methods

stripPrefix :: a -> a -> Maybe a

isPrefixOf :: a -> a -> Bool

Instances

CanStripPrefix LText
CanStripPrefix LByteString
CanStripPrefix FilePath
CanStripPrefix Text
CanStripPrefix ByteString
Eq a => CanStripPrefix [a]
Eq a => CanStripPrefix (Vector a)
Eq a => CanStripPrefix (Seq 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 LText Char
CanBreak LByteString Word8
CanBreak Text Char
CanBreak ByteString Word8
CanBreak [a] a
CanBreak (Vector a) a
CanBreak (Seq a) a

class CanAny c i | c -> i where

Methods

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

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

Instances

CanAny LText Char
CanAny LByteString Word8
CanAny Text Char
CanAny ByteString Word8
CanAny [a] a
CanAny (Maybe a) a
CanAny (Vector a) a
CanAny (Seq a) a

class CanSplitAt c i | c -> i where

Methods

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

Instances

CanSplitAt LText Int64
CanSplitAt LByteString Int64
CanSplitAt Text Int
CanSplitAt ByteString Int
CanSplitAt [c] Int
CanSplitAt (Vector a) Int
CanSplitAt (Seq a) Int

class CanFold c i accum | c -> i where

Methods

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

Strict left fold.

Instances

CanFold LText Char accum
CanFold LByteString Word8 accum
CanFold Text Char accum
CanFold ByteString Word8 accum
CanFold [a] a accum
CanFold (Maybe a) a accum
CanFold (Vector a) a accum
CanFold (HashSet a) a accum
CanFold (Set a) a accum
CanFold (Seq a) a accum

class CanWords t where

Methods

words :: t -> [t]

unwords :: [t] -> t

Instances

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

class CanLines t where

Methods

lines :: t -> [t]

Instances

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

class CanUnlines t where

Methods

unlines :: [t] -> t

Instances

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

class CanSplit c i | c -> i where

Methods

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

Instances

CanSplit LText Char
CanSplit Text Char

class CanStripSuffix a where

Methods

stripSuffix :: a -> a -> Maybe a

isSuffixOf :: a -> a -> Bool

Instances

CanStripSuffix LText
CanStripSuffix LByteString
CanStripSuffix Text
CanStripSuffix ByteString
Eq a => CanStripSuffix (Seq a)

class CanIsInfixOf a where

Methods

isInfixOf :: a -> a -> Bool

Instances

CanIsInfixOf LText
CanIsInfixOf Text
CanIsInfixOf ByteString
Eq a => CanIsInfixOf [a]
Eq a => CanIsInfixOf (Maybe a)

class CanReverse a where

Methods

reverse :: a -> a

Instances

CanReverse LText
CanReverse LByteString
CanReverse Text
CanReverse ByteString
CanReverse [a]
CanReverse (Maybe a)
CanReverse (Vector a)
CanReverse (Seq a)

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

Methods

replicate :: len -> i -> a

Instances

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

Methods

toChunks :: c -> [i]

fromChunks :: [i] -> c

Instances

CanToChunks LText Text
CanToChunks LByteString ByteString

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

Methods

encodeUtf8 :: ci -> co

Instances

CanEncodeUtf8 LText LByteString
CanEncodeUtf8 Text ByteString

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

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

Methods

decodeUtf8 :: ci -> co

Instances

CanDecodeUtf8 LByteString LText
CanDecodeUtf8 ByteString Text

class CanToStrict a b where

Methods

toStrict :: a -> b

fromStrict :: b -> a

Instances

CanToStrict LText Text
CanToStrict LByteString ByteString

class CanGetLine a where

Methods

getLine :: a

Instances

MonadIO m => CanGetLine (m ByteString)
MonadIO m => CanGetLine (m LText)
MonadIO m => CanGetLine (m Text)

class CanToLower a where

Methods

toLower :: a -> a

Instances

CanToLower Char
CanToLower LText
CanToLower Text

class CanToUpper a where

Methods

toUpper :: a -> a

Instances

CanToUpper Char
CanToUpper LText
CanToUpper Text

class CanToCaseFold a where

Methods

toCaseFold :: a -> a

Instances

CanToCaseFold LText
CanToCaseFold Text

class CanFind c i | c -> i where

Methods

find :: (i -> Bool) -> c -> Maybe i

Instances

CanFind LText Char
CanFind Text Char
CanFind [a] a
CanFind (Maybe a) a
CanFind (Vector a) a
CanFind (Set a) a
CanFind (Seq a) a
CanFind (HashMap k v) v
CanFind (Map k v) v

class CanConcat c i | c -> i where

Methods

concat :: c -> i

Instances

Monoid m => CanConcat [m] m
Monoid m => CanConcat (Vector m) m
Monoid m => CanConcat (Set m) m
Monoid m => CanConcat (Seq m) m
Monoid v => CanConcat (HashMap k v) v
Monoid v => CanConcat (Map k v) v

class CanPartition c i | c -> i where

Methods

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

Instances

CanPartition LText Char
CanPartition LByteString Word8
CanPartition Text Char
CanPartition ByteString Word8
CanPartition [a] a
CanPartition (Vector a) a
Ord a => CanPartition (Set a) a
CanPartition (Seq a) a
Hashable k => CanPartition (HashMap k v) v
Ord k => CanPartition (Map k v) v

class CanNubBy c i | c -> i where

Methods

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

nub :: (Ord i, CanNubBy c i) => c -> c

Instances

CanNubBy [a] a

class CanUnion c where

Methods

union :: c -> c -> c

Instances

Eq a => CanUnion [a]
(Eq a, Hashable a) => CanUnion (HashSet a)
Ord a => CanUnion (Set a)
(Hashable k, Eq k) => CanUnion (HashMap k a)
Ord k => CanUnion (Map k a)

class CanDifference c where

Methods

difference :: c -> c -> c

Instances

Eq a => CanDifference [a]
(Eq a, Hashable a) => CanDifference (HashSet a)
Ord a => CanDifference (Set a)
(Hashable k, Eq k) => CanDifference (HashMap k a)
Ord k => CanDifference (Map k a)

class CanIntersection c where

Methods

intersection :: c -> c -> c

Instances

Eq a => CanIntersection [a]
(Eq a, Hashable a) => CanIntersection (HashSet a)
Ord a => CanIntersection (Set a)
(Hashable k, Eq k) => CanIntersection (HashMap k a)
Ord k => CanIntersection (Map k a)

class CanSortBy c a | c -> a where

Methods

sortBy :: (a -> a -> Ordering) -> c -> c

Instances

CanSortBy [a] a
CanSortBy (Seq a) a

class Ord a => CanSort c a | c -> a where

Methods

sort :: c -> c

Instances

Ord a => CanSort [a] a
Ord a => CanSort (Seq a) a

class CanCons c a where

Methods

cons :: a -> c -> c

Instances

CanCons LText Char
CanCons LByteString Word8
CanCons Text Char
CanCons ByteString Word8
CanCons [a] a
CanCons (Vector a) a
CanCons (Seq a) a

class CanUncons c a where

Methods

uncons :: c -> Maybe (a, c)

Instances

CanUncons LText Char
CanUncons LByteString Word8
CanUncons Text Char
CanUncons ByteString Word8
CanUncons [a] a
CanUncons (Vector a) a
CanUncons (Seq a) a

class CanCompareLength c where

Methods

compareLength :: Integral l => c -> l -> Ordering

This is a more effective alternative to statements like i >= length xs for types having an O(n) complexity of length operation like list or Text. It does not traverse the whole data structure if the value being compared to is lesser.

Instances

CanCompareLength LText
CanCompareLength Text
CanCompareLength [a]

class CanGroupBy c a | c -> a where

Methods

groupBy :: (a -> a -> Bool) -> c -> [c]

Instances

CanGroupBy LText Char
CanGroupBy LByteString Word8
CanGroupBy Text Char
CanGroupBy ByteString Word8
CanGroupBy [a] a
CanGroupBy (Vector a) a

class CanGroup c a | c -> a where

Methods

group :: c -> [c]

Instances

CanGroup LText Char
CanGroup LByteString Word8
CanGroup Text Char
CanGroup ByteString Word8
Eq a => CanGroup [a] a
Eq a => CanGroup (Vector a) a

class CanRepeat c a | c -> a where

Methods

repeat :: a -> c

Instances

CanRepeat LByteString Word8
CanRepeat [a] a

class CanZipWith c1 i1 c2 i2 c3 i3 | c1 -> i1, c2 -> i2, c3 -> i3 where

Methods

zipWith :: (i1 -> i2 -> i3) -> c1 -> c2 -> c3

Instances

CanZipWith LText Char LText Char LText Char
CanZipWith Text Char Text Char Text Char
CanZipWith LByteString Word8 LByteString Word8 [a] a
CanZipWith ByteString Word8 ByteString Word8 [a] a
CanZipWith [a] a [b] b [c] c
CanZipWith (Vector a) a (Vector b) b (Vector c) c
CanZipWith (Seq a) a (Seq b) b (Seq c) c

class CanZipWith3 c1 i1 c2 i2 c3 i3 c4 i4 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4 where

Methods

zipWith3 :: (i1 -> i2 -> i3 -> i4) -> c1 -> c2 -> c3 -> c4

Instances

CanZipWith3 [a] a [b] b [c] c [d] d
CanZipWith3 (Vector a) a (Vector b) b (Vector c) c (Vector d) d
CanZipWith3 (Seq a) a (Seq b) b (Seq c) c (Seq d) d

class CanZipWith4 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5 where

Methods

zipWith4 :: (i1 -> i2 -> i3 -> i4 -> i5) -> c1 -> c2 -> c3 -> c4 -> c5

Instances

CanZipWith4 [a] a [b] b [c] c [d] d [e] e
CanZipWith4 (Vector a) a (Vector b) b (Vector c) c (Vector d) d (Vector e) e
CanZipWith4 (Seq a) a (Seq b) b (Seq c) c (Seq d) d (Seq e) e

class CanZipWith5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6 where

Methods

zipWith5 :: (i1 -> i2 -> i3 -> i4 -> i5 -> i6) -> c1 -> c2 -> c3 -> c4 -> c5 -> c6

Instances

CanZipWith5 [a] a [b] b [c] c [d] d [e] e [f] f
CanZipWith5 (Vector a) a (Vector b) b (Vector c) c (Vector d) d (Vector e) e (Vector f) f

class CanZipWith6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6, c7 -> i7 where

Methods

zipWith6 :: (i1 -> i2 -> i3 -> i4 -> i5 -> i6 -> i7) -> c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> c7

Instances

CanZipWith6 [a] a [b] b [c] c [d] d [e] e [f] f [g] g
CanZipWith6 (Vector a) a (Vector b) b (Vector c) c (Vector d) d (Vector e) e (Vector f) f (Vector g) g

class CanZipWith7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 c8 i8 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6, c7 -> i7, c8 -> i8 where

Methods

zipWith7 :: (i1 -> i2 -> i3 -> i4 -> i5 -> i6 -> i7 -> i8) -> c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> c7 -> c8

Instances

CanZipWith7 [a] a [b] b [c] c [d] d [e] e [f] f [g] g [h] h

class CanZip c1 i1 c2 i2 t | c1 -> i1, c2 -> i2 where

Methods

zip :: c1 -> c2 -> t (i1, i2)

Instances

CanZip LText Char LText Char []
CanZip LByteString Word8 LByteString Word8 []
CanZip Text Char Text Char []
CanZip ByteString Word8 ByteString Word8 []
CanZip [a] a [b] b []
CanZip (Vector a) a (Vector b) b Vector
CanZip (Seq a) a (Seq b) b Seq

class CanZip3 c1 i1 c2 i2 c3 i3 t | c1 -> i1, c2 -> i2, c3 -> i3 where

Methods

zip3 :: c1 -> c2 -> c3 -> t (i1, i2, i3)

Instances

CanZip3 [a] a [b] b [c] c []
CanZip3 (Vector a) a (Vector b) b (Vector c) c Vector
CanZip3 (Seq a) a (Seq b) b (Seq c) c Seq

class CanZip4 c1 i1 c2 i2 c3 i3 c4 i4 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4 where

Methods

zip4 :: c1 -> c2 -> c3 -> c4 -> t (i1, i2, i3, i4)

Instances

CanZip4 [a] a [b] b [c] c [d] d []
CanZip4 (Vector a) a (Vector b) b (Vector c) c (Vector d) d Vector
CanZip4 (Seq a) a (Seq b) b (Seq c) c (Seq d) d Seq

class CanZip5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5 where

Methods

zip5 :: c1 -> c2 -> c3 -> c4 -> c5 -> t (i1, i2, i3, i4, i5)

Instances

CanZip5 [a] a [b] b [c] c [d] d [e] e []
CanZip5 (Vector a) a (Vector b) b (Vector c) c (Vector d) d (Vector e) e Vector

class CanZip6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6 where

Methods

zip6 :: c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> t (i1, i2, i3, i4, i5, i6)

Instances

CanZip6 [a] a [b] b [c] c [d] d [e] e [f] f []
CanZip6 (Vector a) a (Vector b) b (Vector c) c (Vector d) d (Vector e) e (Vector f) f Vector

class CanZip7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6, c7 -> i7 where

Methods

zip7 :: c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> c7 -> t (i1, i2, i3, i4, i5, i6, i7)

Instances

CanZip7 [a] a [b] b [c] c [d] d [e] e [f] f [g] g []

class CanUnzip c1 i1 c2 i2 t | c1 -> i1, c2 -> i2 where

Methods

unzip :: t (i1, i2) -> (c1, c2)

Instances

CanUnzip LByteString Word8 LByteString Word8 []
CanUnzip ByteString Word8 ByteString Word8 []
CanUnzip [a] a [b] b []
CanUnzip (Vector a) a (Vector b) b Vector

class CanUnzip3 c1 i1 c2 i2 c3 i3 t | c1 -> i1, c2 -> i2, c3 -> i3 where

Methods

unzip3 :: t (i1, i2, i3) -> (c1, c2, c3)

Instances

CanUnzip3 [a] a [b] b [c] c []
CanUnzip3 (Vector a) a (Vector b) b (Vector c) c Vector

class CanUnzip4 c1 i1 c2 i2 c3 i3 c4 i4 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4 where

Methods

unzip4 :: t (i1, i2, i3, i4) -> (c1, c2, c3, c4)

Instances

CanUnzip4 [a] a [b] b [c] c [d] d []
CanUnzip4 (Vector a) a (Vector b) b (Vector c) c (Vector d) d Vector

class CanUnzip5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5 where

Methods

unzip5 :: t (i1, i2, i3, i4, i5) -> (c1, c2, c3, c4, c5)

Instances

CanUnzip5 [a] a [b] b [c] c [d] d [e] e []
CanUnzip5 (Vector a) a (Vector b) b (Vector c) c (Vector d) d (Vector e) e Vector

class CanUnzip6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6 where

Methods

unzip6 :: t (i1, i2, i3, i4, i5, i6) -> (c1, c2, c3, c4, c5, c6)

Instances

CanUnzip6 [a] a [b] b [c] c [d] d [e] e [f] f []
CanUnzip6 (Vector a) a (Vector b) b (Vector c) c (Vector d) d (Vector e) e (Vector f) f Vector

class CanUnzip7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 t | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4, c5 -> i5, c6 -> i6, c7 -> i7 where

Methods

unzip7 :: t (i1, i2, i3, i4, i5, i6, i7) -> (c1, c2, c3, c4, c5, c6, c7)

Instances

CanUnzip7 [a] a [b] b [c] c [d] d [e] e [f] f [g] g []

class CanEmpty a where

Methods

empty :: a

Instances

CanEmpty LText
CanEmpty LByteString
CanEmpty FilePath
CanEmpty Text
CanEmpty ByteString
CanEmpty [a]
CanEmpty (Maybe a)
CanEmpty (Vector a)
(Eq a, Hashable a) => CanEmpty (HashSet a)
Ord a => CanEmpty (Set a)
CanEmpty (Seq a)
(Hashable k, Eq k) => CanEmpty (HashMap k a)
Ord k => CanEmpty (Map k a)

CanIntersperse LText Char
CanIntersperse LByteString Word8
CanIntersperse FilePath Char
CanIntersperse Text Char
CanIntersperse ByteString Word8
CanIntersperse [a] a
CanIntersperse (Vector a) a
CanIntersperse (Seq a) a

CanReplicate LText LText Int64
CanReplicate LByteString Word8 Int64
CanReplicate Text Text Int
CanReplicate ByteString Word8 Int
CanReplicate [i] i Int
CanReplicate (Vector a) a Int
CanReplicate (Seq a) a Int