Safe Haskell | None |
---|
- 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
- class CanFilterM c i | c -> i where
- class CanLength c len | c -> len where
- length :: c -> len
- class CanSingleton c i | c -> i where
- singleton :: i -> c
- class CanNull c where
- 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
- class CanReplicateM c i len | c -> i len where
- replicateM :: Monad m => len -> m i -> m c
- class CanLookup c k v | c -> k v where
- 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
- class CanReadFile a where
- class CanWriteFile a where
- class CanStripPrefix a where
- stripPrefix :: a -> a -> Maybe a
- isPrefixOf :: a -> a -> Bool
- class CanBreak c i | c -> i where
- class CanAny c i | c -> i where
- 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
- class CanLines t where
- lines :: t -> [t]
- class CanUnlines t where
- unlines :: [t] -> t
- class CanSplit c i | c -> i where
- class CanStripSuffix a where
- stripSuffix :: a -> a -> Maybe a
- isSuffixOf :: a -> a -> Bool
- class CanIsInfixOf a where
- 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
- class CanConcat c i | c -> i where
- concat :: c -> i
- class CanPartition c i | c -> i where
- class CanNubBy c i | c -> i where
- 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
- 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
- class CanCompareLength c where
- compareLength :: Integral l => c -> l -> Ordering
- class CanGroupBy c a | c -> a where
- class CanGroup c a | c -> a where
- group :: c -> [c]
- class CanRepeat c a | c -> a where
- repeat :: a -> c
Documentation
class CanMap ci co i o | ci -> i, co -> o, ci o -> co, co i -> ci whereSource
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 whereSource
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 CanFilterM c i | c -> i whereSource
CanFilterM [a] a | |
CanFilterM (Vector a) a | |
CanFilterM (Seq a) a |
class CanSingleton c i | c -> i whereSource
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 CanPack c i | c -> i whereSource
subsequences :: c -> [c]Source
permutations :: c -> [c]Source
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 whereSource
intersperse :: i -> c -> cSource
class CanReplicateM c i len | c -> i len whereSource
replicateM :: Monad m => len -> m i -> m cSource
CanReplicateM [a] a Int | |
CanReplicateM (Vector a) a Int | |
CanReplicateM (Seq a) a Int |
class CanInsertVal c k v | c -> k v whereSource
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 |
(CanDeleteVal c' k, ~ * c c') => CanDelete (k -> c -> c') |
class CanDeleteVal c k | c -> k whereSource
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 CanReadFile a whereSource
class CanWriteFile a whereSource
class CanStripPrefix a whereSource
stripPrefix :: a -> a -> Maybe aSource
isPrefixOf :: a -> a -> BoolSource
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 CanSplitAt c i | c -> i whereSource
class CanUnlines t whereSource
CanUnlines LText | |
CanUnlines Text | |
~ * c Char => CanUnlines [c] |
class CanStripSuffix a whereSource
stripSuffix :: a -> a -> Maybe aSource
isSuffixOf :: a -> a -> BoolSource
class CanIsInfixOf a whereSource
CanIsInfixOf LText | |
CanIsInfixOf Text | |
CanIsInfixOf ByteString | |
Eq a => CanIsInfixOf [a] | |
Eq a => CanIsInfixOf (Maybe a) |
class CanReverse a whereSource
class CanReplicate a i len | a -> i len whereSource
class CanToChunks c i | c -> i, i -> c whereSource
fromChunks :: [i] -> cSource
class CanEncodeUtf8 ci co | co -> ci, ci -> co whereSource
encodeUtf8 :: ci -> coSource
class CanDecodeUtf8 ci co | co -> ci, ci -> co whereSource
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
.
decodeUtf8 :: ci -> coSource
class CanToStrict a b whereSource
fromStrict :: b -> aSource
class CanGetLine a whereSource
MonadIO m => CanGetLine (m ByteString) | |
MonadIO m => CanGetLine (m LText) | |
MonadIO m => CanGetLine (m Text) |
class CanToLower a whereSource
class CanToUpper a whereSource
class CanPartition c i | c -> i whereSource
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 CanDifference c whereSource
difference :: c -> c -> cSource
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 whereSource
intersection :: c -> c -> cSource
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 CanCompareLength c whereSource
compareLength :: Integral l => c -> l -> OrderingSource
class CanGroupBy c a | c -> a whereSource