ClassyPrelude

Contents

• CorePrelude
• Standard
  • Monoid
  • Monad
  • Mutable references
• Non-standard
  • List-like classes
  • Map-like
  • Set-like
  • Text-like
  • IO
  • Chunking
  • Force types

Synopsis

• module CorePrelude
• empty :: Monoid m => m
• append :: Monoid m => m -> m -> m
• (++) :: Monoid m => m -> m -> m
• module Control.Monad
• module Control.Concurrent.MVar.Lifted
• module Data.IORef.Lifted
• map :: CanMap ci co i o => (i -> o) -> ci -> co
• concat :: CanConcat c i => c -> i
• concatMap :: CanConcatMap ci co i o => (i -> o) -> ci -> co
• filter :: CanFilter c i => (i -> Bool) -> c -> c
• find :: CanFind c i => (i -> Bool) -> c -> Maybe i
• length :: CanLength c len => c -> len
• singleton :: CanSingleton c i => i -> c
• null :: CanNull c => c -> Bool
• pack :: CanPack c i => [i] -> c
• unpack :: CanPack c i => c -> [i]
• repack :: (CanPack a i, CanPack b i) => a -> b
• fromList :: CanPack c i => [i] -> c
• toList :: CanPack c i => c -> [i]
• mapM :: CanMapM ci mco m i o => (i -> m o) -> ci -> mco
• mapM_ :: (CanMapM_ ci i, Monad m) => (i -> m o) -> ci -> m ()
• forM :: CanMapM ci mco m i o => ci -> (i -> m o) -> mco
• forM_ :: (Monad m, CanMapM_ ci i) => ci -> (i -> m o) -> m ()
• replicateM :: (CanReplicateM c i len, Monad m) => len -> m i -> m c
• stripPrefix :: CanStripPrefix a => a -> a -> Maybe a
• isPrefixOf :: CanStripPrefix a => a -> a -> Bool
• stripSuffix :: CanStripSuffix a => a -> a -> Maybe a
• isSuffixOf :: CanStripSuffix a => a -> a -> Bool
• isInfixOf :: CanIsInfixOf a => a -> a -> Bool
• break :: CanBreak c i => (i -> Bool) -> c -> (c, c)
• span :: CanBreak c i => (i -> Bool) -> c -> (c, c)
• dropWhile :: CanBreak c i => (i -> Bool) -> c -> c
• takeWhile :: CanBreak c i => (i -> Bool) -> c -> c
• any :: CanAny c i => (i -> Bool) -> c -> Bool
• all :: CanAny c i => (i -> Bool) -> c -> Bool
• splitAt :: CanSplitAt c i => i -> c -> (c, c)
• take :: CanSplitAt c i => i -> c -> c
• drop :: CanSplitAt c i => i -> c -> c
• fold :: CanFold c i accum => (accum -> i -> accum) -> accum -> c -> accum
• words :: CanWords t => t -> [t]
• unwords :: CanWords t => [t] -> t
• lines :: CanLines t => t -> [t]
• unlines :: CanUnlines t => [t] -> t
• split :: CanSplit c i => (i -> Bool) -> c -> [c]
• reverse :: CanReverse a => a -> a
• readMay :: (Read b, CanPack a Char) => a -> Maybe b
• replicate :: CanReplicate a i len => len -> i -> a
• intercalate :: (CanConcat c i, CanIntersperse c i) => i -> c -> i
• intersperse :: CanIntersperse c i => i -> c -> c
• encodeUtf8 :: CanEncodeUtf8 ci co => ci -> co
• decodeUtf8 :: CanDecodeUtf8 ci co => ci -> co
• subsequences :: CanPack c i => c -> [c]
• permutations :: CanPack c i => c -> [c]
• partition :: CanPartition c i => (i -> Bool) -> c -> (c, c)
• nub :: (CanNubBy c i, Ord i, CanNubBy c i) => c -> c
• nubBy :: CanNubBy c i => (i -> i -> Bool) -> c -> c
• sort :: CanSortBy c a => c a -> c a
• sortBy :: CanSortBy c a => (a -> a -> Ordering) -> c a -> c a
• sortWith :: (CanSortBy c a, Ord b) => (a -> b) -> c a -> c a
• cons :: CanCons c a => a -> c -> c
• uncons :: CanUncons c a => c -> Maybe (a, c)
• lookup :: CanLookup c k v => k -> c -> Maybe v
• insert :: CanInsert f => f
• delete :: CanDelete f => f
• member :: CanMember c k => k -> c -> Bool
• notMember :: CanMember c k => k -> c -> Bool
• elem :: CanMember c k => k -> c -> Bool
• notElem :: CanMember c k => k -> c -> Bool
• union :: CanUnion c => c -> c -> c
• difference :: CanDifference c => c -> c -> c
• (\\) :: CanDifference c => c -> c -> c
• intersection :: CanIntersection c => c -> c -> c
• intersect :: CanIntersection c => c -> c -> c
• unions :: (Foldable cc, Monoid c, CanUnion c) => cc c -> c
• show :: (Show a, CanPack c Char) => a -> c
• toLower :: CanToLower a => a -> a
• toUpper :: CanToUpper a => a -> a
• toCaseFold :: CanToCaseFold a => a -> a
• toStrict :: CanToStrict a b => a -> b
• fromStrict :: CanToStrict a b => b -> a
• readFile :: (CanReadFile a, MonadIO m) => FilePath -> m a
• writeFile :: (CanWriteFile a, MonadIO m) => FilePath -> a -> m ()
• getLine :: CanGetLine a => a
• print :: (Show a, MonadIO m) => a -> m ()
• toChunks :: CanToChunks c i => c -> [i]
• fromChunks :: CanToChunks c i => [i] -> c
• asByteString :: ByteString -> ByteString
• asLByteString :: LByteString -> LByteString
• asHashMap :: HashMap k v -> HashMap k v
• asHashSet :: HashSet a -> HashSet a
• asText :: Text -> Text
• asLText :: LText -> LText
• asList :: [a] -> [a]
• asMap :: Map k v -> Map k v
• asMaybe :: Maybe a -> Maybe a
• asSet :: Set a -> Set a
• asVector :: Vector a -> Vector a

CorePrelude

Standard

Monoid

Monad

Mutable references

Non-standard

List-like classes

Map-like

Set-like

Text-like

IO

Chunking

Force types