-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A typeclass-based Prelude.
--   
--   Focuses on using common typeclasses when possible, and creating new
--   ones to avoid name clashing. Exposes many recommended datastructures
--   (Map, ByteString, etc) directly without requiring long import lists
--   and qualified modules.
@package classy-prelude
@version 0.5.4

module ClassyPrelude.Classes
class CanMap ci co i o | ci -> i, co -> o, ci o -> co, co i -> ci
map :: CanMap ci co i o => (i -> o) -> ci -> co
class CanConcatMap ci co i o | ci -> i, co -> o, ci o -> co, co i -> ci
concatMap :: CanConcatMap ci co i o => (i -> o) -> ci -> co
class CanFilter c i | c -> i
filter :: CanFilter c i => (i -> Bool) -> c -> c
class CanFilterM c i | c -> i
filterM :: (CanFilterM c i, Monad m) => (i -> m Bool) -> c -> m c
class CanLength c len | c -> len
length :: CanLength c len => c -> len
class CanSingleton c i | c -> i
singleton :: CanSingleton c i => i -> c
class CanNull c
null :: CanNull c => c -> Bool
class CanPack c i | c -> i where subsequences = map pack . subsequences . unpack permutations = map pack . permutations . unpack
pack :: CanPack c i => [i] -> c
unpack :: CanPack c i => c -> [i]
subsequences :: CanPack c i => c -> [c]
permutations :: CanPack c i => c -> [c]
class CanIntersperse c i | c -> i
intersperse :: CanIntersperse c i => i -> c -> c
class Monad m => CanMapM ci mco m i o | ci -> i, mco -> m o, ci o m -> mco, mco i -> ci
mapM :: CanMapM ci mco m i o => (i -> m o) -> ci -> mco
class CanMapM_ ci i | ci -> i
mapM_ :: (CanMapM_ ci i, Monad m) => (i -> m o) -> ci -> m ()
class CanReplicateM c i len | c -> i len
replicateM :: (CanReplicateM c i len, Monad m) => len -> m i -> m c
class CanLookup c k v | c -> k v
lookup :: CanLookup c k v => k -> c -> Maybe v
class CanInsert f
insert :: CanInsert f => f
class CanInsertVal c k v | c -> k v
insertVal :: CanInsertVal c k v => k -> v -> c -> c
class CanDelete f
delete :: CanDelete f => f
class CanDeleteVal c k | c -> k
deleteVal :: CanDeleteVal c k => k -> c -> c
class CanMember c k | c -> k where notMember k = not . member k
member :: CanMember c k => k -> c -> Bool
notMember :: CanMember c k => k -> c -> Bool
class CanReadFile a
readFile :: (CanReadFile a, MonadIO m) => FilePath -> m a
class CanWriteFile a
writeFile :: (CanWriteFile a, MonadIO m) => FilePath -> a -> m ()
class CanStripPrefix a
stripPrefix :: CanStripPrefix a => a -> a -> Maybe a
isPrefixOf :: CanStripPrefix a => a -> a -> Bool
class CanBreak c i | c -> i
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
class CanAny c i | c -> i
any :: CanAny c i => (i -> Bool) -> c -> Bool
all :: CanAny c i => (i -> Bool) -> c -> Bool
class CanSplitAt c i | c -> i
splitAt :: CanSplitAt c i => i -> c -> (c, c)
class CanFold c i accum | c -> i
fold :: CanFold c i accum => (accum -> i -> accum) -> accum -> c -> accum
class CanWords t
words :: CanWords t => t -> [t]
unwords :: CanWords t => [t] -> t
class CanLines t
lines :: CanLines t => t -> [t]
class CanUnlines t
unlines :: CanUnlines t => [t] -> t
class CanSplit c i | c -> i
split :: CanSplit c i => (i -> Bool) -> c -> [c]
class CanStripSuffix a
stripSuffix :: CanStripSuffix a => a -> a -> Maybe a
isSuffixOf :: CanStripSuffix a => a -> a -> Bool
class CanIsInfixOf a
isInfixOf :: CanIsInfixOf a => a -> a -> Bool
class CanReverse a
reverse :: CanReverse a => a -> a
class CanReplicate a i len | a -> i len
replicate :: CanReplicate a i len => len -> i -> a
class CanToChunks c i | c -> i, i -> c
toChunks :: CanToChunks c i => c -> [i]
fromChunks :: CanToChunks c i => [i] -> c
class CanEncodeUtf8 ci co | co -> ci, ci -> co
encodeUtf8 :: CanEncodeUtf8 ci co => ci -> co

-- | Note: implementations should ensure that <tt>decodeUtf8</tt> is a
--   total function. As such, the standard <tt>decodeUtf8</tt> provided by
--   the text package should not be used, but instead <tt>decodeUtf8With
--   lenientDecode</tt>.
class CanDecodeUtf8 ci co | co -> ci, ci -> co
decodeUtf8 :: CanDecodeUtf8 ci co => ci -> co
class CanToStrict a b
toStrict :: CanToStrict a b => a -> b
fromStrict :: CanToStrict a b => b -> a
class CanGetLine a
getLine :: CanGetLine a => a
class CanToLower a
toLower :: CanToLower a => a -> a
class CanToUpper a
toUpper :: CanToUpper a => a -> a
class CanToCaseFold a
toCaseFold :: CanToCaseFold a => a -> a
class CanFind c i | c -> i
find :: CanFind c i => (i -> Bool) -> c -> Maybe i
class CanConcat c i | c -> i
concat :: CanConcat c i => c -> i
class CanPartition c i | c -> i
partition :: CanPartition c i => (i -> Bool) -> c -> (c, c)
class CanNubBy c i | c -> i where nub = nubBy (==)
nubBy :: CanNubBy c i => (i -> i -> Bool) -> c -> c
nub :: (CanNubBy c i, Ord i, CanNubBy c i) => c -> c
class CanUnion c
union :: CanUnion c => c -> c -> c
class CanDifference c
difference :: CanDifference c => c -> c -> c
class CanIntersection c
intersection :: CanIntersection c => c -> c -> c
class CanSortBy c a | c -> a
sortBy :: CanSortBy c a => (a -> a -> Ordering) -> c -> c
class Ord a => CanSort c a | c -> a where sort = sortBy compare
sort :: CanSort c a => c -> c
class CanCons c a
cons :: CanCons c a => a -> c -> c
class CanUncons c a
uncons :: CanUncons c a => c -> Maybe (a, c)
class CanCompareLength c
compareLength :: (CanCompareLength c, Integral l) => c -> l -> Ordering
class CanGroupBy c a | c -> a
groupBy :: CanGroupBy c a => (a -> a -> Bool) -> c -> [c]
class CanGroup c a | c -> a where group = groupBy (==)
group :: CanGroup c a => c -> [c]
class CanRepeat c a | c -> a
repeat :: CanRepeat c a => a -> c
class CanZipWith c1 i1 c2 i2 c3 i3 | c1 -> i1, c2 -> i2, c3 -> i3
zipWith :: CanZipWith c1 i1 c2 i2 c3 i3 => (i1 -> i2 -> i3) -> c1 -> c2 -> c3
class CanZipWith3 c1 i1 c2 i2 c3 i3 c4 i4 | c1 -> i1, c2 -> i2, c3 -> i3, c4 -> i4
zipWith3 :: CanZipWith3 c1 i1 c2 i2 c3 i3 c4 i4 => (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
zipWith4 :: CanZipWith4 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 => (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
zipWith5 :: CanZipWith5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 => (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
zipWith6 :: CanZipWith6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 => (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
zipWith7 :: CanZipWith7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 c8 i8 => (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
zip :: CanZip c1 i1 c2 i2 t => c1 -> c2 -> t (i1, i2)
class CanZip3 c1 i1 c2 i2 c3 i3 t | c1 -> i1, c2 -> i2, c3 -> i3
zip3 :: CanZip3 c1 i1 c2 i2 c3 i3 t => 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
zip4 :: CanZip4 c1 i1 c2 i2 c3 i3 c4 i4 t => 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
zip5 :: CanZip5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 t => 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
zip6 :: CanZip6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 t => 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
zip7 :: CanZip7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 t => 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
unzip :: CanUnzip c1 i1 c2 i2 t => t (i1, i2) -> (c1, c2)
class CanUnzip3 c1 i1 c2 i2 c3 i3 t | c1 -> i1, c2 -> i2, c3 -> i3
unzip3 :: CanUnzip3 c1 i1 c2 i2 c3 i3 t => 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
unzip4 :: CanUnzip4 c1 i1 c2 i2 c3 i3 c4 i4 t => 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
unzip5 :: CanUnzip5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 t => 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
unzip6 :: CanUnzip6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 t => 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
unzip7 :: CanUnzip7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 t => t (i1, i2, i3, i4, i5, i6, i7) -> (c1, c2, c3, c4, c5, c6, c7)
instance (CanDeleteVal c' k, c ~ c') => CanDelete (k -> c -> c')
instance (CanInsertVal c' k v, c ~ c') => CanInsert (k -> v -> c -> c')

module ClassyPrelude

-- | General-purpose finite sequences.
data Seq a :: * -> *
empty :: Monoid m => m
append :: Monoid m => m -> m -> m
(++) :: Monoid m => m -> m -> m
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 from one type to another, dropping to a list in the middle.
--   
--   <tt>repack = pack . unpack</tt>.
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

-- | Strict left fold.
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)
zip :: CanZip c1 i1 c2 i2 t => c1 -> c2 -> t (i1, i2)
zip3 :: CanZip3 c1 i1 c2 i2 c3 i3 t => c1 -> c2 -> c3 -> t (i1, i2, i3)
zip4 :: CanZip4 c1 i1 c2 i2 c3 i3 c4 i4 t => c1 -> c2 -> c3 -> c4 -> t (i1, i2, i3, i4)
zip5 :: CanZip5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 t => c1 -> c2 -> c3 -> c4 -> c5 -> t (i1, i2, i3, i4, i5)
zip6 :: CanZip6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 t => c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> t (i1, i2, i3, i4, i5, i6)
zip7 :: CanZip7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 t => c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> c7 -> t (i1, i2, i3, i4, i5, i6, i7)
unzip :: CanUnzip c1 i1 c2 i2 t => t (i1, i2) -> (c1, c2)
unzip3 :: CanUnzip3 c1 i1 c2 i2 c3 i3 t => t (i1, i2, i3) -> (c1, c2, c3)
unzip4 :: CanUnzip4 c1 i1 c2 i2 c3 i3 c4 i4 t => t (i1, i2, i3, i4) -> (c1, c2, c3, c4)
unzip5 :: CanUnzip5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 t => t (i1, i2, i3, i4, i5) -> (c1, c2, c3, c4, c5)
unzip6 :: CanUnzip6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 t => t (i1, i2, i3, i4, i5, i6) -> (c1, c2, c3, c4, c5, c6)
unzip7 :: CanUnzip7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 t => t (i1, i2, i3, i4, i5, i6, i7) -> (c1, c2, c3, c4, c5, c6, c7)
zipWith :: CanZipWith c1 i1 c2 i2 c3 i3 => (i1 -> i2 -> i3) -> c1 -> c2 -> c3
zipWith3 :: CanZipWith3 c1 i1 c2 i2 c3 i3 c4 i4 => (i1 -> i2 -> i3 -> i4) -> c1 -> c2 -> c3 -> c4
zipWith4 :: CanZipWith4 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 => (i1 -> i2 -> i3 -> i4 -> i5) -> c1 -> c2 -> c3 -> c4 -> c5
zipWith5 :: CanZipWith5 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 => (i1 -> i2 -> i3 -> i4 -> i5 -> i6) -> c1 -> c2 -> c3 -> c4 -> c5 -> c6
zipWith6 :: CanZipWith6 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 => (i1 -> i2 -> i3 -> i4 -> i5 -> i6 -> i7) -> c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> c7
zipWith7 :: CanZipWith7 c1 i1 c2 i2 c3 i3 c4 i4 c5 i5 c6 i6 c7 i7 c8 i8 => (i1 -> i2 -> i3 -> i4 -> i5 -> i6 -> i7 -> i8) -> c1 -> c2 -> c3 -> c4 -> c5 -> c6 -> c7 -> c8
nub :: (CanNubBy c i, Ord i, CanNubBy c i) => c -> c
nubBy :: CanNubBy c i => (i -> i -> Bool) -> c -> c
sort :: CanSort c a => c -> c
sortBy :: CanSortBy c a => (a -> a -> Ordering) -> c -> c

-- | Sort elements using the user supplied function to project something
--   out of each element. Inspired by
--   <a>http://hackage.haskell.org/packages/archive/base/latest/doc/html/GHC-Exts.html#v:sortWith</a>.
sortWith :: (CanSortBy c a, Ord b) => (a -> b) -> c -> c
group :: CanGroup c a => c -> [c]
groupBy :: CanGroupBy c a => (a -> a -> Bool) -> c -> [c]

-- | The <a>groupWith</a> function uses the user supplied function which
--   projects an element out of every list element in order to first sort
--   the input list and then to form groups by equality on these projected
--   elements
--   
--   Inspired by
--   <a>http://hackage.haskell.org/packages/archive/base/latest/doc/html/GHC-Exts.html#v:groupWith</a>
groupWith :: (CanGroupBy c a, Eq b) => (a -> b) -> c -> [c]
cons :: CanCons c a => a -> c -> c
uncons :: CanUncons c a => c -> Maybe (a, c)

-- | This is a more effective alternative to statements like <tt>i &gt;=
--   length xs</tt> for types having an O(n) complexity of <a>length</a>
--   operation like list or <a>Text</a>. It does not traverse the whole
--   data structure if the value being compared to is lesser.
compareLength :: (CanCompareLength c, Integral l) => c -> l -> Ordering

-- | The <a>sum</a> function computes the sum of the numbers of a
--   structure.
sum :: (Foldable t, Num a) => t a -> a

-- | The <a>product</a> function computes the product of the numbers of a
--   structure.
product :: (Foldable t, Num a) => t a -> a
repeat :: CanRepeat c a => 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

-- | An alias for <a>member</a>
elem :: CanMember c k => k -> c -> Bool

-- | An alias for <a>notMember</a>
notElem :: CanMember c k => k -> c -> Bool
union :: CanUnion c => c -> c -> c
difference :: CanDifference c => c -> c -> c

-- | An alias for <a>difference</a>.
(\\) :: CanDifference c => c -> c -> c
intersection :: CanIntersection c => c -> c -> c

-- | An alias for <a>intersection</a>.
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
