| Safe Haskell | None |
|---|
ClassyPrelude.Classes
- 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 where
- class CanCons c a where
- cons :: a -> c -> c
- class CanUncons c a where
Documentation
class CanMap ci co i o | ci -> i, co -> o, ci o -> co, co i -> ci whereSource
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 (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
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) |
class CanFilterM c i | c -> i whereSource
Instances
| CanFilterM [a] a | |
| CanFilterM (Vector a) a |
class CanSingleton c i | c -> i whereSource
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 | |
| (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
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 | |
| (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
Methods
intersperse :: i -> c -> cSource
class CanReplicateM c i len | c -> i len whereSource
Methods
replicateM :: Monad m => len -> m i -> m cSource
Instances
| CanReplicateM [a] a Int | |
| CanReplicateM (Vector a) a Int |
class CanInsertVal c k v | c -> k v whereSource
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 |
Instances
| (CanDeleteVal c' k, ~ * c c') => CanDelete (k -> c -> c') |
class CanDeleteVal c k | c -> k whereSource
Instances
| Eq k => CanDeleteVal [(k, v)] k | |
| (Eq k, Hashable k) => CanDeleteVal (HashMap k v) k | |
| Ord k => CanDeleteVal (Map k v) k |
class CanReadFile a whereSource
Instances
class CanWriteFile a whereSource
Instances
class CanStripPrefix a whereSource
Instances
class CanSplitAt c i | c -> i whereSource
Instances
class CanUnlines t whereSource
Instances
| CanUnlines LText | |
| CanUnlines Text | |
| ~ * c Char => CanUnlines [c] |
class CanStripSuffix a whereSource
class CanIsInfixOf a whereSource
Instances
| CanIsInfixOf LText | |
| CanIsInfixOf Text | |
| Eq a => CanIsInfixOf [a] | |
| Eq a => CanIsInfixOf (Maybe a) |
class CanReverse a whereSource
Instances
class CanReplicate a i len | a -> i len whereSource
Instances
class CanToChunks c i | c -> i, i -> c whereSource
Instances
class CanEncodeUtf8 ci co | co -> ci, ci -> co whereSource
Methods
encodeUtf8 :: ci -> coSource
Instances
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.
Methods
decodeUtf8 :: ci -> coSource
Instances
class CanToStrict a b whereSource
Instances
class CanGetLine a whereSource
Instances
| MonadIO m => CanGetLine (m ByteString) | |
| MonadIO m => CanGetLine (m LText) | |
| MonadIO m => CanGetLine (m Text) |
class CanToLower a whereSource
Instances
class CanToUpper a whereSource
Instances
class CanPartition c i | c -> i whereSource
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 | |
| Hashable k => CanPartition (HashMap k v) v | |
| Ord k => CanPartition (Map k v) v |
class CanDifference c whereSource
Methods
difference :: c -> c -> cSource
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 whereSource
Methods
intersection :: c -> c -> cSource
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) |