ListLike-4.7.8.2: Generalized support for list-like structures

Copyright | Copyright (C) 2007 John Goerzen
License | BSD3
Maintainer | David Fox <dsf@seereason.com>, Andreas Abel
Stability | stable
Portability | portable
Safe Haskell | Safe-Inferred
Language | Haskell2010

Data.ListLike.Instances

Contents

- Orphan instances

Description

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

Written by John Goerzen, jgoerzen@complete.org

# Orphan instances

StringLike String # |

Instance details

Methods

toString :: String -> String #

lines :: ListLike full String => String -> full #

words :: ListLike full String => String -> full #

unlines :: ListLike full String => full -> String #

unwords :: ListLike full String => full -> String #

show :: Show a => a -> String #

fromStringLike :: StringLike s' => String -> s' #

fromText :: Text -> String #

fromLazyText :: Text -> String #

ListLike ByteString Word8 # |

Instance details

Methods

empty :: ByteString #

singleton :: Word8 -> ByteString #

cons :: Word8 -> ByteString -> ByteString #

snoc :: ByteString -> Word8 -> ByteString #

append :: ByteString -> ByteString -> ByteString #

head :: ByteString -> Word8 #

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

last :: ByteString -> Word8 #

tail :: ByteString -> ByteString #

init :: ByteString -> ByteString #

null :: ByteString -> Bool #

length :: ByteString -> Int #

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

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

reverse :: ByteString -> ByteString #

intersperse :: Word8 -> ByteString -> ByteString #

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

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

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

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

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

maximum :: ByteString -> Word8 #

minimum :: ByteString -> Word8 #

replicate :: Int -> Word8 -> ByteString #

take :: Int -> ByteString -> ByteString #

drop :: Int -> ByteString -> ByteString #

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

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

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

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

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

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

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

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

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

isPrefixOf :: ByteString -> ByteString -> Bool #

isSuffixOf :: ByteString -> ByteString -> Bool #

isInfixOf :: ByteString -> ByteString -> Bool #

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

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

elem :: Word8 -> ByteString -> Bool #

notElem :: Word8 -> ByteString -> Bool #

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

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

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

index :: ByteString -> Int -> Word8 #

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

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

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

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

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

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

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

nub :: ByteString -> ByteString #

delete :: Word8 -> ByteString -> ByteString #

deleteFirsts :: ByteString -> ByteString -> ByteString #

union :: ByteString -> ByteString -> ByteString #

intersect :: ByteString -> ByteString -> ByteString #

sort :: ByteString -> ByteString #

insert :: Word8 -> ByteString -> ByteString #

toList' :: ByteString -> [Word8] #

fromList' :: [Word8] -> ByteString #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ListLike ByteString Word8 # |

Instance details

Methods

empty :: ByteString #

singleton :: Word8 -> ByteString #

cons :: Word8 -> ByteString -> ByteString #

snoc :: ByteString -> Word8 -> ByteString #

append :: ByteString -> ByteString -> ByteString #

head :: ByteString -> Word8 #

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

last :: ByteString -> Word8 #

tail :: ByteString -> ByteString #

init :: ByteString -> ByteString #

null :: ByteString -> Bool #

length :: ByteString -> Int #

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

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

reverse :: ByteString -> ByteString #

intersperse :: Word8 -> ByteString -> ByteString #

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

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

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

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

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

maximum :: ByteString -> Word8 #

minimum :: ByteString -> Word8 #

replicate :: Int -> Word8 -> ByteString #

take :: Int -> ByteString -> ByteString #

drop :: Int -> ByteString -> ByteString #

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

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

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

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

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

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

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

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

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

isPrefixOf :: ByteString -> ByteString -> Bool #

isSuffixOf :: ByteString -> ByteString -> Bool #

isInfixOf :: ByteString -> ByteString -> Bool #

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

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

elem :: Word8 -> ByteString -> Bool #

notElem :: Word8 -> ByteString -> Bool #

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

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

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

index :: ByteString -> Int -> Word8 #

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

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

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

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

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

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

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

nub :: ByteString -> ByteString #

delete :: Word8 -> ByteString -> ByteString #

deleteFirsts :: ByteString -> ByteString -> ByteString #

union :: ByteString -> ByteString -> ByteString #

intersect :: ByteString -> ByteString -> ByteString #

sort :: ByteString -> ByteString #

insert :: Word8 -> ByteString -> ByteString #

toList' :: ByteString -> [Word8] #

fromList' :: [Word8] -> ByteString #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

FoldableLL ByteString Word8 # |
Instance details Methods foldl :: (a -> Word8 -> a) -> a -> ByteString -> a # foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a # foldl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 # foldr :: (Word8 -> b -> b) -> b -> ByteString -> b # foldr' :: (Word8 -> b -> b) -> b -> ByteString -> b # foldr1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 #
FoldableLL ByteString Word8 # |
Instance details Methods foldl :: (a -> Word8 -> a) -> a -> ByteString -> a # foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a # foldl1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 # foldr :: (Word8 -> b -> b) -> b -> ByteString -> b # foldr' :: (Word8 -> b -> b) -> b -> ByteString -> b # foldr1 :: (Word8 -> Word8 -> Word8) -> ByteString -> Word8 #
ListLikeIO ByteString Word8 # |

Instance details

Methods

hGetLine :: Handle -> IO ByteString #

hGetContents :: Handle -> IO ByteString #

hGet :: Handle -> Int -> IO ByteString #

hGetNonBlocking :: Handle -> Int -> IO ByteString #

hPutStr :: Handle -> ByteString -> IO () #

hPutStrLn :: Handle -> ByteString -> IO () #

getLine :: IO ByteString #

getContents :: IO ByteString #

putStr :: ByteString -> IO () #

putStrLn :: ByteString -> IO () #

interact :: (ByteString -> ByteString) -> IO () #

readFile :: FilePath -> IO ByteString #

writeFile :: FilePath -> ByteString -> IO () #

appendFile :: FilePath -> ByteString -> IO () #

ListLikeIO ByteString Word8 # |

Instance details

Methods

hGetLine :: Handle -> IO ByteString #

hGetContents :: Handle -> IO ByteString #

hGet :: Handle -> Int -> IO ByteString #

hGetNonBlocking :: Handle -> Int -> IO ByteString #

hPutStr :: Handle -> ByteString -> IO () #

hPutStrLn :: Handle -> ByteString -> IO () #

getLine :: IO ByteString #

getContents :: IO ByteString #

putStr :: ByteString -> IO () #

putStrLn :: ByteString -> IO () #

interact :: (ByteString -> ByteString) -> IO () #

readFile :: FilePath -> IO ByteString #

writeFile :: FilePath -> ByteString -> IO () #

appendFile :: FilePath -> ByteString -> IO () #

ListLikeIO String Char # |

Instance details

Methods

hGetLine :: Handle -> IO String #

hGetContents :: Handle -> IO String #

hGet :: Handle -> Int -> IO String #

hGetNonBlocking :: Handle -> Int -> IO String #

hPutStr :: Handle -> String -> IO () #

hPutStrLn :: Handle -> String -> IO () #

getLine :: IO String #

getContents :: IO String #

putStr :: String -> IO () #

putStrLn :: String -> IO () #

interact :: (String -> String) -> IO () #

readFile :: FilePath -> IO String #

writeFile :: FilePath -> String -> IO () #

appendFile :: FilePath -> String -> IO () #

StringLike (Seq Char) # |

Instance details

Methods

toString :: Seq Char -> String #

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

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

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

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

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

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

fromText :: Text -> Seq Char #

fromLazyText :: Text -> Seq Char #

InfiniteListLike [a] a # |
Instance details Methods iterate :: (a -> a) -> a -> [a] # repeat :: a -> [a] # cycle :: [a] -> [a] #
ListLike (Seq a) a # |

Instance details

Methods

empty :: Seq a #

singleton :: a -> Seq a #

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

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

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

head :: Seq a -> a #

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

last :: Seq a -> a #

tail :: Seq a -> Seq a #

init :: Seq a -> Seq a #

null :: Seq a -> Bool #

length :: Seq a -> Int #

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

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

reverse :: Seq a -> Seq a #

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

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

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

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

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

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

maximum :: Seq a -> a #

minimum :: Seq a -> a #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

nub :: Seq a -> Seq a #

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

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

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

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

sort :: Seq a -> Seq a #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

FoldableLL (Seq a) a # |
Instance details Methods foldl :: (a0 -> a -> a0) -> a0 -> Seq a -> a0 # foldl' :: (a0 -> a -> a0) -> a0 -> Seq a -> a0 # foldl1 :: (a -> a -> a) -> Seq a -> a # foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b # foldr1 :: (a -> a -> a) -> Seq a -> a #
ListLikeIO (Seq Char) Char # |

Instance details

Methods

hGetLine :: Handle -> IO (Seq Char) #

hGetContents :: Handle -> IO (Seq Char) #

hGet :: Handle -> Int -> IO (Seq Char) #

hGetNonBlocking :: Handle -> Int -> IO (Seq Char) #

hPutStr :: Handle -> Seq Char -> IO () #

hPutStrLn :: Handle -> Seq Char -> IO () #

getLine :: IO (Seq Char) #

getContents :: IO (Seq Char) #

putStr :: Seq Char -> IO () #

putStrLn :: Seq Char -> IO () #

interact :: (Seq Char -> Seq Char) -> IO () #

readFile :: FilePath -> IO (Seq Char) #

writeFile :: FilePath -> Seq Char -> IO () #

appendFile :: FilePath -> Seq Char -> IO () #

(Integral i, Ix i) => StringLike (Array i Char) # |

Instance details

Methods

toString :: Array i Char -> String #

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

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

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

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

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

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

fromText :: Text -> Array i Char #

fromLazyText :: Text -> Array i Char #

(Integral i, Ix i) => IsString (Array i Char) # |
Instance details Methods fromString :: String -> Array i Char #
(Integral i, Ix i) => Monoid (Array i e) # |
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) => Semigroup (Array i e) # |
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) => IsList (Array i e) # |
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) => ListLike (Array i e) e # |

Instance details

Methods

empty :: Array i e #

singleton :: e -> Array i e #

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

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

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

head :: Array i e -> e #

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

last :: Array i e -> e #

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

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

null :: Array i e -> Bool #

length :: Array i e -> Int #

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

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

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

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

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

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

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

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

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

maximum :: Array i e -> e #

minimum :: Array i e -> e #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ix i => FoldableLL (Array i e) e # |
Instance details Methods foldl :: (a -> e -> a) -> a -> Array i e -> a # foldl' :: (a -> e -> a) -> a -> Array i e -> a # foldl1 :: (e -> e -> e) -> Array i e -> e # foldr :: (e -> b -> b) -> b -> Array i e -> b # foldr' :: (e -> b -> b) -> b -> Array i e -> b # foldr1 :: (e -> e -> e) -> Array i e -> e #
(Integral i, Ix i) => ListLikeIO (Array i Char) Char # |

Instance details

Methods

hGetLine :: Handle -> IO (Array i Char) #

hGetContents :: Handle -> IO (Array i Char) #

hGet :: Handle -> Int -> IO (Array i Char) #

hGetNonBlocking :: Handle -> Int -> IO (Array i Char) #

hPutStr :: Handle -> Array i Char -> IO () #

hPutStrLn :: Handle -> Array i Char -> IO () #

getLine :: IO (Array i Char) #

getContents :: IO (Array i Char) #

putStr :: Array i Char -> IO () #

putStrLn :: Array i Char -> IO () #

interact :: (Array i Char -> Array i Char) -> IO () #

readFile :: FilePath -> IO (Array i Char) #

writeFile :: FilePath -> Array i Char -> IO () #

appendFile :: FilePath -> Array i Char -> IO () #