ListLike-4.7.4: Generalized support for list-like structures
CopyrightCopyright (C) 2007 John Goerzen
LicenseBSD3
MaintainerJohn Lato <jwlato@gmail.com>
Stabilityprovisional
Portabilityportable
Safe HaskellNone
LanguageHaskell2010

Data.ListLike.Instances

Description

Instances of ListLike and related classes. Re-exported by Data.ListLike.

Written by John Goerzen, jgoerzen@complete.org

Orphan instances

StringLike String Source # 
Instance details

FoldableLL ByteString Word8 Source # 
Instance details

Methods

foldl :: (a -> Word8 -> a) -> a -> ByteString -> a Source #

foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a Source #

foldl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 Source #

foldr :: (Word8 -> b -> b) -> b -> ByteString -> b Source #

foldr' :: (Word8 -> b -> b) -> b -> ByteString -> b Source #

foldr1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 Source #

FoldableLL ByteString Word8 Source # 
Instance details

Methods

foldl :: (a -> Word8 -> a) -> a -> ByteString -> a Source #

foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a Source #

foldl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 Source #

foldr :: (Word8 -> b -> b) -> b -> ByteString -> b Source #

foldr' :: (Word8 -> b -> b) -> b -> ByteString -> b Source #

foldr1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 Source #

ListLike ByteString Word8 Source # 
Instance details

Methods

empty :: ByteString Source #

singleton :: Word8 -> ByteString Source #

cons :: Word8 -> ByteString -> ByteString Source #

snoc :: ByteString -> Word8 -> ByteString Source #

append :: ByteString -> ByteString -> ByteString Source #

head :: ByteString -> Word8 Source #

uncons :: ByteString -> Maybe (Word8, ByteString) Source #

last :: ByteString -> Word8 Source #

tail :: ByteString -> ByteString Source #

init :: ByteString -> ByteString Source #

null :: ByteString -> Bool Source #

length :: ByteString -> Int Source #

map :: ListLike full' item' => (Word8 -> item') -> ByteString -> full' Source #

rigidMap :: (Word8 -> Word8) -> ByteString -> ByteString Source #

reverse :: ByteString -> ByteString Source #

intersperse :: Word8 -> ByteString -> ByteString Source #

concat :: ListLike full' ByteString => full' -> ByteString Source #

concatMap :: ListLike full' item' => (Word8 -> full') -> ByteString -> full' Source #

rigidConcatMap :: (Word8 -> ByteString) -> ByteString -> ByteString Source #

any :: (Word8 -> Bool) -> ByteString -> Bool Source #

all :: (Word8 -> Bool) -> ByteString -> Bool Source #

maximum :: ByteString -> Word8 Source #

minimum :: ByteString -> Word8 Source #

replicate :: Int -> Word8 -> ByteString Source #

take :: Int -> ByteString -> ByteString Source #

drop :: Int -> ByteString -> ByteString Source #

splitAt :: Int -> ByteString -> (ByteString, ByteString) Source #

takeWhile :: (Word8 -> Bool) -> ByteString -> ByteString Source #

dropWhile :: (Word8 -> Bool) -> ByteString -> ByteString Source #

dropWhileEnd :: (Word8 -> Bool) -> ByteString -> ByteString Source #

span :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source #

break :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source #

group :: (ListLike full' ByteString, Eq Word8) => ByteString -> full' Source #

inits :: ListLike full' ByteString => ByteString -> full' Source #

tails :: ListLike full' ByteString => ByteString -> full' Source #

isPrefixOf :: ByteString -> ByteString -> Bool Source #

isSuffixOf :: ByteString -> ByteString -> Bool Source #

isInfixOf :: ByteString -> ByteString -> Bool Source #

stripPrefix :: ByteString -> ByteString -> Maybe ByteString Source #

stripSuffix :: ByteString -> ByteString -> Maybe ByteString Source #

elem :: Word8 -> ByteString -> Bool Source #

notElem :: Word8 -> ByteString -> Bool Source #

find :: (Word8 -> Bool) -> ByteString -> Maybe Word8 Source #

filter :: (Word8 -> Bool) -> ByteString -> ByteString Source #

partition :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source #

index :: ByteString -> Int -> Word8 Source #

elemIndex :: Word8 -> ByteString -> Maybe Int Source #

elemIndices :: (Eq Word8, ListLike result Int) => Word8 -> ByteString -> result Source #

findIndex :: (Word8 -> Bool) -> ByteString -> Maybe Int Source #

findIndices :: ListLike result Int => (Word8 -> Bool) -> ByteString -> result Source #

sequence :: (Monad m, ListLike fullinp (m Word8)) => fullinp -> m ByteString Source #

mapM :: (Monad m, ListLike full' item') => (Word8 -> m item') -> ByteString -> m full' Source #

rigidMapM :: Monad m => (Word8 -> m Word8) -> ByteString -> m ByteString Source #

nub :: ByteString -> ByteString Source #

delete :: Word8 -> ByteString -> ByteString Source #

deleteFirsts :: ByteString -> ByteString -> ByteString Source #

union :: ByteString -> ByteString -> ByteString Source #

intersect :: ByteString -> ByteString -> ByteString Source #

sort :: ByteString -> ByteString Source #

insert :: Word8 -> ByteString -> ByteString Source #

toList' :: ByteString -> [Word8] Source #

fromList' :: [Word8] -> ByteString Source #

fromListLike :: ListLike full' Word8 => ByteString -> full' Source #

nubBy :: (Word8 -> Word8 -> Bool) -> ByteString -> ByteString Source #

deleteBy :: (Word8 -> Word8 -> Bool) -> Word8 -> ByteString -> ByteString Source #

deleteFirstsBy :: (Word8 -> Word8 -> Bool) -> ByteString -> ByteString -> ByteString Source #

unionBy :: (Word8 -> Word8 -> Bool) -> ByteString -> ByteString -> ByteString Source #

intersectBy :: (Word8 -> Word8 -> Bool) -> ByteString -> ByteString -> ByteString Source #

groupBy :: (ListLike full' ByteString, Eq Word8) => (Word8 -> Word8 -> Bool) -> ByteString -> full' Source #

sortBy :: (Word8 -> Word8 -> Ordering) -> ByteString -> ByteString Source #

insertBy :: (Word8 -> Word8 -> Ordering) -> Word8 -> ByteString -> ByteString Source #

genericLength :: Num a => ByteString -> a Source #

genericTake :: Integral a => a -> ByteString -> ByteString Source #

genericDrop :: Integral a => a -> ByteString -> ByteString Source #

genericSplitAt :: Integral a => a -> ByteString -> (ByteString, ByteString) Source #

genericReplicate :: Integral a => a -> Word8 -> ByteString Source #

ListLike ByteString Word8 Source # 
Instance details

Methods

empty :: ByteString Source #

singleton :: Word8 -> ByteString Source #

cons :: Word8 -> ByteString -> ByteString Source #

snoc :: ByteString -> Word8 -> ByteString Source #

append :: ByteString -> ByteString -> ByteString Source #

head :: ByteString -> Word8 Source #

uncons :: ByteString -> Maybe (Word8, ByteString) Source #

last :: ByteString -> Word8 Source #

tail :: ByteString -> ByteString Source #

init :: ByteString -> ByteString Source #

null :: ByteString -> Bool Source #

length :: ByteString -> Int Source #

map :: ListLike full' item' => (Word8 -> item') -> ByteString -> full' Source #

rigidMap :: (Word8 -> Word8) -> ByteString -> ByteString Source #

reverse :: ByteString -> ByteString Source #

intersperse :: Word8 -> ByteString -> ByteString Source #

concat :: ListLike full' ByteString => full' -> ByteString Source #

concatMap :: ListLike full' item' => (Word8 -> full') -> ByteString -> full' Source #

rigidConcatMap :: (Word8 -> ByteString) -> ByteString -> ByteString Source #

any :: (Word8 -> Bool) -> ByteString -> Bool Source #

all :: (Word8 -> Bool) -> ByteString -> Bool Source #

maximum :: ByteString -> Word8 Source #

minimum :: ByteString -> Word8 Source #

replicate :: Int -> Word8 -> ByteString Source #

take :: Int -> ByteString -> ByteString Source #

drop :: Int -> ByteString -> ByteString Source #

splitAt :: Int -> ByteString -> (ByteString, ByteString) Source #

takeWhile :: (Word8 -> Bool) -> ByteString -> ByteString Source #

dropWhile :: (Word8 -> Bool) -> ByteString -> ByteString Source #

dropWhileEnd :: (Word8 -> Bool) -> ByteString -> ByteString Source #

span :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source #

break :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source #

group :: (ListLike full' ByteString, Eq Word8) => ByteString -> full' Source #

inits :: ListLike full' ByteString => ByteString -> full' Source #

tails :: ListLike full' ByteString => ByteString -> full' Source #

isPrefixOf :: ByteString -> ByteString -> Bool Source #

isSuffixOf :: ByteString -> ByteString -> Bool Source #

isInfixOf :: ByteString -> ByteString -> Bool Source #

stripPrefix :: ByteString -> ByteString -> Maybe ByteString Source #

stripSuffix :: ByteString -> ByteString -> Maybe ByteString Source #

elem :: Word8 -> ByteString -> Bool Source #

notElem :: Word8 -> ByteString -> Bool Source #

find :: (Word8 -> Bool) -> ByteString -> Maybe Word8 Source #

filter :: (Word8 -> Bool) -> ByteString -> ByteString Source #

partition :: (Word8 -> Bool) -> ByteString -> (ByteString, ByteString) Source #

index :: ByteString -> Int -> Word8 Source #

elemIndex :: Word8 -> ByteString -> Maybe Int Source #

elemIndices :: (Eq Word8, ListLike result Int) => Word8 -> ByteString -> result Source #

findIndex :: (Word8 -> Bool) -> ByteString -> Maybe Int Source #

findIndices :: ListLike result Int => (Word8 -> Bool) -> ByteString -> result Source #

sequence :: (Monad m, ListLike fullinp (m Word8)) => fullinp -> m ByteString Source #

mapM :: (Monad m, ListLike full' item') => (Word8 -> m item') -> ByteString -> m full' Source #

rigidMapM :: Monad m => (Word8 -> m Word8) -> ByteString -> m ByteString Source #

nub :: ByteString -> ByteString Source #

delete :: Word8 -> ByteString -> ByteString Source #

deleteFirsts :: ByteString -> ByteString -> ByteString Source #

union :: ByteString -> ByteString -> ByteString Source #

intersect :: ByteString -> ByteString -> ByteString Source #

sort :: ByteString -> ByteString Source #

insert :: Word8 -> ByteString -> ByteString Source #

toList' :: ByteString -> [Word8] Source #

fromList' :: [Word8] -> ByteString Source #

fromListLike :: ListLike full' Word8 => ByteString -> full' Source #

nubBy :: (Word8 -> Word8 -> Bool) -> ByteString -> ByteString Source #

deleteBy :: (Word8 -> Word8 -> Bool) -> Word8 -> ByteString -> ByteString Source #

deleteFirstsBy :: (Word8 -> Word8 -> Bool) -> ByteString -> ByteString -> ByteString Source #

unionBy :: (Word8 -> Word8 -> Bool) -> ByteString -> ByteString -> ByteString Source #

intersectBy :: (Word8 -> Word8 -> Bool) -> ByteString -> ByteString -> ByteString Source #

groupBy :: (ListLike full' ByteString, Eq Word8) => (Word8 -> Word8 -> Bool) -> ByteString -> full' Source #

sortBy :: (Word8 -> Word8 -> Ordering) -> ByteString -> ByteString Source #

insertBy :: (Word8 -> Word8 -> Ordering) -> Word8 -> ByteString -> ByteString Source #

genericLength :: Num a => ByteString -> a Source #

genericTake :: Integral a => a -> ByteString -> ByteString Source #

genericDrop :: Integral a => a -> ByteString -> ByteString Source #

genericSplitAt :: Integral a => a -> ByteString -> (ByteString, ByteString) Source #

genericReplicate :: Integral a => a -> Word8 -> ByteString Source #

ListLikeIO String Char Source # 
Instance details

ListLikeIO ByteString Word8 Source # 
Instance details

ListLikeIO ByteString Word8 Source # 
Instance details

StringLike (Seq Char) Source # 
Instance details

Methods

toString :: Seq Char -> String Source #

lines :: ListLike full (Seq Char) => Seq Char -> full Source #

words :: ListLike full (Seq Char) => Seq Char -> full Source #

unlines :: ListLike full (Seq Char) => full -> Seq Char Source #

unwords :: ListLike full (Seq Char) => full -> Seq Char Source #

show :: Show a => a -> Seq Char Source #

fromStringLike :: StringLike s' => Seq Char -> s' Source #

fromText :: Text -> Seq Char Source #

fromLazyText :: Text -> Seq Char Source #

FoldableLL (Seq a) a Source # 
Instance details

Methods

foldl :: (a0 -> a -> a0) -> a0 -> Seq a -> a0 Source #

foldl' :: (a0 -> a -> a0) -> a0 -> Seq a -> a0 Source #

foldl1 :: (a -> a -> a) -> Seq a -> a Source #

foldr :: (a -> b -> b) -> b -> Seq a -> b Source #

foldr' :: (a -> b -> b) -> b -> Seq a -> b Source #

foldr1 :: (a -> a -> a) -> Seq a -> a Source #

InfiniteListLike [a] a Source # 
Instance details

Methods

iterate :: (a -> a) -> a -> [a] Source #

repeat :: a -> [a] Source #

cycle :: [a] -> [a] Source #

ListLike (Seq a) a Source # 
Instance details

Methods

empty :: Seq a Source #

singleton :: a -> Seq a Source #

cons :: a -> Seq a -> Seq a Source #

snoc :: Seq a -> a -> Seq a Source #

append :: Seq a -> Seq a -> Seq a Source #

head :: Seq a -> a Source #

uncons :: Seq a -> Maybe (a, Seq a) Source #

last :: Seq a -> a Source #

tail :: Seq a -> Seq a Source #

init :: Seq a -> Seq a Source #

null :: Seq a -> Bool Source #

length :: Seq a -> Int Source #

map :: ListLike full' item' => (a -> item') -> Seq a -> full' Source #

rigidMap :: (a -> a) -> Seq a -> Seq a Source #

reverse :: Seq a -> Seq a Source #

intersperse :: a -> Seq a -> Seq a Source #

concat :: ListLike full' (Seq a) => full' -> Seq a Source #

concatMap :: ListLike full' item' => (a -> full') -> Seq a -> full' Source #

rigidConcatMap :: (a -> Seq a) -> Seq a -> Seq a Source #

any :: (a -> Bool) -> Seq a -> Bool Source #

all :: (a -> Bool) -> Seq a -> Bool Source #

maximum :: Seq a -> a Source #

minimum :: Seq a -> a Source #

replicate :: Int -> a -> Seq a Source #

take :: Int -> Seq a -> Seq a Source #

drop :: Int -> Seq a -> Seq a Source #

splitAt :: Int -> Seq a -> (Seq a, Seq a) Source #

takeWhile :: (a -> Bool) -> Seq a -> Seq a Source #

dropWhile :: (a -> Bool) -> Seq a -> Seq a Source #

dropWhileEnd :: (a -> Bool) -> Seq a -> Seq a Source #

span :: (a -> Bool) -> Seq a -> (Seq a, Seq a) Source #

break :: (a -> Bool) -> Seq a -> (Seq a, Seq a) Source #

group :: (ListLike full' (Seq a), Eq a) => Seq a -> full' Source #

inits :: ListLike full' (Seq a) => Seq a -> full' Source #

tails :: ListLike full' (Seq a) => Seq a -> full' Source #

isPrefixOf :: Seq a -> Seq a -> Bool Source #

isSuffixOf :: Seq a -> Seq a -> Bool Source #

isInfixOf :: Seq a -> Seq a -> Bool Source #

stripPrefix :: Seq a -> Seq a -> Maybe (Seq a) Source #

stripSuffix :: Seq a -> Seq a -> Maybe (Seq a) Source #

elem :: a -> Seq a -> Bool Source #

notElem :: a -> Seq a -> Bool Source #

find :: (a -> Bool) -> Seq a -> Maybe a Source #

filter :: (a -> Bool) -> Seq a -> Seq a Source #

partition :: (a -> Bool) -> Seq a -> (Seq a, Seq a) Source #

index :: Seq a -> Int -> a Source #

elemIndex :: a -> Seq a -> Maybe Int Source #

elemIndices :: (Eq a, ListLike result Int) => a -> Seq a -> result Source #

findIndex :: (a -> Bool) -> Seq a -> Maybe Int Source #

findIndices :: ListLike result Int => (a -> Bool) -> Seq a -> result Source #

sequence :: (Monad m, ListLike fullinp (m a)) => fullinp -> m (Seq a) Source #

mapM :: (Monad m, ListLike full' item') => (a -> m item') -> Seq a -> m full' Source #

rigidMapM :: Monad m => (a -> m a) -> Seq a -> m (Seq a) Source #

nub :: Seq a -> Seq a Source #

delete :: a -> Seq a -> Seq a Source #

deleteFirsts :: Seq a -> Seq a -> Seq a Source #

union :: Seq a -> Seq a -> Seq a Source #

intersect :: Seq a -> Seq a -> Seq a Source #

sort :: Seq a -> Seq a Source #

insert :: a -> Seq a -> Seq a Source #

toList' :: Seq a -> [a] Source #

fromList' :: [a] -> Seq a Source #

fromListLike :: ListLike full' a => Seq a -> full' Source #

nubBy :: (a -> a -> Bool) -> Seq a -> Seq a Source #

deleteBy :: (a -> a -> Bool) -> a -> Seq a -> Seq a Source #

deleteFirstsBy :: (a -> a -> Bool) -> Seq a -> Seq a -> Seq a Source #

unionBy :: (a -> a -> Bool) -> Seq a -> Seq a -> Seq a Source #

intersectBy :: (a -> a -> Bool) -> Seq a -> Seq a -> Seq a Source #

groupBy :: (ListLike full' (Seq a), Eq a) => (a -> a -> Bool) -> Seq a -> full' Source #

sortBy :: (a -> a -> Ordering) -> Seq a -> Seq a Source #

insertBy :: (a -> a -> Ordering) -> a -> Seq a -> Seq a Source #

genericLength :: Num a0 => Seq a -> a0 Source #

genericTake :: Integral a0 => a0 -> Seq a -> Seq a Source #

genericDrop :: Integral a0 => a0 -> Seq a -> Seq a Source #

genericSplitAt :: Integral a0 => a0 -> Seq a -> (Seq a, Seq a) Source #

genericReplicate :: Integral a0 => a0 -> a -> Seq a Source #

ListLikeIO (Seq Char) Char Source # 
Instance details

(Integral i, Ix i) => IsList (Array i e) Source # 
Instance details

Associated Types

type Item (Array i e) #

Methods

fromList :: [Item (Array i e)] -> Array i e #

fromListN :: Int -> [Item (Array i e)] -> Array i e #

toList :: Array i e -> [Item (Array i e)] #

(Integral i, Ix i) => IsString (Array i Char) Source # 
Instance details

Methods

fromString :: String -> Array i Char #

(Integral i, Ix i) => Semigroup (Array i e) Source # 
Instance details

Methods

(<>) :: Array i e -> Array i e -> Array i e #

sconcat :: NonEmpty (Array i e) -> Array i e #

stimes :: Integral b => b -> Array i e -> Array i e #

(Integral i, Ix i) => Monoid (Array i e) Source # 
Instance details

Methods

mempty :: Array i e #

mappend :: Array i e -> Array i e -> Array i e #

mconcat :: [Array i e] -> Array i e #

(Integral i, Ix i) => StringLike (Array i Char) Source # 
Instance details

Methods

toString :: Array i Char -> String Source #

lines :: ListLike full (Array i Char) => Array i Char -> full Source #

words :: ListLike full (Array i Char) => Array i Char -> full Source #

unlines :: ListLike full (Array i Char) => full -> Array i Char Source #

unwords :: ListLike full (Array i Char) => full -> Array i Char Source #

show :: Show a => a -> Array i Char Source #

fromStringLike :: StringLike s' => Array i Char -> s' Source #

fromText :: Text -> Array i Char Source #

fromLazyText :: Text -> Array i Char Source #

Ix i => FoldableLL (Array i e) e Source # 
Instance details

Methods

foldl :: (a -> e -> a) -> a -> Array i e -> a Source #

foldl' :: (a -> e -> a) -> a -> Array i e -> a Source #

foldl1 :: (e -> e -> e) -> Array i e -> e Source #

foldr :: (e -> b -> b) -> b -> Array i e -> b Source #

foldr' :: (e -> b -> b) -> b -> Array i e -> b Source #

foldr1 :: (e -> e -> e) -> Array i e -> e Source #

(Integral i, Ix i) => ListLike (Array i e) e Source # 
Instance details

Methods

empty :: Array i e Source #

singleton :: e -> Array i e Source #

cons :: e -> Array i e -> Array i e Source #

snoc :: Array i e -> e -> Array i e Source #

append :: Array i e -> Array i e -> Array i e Source #

head :: Array i e -> e Source #

uncons :: Array i e -> Maybe (e, Array i e) Source #

last :: Array i e -> e Source #

tail :: Array i e -> Array i e Source #

init :: Array i e -> Array i e Source #

null :: Array i e -> Bool Source #

length :: Array i e -> Int Source #

map :: ListLike full' item' => (e -> item') -> Array i e -> full' Source #

rigidMap :: (e -> e) -> Array i e -> Array i e Source #

reverse :: Array i e -> Array i e Source #

intersperse :: e -> Array i e -> Array i e Source #

concat :: ListLike full' (Array i e) => full' -> Array i e Source #

concatMap :: ListLike full' item' => (e -> full') -> Array i e -> full' Source #

rigidConcatMap :: (e -> Array i e) -> Array i e -> Array i e Source #

any :: (e -> Bool) -> Array i e -> Bool Source #

all :: (e -> Bool) -> Array i e -> Bool Source #

maximum :: Array i e -> e Source #

minimum :: Array i e -> e Source #

replicate :: Int -> e -> Array i e Source #

take :: Int -> Array i e -> Array i e Source #

drop :: Int -> Array i e -> Array i e Source #

splitAt :: Int -> Array i e -> (Array i e, Array i e) Source #

takeWhile :: (e -> Bool) -> Array i e -> Array i e Source #

dropWhile :: (e -> Bool) -> Array i e -> Array i e Source #

dropWhileEnd :: (e -> Bool) -> Array i e -> Array i e Source #

span :: (e -> Bool) -> Array i e -> (Array i e, Array i e) Source #

break :: (e -> Bool) -> Array i e -> (Array i e, Array i e) Source #

group :: (ListLike full' (Array i e), Eq e) => Array i e -> full' Source #

inits :: ListLike full' (Array i e) => Array i e -> full' Source #

tails :: ListLike full' (Array i e) => Array i e -> full' Source #

isPrefixOf :: Array i e -> Array i e -> Bool Source #

isSuffixOf :: Array i e -> Array i e -> Bool Source #

isInfixOf :: Array i e -> Array i e -> Bool Source #

stripPrefix :: Array i e -> Array i e -> Maybe (Array i e) Source #

stripSuffix :: Array i e -> Array i e -> Maybe (Array i e) Source #

elem :: e -> Array i e -> Bool Source #

notElem :: e -> Array i e -> Bool Source #

find :: (e -> Bool) -> Array i e -> Maybe e Source #

filter :: (e -> Bool) -> Array i e -> Array i e Source #

partition :: (e -> Bool) -> Array i e -> (Array i e, Array i e) Source #

index :: Array i e -> Int -> e Source #

elemIndex :: e -> Array i e -> Maybe Int Source #

elemIndices :: (Eq e, ListLike result Int) => e -> Array i e -> result Source #

findIndex :: (e -> Bool) -> Array i e -> Maybe Int Source #

findIndices :: ListLike result Int => (e -> Bool) -> Array i e -> result Source #

sequence :: (Monad m, ListLike fullinp (m e)) => fullinp -> m (Array i e) Source #

mapM :: (Monad m, ListLike full' item') => (e -> m item') -> Array i e -> m full' Source #

rigidMapM :: Monad m => (e -> m e) -> Array i e -> m (Array i e) Source #

nub :: Array i e -> Array i e Source #

delete :: e -> Array i e -> Array i e Source #

deleteFirsts :: Array i e -> Array i e -> Array i e Source #

union :: Array i e -> Array i e -> Array i e Source #

intersect :: Array i e -> Array i e -> Array i e Source #

sort :: Array i e -> Array i e Source #

insert :: e -> Array i e -> Array i e Source #

toList' :: Array i e -> [e] Source #

fromList' :: [e] -> Array i e Source #

fromListLike :: ListLike full' e => Array i e -> full' Source #

nubBy :: (e -> e -> Bool) -> Array i e -> Array i e Source #

deleteBy :: (e -> e -> Bool) -> e -> Array i e -> Array i e Source #

deleteFirstsBy :: (e -> e -> Bool) -> Array i e -> Array i e -> Array i e Source #

unionBy :: (e -> e -> Bool) -> Array i e -> Array i e -> Array i e Source #

intersectBy :: (e -> e -> Bool) -> Array i e -> Array i e -> Array i e Source #

groupBy :: (ListLike full' (Array i e), Eq e) => (e -> e -> Bool) -> Array i e -> full' Source #

sortBy :: (e -> e -> Ordering) -> Array i e -> Array i e Source #

insertBy :: (e -> e -> Ordering) -> e -> Array i e -> Array i e Source #

genericLength :: Num a => Array i e -> a Source #

genericTake :: Integral a => a -> Array i e -> Array i e Source #

genericDrop :: Integral a => a -> Array i e -> Array i e Source #

genericSplitAt :: Integral a => a -> Array i e -> (Array i e, Array i e) Source #

genericReplicate :: Integral a => a -> e -> Array i e Source #

(Integral i, Ix i) => ListLikeIO (Array i Char) Char Source # 
Instance details