Data.ListLike

Generic operations over list-like structures

Written by John Goerzen, [e-mail]

Please start with the introduction at Data.ListLike.

Introduction

Welcome to ListLike.

This module provides abstractions over typical list operations. It is designed to let you freely interchange different ways to represent sequences of data. It works with lists, various types of ByteStrings, and much more.

In this module, you'll find generic versions of most of the functions you're used to using in the Prelude, Data.List, and System.IO. They carry the same names, too. Therefore, you'll want to be careful how you import the module. I suggest using:

import qualified Data.ListLike as LL

Then, you can use LL.fold, LL.map, etc. to get the generic version of the functions you want. Alternatively, you can hide the other versions from Prelude and import specific generic functions from here, such as:

import Prelude hiding (map)
import Data.ListLike (map)

The module Data.ListLike actually simply re-exports the items found in a number of its sub-modules. If you want a smaller subset of Data.ListLike, look at the documentation for its sub-modules and import the relevant one.

In most cases, functions here can act as drop-in replacements for their list-specific counterparts. They will use the same underlying implementations for lists, so there should be no performance difference.

You can make your own types instances of ListLike as well. For more details, see the notes for the ListLike typeclass.

Creation & Basic Functions

empty :: ListLike full item => full

The empty list

singleton :: ListLike full item => item -> full

Creates a single-element list out of an element

cons :: ListLike full item => item -> full -> full

Like (:) for lists: adds an element to the beginning of a list

snoc :: ListLike full item => full -> item -> full

Adds an element to the *end* of a ListLike.

append :: ListLike full item => full -> full -> full

Combines two lists. Like (++).

uncons :: ListLike full item => full -> Maybe (item, full)

Extract head and tail, return Nothing if empty

head :: ListLike full item => full -> item

Extracts the first element of a ListLike.

last :: ListLike full item => full -> item

Extracts the last element of a ListLike.

tail :: ListLike full item => full -> full

Gives all elements after the head.

init :: ListLike full item => full -> full

All elements of the list except the last one. See also inits.

null :: ListLike full item => full -> Bool

Tests whether the list is empty.

length :: ListLike full item => full -> Int

Length of the list. See also genericLength.

List transformations

map :: (ListLike full item, ListLike full' item') => (item -> item') -> full -> full'

Apply a function to each element, returning any other valid ListLike. rigidMap will always be at least as fast, if not faster, than this function and is recommended if it will work for your purposes. See also mapM.

rigidMap :: ListLike full item => (item -> item) -> full -> full

Like map, but without the possibility of changing the type of the item. This can have performance benefits for things such as ByteStrings, since it will let the ByteString use its native low-level map implementation.

reverse :: ListLike full item => full -> full

Reverse the elements in a list.

intersperse :: ListLike full item => item -> full -> full

Add an item between each element in the structure

Conversions

toList :: IsList l => l -> [Item l]

The toList function extracts a list of Item l from the structure l. It should satisfy fromList . toList = id.

fromList :: IsList l => [Item l] -> l

The fromList function constructs the structure l from the given list of Item l

fromListLike :: (ListLike full item, ListLike full' item) => full -> full'

Converts one ListLike to another. See also toList'. Default implementation is fromListLike = map id

Reducing lists (folds), from FoldableLL

foldl :: FoldableLL full item => (a -> item -> a) -> a -> full -> a

Left-associative fold

foldl' :: FoldableLL full item => (a -> item -> a) -> a -> full -> a

Strict version of foldl.

foldl1 :: FoldableLL full item => (item -> item -> item) -> full -> item

A variant of foldl with no base case. Requires at least 1 list element.

foldr :: FoldableLL full item => (item -> b -> b) -> b -> full -> b

Right-associative fold

foldr' :: FoldableLL full item => (item -> b -> b) -> b -> full -> b

Strict version of foldr

foldr1 :: FoldableLL full item => (item -> item -> item) -> full -> item

Like foldr, but with no starting value

Special folds

concat :: (ListLike full item, ListLike full' full) => full' -> full

Flatten the structure.

concatMap :: (ListLike full item, ListLike full' item') => (item -> full') -> full -> full'

Map a function over the items and concatenate the results. See also rigidConcatMap.

rigidConcatMap :: ListLike full item => (item -> full) -> full -> full

Like concatMap, but without the possibility of changing the type of the item. This can have performance benefits for some things such as ByteString.

and :: ListLike full Bool => full -> Bool

Returns True if all elements are True

or :: ListLike full Bool => full -> Bool

Returns True if any element is True

any :: ListLike full item => (item -> Bool) -> full -> Bool

True if any items satisfy the function

all :: ListLike full item => (item -> Bool) -> full -> Bool

True if all items satisfy the function

sum :: (Num a, ListLike full a) => full -> a

The sum of the list

product :: (Num a, ListLike full a) => full -> a

The product of the list

maximum :: (ListLike full item, Ord item) => full -> item

The maximum value of the list

minimum :: (ListLike full item, Ord item) => full -> item

The minimum value of the list

fold :: (FoldableLL full item, Monoid item) => full -> item

Combine the elements of a structure using a monoid. fold = foldMap id

foldMap :: (FoldableLL full item, Monoid m) => (item -> m) -> full -> m

Map each element to a monoid, then combine the results

Building lists

Scans

Accumulating maps

Infinite lists

iterate :: InfiniteListLike full item => (item -> item) -> item -> full

An infinite list of repeated calls of the function to args

repeat :: InfiniteListLike full item => item -> full

An infinite list where each element is the same

replicate :: ListLike full item => Int -> item -> full

Generate a structure with the specified length with every element set to the item passed in. See also genericReplicate

cycle :: InfiniteListLike full item => full -> full

Converts a finite list into a circular one

Unfolding

Sublists

Extracting sublists

take :: ListLike full item => Int -> full -> full

Takes the first n elements of the list. See also genericTake.

drop :: ListLike full item => Int -> full -> full

Drops the first n elements of the list. See also genericDrop

splitAt :: ListLike full item => Int -> full -> (full, full)

Equivalent to (take n xs, drop n xs). See also genericSplitAt.

takeWhile :: ListLike full item => (item -> Bool) -> full -> full

Returns all elements at start of list that satisfy the function.

dropWhile :: ListLike full item => (item -> Bool) -> full -> full

Drops all elements from the start of the list that satisfy the function.

dropWhileEnd :: ListLike full item => (item -> Bool) -> full -> full

Drops all elements from the end of the list that satisfy the function.

span :: ListLike full item => (item -> Bool) -> full -> (full, full)

The equivalent of (takeWhile f xs, dropWhile f xs)

break :: ListLike full item => (item -> Bool) -> full -> (full, full)

The equivalent of span (not . f)

group :: (ListLike full item, ListLike full' full, Eq item) => full -> full'

Split a list into sublists, each which contains equal arguments. For order-preserving types, concatenating these sublists will produce the original list. See also groupBy.

inits :: (ListLike full item, ListLike full' full) => full -> full'

All initial segments of the list, shortest first

tails :: (ListLike full item, ListLike full' full) => full -> full'

All final segnemts, longest first

Predicates

isPrefixOf :: (ListLike full item, Eq item) => full -> full -> Bool

True when the first list is at the beginning of the second.

isSuffixOf :: (ListLike full item, Eq item) => full -> full -> Bool

True when the first list is at the beginning of the second.

isInfixOf :: (ListLike full item, Eq item) => full -> full -> Bool

True when the first list is wholly containted within the second

Modify based on predicate

stripPrefix :: (ListLike full item, Eq item) => full -> full -> Maybe full

Remove a prefix from a listlike if possible

stripSuffix :: (ListLike full item, Eq item) => full -> full -> Maybe full

Remove a suffix from a listlike if possible

Searching lists

Searching by equality

elem :: (ListLike full item, Eq item) => item -> full -> Bool

True if the item occurs in the list

notElem :: (ListLike full item, Eq item) => item -> full -> Bool

True if the item does not occur in the list

Searching with a predicate

find :: ListLike full item => (item -> Bool) -> full -> Maybe item

Take a function and return the first matching element, or Nothing if there is no such element.

filter :: ListLike full item => (item -> Bool) -> full -> full

Returns only the elements that satisfy the function.

partition :: ListLike full item => (item -> Bool) -> full -> (full, full)

Returns the lists that do and do not satisfy the function. Same as (filter p xs, filter (not . p) xs)

Indexing lists

index :: ListLike full item => full -> Int -> item

The element at 0-based index i. Raises an exception if i is out of bounds. Like (!!) for lists.

elemIndex :: (ListLike full item, Eq item) => item -> full -> Maybe Int

Returns the index of the element, if it exists.

elemIndices :: (ListLike full item, Eq item, ListLike result Int) => item -> full -> result

Returns the indices of the matching elements. See also findIndices

findIndex :: ListLike full item => (item -> Bool) -> full -> Maybe Int

Take a function and return the index of the first matching element, or Nothing if no element matches

findIndices :: (ListLike full item, ListLike result Int) => (item -> Bool) -> full -> result

Returns the indices of all elements satisfying the function

Zipping and unzipping lists

zip :: (ListLike full item, ListLike fullb itemb, ListLike result (item, itemb)) => full -> fullb -> result

Takes two lists and returns a list of corresponding pairs.

zipWith :: (ListLike full item, ListLike fullb itemb, ListLike result resultitem) => (item -> itemb -> resultitem) -> full -> fullb -> result

Takes two lists and combines them with a custom combining function

unzip :: (ListLike full (itema, itemb), ListLike ra itema, ListLike rb itemb) => full -> (ra, rb)

Converts a list of pairs into two separate lists of elements

Monadic Operations

sequence :: (ListLike full item, Monad m, ListLike fullinp (m item)) => fullinp -> m full

Evaluate each action in the sequence and collect the results

sequence_ :: (Monad m, FoldableLL full (m item)) => full -> m ()

Evaluate each action, ignoring the results. Same as mapM_ id.

mapM :: (ListLike full item, Monad m, ListLike full' item') => (item -> m item') -> full -> m full'

A map in monad space. Same as sequence . map

See also rigidMapM

rigidMapM :: (ListLike full item, Monad m) => (item -> m item) -> full -> m full

Like mapM, but without the possibility of changing the type of the item. This can have performance benefits with some types.

mapM_ :: (Monad m, FoldableLL full item) => (item -> m b) -> full -> m ()

A map in monad space, discarding results.

Input and Output

class ListLike full item => ListLikeIO full item | full -> item where

An extension to ListLike for those data types that support I/O. These functions mirror those in System.IO for the most part. They also share the same names; see the comments in Data.ListLike for help importing them.

Note that some types may not be capable of lazy reading or writing. Therefore, the usual semantics of System.IO functions regarding laziness may or may not be available from a particular implementation.

Minimal complete definition:

• hGetLine
• hGetContents
• hGet
• hGetNonBlocking
• hPutStr

Minimal complete definition

hGetLine, hGetContents, hGet, hGetNonBlocking, hPutStr

Methods

hGetLine :: Handle -> IO full

Reads a line from the specified handle

hGetContents :: Handle -> IO full

Read entire handle contents. May be done lazily like hGetContents.

hGet :: Handle -> Int -> IO full

Read specified number of bytes. See hGet for particular semantics.

hGetNonBlocking :: Handle -> Int -> IO full

Non-blocking read. See hGetNonBlocking for more.

hPutStr :: Handle -> full -> IO ()

Writing entire data.

hPutStrLn :: Handle -> full -> IO ()

Write data plus newline character.

getLine :: IO full

Read one line

getContents :: IO full

Read entire content from stdin. See hGetContents.

putStr :: full -> IO ()

Write data to stdout.

putStrLn :: full -> IO ()

Write data plus newline character to stdout.

interact :: (full -> full) -> IO ()

Interact with stdin and stdout by using a function to transform input to output. May be lazy. See interact for more.

readFile :: FilePath -> IO full

Read file. May be lazy.

writeFile :: FilePath -> full -> IO ()

Write data to file.

appendFile :: FilePath -> full -> IO ()

Append data to file.

Instances

ListLikeIO String Char

Defined in Data.ListLike.Instances

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 ()

ListLikeIO ByteString Word8

Defined in Data.ListLike.Instances

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

Defined in Data.ListLike.Instances

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 Builder Char

Defined in Data.ListLike.Text.Builder

Methods

hGetLine :: Handle -> IO Builder

hGetContents :: Handle -> IO Builder

hGet :: Handle -> Int -> IO Builder

hGetNonBlocking :: Handle -> Int -> IO Builder

hPutStr :: Handle -> Builder -> IO ()

hPutStrLn :: Handle -> Builder -> IO ()

getLine :: IO Builder

getContents :: IO Builder

putStr :: Builder -> IO ()

putStrLn :: Builder -> IO ()

interact :: (Builder -> Builder) -> IO ()

readFile :: FilePath -> IO Builder

writeFile :: FilePath -> Builder -> IO ()

appendFile :: FilePath -> Builder -> IO ()

ListLikeIO Text Char

Defined in Data.ListLike.Text.TextLazy

Methods

hGetLine :: Handle -> IO Text

hGetContents :: Handle -> IO Text

hGet :: Handle -> Int -> IO Text

hGetNonBlocking :: Handle -> Int -> IO Text

hPutStr :: Handle -> Text -> IO ()

hPutStrLn :: Handle -> Text -> IO ()

getLine :: IO Text

getContents :: IO Text

putStr :: Text -> IO ()

putStrLn :: Text -> IO ()

interact :: (Text -> Text) -> IO ()

readFile :: FilePath -> IO Text

writeFile :: FilePath -> Text -> IO ()

appendFile :: FilePath -> Text -> IO ()

ListLikeIO Text Char

Defined in Data.ListLike.Text.Text

Methods

hGetLine :: Handle -> IO Text

hGetContents :: Handle -> IO Text

hGet :: Handle -> Int -> IO Text

hGetNonBlocking :: Handle -> Int -> IO Text

hPutStr :: Handle -> Text -> IO ()

hPutStrLn :: Handle -> Text -> IO ()

getLine :: IO Text

getContents :: IO Text

putStr :: Text -> IO ()

putStrLn :: Text -> IO ()

interact :: (Text -> Text) -> IO ()

readFile :: FilePath -> IO Text

writeFile :: FilePath -> Text -> IO ()

appendFile :: FilePath -> Text -> IO ()

ListLikeIO CharStringLazy Char

Defined in Data.ListLike.CharString

Methods

hGetLine :: Handle -> IO CharStringLazy

hGetContents :: Handle -> IO CharStringLazy

hGet :: Handle -> Int -> IO CharStringLazy

hGetNonBlocking :: Handle -> Int -> IO CharStringLazy

hPutStr :: Handle -> CharStringLazy -> IO ()

hPutStrLn :: Handle -> CharStringLazy -> IO ()

getLine :: IO CharStringLazy

getContents :: IO CharStringLazy

putStr :: CharStringLazy -> IO ()

putStrLn :: CharStringLazy -> IO ()

interact :: (CharStringLazy -> CharStringLazy) -> IO ()

readFile :: FilePath -> IO CharStringLazy

writeFile :: FilePath -> CharStringLazy -> IO ()

appendFile :: FilePath -> CharStringLazy -> IO ()

ListLikeIO CharString Char

Defined in Data.ListLike.CharString

Methods

hGetLine :: Handle -> IO CharString

hGetContents :: Handle -> IO CharString

hGet :: Handle -> Int -> IO CharString

hGetNonBlocking :: Handle -> Int -> IO CharString

hPutStr :: Handle -> CharString -> IO ()

hPutStrLn :: Handle -> CharString -> IO ()

getLine :: IO CharString

getContents :: IO CharString

putStr :: CharString -> IO ()

putStrLn :: CharString -> IO ()

interact :: (CharString -> CharString) -> IO ()

readFile :: FilePath -> IO CharString

writeFile :: FilePath -> CharString -> IO ()

appendFile :: FilePath -> CharString -> IO ()

ListLikeIO Chars Char

Defined in Data.ListLike.Chars

Methods

hGetLine :: Handle -> IO Chars

hGetContents :: Handle -> IO Chars

hGet :: Handle -> Int -> IO Chars

hGetNonBlocking :: Handle -> Int -> IO Chars

hPutStr :: Handle -> Chars -> IO ()

hPutStrLn :: Handle -> Chars -> IO ()

getLine :: IO Chars

getContents :: IO Chars

putStr :: Chars -> IO ()

putStrLn :: Chars -> IO ()

interact :: (Chars -> Chars) -> IO ()

readFile :: FilePath -> IO Chars

writeFile :: FilePath -> Chars -> IO ()

appendFile :: FilePath -> Chars -> IO ()

ListLikeIO (Seq Char) Char

Defined in Data.ListLike.Instances

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 ()

ListLikeIO (UTF8 ByteString) Char

Defined in Data.ListLike.UTF8

Methods

hGetLine :: Handle -> IO (UTF8 ByteString)

hGetContents :: Handle -> IO (UTF8 ByteString)

hGet :: Handle -> Int -> IO (UTF8 ByteString)

hGetNonBlocking :: Handle -> Int -> IO (UTF8 ByteString)

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

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

getLine :: IO (UTF8 ByteString)

getContents :: IO (UTF8 ByteString)

putStr :: UTF8 ByteString -> IO ()

putStrLn :: UTF8 ByteString -> IO ()

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

readFile :: FilePath -> IO (UTF8 ByteString)

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

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

ListLikeIO (UTF8 ByteString) Char

Defined in Data.ListLike.UTF8

Methods

hGetLine :: Handle -> IO (UTF8 ByteString)

hGetContents :: Handle -> IO (UTF8 ByteString)

hGet :: Handle -> Int -> IO (UTF8 ByteString)

hGetNonBlocking :: Handle -> Int -> IO (UTF8 ByteString)

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

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

getLine :: IO (UTF8 ByteString)

getContents :: IO (UTF8 ByteString)

putStr :: UTF8 ByteString -> IO ()

putStrLn :: UTF8 ByteString -> IO ()

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

readFile :: FilePath -> IO (UTF8 ByteString)

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

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

(Integral i, Ix i) => ListLikeIO (Array i Char) Char

Defined in Data.ListLike.Instances

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 ()

Special lists

Strings

toString :: StringLike s => s -> String

Converts the structure to a String

fromString :: IsString a => String -> a

lines :: (StringLike s, ListLike full s) => s -> full

Breaks a string into a list of strings

words :: (StringLike s, ListLike full s) => s -> full

Breaks a string into a list of words

show :: (StringLike s, Show a) => a -> s

Generalize the Show method t return any StringLike.

fromStringLike :: (StringLike s, StringLike s') => s -> s'

Deprecated: Use fromString . toString or something more efficient using local knowledge

fromText :: (StringLike s, StringLike Text) => Text -> s

Override this to avoid extra String conversions.

fromLazyText :: (StringLike s, StringLike Text) => Text -> s

Override this to avoid extra String conversions.

"Set" operations

nub :: (ListLike full item, Eq item) => full -> full

Removes duplicate elements from the list. See also nubBy

delete :: (ListLike full item, Eq item) => item -> full -> full

Removes the first instance of the element from the list. See also deleteBy

deleteFirsts :: (ListLike full item, Eq item) => full -> full -> full

List difference. Removes from the first list the first instance of each element of the second list. See (\\) and deleteFirstsBy

union :: (ListLike full item, Eq item) => full -> full -> full

List union: the set of elements that occur in either list. Duplicate elements in the first list will remain duplicate. See also unionBy.

intersect :: (ListLike full item, Eq item) => full -> full -> full

List intersection: the set of elements that occur in both lists. See also intersectBy

Ordered lists

sort :: (ListLike full item, Ord item) => full -> full

Sorts the list. On data types that do not preserve ordering, or enforce their own ordering, the result may not be what you expect. See also sortBy.

insert :: (ListLike full item, Ord item) => item -> full -> full

Inserts the element at the last place where it is still less than or equal to the next element. On data types that do not preserve ordering, or enforce their own ordering, the result may not be what you expect. On types such as maps, this may result in changing an existing item. See also insertBy.

Generalized functions

The "By" operations

User-supplied equality (replacing an Eq context)

nubBy :: ListLike full item => (item -> item -> Bool) -> full -> full

Generic version of nub

deleteBy :: ListLike full item => (item -> item -> Bool) -> item -> full -> full

Generic version of deleteBy

deleteFirstsBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full

Generic version of deleteFirsts

unionBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full

Generic version of union

intersectBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full

Generic version of intersect

groupBy :: (ListLike full item, ListLike full' full, Eq item) => (item -> item -> Bool) -> full -> full'

Generic version of group.

User-supplied comparison (replacing an Ord context)

sortBy :: ListLike full item => (item -> item -> Ordering) -> full -> full

Sort function taking a custom comparison function

insertBy :: ListLike full item => (item -> item -> Ordering) -> item -> full -> full

Like insert, but with a custom comparison function

The "generic" operations

genericLength :: (ListLike full item, Num a) => full -> a

Length of the list

genericTake :: (ListLike full item, Integral a) => a -> full -> full

Generic version of take

genericDrop :: (ListLike full item, Integral a) => a -> full -> full

Generic version of drop

genericSplitAt :: (ListLike full item, Integral a) => a -> full -> (full, full)

Generic version of splitAt

genericReplicate :: (ListLike full item, Integral a) => a -> item -> full

Generic version of replicate

Notes on specific instances

Lists

Functions for operating on regular lists almost all use the native implementations in Data.List, Prelude, or similar standard modules. The exceptions are:

• mapM uses the default ListLike implementation
• hGet does not exist for String in the Haskell modules. It is implemented in terms of Data.ByteString.Lazy.
• hGetNonBlocking is the same way.

Arrays

Array is an instance of ListLike. Here are some notes about it:

• The index you use must be an integral
• ListLike functions that take an index always take a 0-based index for compatibility with other ListLike instances. This is translated by the instance functions into the proper offset from the bounds in the Array.
• ListLike functions preserve the original Array index numbers when possible. Functions such as cons will reduce the lower bound to do their job. snoc and append increase the upper bound. drop raises the lower bound and take lowers the upper bound.
• Functions that change the length of the array by an amount not known in advance, such as filter, will generate a new array with the lower bound set to 0. Furthermore, these functions cannot operate on infinite lists because they must know their length in order to generate the array. hGetContents and its friends will therefore require the entire file to be read into memory before processing is possible.
• empty, singleton, and fromList also generate an array with the lower bound set to 0.
• Many of these functions will generate runtime exceptions if you have not assigned a value to every slot in the array.

ByteStrings

Both strict and lazy ByteStreams can be used with ListLike.

ByteString ListLike instances operate on Word8 elements. This is because both Data.ByteString.ByteString and Data.ByteString.Char8.ByteString have the same underlying type. If you wish to use the Char8 representation, the newtype wrappers CharString and CharStringLazy are available.

Most ListLike operations map directly to ByteStream options. Notable exceptions:

• map uses the ListLike implementation. rigidMap is more efficient. The same goes for concatMap vs. rigidConcatMap.
• isInfixOf, sequence, mapM and similar monad operations, insert, union, intersect, sortBy, and similar functions are not implemented in ByteStream and use a naive default implementation.
• The lazy ByteStream module implements fewer funtions than the strict ByteStream module. In some cases, default implementations are used. In others, notably related to I/O, the lazy ByteStreams are converted back and forth to strict ones as appropriate.

data Chars

Constructors

B Builder

T Text

Instances

IsList Chars

Defined in Data.ListLike.Chars

Associated Types

type Item Chars

Methods

fromList :: [Item Chars] -> Chars

fromListN :: Int -> [Item Chars] -> Chars

toList :: Chars -> [Item Chars]

Eq Chars

Defined in Data.ListLike.Chars

Methods

(==) :: Chars -> Chars -> Bool

(/=) :: Chars -> Chars -> Bool

Ord Chars

Defined in Data.ListLike.Chars

Methods

compare :: Chars -> Chars -> Ordering

(<) :: Chars -> Chars -> Bool

(<=) :: Chars -> Chars -> Bool

(>) :: Chars -> Chars -> Bool

(>=) :: Chars -> Chars -> Bool

max :: Chars -> Chars -> Chars

min :: Chars -> Chars -> Chars

Show Chars

Defined in Data.ListLike.Chars

Methods

showsPrec :: Int -> Chars -> ShowS

show :: Chars -> String

showList :: [Chars] -> ShowS

IsString Chars

Defined in Data.ListLike.Chars

Methods

fromString :: String -> Chars

Semigroup Chars

Defined in Data.ListLike.Chars

Methods

(<>) :: Chars -> Chars -> Chars

sconcat :: NonEmpty Chars -> Chars

stimes :: Integral b => b -> Chars -> Chars

Monoid Chars

Defined in Data.ListLike.Chars

Methods

mempty :: Chars

mappend :: Chars -> Chars -> Chars

mconcat :: [Chars] -> Chars

NFData Chars

Defined in Data.ListLike.Chars

Methods

rnf :: Chars -> ()

StringLike Chars

Defined in Data.ListLike.Chars

Methods

toString :: Chars -> String

lines :: ListLike full Chars => Chars -> full

words :: ListLike full Chars => Chars -> full

unlines :: ListLike full Chars => full -> Chars

unwords :: ListLike full Chars => full -> Chars

show :: Show a => a -> Chars

fromStringLike :: StringLike s' => Chars -> s'

fromText :: Text -> Chars

fromLazyText :: Text -> Chars

FoldableLL Chars Char

Defined in Data.ListLike.Chars

Methods

foldl :: (a -> Char -> a) -> a -> Chars -> a

foldl' :: (a -> Char -> a) -> a -> Chars -> a

foldl1 :: (Char -> Char -> Char) -> Chars -> Char

foldr :: (Char -> b -> b) -> b -> Chars -> b

foldr' :: (Char -> b -> b) -> b -> Chars -> b

foldr1 :: (Char -> Char -> Char) -> Chars -> Char

ListLike Chars Char

Defined in Data.ListLike.Chars

Methods

empty :: Chars

singleton :: Char -> Chars

cons :: Char -> Chars -> Chars

snoc :: Chars -> Char -> Chars

append :: Chars -> Chars -> Chars

head :: Chars -> Char

uncons :: Chars -> Maybe (Char, Chars)

last :: Chars -> Char

tail :: Chars -> Chars

init :: Chars -> Chars

null :: Chars -> Bool

length :: Chars -> Int

map :: ListLike full' item' => (Char -> item') -> Chars -> full'

rigidMap :: (Char -> Char) -> Chars -> Chars

reverse :: Chars -> Chars

intersperse :: Char -> Chars -> Chars

concat :: ListLike full' Chars => full' -> Chars

concatMap :: ListLike full' item' => (Char -> full') -> Chars -> full'

rigidConcatMap :: (Char -> Chars) -> Chars -> Chars

any :: (Char -> Bool) -> Chars -> Bool

all :: (Char -> Bool) -> Chars -> Bool

maximum :: Chars -> Char

minimum :: Chars -> Char

replicate :: Int -> Char -> Chars

take :: Int -> Chars -> Chars

drop :: Int -> Chars -> Chars

splitAt :: Int -> Chars -> (Chars, Chars)

takeWhile :: (Char -> Bool) -> Chars -> Chars

dropWhile :: (Char -> Bool) -> Chars -> Chars

dropWhileEnd :: (Char -> Bool) -> Chars -> Chars

span :: (Char -> Bool) -> Chars -> (Chars, Chars)

break :: (Char -> Bool) -> Chars -> (Chars, Chars)

group :: (ListLike full' Chars, Eq Char) => Chars -> full'

inits :: ListLike full' Chars => Chars -> full'

tails :: ListLike full' Chars => Chars -> full'

isPrefixOf :: Chars -> Chars -> Bool

isSuffixOf :: Chars -> Chars -> Bool

isInfixOf :: Chars -> Chars -> Bool

stripPrefix :: Chars -> Chars -> Maybe Chars

stripSuffix :: Chars -> Chars -> Maybe Chars

elem :: Char -> Chars -> Bool

notElem :: Char -> Chars -> Bool

find :: (Char -> Bool) -> Chars -> Maybe Char

filter :: (Char -> Bool) -> Chars -> Chars

partition :: (Char -> Bool) -> Chars -> (Chars, Chars)

index :: Chars -> Int -> Char

elemIndex :: Char -> Chars -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> Chars -> result

findIndex :: (Char -> Bool) -> Chars -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> Chars -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m Chars

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> Chars -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> Chars -> m Chars

nub :: Chars -> Chars

delete :: Char -> Chars -> Chars

deleteFirsts :: Chars -> Chars -> Chars

union :: Chars -> Chars -> Chars

intersect :: Chars -> Chars -> Chars

sort :: Chars -> Chars

insert :: Char -> Chars -> Chars

toList' :: Chars -> [Char]

fromList' :: [Char] -> Chars

fromListLike :: ListLike full' Char => Chars -> full'

nubBy :: (Char -> Char -> Bool) -> Chars -> Chars

deleteBy :: (Char -> Char -> Bool) -> Char -> Chars -> Chars

deleteFirstsBy :: (Char -> Char -> Bool) -> Chars -> Chars -> Chars

unionBy :: (Char -> Char -> Bool) -> Chars -> Chars -> Chars

intersectBy :: (Char -> Char -> Bool) -> Chars -> Chars -> Chars

groupBy :: (ListLike full' Chars, Eq Char) => (Char -> Char -> Bool) -> Chars -> full'

sortBy :: (Char -> Char -> Ordering) -> Chars -> Chars

insertBy :: (Char -> Char -> Ordering) -> Char -> Chars -> Chars

genericLength :: Num a => Chars -> a

genericTake :: Integral a => a -> Chars -> Chars

genericDrop :: Integral a => a -> Chars -> Chars

genericSplitAt :: Integral a => a -> Chars -> (Chars, Chars)

genericReplicate :: Integral a => a -> Char -> Chars

ListLikeIO Chars Char

Defined in Data.ListLike.Chars

Methods

hGetLine :: Handle -> IO Chars

hGetContents :: Handle -> IO Chars

hGet :: Handle -> Int -> IO Chars

hGetNonBlocking :: Handle -> Int -> IO Chars

hPutStr :: Handle -> Chars -> IO ()

hPutStrLn :: Handle -> Chars -> IO ()

getLine :: IO Chars

getContents :: IO Chars

putStr :: Chars -> IO ()

putStrLn :: Chars -> IO ()

interact :: (Chars -> Chars) -> IO ()

readFile :: FilePath -> IO Chars

writeFile :: FilePath -> Chars -> IO ()

appendFile :: FilePath -> Chars -> IO ()

type Item Chars

Defined in Data.ListLike.Chars

type Item Chars = Char

newtype CharString

Newtype wrapper around Data.ByteString.Char8.ByteString, this allows for ListLike instances with Char elements.

Constructors

CS

Fields

• unCS :: ByteString

Instances

IsList CharString

Defined in Data.ListLike.CharString

Associated Types

type Item CharString

Methods

fromList :: [Item CharString] -> CharString

fromListN :: Int -> [Item CharString] -> CharString

toList :: CharString -> [Item CharString]

Eq CharString

Defined in Data.ListLike.CharString

Methods

(==) :: CharString -> CharString -> Bool

(/=) :: CharString -> CharString -> Bool

Ord CharString

Defined in Data.ListLike.CharString

Methods

compare :: CharString -> CharString -> Ordering

(<) :: CharString -> CharString -> Bool

(<=) :: CharString -> CharString -> Bool

(>) :: CharString -> CharString -> Bool

(>=) :: CharString -> CharString -> Bool

max :: CharString -> CharString -> CharString

min :: CharString -> CharString -> CharString

Read CharString

Defined in Data.ListLike.CharString

Methods

readsPrec :: Int -> ReadS CharString

readList :: ReadS [CharString]

readPrec :: ReadPrec CharString

readListPrec :: ReadPrec [CharString]

Show CharString

Defined in Data.ListLike.CharString

Methods

showsPrec :: Int -> CharString -> ShowS

show :: CharString -> String

showList :: [CharString] -> ShowS

IsString CharString

Defined in Data.ListLike.CharString

Methods

fromString :: String -> CharString

Semigroup CharString

Defined in Data.ListLike.CharString

Methods

(<>) :: CharString -> CharString -> CharString

sconcat :: NonEmpty CharString -> CharString

stimes :: Integral b => b -> CharString -> CharString

Monoid CharString

Defined in Data.ListLike.CharString

Methods

mempty :: CharString

mappend :: CharString -> CharString -> CharString

mconcat :: [CharString] -> CharString

StringLike CharString

Defined in Data.ListLike.CharString

Methods

toString :: CharString -> String

lines :: ListLike full CharString => CharString -> full

words :: ListLike full CharString => CharString -> full

unlines :: ListLike full CharString => full -> CharString

unwords :: ListLike full CharString => full -> CharString

show :: Show a => a -> CharString

fromStringLike :: StringLike s' => CharString -> s'

fromText :: Text -> CharString

fromLazyText :: Text -> CharString

FoldableLL CharString Char

Defined in Data.ListLike.CharString

Methods

foldl :: (a -> Char -> a) -> a -> CharString -> a

foldl' :: (a -> Char -> a) -> a -> CharString -> a

foldl1 :: (Char -> Char -> Char) -> CharString -> Char

foldr :: (Char -> b -> b) -> b -> CharString -> b

foldr' :: (Char -> b -> b) -> b -> CharString -> b

foldr1 :: (Char -> Char -> Char) -> CharString -> Char

ListLike CharString Char

Defined in Data.ListLike.CharString

Methods

empty :: CharString

singleton :: Char -> CharString

cons :: Char -> CharString -> CharString

snoc :: CharString -> Char -> CharString

append :: CharString -> CharString -> CharString

head :: CharString -> Char

uncons :: CharString -> Maybe (Char, CharString)

last :: CharString -> Char

tail :: CharString -> CharString

init :: CharString -> CharString

null :: CharString -> Bool

length :: CharString -> Int

map :: ListLike full' item' => (Char -> item') -> CharString -> full'

rigidMap :: (Char -> Char) -> CharString -> CharString

reverse :: CharString -> CharString

intersperse :: Char -> CharString -> CharString

concat :: ListLike full' CharString => full' -> CharString

concatMap :: ListLike full' item' => (Char -> full') -> CharString -> full'

rigidConcatMap :: (Char -> CharString) -> CharString -> CharString

any :: (Char -> Bool) -> CharString -> Bool

all :: (Char -> Bool) -> CharString -> Bool

maximum :: CharString -> Char

minimum :: CharString -> Char

replicate :: Int -> Char -> CharString

take :: Int -> CharString -> CharString

drop :: Int -> CharString -> CharString

splitAt :: Int -> CharString -> (CharString, CharString)

takeWhile :: (Char -> Bool) -> CharString -> CharString

dropWhile :: (Char -> Bool) -> CharString -> CharString

dropWhileEnd :: (Char -> Bool) -> CharString -> CharString

span :: (Char -> Bool) -> CharString -> (CharString, CharString)

break :: (Char -> Bool) -> CharString -> (CharString, CharString)

group :: (ListLike full' CharString, Eq Char) => CharString -> full'

inits :: ListLike full' CharString => CharString -> full'

tails :: ListLike full' CharString => CharString -> full'

isPrefixOf :: CharString -> CharString -> Bool

isSuffixOf :: CharString -> CharString -> Bool

isInfixOf :: CharString -> CharString -> Bool

stripPrefix :: CharString -> CharString -> Maybe CharString

stripSuffix :: CharString -> CharString -> Maybe CharString

elem :: Char -> CharString -> Bool

notElem :: Char -> CharString -> Bool

find :: (Char -> Bool) -> CharString -> Maybe Char

filter :: (Char -> Bool) -> CharString -> CharString

partition :: (Char -> Bool) -> CharString -> (CharString, CharString)

index :: CharString -> Int -> Char

elemIndex :: Char -> CharString -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> CharString -> result

findIndex :: (Char -> Bool) -> CharString -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> CharString -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m CharString

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> CharString -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> CharString -> m CharString

nub :: CharString -> CharString

delete :: Char -> CharString -> CharString

deleteFirsts :: CharString -> CharString -> CharString

union :: CharString -> CharString -> CharString

intersect :: CharString -> CharString -> CharString

sort :: CharString -> CharString

insert :: Char -> CharString -> CharString

toList' :: CharString -> [Char]

fromList' :: [Char] -> CharString

fromListLike :: ListLike full' Char => CharString -> full'

nubBy :: (Char -> Char -> Bool) -> CharString -> CharString

deleteBy :: (Char -> Char -> Bool) -> Char -> CharString -> CharString

deleteFirstsBy :: (Char -> Char -> Bool) -> CharString -> CharString -> CharString

unionBy :: (Char -> Char -> Bool) -> CharString -> CharString -> CharString

intersectBy :: (Char -> Char -> Bool) -> CharString -> CharString -> CharString

groupBy :: (ListLike full' CharString, Eq Char) => (Char -> Char -> Bool) -> CharString -> full'

sortBy :: (Char -> Char -> Ordering) -> CharString -> CharString

insertBy :: (Char -> Char -> Ordering) -> Char -> CharString -> CharString

genericLength :: Num a => CharString -> a

genericTake :: Integral a => a -> CharString -> CharString

genericDrop :: Integral a => a -> CharString -> CharString

genericSplitAt :: Integral a => a -> CharString -> (CharString, CharString)

genericReplicate :: Integral a => a -> Char -> CharString

ListLikeIO CharString Char

Defined in Data.ListLike.CharString

Methods

hGetLine :: Handle -> IO CharString

hGetContents :: Handle -> IO CharString

hGet :: Handle -> Int -> IO CharString

hGetNonBlocking :: Handle -> Int -> IO CharString

hPutStr :: Handle -> CharString -> IO ()

hPutStrLn :: Handle -> CharString -> IO ()

getLine :: IO CharString

getContents :: IO CharString

putStr :: CharString -> IO ()

putStrLn :: CharString -> IO ()

interact :: (CharString -> CharString) -> IO ()

readFile :: FilePath -> IO CharString

writeFile :: FilePath -> CharString -> IO ()

appendFile :: FilePath -> CharString -> IO ()

type Item CharString

Defined in Data.ListLike.CharString

type Item CharString = Char

newtype CharStringLazy

Newtype wrapper around Data.ByteString.Lazy.Char8.ByteString, this allows for ListLike instances with Char elements.

Constructors

CSL

Fields

• unCSL :: ByteString

Instances

IsList CharStringLazy

Defined in Data.ListLike.CharString

Associated Types

type Item CharStringLazy

Methods

fromList :: [Item CharStringLazy] -> CharStringLazy

fromListN :: Int -> [Item CharStringLazy] -> CharStringLazy

toList :: CharStringLazy -> [Item CharStringLazy]

Eq CharStringLazy

Defined in Data.ListLike.CharString

Methods

(==) :: CharStringLazy -> CharStringLazy -> Bool

(/=) :: CharStringLazy -> CharStringLazy -> Bool

Ord CharStringLazy

Defined in Data.ListLike.CharString

Methods

compare :: CharStringLazy -> CharStringLazy -> Ordering

(<) :: CharStringLazy -> CharStringLazy -> Bool

(<=) :: CharStringLazy -> CharStringLazy -> Bool

(>) :: CharStringLazy -> CharStringLazy -> Bool

(>=) :: CharStringLazy -> CharStringLazy -> Bool

max :: CharStringLazy -> CharStringLazy -> CharStringLazy

min :: CharStringLazy -> CharStringLazy -> CharStringLazy

Read CharStringLazy

Defined in Data.ListLike.CharString

Methods

readsPrec :: Int -> ReadS CharStringLazy

readList :: ReadS [CharStringLazy]

readPrec :: ReadPrec CharStringLazy

readListPrec :: ReadPrec [CharStringLazy]

Show CharStringLazy

Defined in Data.ListLike.CharString

Methods

showsPrec :: Int -> CharStringLazy -> ShowS

show :: CharStringLazy -> String

showList :: [CharStringLazy] -> ShowS

IsString CharStringLazy

Defined in Data.ListLike.CharString

Methods

fromString :: String -> CharStringLazy

Semigroup CharStringLazy

Defined in Data.ListLike.CharString

Methods

(<>) :: CharStringLazy -> CharStringLazy -> CharStringLazy

sconcat :: NonEmpty CharStringLazy -> CharStringLazy

stimes :: Integral b => b -> CharStringLazy -> CharStringLazy

Monoid CharStringLazy

Defined in Data.ListLike.CharString

Methods

mempty :: CharStringLazy

mappend :: CharStringLazy -> CharStringLazy -> CharStringLazy

mconcat :: [CharStringLazy] -> CharStringLazy

StringLike CharStringLazy

Defined in Data.ListLike.CharString

Methods

toString :: CharStringLazy -> String

lines :: ListLike full CharStringLazy => CharStringLazy -> full

words :: ListLike full CharStringLazy => CharStringLazy -> full

unlines :: ListLike full CharStringLazy => full -> CharStringLazy

unwords :: ListLike full CharStringLazy => full -> CharStringLazy

show :: Show a => a -> CharStringLazy

fromStringLike :: StringLike s' => CharStringLazy -> s'

fromText :: Text -> CharStringLazy

fromLazyText :: Text -> CharStringLazy

FoldableLL CharStringLazy Char

Defined in Data.ListLike.CharString

Methods

foldl :: (a -> Char -> a) -> a -> CharStringLazy -> a

foldl' :: (a -> Char -> a) -> a -> CharStringLazy -> a

foldl1 :: (Char -> Char -> Char) -> CharStringLazy -> Char

foldr :: (Char -> b -> b) -> b -> CharStringLazy -> b

foldr' :: (Char -> b -> b) -> b -> CharStringLazy -> b

foldr1 :: (Char -> Char -> Char) -> CharStringLazy -> Char

ListLike CharStringLazy Char

Defined in Data.ListLike.CharString

Methods

empty :: CharStringLazy

singleton :: Char -> CharStringLazy

cons :: Char -> CharStringLazy -> CharStringLazy

snoc :: CharStringLazy -> Char -> CharStringLazy

append :: CharStringLazy -> CharStringLazy -> CharStringLazy

head :: CharStringLazy -> Char

uncons :: CharStringLazy -> Maybe (Char, CharStringLazy)

last :: CharStringLazy -> Char

tail :: CharStringLazy -> CharStringLazy

init :: CharStringLazy -> CharStringLazy

null :: CharStringLazy -> Bool

length :: CharStringLazy -> Int

map :: ListLike full' item' => (Char -> item') -> CharStringLazy -> full'

rigidMap :: (Char -> Char) -> CharStringLazy -> CharStringLazy

reverse :: CharStringLazy -> CharStringLazy

intersperse :: Char -> CharStringLazy -> CharStringLazy

concat :: ListLike full' CharStringLazy => full' -> CharStringLazy

concatMap :: ListLike full' item' => (Char -> full') -> CharStringLazy -> full'

rigidConcatMap :: (Char -> CharStringLazy) -> CharStringLazy -> CharStringLazy

any :: (Char -> Bool) -> CharStringLazy -> Bool

all :: (Char -> Bool) -> CharStringLazy -> Bool

maximum :: CharStringLazy -> Char

minimum :: CharStringLazy -> Char

replicate :: Int -> Char -> CharStringLazy

take :: Int -> CharStringLazy -> CharStringLazy

drop :: Int -> CharStringLazy -> CharStringLazy

splitAt :: Int -> CharStringLazy -> (CharStringLazy, CharStringLazy)

takeWhile :: (Char -> Bool) -> CharStringLazy -> CharStringLazy

dropWhile :: (Char -> Bool) -> CharStringLazy -> CharStringLazy

dropWhileEnd :: (Char -> Bool) -> CharStringLazy -> CharStringLazy

span :: (Char -> Bool) -> CharStringLazy -> (CharStringLazy, CharStringLazy)

break :: (Char -> Bool) -> CharStringLazy -> (CharStringLazy, CharStringLazy)

group :: (ListLike full' CharStringLazy, Eq Char) => CharStringLazy -> full'

inits :: ListLike full' CharStringLazy => CharStringLazy -> full'

tails :: ListLike full' CharStringLazy => CharStringLazy -> full'

isPrefixOf :: CharStringLazy -> CharStringLazy -> Bool

isSuffixOf :: CharStringLazy -> CharStringLazy -> Bool

isInfixOf :: CharStringLazy -> CharStringLazy -> Bool

stripPrefix :: CharStringLazy -> CharStringLazy -> Maybe CharStringLazy

stripSuffix :: CharStringLazy -> CharStringLazy -> Maybe CharStringLazy

elem :: Char -> CharStringLazy -> Bool

notElem :: Char -> CharStringLazy -> Bool

find :: (Char -> Bool) -> CharStringLazy -> Maybe Char

filter :: (Char -> Bool) -> CharStringLazy -> CharStringLazy

partition :: (Char -> Bool) -> CharStringLazy -> (CharStringLazy, CharStringLazy)

index :: CharStringLazy -> Int -> Char

elemIndex :: Char -> CharStringLazy -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> CharStringLazy -> result

findIndex :: (Char -> Bool) -> CharStringLazy -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> CharStringLazy -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m CharStringLazy

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> CharStringLazy -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> CharStringLazy -> m CharStringLazy

nub :: CharStringLazy -> CharStringLazy

delete :: Char -> CharStringLazy -> CharStringLazy

deleteFirsts :: CharStringLazy -> CharStringLazy -> CharStringLazy

union :: CharStringLazy -> CharStringLazy -> CharStringLazy

intersect :: CharStringLazy -> CharStringLazy -> CharStringLazy

sort :: CharStringLazy -> CharStringLazy

insert :: Char -> CharStringLazy -> CharStringLazy

toList' :: CharStringLazy -> [Char]

fromList' :: [Char] -> CharStringLazy

fromListLike :: ListLike full' Char => CharStringLazy -> full'

nubBy :: (Char -> Char -> Bool) -> CharStringLazy -> CharStringLazy

deleteBy :: (Char -> Char -> Bool) -> Char -> CharStringLazy -> CharStringLazy

deleteFirstsBy :: (Char -> Char -> Bool) -> CharStringLazy -> CharStringLazy -> CharStringLazy

unionBy :: (Char -> Char -> Bool) -> CharStringLazy -> CharStringLazy -> CharStringLazy

intersectBy :: (Char -> Char -> Bool) -> CharStringLazy -> CharStringLazy -> CharStringLazy

groupBy :: (ListLike full' CharStringLazy, Eq Char) => (Char -> Char -> Bool) -> CharStringLazy -> full'

sortBy :: (Char -> Char -> Ordering) -> CharStringLazy -> CharStringLazy

insertBy :: (Char -> Char -> Ordering) -> Char -> CharStringLazy -> CharStringLazy

genericLength :: Num a => CharStringLazy -> a

genericTake :: Integral a => a -> CharStringLazy -> CharStringLazy

genericDrop :: Integral a => a -> CharStringLazy -> CharStringLazy

genericSplitAt :: Integral a => a -> CharStringLazy -> (CharStringLazy, CharStringLazy)

genericReplicate :: Integral a => a -> Char -> CharStringLazy

ListLikeIO CharStringLazy Char

Defined in Data.ListLike.CharString

Methods

hGetLine :: Handle -> IO CharStringLazy

hGetContents :: Handle -> IO CharStringLazy

hGet :: Handle -> Int -> IO CharStringLazy

hGetNonBlocking :: Handle -> Int -> IO CharStringLazy

hPutStr :: Handle -> CharStringLazy -> IO ()

hPutStrLn :: Handle -> CharStringLazy -> IO ()

getLine :: IO CharStringLazy

getContents :: IO CharStringLazy

putStr :: CharStringLazy -> IO ()

putStrLn :: CharStringLazy -> IO ()

interact :: (CharStringLazy -> CharStringLazy) -> IO ()

readFile :: FilePath -> IO CharStringLazy

writeFile :: FilePath -> CharStringLazy -> IO ()

appendFile :: FilePath -> CharStringLazy -> IO ()

type Item CharStringLazy

Defined in Data.ListLike.CharString

type Item CharStringLazy = Char

Base Typeclasses

The ListLike class

class (IsList full, item ~ Item full, FoldableLL full item, Monoid full) => ListLike full item | full -> item

The class implementing list-like functions.

It is worth noting that types such as Map can be instances of ListLike. Due to their specific ways of operating, they may not behave in the expected way in some cases. For instance, cons may not increase the size of a map if the key you have given is already in the map; it will just replace the value already there.

Implementators must define at least:

• singleton
• head
• tail
• null or genericLength

Minimal complete definition

singleton, uncons, null | singleton, uncons, genericLength | singleton, head, tail, null | singleton, head, tail, genericLength

Instances

ListLike ByteString Word8

Defined in Data.ListLike.Instances

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 :: (Monad m, ListLike fullinp (m Word8)) => fullinp -> m ByteString

mapM :: (Monad 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

Defined in Data.ListLike.Instances

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 :: (Monad m, ListLike fullinp (m Word8)) => fullinp -> m ByteString

mapM :: (Monad 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 Builder Char

Defined in Data.ListLike.Text.Builder

Methods

empty :: Builder

singleton :: Char -> Builder

cons :: Char -> Builder -> Builder

snoc :: Builder -> Char -> Builder

append :: Builder -> Builder -> Builder

head :: Builder -> Char

uncons :: Builder -> Maybe (Char, Builder)

last :: Builder -> Char

tail :: Builder -> Builder

init :: Builder -> Builder

null :: Builder -> Bool

length :: Builder -> Int

map :: ListLike full' item' => (Char -> item') -> Builder -> full'

rigidMap :: (Char -> Char) -> Builder -> Builder

reverse :: Builder -> Builder

intersperse :: Char -> Builder -> Builder

concat :: ListLike full' Builder => full' -> Builder

concatMap :: ListLike full' item' => (Char -> full') -> Builder -> full'

rigidConcatMap :: (Char -> Builder) -> Builder -> Builder

any :: (Char -> Bool) -> Builder -> Bool

all :: (Char -> Bool) -> Builder -> Bool

maximum :: Builder -> Char

minimum :: Builder -> Char

replicate :: Int -> Char -> Builder

take :: Int -> Builder -> Builder

drop :: Int -> Builder -> Builder

splitAt :: Int -> Builder -> (Builder, Builder)

takeWhile :: (Char -> Bool) -> Builder -> Builder

dropWhile :: (Char -> Bool) -> Builder -> Builder

dropWhileEnd :: (Char -> Bool) -> Builder -> Builder

span :: (Char -> Bool) -> Builder -> (Builder, Builder)

break :: (Char -> Bool) -> Builder -> (Builder, Builder)

group :: (ListLike full' Builder, Eq Char) => Builder -> full'

inits :: ListLike full' Builder => Builder -> full'

tails :: ListLike full' Builder => Builder -> full'

isPrefixOf :: Builder -> Builder -> Bool

isSuffixOf :: Builder -> Builder -> Bool

isInfixOf :: Builder -> Builder -> Bool

stripPrefix :: Builder -> Builder -> Maybe Builder

stripSuffix :: Builder -> Builder -> Maybe Builder

elem :: Char -> Builder -> Bool

notElem :: Char -> Builder -> Bool

find :: (Char -> Bool) -> Builder -> Maybe Char

filter :: (Char -> Bool) -> Builder -> Builder

partition :: (Char -> Bool) -> Builder -> (Builder, Builder)

index :: Builder -> Int -> Char

elemIndex :: Char -> Builder -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> Builder -> result

findIndex :: (Char -> Bool) -> Builder -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> Builder -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m Builder

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> Builder -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> Builder -> m Builder

nub :: Builder -> Builder

delete :: Char -> Builder -> Builder

deleteFirsts :: Builder -> Builder -> Builder

union :: Builder -> Builder -> Builder

intersect :: Builder -> Builder -> Builder

sort :: Builder -> Builder

insert :: Char -> Builder -> Builder

toList' :: Builder -> [Char]

fromList' :: [Char] -> Builder

fromListLike :: ListLike full' Char => Builder -> full'

nubBy :: (Char -> Char -> Bool) -> Builder -> Builder

deleteBy :: (Char -> Char -> Bool) -> Char -> Builder -> Builder

deleteFirstsBy :: (Char -> Char -> Bool) -> Builder -> Builder -> Builder

unionBy :: (Char -> Char -> Bool) -> Builder -> Builder -> Builder

intersectBy :: (Char -> Char -> Bool) -> Builder -> Builder -> Builder

groupBy :: (ListLike full' Builder, Eq Char) => (Char -> Char -> Bool) -> Builder -> full'

sortBy :: (Char -> Char -> Ordering) -> Builder -> Builder

insertBy :: (Char -> Char -> Ordering) -> Char -> Builder -> Builder

genericLength :: Num a => Builder -> a

genericTake :: Integral a => a -> Builder -> Builder

genericDrop :: Integral a => a -> Builder -> Builder

genericSplitAt :: Integral a => a -> Builder -> (Builder, Builder)

genericReplicate :: Integral a => a -> Char -> Builder

ListLike Text Char

Defined in Data.ListLike.Text.TextLazy

Methods

empty :: Text

singleton :: Char -> Text

cons :: Char -> Text -> Text

snoc :: Text -> Char -> Text

append :: Text -> Text -> Text

head :: Text -> Char

uncons :: Text -> Maybe (Char, Text)

last :: Text -> Char

tail :: Text -> Text

init :: Text -> Text

null :: Text -> Bool

length :: Text -> Int

map :: ListLike full' item' => (Char -> item') -> Text -> full'

rigidMap :: (Char -> Char) -> Text -> Text

reverse :: Text -> Text

intersperse :: Char -> Text -> Text

concat :: ListLike full' Text => full' -> Text

concatMap :: ListLike full' item' => (Char -> full') -> Text -> full'

rigidConcatMap :: (Char -> Text) -> Text -> Text

any :: (Char -> Bool) -> Text -> Bool

all :: (Char -> Bool) -> Text -> Bool

maximum :: Text -> Char

minimum :: Text -> Char

replicate :: Int -> Char -> Text

take :: Int -> Text -> Text

drop :: Int -> Text -> Text

splitAt :: Int -> Text -> (Text, Text)

takeWhile :: (Char -> Bool) -> Text -> Text

dropWhile :: (Char -> Bool) -> Text -> Text

dropWhileEnd :: (Char -> Bool) -> Text -> Text

span :: (Char -> Bool) -> Text -> (Text, Text)

break :: (Char -> Bool) -> Text -> (Text, Text)

group :: (ListLike full' Text, Eq Char) => Text -> full'

inits :: ListLike full' Text => Text -> full'

tails :: ListLike full' Text => Text -> full'

isPrefixOf :: Text -> Text -> Bool

isSuffixOf :: Text -> Text -> Bool

isInfixOf :: Text -> Text -> Bool

stripPrefix :: Text -> Text -> Maybe Text

stripSuffix :: Text -> Text -> Maybe Text

elem :: Char -> Text -> Bool

notElem :: Char -> Text -> Bool

find :: (Char -> Bool) -> Text -> Maybe Char

filter :: (Char -> Bool) -> Text -> Text

partition :: (Char -> Bool) -> Text -> (Text, Text)

index :: Text -> Int -> Char

elemIndex :: Char -> Text -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> Text -> result

findIndex :: (Char -> Bool) -> Text -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> Text -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m Text

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> Text -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> Text -> m Text

nub :: Text -> Text

delete :: Char -> Text -> Text

deleteFirsts :: Text -> Text -> Text

union :: Text -> Text -> Text

intersect :: Text -> Text -> Text

sort :: Text -> Text

insert :: Char -> Text -> Text

toList' :: Text -> [Char]

fromList' :: [Char] -> Text

fromListLike :: ListLike full' Char => Text -> full'

nubBy :: (Char -> Char -> Bool) -> Text -> Text

deleteBy :: (Char -> Char -> Bool) -> Char -> Text -> Text

deleteFirstsBy :: (Char -> Char -> Bool) -> Text -> Text -> Text

unionBy :: (Char -> Char -> Bool) -> Text -> Text -> Text

intersectBy :: (Char -> Char -> Bool) -> Text -> Text -> Text

groupBy :: (ListLike full' Text, Eq Char) => (Char -> Char -> Bool) -> Text -> full'

sortBy :: (Char -> Char -> Ordering) -> Text -> Text

insertBy :: (Char -> Char -> Ordering) -> Char -> Text -> Text

genericLength :: Num a => Text -> a

genericTake :: Integral a => a -> Text -> Text

genericDrop :: Integral a => a -> Text -> Text

genericSplitAt :: Integral a => a -> Text -> (Text, Text)

genericReplicate :: Integral a => a -> Char -> Text

ListLike Text Char

Defined in Data.ListLike.Text.Text

Methods

empty :: Text

singleton :: Char -> Text

cons :: Char -> Text -> Text

snoc :: Text -> Char -> Text

append :: Text -> Text -> Text

head :: Text -> Char

uncons :: Text -> Maybe (Char, Text)

last :: Text -> Char

tail :: Text -> Text

init :: Text -> Text

null :: Text -> Bool

length :: Text -> Int

map :: ListLike full' item' => (Char -> item') -> Text -> full'

rigidMap :: (Char -> Char) -> Text -> Text

reverse :: Text -> Text

intersperse :: Char -> Text -> Text

concat :: ListLike full' Text => full' -> Text

concatMap :: ListLike full' item' => (Char -> full') -> Text -> full'

rigidConcatMap :: (Char -> Text) -> Text -> Text

any :: (Char -> Bool) -> Text -> Bool

all :: (Char -> Bool) -> Text -> Bool

maximum :: Text -> Char

minimum :: Text -> Char

replicate :: Int -> Char -> Text

take :: Int -> Text -> Text

drop :: Int -> Text -> Text

splitAt :: Int -> Text -> (Text, Text)

takeWhile :: (Char -> Bool) -> Text -> Text

dropWhile :: (Char -> Bool) -> Text -> Text

dropWhileEnd :: (Char -> Bool) -> Text -> Text

span :: (Char -> Bool) -> Text -> (Text, Text)

break :: (Char -> Bool) -> Text -> (Text, Text)

group :: (ListLike full' Text, Eq Char) => Text -> full'

inits :: ListLike full' Text => Text -> full'

tails :: ListLike full' Text => Text -> full'

isPrefixOf :: Text -> Text -> Bool

isSuffixOf :: Text -> Text -> Bool

isInfixOf :: Text -> Text -> Bool

stripPrefix :: Text -> Text -> Maybe Text

stripSuffix :: Text -> Text -> Maybe Text

elem :: Char -> Text -> Bool

notElem :: Char -> Text -> Bool

find :: (Char -> Bool) -> Text -> Maybe Char

filter :: (Char -> Bool) -> Text -> Text

partition :: (Char -> Bool) -> Text -> (Text, Text)

index :: Text -> Int -> Char

elemIndex :: Char -> Text -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> Text -> result

findIndex :: (Char -> Bool) -> Text -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> Text -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m Text

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> Text -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> Text -> m Text

nub :: Text -> Text

delete :: Char -> Text -> Text

deleteFirsts :: Text -> Text -> Text

union :: Text -> Text -> Text

intersect :: Text -> Text -> Text

sort :: Text -> Text

insert :: Char -> Text -> Text

toList' :: Text -> [Char]

fromList' :: [Char] -> Text

fromListLike :: ListLike full' Char => Text -> full'

nubBy :: (Char -> Char -> Bool) -> Text -> Text

deleteBy :: (Char -> Char -> Bool) -> Char -> Text -> Text

deleteFirstsBy :: (Char -> Char -> Bool) -> Text -> Text -> Text

unionBy :: (Char -> Char -> Bool) -> Text -> Text -> Text

intersectBy :: (Char -> Char -> Bool) -> Text -> Text -> Text

groupBy :: (ListLike full' Text, Eq Char) => (Char -> Char -> Bool) -> Text -> full'

sortBy :: (Char -> Char -> Ordering) -> Text -> Text

insertBy :: (Char -> Char -> Ordering) -> Char -> Text -> Text

genericLength :: Num a => Text -> a

genericTake :: Integral a => a -> Text -> Text

genericDrop :: Integral a => a -> Text -> Text

genericSplitAt :: Integral a => a -> Text -> (Text, Text)

genericReplicate :: Integral a => a -> Char -> Text

ListLike CharStringLazy Char

Defined in Data.ListLike.CharString

Methods

empty :: CharStringLazy

singleton :: Char -> CharStringLazy

cons :: Char -> CharStringLazy -> CharStringLazy

snoc :: CharStringLazy -> Char -> CharStringLazy

append :: CharStringLazy -> CharStringLazy -> CharStringLazy

head :: CharStringLazy -> Char

uncons :: CharStringLazy -> Maybe (Char, CharStringLazy)

last :: CharStringLazy -> Char

tail :: CharStringLazy -> CharStringLazy

init :: CharStringLazy -> CharStringLazy

null :: CharStringLazy -> Bool

length :: CharStringLazy -> Int

map :: ListLike full' item' => (Char -> item') -> CharStringLazy -> full'

rigidMap :: (Char -> Char) -> CharStringLazy -> CharStringLazy

reverse :: CharStringLazy -> CharStringLazy

intersperse :: Char -> CharStringLazy -> CharStringLazy

concat :: ListLike full' CharStringLazy => full' -> CharStringLazy

concatMap :: ListLike full' item' => (Char -> full') -> CharStringLazy -> full'

rigidConcatMap :: (Char -> CharStringLazy) -> CharStringLazy -> CharStringLazy

any :: (Char -> Bool) -> CharStringLazy -> Bool

all :: (Char -> Bool) -> CharStringLazy -> Bool

maximum :: CharStringLazy -> Char

minimum :: CharStringLazy -> Char

replicate :: Int -> Char -> CharStringLazy

take :: Int -> CharStringLazy -> CharStringLazy

drop :: Int -> CharStringLazy -> CharStringLazy

splitAt :: Int -> CharStringLazy -> (CharStringLazy, CharStringLazy)

takeWhile :: (Char -> Bool) -> CharStringLazy -> CharStringLazy

dropWhile :: (Char -> Bool) -> CharStringLazy -> CharStringLazy

dropWhileEnd :: (Char -> Bool) -> CharStringLazy -> CharStringLazy

span :: (Char -> Bool) -> CharStringLazy -> (CharStringLazy, CharStringLazy)

break :: (Char -> Bool) -> CharStringLazy -> (CharStringLazy, CharStringLazy)

group :: (ListLike full' CharStringLazy, Eq Char) => CharStringLazy -> full'

inits :: ListLike full' CharStringLazy => CharStringLazy -> full'

tails :: ListLike full' CharStringLazy => CharStringLazy -> full'

isPrefixOf :: CharStringLazy -> CharStringLazy -> Bool

isSuffixOf :: CharStringLazy -> CharStringLazy -> Bool

isInfixOf :: CharStringLazy -> CharStringLazy -> Bool

stripPrefix :: CharStringLazy -> CharStringLazy -> Maybe CharStringLazy

stripSuffix :: CharStringLazy -> CharStringLazy -> Maybe CharStringLazy

elem :: Char -> CharStringLazy -> Bool

notElem :: Char -> CharStringLazy -> Bool

find :: (Char -> Bool) -> CharStringLazy -> Maybe Char

filter :: (Char -> Bool) -> CharStringLazy -> CharStringLazy

partition :: (Char -> Bool) -> CharStringLazy -> (CharStringLazy, CharStringLazy)

index :: CharStringLazy -> Int -> Char

elemIndex :: Char -> CharStringLazy -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> CharStringLazy -> result

findIndex :: (Char -> Bool) -> CharStringLazy -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> CharStringLazy -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m CharStringLazy

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> CharStringLazy -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> CharStringLazy -> m CharStringLazy

nub :: CharStringLazy -> CharStringLazy

delete :: Char -> CharStringLazy -> CharStringLazy

deleteFirsts :: CharStringLazy -> CharStringLazy -> CharStringLazy

union :: CharStringLazy -> CharStringLazy -> CharStringLazy

intersect :: CharStringLazy -> CharStringLazy -> CharStringLazy

sort :: CharStringLazy -> CharStringLazy

insert :: Char -> CharStringLazy -> CharStringLazy

toList' :: CharStringLazy -> [Char]

fromList' :: [Char] -> CharStringLazy

fromListLike :: ListLike full' Char => CharStringLazy -> full'

nubBy :: (Char -> Char -> Bool) -> CharStringLazy -> CharStringLazy

deleteBy :: (Char -> Char -> Bool) -> Char -> CharStringLazy -> CharStringLazy

deleteFirstsBy :: (Char -> Char -> Bool) -> CharStringLazy -> CharStringLazy -> CharStringLazy

unionBy :: (Char -> Char -> Bool) -> CharStringLazy -> CharStringLazy -> CharStringLazy

intersectBy :: (Char -> Char -> Bool) -> CharStringLazy -> CharStringLazy -> CharStringLazy

groupBy :: (ListLike full' CharStringLazy, Eq Char) => (Char -> Char -> Bool) -> CharStringLazy -> full'

sortBy :: (Char -> Char -> Ordering) -> CharStringLazy -> CharStringLazy

insertBy :: (Char -> Char -> Ordering) -> Char -> CharStringLazy -> CharStringLazy

genericLength :: Num a => CharStringLazy -> a

genericTake :: Integral a => a -> CharStringLazy -> CharStringLazy

genericDrop :: Integral a => a -> CharStringLazy -> CharStringLazy

genericSplitAt :: Integral a => a -> CharStringLazy -> (CharStringLazy, CharStringLazy)

genericReplicate :: Integral a => a -> Char -> CharStringLazy

ListLike CharString Char

Defined in Data.ListLike.CharString

Methods

empty :: CharString

singleton :: Char -> CharString

cons :: Char -> CharString -> CharString

snoc :: CharString -> Char -> CharString

append :: CharString -> CharString -> CharString

head :: CharString -> Char

uncons :: CharString -> Maybe (Char, CharString)

last :: CharString -> Char

tail :: CharString -> CharString

init :: CharString -> CharString

null :: CharString -> Bool

length :: CharString -> Int

map :: ListLike full' item' => (Char -> item') -> CharString -> full'

rigidMap :: (Char -> Char) -> CharString -> CharString

reverse :: CharString -> CharString

intersperse :: Char -> CharString -> CharString

concat :: ListLike full' CharString => full' -> CharString

concatMap :: ListLike full' item' => (Char -> full') -> CharString -> full'

rigidConcatMap :: (Char -> CharString) -> CharString -> CharString

any :: (Char -> Bool) -> CharString -> Bool

all :: (Char -> Bool) -> CharString -> Bool

maximum :: CharString -> Char

minimum :: CharString -> Char

replicate :: Int -> Char -> CharString

take :: Int -> CharString -> CharString

drop :: Int -> CharString -> CharString

splitAt :: Int -> CharString -> (CharString, CharString)

takeWhile :: (Char -> Bool) -> CharString -> CharString

dropWhile :: (Char -> Bool) -> CharString -> CharString

dropWhileEnd :: (Char -> Bool) -> CharString -> CharString

span :: (Char -> Bool) -> CharString -> (CharString, CharString)

break :: (Char -> Bool) -> CharString -> (CharString, CharString)

group :: (ListLike full' CharString, Eq Char) => CharString -> full'

inits :: ListLike full' CharString => CharString -> full'

tails :: ListLike full' CharString => CharString -> full'

isPrefixOf :: CharString -> CharString -> Bool

isSuffixOf :: CharString -> CharString -> Bool

isInfixOf :: CharString -> CharString -> Bool

stripPrefix :: CharString -> CharString -> Maybe CharString

stripSuffix :: CharString -> CharString -> Maybe CharString

elem :: Char -> CharString -> Bool

notElem :: Char -> CharString -> Bool

find :: (Char -> Bool) -> CharString -> Maybe Char

filter :: (Char -> Bool) -> CharString -> CharString

partition :: (Char -> Bool) -> CharString -> (CharString, CharString)

index :: CharString -> Int -> Char

elemIndex :: Char -> CharString -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> CharString -> result

findIndex :: (Char -> Bool) -> CharString -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> CharString -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m CharString

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> CharString -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> CharString -> m CharString

nub :: CharString -> CharString

delete :: Char -> CharString -> CharString

deleteFirsts :: CharString -> CharString -> CharString

union :: CharString -> CharString -> CharString

intersect :: CharString -> CharString -> CharString

sort :: CharString -> CharString

insert :: Char -> CharString -> CharString

toList' :: CharString -> [Char]

fromList' :: [Char] -> CharString

fromListLike :: ListLike full' Char => CharString -> full'

nubBy :: (Char -> Char -> Bool) -> CharString -> CharString

deleteBy :: (Char -> Char -> Bool) -> Char -> CharString -> CharString

deleteFirstsBy :: (Char -> Char -> Bool) -> CharString -> CharString -> CharString

unionBy :: (Char -> Char -> Bool) -> CharString -> CharString -> CharString

intersectBy :: (Char -> Char -> Bool) -> CharString -> CharString -> CharString

groupBy :: (ListLike full' CharString, Eq Char) => (Char -> Char -> Bool) -> CharString -> full'

sortBy :: (Char -> Char -> Ordering) -> CharString -> CharString

insertBy :: (Char -> Char -> Ordering) -> Char -> CharString -> CharString

genericLength :: Num a => CharString -> a

genericTake :: Integral a => a -> CharString -> CharString

genericDrop :: Integral a => a -> CharString -> CharString

genericSplitAt :: Integral a => a -> CharString -> (CharString, CharString)

genericReplicate :: Integral a => a -> Char -> CharString

ListLike Chars Char

Defined in Data.ListLike.Chars

Methods

empty :: Chars

singleton :: Char -> Chars

cons :: Char -> Chars -> Chars

snoc :: Chars -> Char -> Chars

append :: Chars -> Chars -> Chars

head :: Chars -> Char

uncons :: Chars -> Maybe (Char, Chars)

last :: Chars -> Char

tail :: Chars -> Chars

init :: Chars -> Chars

null :: Chars -> Bool

length :: Chars -> Int

map :: ListLike full' item' => (Char -> item') -> Chars -> full'

rigidMap :: (Char -> Char) -> Chars -> Chars

reverse :: Chars -> Chars

intersperse :: Char -> Chars -> Chars

concat :: ListLike full' Chars => full' -> Chars

concatMap :: ListLike full' item' => (Char -> full') -> Chars -> full'

rigidConcatMap :: (Char -> Chars) -> Chars -> Chars

any :: (Char -> Bool) -> Chars -> Bool

all :: (Char -> Bool) -> Chars -> Bool

maximum :: Chars -> Char

minimum :: Chars -> Char

replicate :: Int -> Char -> Chars

take :: Int -> Chars -> Chars

drop :: Int -> Chars -> Chars

splitAt :: Int -> Chars -> (Chars, Chars)

takeWhile :: (Char -> Bool) -> Chars -> Chars

dropWhile :: (Char -> Bool) -> Chars -> Chars

dropWhileEnd :: (Char -> Bool) -> Chars -> Chars

span :: (Char -> Bool) -> Chars -> (Chars, Chars)

break :: (Char -> Bool) -> Chars -> (Chars, Chars)

group :: (ListLike full' Chars, Eq Char) => Chars -> full'

inits :: ListLike full' Chars => Chars -> full'

tails :: ListLike full' Chars => Chars -> full'

isPrefixOf :: Chars -> Chars -> Bool

isSuffixOf :: Chars -> Chars -> Bool

isInfixOf :: Chars -> Chars -> Bool

stripPrefix :: Chars -> Chars -> Maybe Chars

stripSuffix :: Chars -> Chars -> Maybe Chars

elem :: Char -> Chars -> Bool

notElem :: Char -> Chars -> Bool

find :: (Char -> Bool) -> Chars -> Maybe Char

filter :: (Char -> Bool) -> Chars -> Chars

partition :: (Char -> Bool) -> Chars -> (Chars, Chars)

index :: Chars -> Int -> Char

elemIndex :: Char -> Chars -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> Chars -> result

findIndex :: (Char -> Bool) -> Chars -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> Chars -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m Chars

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> Chars -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> Chars -> m Chars

nub :: Chars -> Chars

delete :: Char -> Chars -> Chars

deleteFirsts :: Chars -> Chars -> Chars

union :: Chars -> Chars -> Chars

intersect :: Chars -> Chars -> Chars

sort :: Chars -> Chars

insert :: Char -> Chars -> Chars

toList' :: Chars -> [Char]

fromList' :: [Char] -> Chars

fromListLike :: ListLike full' Char => Chars -> full'

nubBy :: (Char -> Char -> Bool) -> Chars -> Chars

deleteBy :: (Char -> Char -> Bool) -> Char -> Chars -> Chars

deleteFirstsBy :: (Char -> Char -> Bool) -> Chars -> Chars -> Chars

unionBy :: (Char -> Char -> Bool) -> Chars -> Chars -> Chars

intersectBy :: (Char -> Char -> Bool) -> Chars -> Chars -> Chars

groupBy :: (ListLike full' Chars, Eq Char) => (Char -> Char -> Bool) -> Chars -> full'

sortBy :: (Char -> Char -> Ordering) -> Chars -> Chars

insertBy :: (Char -> Char -> Ordering) -> Char -> Chars -> Chars

genericLength :: Num a => Chars -> a

genericTake :: Integral a => a -> Chars -> Chars

genericDrop :: Integral a => a -> Chars -> Chars

genericSplitAt :: Integral a => a -> Chars -> (Chars, Chars)

genericReplicate :: Integral a => a -> Char -> Chars

ListLike [a] a

Defined in Data.ListLike.Base

Methods

empty :: [a]

singleton :: a -> [a]

cons :: a -> [a] -> [a]

snoc :: [a] -> a -> [a]

append :: [a] -> [a] -> [a]

head :: [a] -> a

uncons :: [a] -> Maybe (a, [a])

last :: [a] -> a

tail :: [a] -> [a]

init :: [a] -> [a]

null :: [a] -> Bool

length :: [a] -> Int

map :: ListLike full' item' => (a -> item') -> [a] -> full'

rigidMap :: (a -> a) -> [a] -> [a]

reverse :: [a] -> [a]

intersperse :: a -> [a] -> [a]

concat :: ListLike full' [a] => full' -> [a]

concatMap :: ListLike full' item' => (a -> full') -> [a] -> full'

rigidConcatMap :: (a -> [a]) -> [a] -> [a]

any :: (a -> Bool) -> [a] -> Bool

all :: (a -> Bool) -> [a] -> Bool

maximum :: [a] -> a

minimum :: [a] -> a

replicate :: Int -> a -> [a]

take :: Int -> [a] -> [a]

drop :: Int -> [a] -> [a]

splitAt :: Int -> [a] -> ([a], [a])

takeWhile :: (a -> Bool) -> [a] -> [a]

dropWhile :: (a -> Bool) -> [a] -> [a]

dropWhileEnd :: (a -> Bool) -> [a] -> [a]

span :: (a -> Bool) -> [a] -> ([a], [a])

break :: (a -> Bool) -> [a] -> ([a], [a])

group :: (ListLike full' [a], Eq a) => [a] -> full'

inits :: ListLike full' [a] => [a] -> full'

tails :: ListLike full' [a] => [a] -> full'

isPrefixOf :: [a] -> [a] -> Bool

isSuffixOf :: [a] -> [a] -> Bool

isInfixOf :: [a] -> [a] -> Bool

stripPrefix :: [a] -> [a] -> Maybe [a]

stripSuffix :: [a] -> [a] -> Maybe [a]

elem :: a -> [a] -> Bool

notElem :: a -> [a] -> Bool

find :: (a -> Bool) -> [a] -> Maybe a

filter :: (a -> Bool) -> [a] -> [a]

partition :: (a -> Bool) -> [a] -> ([a], [a])

index :: [a] -> Int -> a

elemIndex :: a -> [a] -> Maybe Int

elemIndices :: (Eq a, ListLike result Int) => a -> [a] -> result

findIndex :: (a -> Bool) -> [a] -> Maybe Int

findIndices :: ListLike result Int => (a -> Bool) -> [a] -> result

sequence :: (Monad m, ListLike fullinp (m a)) => fullinp -> m [a]

mapM :: (Monad m, ListLike full' item') => (a -> m item') -> [a] -> m full'

rigidMapM :: Monad m => (a -> m a) -> [a] -> m [a]

nub :: [a] -> [a]

delete :: a -> [a] -> [a]

deleteFirsts :: [a] -> [a] -> [a]

union :: [a] -> [a] -> [a]

intersect :: [a] -> [a] -> [a]

sort :: [a] -> [a]

insert :: a -> [a] -> [a]

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

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

fromListLike :: ListLike full' a => [a] -> full'

nubBy :: (a -> a -> Bool) -> [a] -> [a]

deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]

deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]

groupBy :: (ListLike full' [a], Eq a) => (a -> a -> Bool) -> [a] -> full'

sortBy :: (a -> a -> Ordering) -> [a] -> [a]

insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]

genericLength :: Num a0 => [a] -> a0

genericTake :: Integral a0 => a0 -> [a] -> [a]

genericDrop :: Integral a0 => a0 -> [a] -> [a]

genericSplitAt :: Integral a0 => a0 -> [a] -> ([a], [a])

genericReplicate :: Integral a0 => a0 -> a -> [a]

(IsList (v a), Item (v a) ~ a, Monoid (v a), Eq (v a), Vector v a) => ListLike (v a) a

Defined in Data.ListLike.Vector.Generic

Methods

empty :: v a

singleton :: a -> v a

cons :: a -> v a -> v a

snoc :: v a -> a -> v a

append :: v a -> v a -> v a

head :: v a -> a

uncons :: v a -> Maybe (a, v a)

last :: v a -> a

tail :: v a -> v a

init :: v a -> v a

null :: v a -> Bool

length :: v a -> Int

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

rigidMap :: (a -> a) -> v a -> v a

reverse :: v a -> v a

intersperse :: a -> v a -> v a

concat :: ListLike full' (v a) => full' -> v a

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

rigidConcatMap :: (a -> v a) -> v a -> v a

any :: (a -> Bool) -> v a -> Bool

all :: (a -> Bool) -> v a -> Bool

maximum :: v a -> a

minimum :: v a -> a

replicate :: Int -> a -> v a

take :: Int -> v a -> v a

drop :: Int -> v a -> v a

splitAt :: Int -> v a -> (v a, v a)

takeWhile :: (a -> Bool) -> v a -> v a

dropWhile :: (a -> Bool) -> v a -> v a

dropWhileEnd :: (a -> Bool) -> v a -> v a

span :: (a -> Bool) -> v a -> (v a, v a)

break :: (a -> Bool) -> v a -> (v a, v a)

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

inits :: ListLike full' (v a) => v a -> full'

tails :: ListLike full' (v a) => v a -> full'

isPrefixOf :: v a -> v a -> Bool

isSuffixOf :: v a -> v a -> Bool

isInfixOf :: v a -> v a -> Bool

stripPrefix :: v a -> v a -> Maybe (v a)

stripSuffix :: v a -> v a -> Maybe (v a)

elem :: a -> v a -> Bool

notElem :: a -> v a -> Bool

find :: (a -> Bool) -> v a -> Maybe a

filter :: (a -> Bool) -> v a -> v a

partition :: (a -> Bool) -> v a -> (v a, v a)

index :: v a -> Int -> a

elemIndex :: a -> v a -> Maybe Int

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

findIndex :: (a -> Bool) -> v a -> Maybe Int

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

sequence :: (Monad m, ListLike fullinp (m a)) => fullinp -> m (v a)

mapM :: (Monad m, ListLike full' item') => (a -> m item') -> v a -> m full'

rigidMapM :: Monad m => (a -> m a) -> v a -> m (v a)

nub :: v a -> v a

delete :: a -> v a -> v a

deleteFirsts :: v a -> v a -> v a

union :: v a -> v a -> v a

intersect :: v a -> v a -> v a

sort :: v a -> v a

insert :: a -> v a -> v a

toList' :: v a -> [a]

fromList' :: [a] -> v a

fromListLike :: ListLike full' a => v a -> full'

nubBy :: (a -> a -> Bool) -> v a -> v a

deleteBy :: (a -> a -> Bool) -> a -> v a -> v a

deleteFirstsBy :: (a -> a -> Bool) -> v a -> v a -> v a

unionBy :: (a -> a -> Bool) -> v a -> v a -> v a

intersectBy :: (a -> a -> Bool) -> v a -> v a -> v a

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

sortBy :: (a -> a -> Ordering) -> v a -> v a

insertBy :: (a -> a -> Ordering) -> a -> v a -> v a

genericLength :: Num a0 => v a -> a0

genericTake :: Integral a0 => a0 -> v a -> v a

genericDrop :: Integral a0 => a0 -> v a -> v a

genericSplitAt :: Integral a0 => a0 -> v a -> (v a, v a)

genericReplicate :: Integral a0 => a0 -> a -> v a

ListLike (Seq a) a

Defined in Data.ListLike.Instances

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 :: (Monad m, ListLike fullinp (m a)) => fullinp -> m (Seq a)

mapM :: (Monad 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

ListLike (FMList a) a

Defined in Data.ListLike.FMList

Methods

empty :: FMList a

singleton :: a -> FMList a

cons :: a -> FMList a -> FMList a

snoc :: FMList a -> a -> FMList a

append :: FMList a -> FMList a -> FMList a

head :: FMList a -> a

uncons :: FMList a -> Maybe (a, FMList a)

last :: FMList a -> a

tail :: FMList a -> FMList a

init :: FMList a -> FMList a

null :: FMList a -> Bool

length :: FMList a -> Int

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

rigidMap :: (a -> a) -> FMList a -> FMList a

reverse :: FMList a -> FMList a

intersperse :: a -> FMList a -> FMList a

concat :: ListLike full' (FMList a) => full' -> FMList a

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

rigidConcatMap :: (a -> FMList a) -> FMList a -> FMList a

any :: (a -> Bool) -> FMList a -> Bool

all :: (a -> Bool) -> FMList a -> Bool

maximum :: FMList a -> a

minimum :: FMList a -> a

replicate :: Int -> a -> FMList a

take :: Int -> FMList a -> FMList a

drop :: Int -> FMList a -> FMList a

splitAt :: Int -> FMList a -> (FMList a, FMList a)

takeWhile :: (a -> Bool) -> FMList a -> FMList a

dropWhile :: (a -> Bool) -> FMList a -> FMList a

dropWhileEnd :: (a -> Bool) -> FMList a -> FMList a

span :: (a -> Bool) -> FMList a -> (FMList a, FMList a)

break :: (a -> Bool) -> FMList a -> (FMList a, FMList a)

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

inits :: ListLike full' (FMList a) => FMList a -> full'

tails :: ListLike full' (FMList a) => FMList a -> full'

isPrefixOf :: FMList a -> FMList a -> Bool

isSuffixOf :: FMList a -> FMList a -> Bool

isInfixOf :: FMList a -> FMList a -> Bool

stripPrefix :: FMList a -> FMList a -> Maybe (FMList a)

stripSuffix :: FMList a -> FMList a -> Maybe (FMList a)

elem :: a -> FMList a -> Bool

notElem :: a -> FMList a -> Bool

find :: (a -> Bool) -> FMList a -> Maybe a

filter :: (a -> Bool) -> FMList a -> FMList a

partition :: (a -> Bool) -> FMList a -> (FMList a, FMList a)

index :: FMList a -> Int -> a

elemIndex :: a -> FMList a -> Maybe Int

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

findIndex :: (a -> Bool) -> FMList a -> Maybe Int

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

sequence :: (Monad m, ListLike fullinp (m a)) => fullinp -> m (FMList a)

mapM :: (Monad m, ListLike full' item') => (a -> m item') -> FMList a -> m full'

rigidMapM :: Monad m => (a -> m a) -> FMList a -> m (FMList a)

nub :: FMList a -> FMList a

delete :: a -> FMList a -> FMList a

deleteFirsts :: FMList a -> FMList a -> FMList a

union :: FMList a -> FMList a -> FMList a

intersect :: FMList a -> FMList a -> FMList a

sort :: FMList a -> FMList a

insert :: a -> FMList a -> FMList a

toList' :: FMList a -> [a]

fromList' :: [a] -> FMList a

fromListLike :: ListLike full' a => FMList a -> full'

nubBy :: (a -> a -> Bool) -> FMList a -> FMList a

deleteBy :: (a -> a -> Bool) -> a -> FMList a -> FMList a

deleteFirstsBy :: (a -> a -> Bool) -> FMList a -> FMList a -> FMList a

unionBy :: (a -> a -> Bool) -> FMList a -> FMList a -> FMList a

intersectBy :: (a -> a -> Bool) -> FMList a -> FMList a -> FMList a

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

sortBy :: (a -> a -> Ordering) -> FMList a -> FMList a

insertBy :: (a -> a -> Ordering) -> a -> FMList a -> FMList a

genericLength :: Num a0 => FMList a -> a0

genericTake :: Integral a0 => a0 -> FMList a -> FMList a

genericDrop :: Integral a0 => a0 -> FMList a -> FMList a

genericSplitAt :: Integral a0 => a0 -> FMList a -> (FMList a, FMList a)

genericReplicate :: Integral a0 => a0 -> a -> FMList a

ListLike (DList a) a

Defined in Data.ListLike.DList

Methods

empty :: DList a

singleton :: a -> DList a

cons :: a -> DList a -> DList a

snoc :: DList a -> a -> DList a

append :: DList a -> DList a -> DList a

head :: DList a -> a

uncons :: DList a -> Maybe (a, DList a)

last :: DList a -> a

tail :: DList a -> DList a

init :: DList a -> DList a

null :: DList a -> Bool

length :: DList a -> Int

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

rigidMap :: (a -> a) -> DList a -> DList a

reverse :: DList a -> DList a

intersperse :: a -> DList a -> DList a

concat :: ListLike full' (DList a) => full' -> DList a

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

rigidConcatMap :: (a -> DList a) -> DList a -> DList a

any :: (a -> Bool) -> DList a -> Bool

all :: (a -> Bool) -> DList a -> Bool

maximum :: DList a -> a

minimum :: DList a -> a

replicate :: Int -> a -> DList a

take :: Int -> DList a -> DList a

drop :: Int -> DList a -> DList a

splitAt :: Int -> DList a -> (DList a, DList a)

takeWhile :: (a -> Bool) -> DList a -> DList a

dropWhile :: (a -> Bool) -> DList a -> DList a

dropWhileEnd :: (a -> Bool) -> DList a -> DList a

span :: (a -> Bool) -> DList a -> (DList a, DList a)

break :: (a -> Bool) -> DList a -> (DList a, DList a)

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

inits :: ListLike full' (DList a) => DList a -> full'

tails :: ListLike full' (DList a) => DList a -> full'

isPrefixOf :: DList a -> DList a -> Bool

isSuffixOf :: DList a -> DList a -> Bool

isInfixOf :: DList a -> DList a -> Bool

stripPrefix :: DList a -> DList a -> Maybe (DList a)

stripSuffix :: DList a -> DList a -> Maybe (DList a)

elem :: a -> DList a -> Bool

notElem :: a -> DList a -> Bool

find :: (a -> Bool) -> DList a -> Maybe a

filter :: (a -> Bool) -> DList a -> DList a

partition :: (a -> Bool) -> DList a -> (DList a, DList a)

index :: DList a -> Int -> a

elemIndex :: a -> DList a -> Maybe Int

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

findIndex :: (a -> Bool) -> DList a -> Maybe Int

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

sequence :: (Monad m, ListLike fullinp (m a)) => fullinp -> m (DList a)

mapM :: (Monad m, ListLike full' item') => (a -> m item') -> DList a -> m full'

rigidMapM :: Monad m => (a -> m a) -> DList a -> m (DList a)

nub :: DList a -> DList a

delete :: a -> DList a -> DList a

deleteFirsts :: DList a -> DList a -> DList a

union :: DList a -> DList a -> DList a

intersect :: DList a -> DList a -> DList a

sort :: DList a -> DList a

insert :: a -> DList a -> DList a

toList' :: DList a -> [a]

fromList' :: [a] -> DList a

fromListLike :: ListLike full' a => DList a -> full'

nubBy :: (a -> a -> Bool) -> DList a -> DList a

deleteBy :: (a -> a -> Bool) -> a -> DList a -> DList a

deleteFirstsBy :: (a -> a -> Bool) -> DList a -> DList a -> DList a

unionBy :: (a -> a -> Bool) -> DList a -> DList a -> DList a

intersectBy :: (a -> a -> Bool) -> DList a -> DList a -> DList a

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

sortBy :: (a -> a -> Ordering) -> DList a -> DList a

insertBy :: (a -> a -> Ordering) -> a -> DList a -> DList a

genericLength :: Num a0 => DList a -> a0

genericTake :: Integral a0 => a0 -> DList a -> DList a

genericDrop :: Integral a0 => a0 -> DList a -> DList a

genericSplitAt :: Integral a0 => a0 -> DList a -> (DList a, DList a)

genericReplicate :: Integral a0 => a0 -> a -> DList a

ListLike (UTF8 ByteString) Char

Defined in Data.ListLike.UTF8

Methods

empty :: UTF8 ByteString

singleton :: Char -> UTF8 ByteString

cons :: Char -> UTF8 ByteString -> UTF8 ByteString

snoc :: UTF8 ByteString -> Char -> UTF8 ByteString

append :: UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

head :: UTF8 ByteString -> Char

uncons :: UTF8 ByteString -> Maybe (Char, UTF8 ByteString)

last :: UTF8 ByteString -> Char

tail :: UTF8 ByteString -> UTF8 ByteString

init :: UTF8 ByteString -> UTF8 ByteString

null :: UTF8 ByteString -> Bool

length :: UTF8 ByteString -> Int

map :: ListLike full' item' => (Char -> item') -> UTF8 ByteString -> full'

rigidMap :: (Char -> Char) -> UTF8 ByteString -> UTF8 ByteString

reverse :: UTF8 ByteString -> UTF8 ByteString

intersperse :: Char -> UTF8 ByteString -> UTF8 ByteString

concat :: ListLike full' (UTF8 ByteString) => full' -> UTF8 ByteString

concatMap :: ListLike full' item' => (Char -> full') -> UTF8 ByteString -> full'

rigidConcatMap :: (Char -> UTF8 ByteString) -> UTF8 ByteString -> UTF8 ByteString

any :: (Char -> Bool) -> UTF8 ByteString -> Bool

all :: (Char -> Bool) -> UTF8 ByteString -> Bool

maximum :: UTF8 ByteString -> Char

minimum :: UTF8 ByteString -> Char

replicate :: Int -> Char -> UTF8 ByteString

take :: Int -> UTF8 ByteString -> UTF8 ByteString

drop :: Int -> UTF8 ByteString -> UTF8 ByteString

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

takeWhile :: (Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString

dropWhile :: (Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString

dropWhileEnd :: (Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString

span :: (Char -> Bool) -> UTF8 ByteString -> (UTF8 ByteString, UTF8 ByteString)

break :: (Char -> Bool) -> UTF8 ByteString -> (UTF8 ByteString, UTF8 ByteString)

group :: (ListLike full' (UTF8 ByteString), Eq Char) => UTF8 ByteString -> full'

inits :: ListLike full' (UTF8 ByteString) => UTF8 ByteString -> full'

tails :: ListLike full' (UTF8 ByteString) => UTF8 ByteString -> full'

isPrefixOf :: UTF8 ByteString -> UTF8 ByteString -> Bool

isSuffixOf :: UTF8 ByteString -> UTF8 ByteString -> Bool

isInfixOf :: UTF8 ByteString -> UTF8 ByteString -> Bool

stripPrefix :: UTF8 ByteString -> UTF8 ByteString -> Maybe (UTF8 ByteString)

stripSuffix :: UTF8 ByteString -> UTF8 ByteString -> Maybe (UTF8 ByteString)

elem :: Char -> UTF8 ByteString -> Bool

notElem :: Char -> UTF8 ByteString -> Bool

find :: (Char -> Bool) -> UTF8 ByteString -> Maybe Char

filter :: (Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString

partition :: (Char -> Bool) -> UTF8 ByteString -> (UTF8 ByteString, UTF8 ByteString)

index :: UTF8 ByteString -> Int -> Char

elemIndex :: Char -> UTF8 ByteString -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> UTF8 ByteString -> result

findIndex :: (Char -> Bool) -> UTF8 ByteString -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> UTF8 ByteString -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m (UTF8 ByteString)

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> UTF8 ByteString -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> UTF8 ByteString -> m (UTF8 ByteString)

nub :: UTF8 ByteString -> UTF8 ByteString

delete :: Char -> UTF8 ByteString -> UTF8 ByteString

deleteFirsts :: UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

union :: UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

intersect :: UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

sort :: UTF8 ByteString -> UTF8 ByteString

insert :: Char -> UTF8 ByteString -> UTF8 ByteString

toList' :: UTF8 ByteString -> [Char]

fromList' :: [Char] -> UTF8 ByteString

fromListLike :: ListLike full' Char => UTF8 ByteString -> full'

nubBy :: (Char -> Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString

deleteBy :: (Char -> Char -> Bool) -> Char -> UTF8 ByteString -> UTF8 ByteString

deleteFirstsBy :: (Char -> Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

unionBy :: (Char -> Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

intersectBy :: (Char -> Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

groupBy :: (ListLike full' (UTF8 ByteString), Eq Char) => (Char -> Char -> Bool) -> UTF8 ByteString -> full'

sortBy :: (Char -> Char -> Ordering) -> UTF8 ByteString -> UTF8 ByteString

insertBy :: (Char -> Char -> Ordering) -> Char -> UTF8 ByteString -> UTF8 ByteString

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

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

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

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

genericReplicate :: Integral a => a -> Char -> UTF8 ByteString

ListLike (UTF8 ByteString) Char

Defined in Data.ListLike.UTF8

Methods

empty :: UTF8 ByteString

singleton :: Char -> UTF8 ByteString

cons :: Char -> UTF8 ByteString -> UTF8 ByteString

snoc :: UTF8 ByteString -> Char -> UTF8 ByteString

append :: UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

head :: UTF8 ByteString -> Char

uncons :: UTF8 ByteString -> Maybe (Char, UTF8 ByteString)

last :: UTF8 ByteString -> Char

tail :: UTF8 ByteString -> UTF8 ByteString

init :: UTF8 ByteString -> UTF8 ByteString

null :: UTF8 ByteString -> Bool

length :: UTF8 ByteString -> Int

map :: ListLike full' item' => (Char -> item') -> UTF8 ByteString -> full'

rigidMap :: (Char -> Char) -> UTF8 ByteString -> UTF8 ByteString

reverse :: UTF8 ByteString -> UTF8 ByteString

intersperse :: Char -> UTF8 ByteString -> UTF8 ByteString

concat :: ListLike full' (UTF8 ByteString) => full' -> UTF8 ByteString

concatMap :: ListLike full' item' => (Char -> full') -> UTF8 ByteString -> full'

rigidConcatMap :: (Char -> UTF8 ByteString) -> UTF8 ByteString -> UTF8 ByteString

any :: (Char -> Bool) -> UTF8 ByteString -> Bool

all :: (Char -> Bool) -> UTF8 ByteString -> Bool

maximum :: UTF8 ByteString -> Char

minimum :: UTF8 ByteString -> Char

replicate :: Int -> Char -> UTF8 ByteString

take :: Int -> UTF8 ByteString -> UTF8 ByteString

drop :: Int -> UTF8 ByteString -> UTF8 ByteString

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

takeWhile :: (Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString

dropWhile :: (Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString

dropWhileEnd :: (Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString

span :: (Char -> Bool) -> UTF8 ByteString -> (UTF8 ByteString, UTF8 ByteString)

break :: (Char -> Bool) -> UTF8 ByteString -> (UTF8 ByteString, UTF8 ByteString)

group :: (ListLike full' (UTF8 ByteString), Eq Char) => UTF8 ByteString -> full'

inits :: ListLike full' (UTF8 ByteString) => UTF8 ByteString -> full'

tails :: ListLike full' (UTF8 ByteString) => UTF8 ByteString -> full'

isPrefixOf :: UTF8 ByteString -> UTF8 ByteString -> Bool

isSuffixOf :: UTF8 ByteString -> UTF8 ByteString -> Bool

isInfixOf :: UTF8 ByteString -> UTF8 ByteString -> Bool

stripPrefix :: UTF8 ByteString -> UTF8 ByteString -> Maybe (UTF8 ByteString)

stripSuffix :: UTF8 ByteString -> UTF8 ByteString -> Maybe (UTF8 ByteString)

elem :: Char -> UTF8 ByteString -> Bool

notElem :: Char -> UTF8 ByteString -> Bool

find :: (Char -> Bool) -> UTF8 ByteString -> Maybe Char

filter :: (Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString

partition :: (Char -> Bool) -> UTF8 ByteString -> (UTF8 ByteString, UTF8 ByteString)

index :: UTF8 ByteString -> Int -> Char

elemIndex :: Char -> UTF8 ByteString -> Maybe Int

elemIndices :: (Eq Char, ListLike result Int) => Char -> UTF8 ByteString -> result

findIndex :: (Char -> Bool) -> UTF8 ByteString -> Maybe Int

findIndices :: ListLike result Int => (Char -> Bool) -> UTF8 ByteString -> result

sequence :: (Monad m, ListLike fullinp (m Char)) => fullinp -> m (UTF8 ByteString)

mapM :: (Monad m, ListLike full' item') => (Char -> m item') -> UTF8 ByteString -> m full'

rigidMapM :: Monad m => (Char -> m Char) -> UTF8 ByteString -> m (UTF8 ByteString)

nub :: UTF8 ByteString -> UTF8 ByteString

delete :: Char -> UTF8 ByteString -> UTF8 ByteString

deleteFirsts :: UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

union :: UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

intersect :: UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

sort :: UTF8 ByteString -> UTF8 ByteString

insert :: Char -> UTF8 ByteString -> UTF8 ByteString

toList' :: UTF8 ByteString -> [Char]

fromList' :: [Char] -> UTF8 ByteString

fromListLike :: ListLike full' Char => UTF8 ByteString -> full'

nubBy :: (Char -> Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString

deleteBy :: (Char -> Char -> Bool) -> Char -> UTF8 ByteString -> UTF8 ByteString

deleteFirstsBy :: (Char -> Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

unionBy :: (Char -> Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

intersectBy :: (Char -> Char -> Bool) -> UTF8 ByteString -> UTF8 ByteString -> UTF8 ByteString

groupBy :: (ListLike full' (UTF8 ByteString), Eq Char) => (Char -> Char -> Bool) -> UTF8 ByteString -> full'

sortBy :: (Char -> Char -> Ordering) -> UTF8 ByteString -> UTF8 ByteString

insertBy :: (Char -> Char -> Ordering) -> Char -> UTF8 ByteString -> UTF8 ByteString

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

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

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

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

genericReplicate :: Integral a => a -> Char -> UTF8 ByteString

Storable a => ListLike (Vector a) a

Defined in Data.ListLike.Vector.Storable

Methods

empty :: Vector a

singleton :: a -> Vector a

cons :: a -> Vector a -> Vector a

snoc :: Vector a -> a -> Vector a

append :: Vector a -> Vector a -> Vector a

head :: Vector a -> a

uncons :: Vector a -> Maybe (a, Vector a)

last :: Vector a -> a

tail :: Vector a -> Vector a

init :: Vector a -> Vector a

null :: Vector a -> Bool

length :: Vector a -> Int

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

rigidMap :: (a -> a) -> Vector a -> Vector a

reverse :: Vector a -> Vector a

intersperse :: a -> Vector a -> Vector a

concat :: ListLike full' (Vector a) => full' -> Vector a

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

rigidConcatMap :: (a -> Vector a) -> Vector a -> Vector a

any :: (a -> Bool) -> Vector a -> Bool

all :: (a -> Bool) -> Vector a -> Bool

maximum :: Vector a -> a

minimum :: Vector a -> a

replicate :: Int -> a -> Vector a

take :: Int -> Vector a -> Vector a

drop :: Int -> Vector a -> Vector a

splitAt :: Int -> Vector a -> (Vector a, Vector a)

takeWhile :: (a -> Bool) -> Vector a -> Vector a

dropWhile :: (a -> Bool) -> Vector a -> Vector a

dropWhileEnd :: (a -> Bool) -> Vector a -> Vector a

span :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

break :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

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

inits :: ListLike full' (Vector a) => Vector a -> full'

tails :: ListLike full' (Vector a) => Vector a -> full'

isPrefixOf :: Vector a -> Vector a -> Bool

isSuffixOf :: Vector a -> Vector a -> Bool

isInfixOf :: Vector a -> Vector a -> Bool

stripPrefix :: Vector a -> Vector a -> Maybe (Vector a)

stripSuffix :: Vector a -> Vector a -> Maybe (Vector a)

elem :: a -> Vector a -> Bool

notElem :: a -> Vector a -> Bool

find :: (a -> Bool) -> Vector a -> Maybe a

filter :: (a -> Bool) -> Vector a -> Vector a

partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

index :: Vector a -> Int -> a

elemIndex :: a -> Vector a -> Maybe Int

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

findIndex :: (a -> Bool) -> Vector a -> Maybe Int

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

sequence :: (Monad m, ListLike fullinp (m a)) => fullinp -> m (Vector a)

mapM :: (Monad m, ListLike full' item') => (a -> m item') -> Vector a -> m full'

rigidMapM :: Monad m => (a -> m a) -> Vector a -> m (Vector a)

nub :: Vector a -> Vector a

delete :: a -> Vector a -> Vector a

deleteFirsts :: Vector a -> Vector a -> Vector a

union :: Vector a -> Vector a -> Vector a

intersect :: Vector a -> Vector a -> Vector a

sort :: Vector a -> Vector a

insert :: a -> Vector a -> Vector a

toList' :: Vector a -> [a]

fromList' :: [a] -> Vector a

fromListLike :: ListLike full' a => Vector a -> full'

nubBy :: (a -> a -> Bool) -> Vector a -> Vector a

deleteBy :: (a -> a -> Bool) -> a -> Vector a -> Vector a

deleteFirstsBy :: (a -> a -> Bool) -> Vector a -> Vector a -> Vector a

unionBy :: (a -> a -> Bool) -> Vector a -> Vector a -> Vector a

intersectBy :: (a -> a -> Bool) -> Vector a -> Vector a -> Vector a

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

sortBy :: (a -> a -> Ordering) -> Vector a -> Vector a

insertBy :: (a -> a -> Ordering) -> a -> Vector a -> Vector a

genericLength :: Num a0 => Vector a -> a0

genericTake :: Integral a0 => a0 -> Vector a -> Vector a

genericDrop :: Integral a0 => a0 -> Vector a -> Vector a

genericSplitAt :: Integral a0 => a0 -> Vector a -> (Vector a, Vector a)

genericReplicate :: Integral a0 => a0 -> a -> Vector a

Unbox a => ListLike (Vector a) a

Defined in Data.ListLike.Vector.Unboxed

Methods

empty :: Vector a

singleton :: a -> Vector a

cons :: a -> Vector a -> Vector a

snoc :: Vector a -> a -> Vector a

append :: Vector a -> Vector a -> Vector a

head :: Vector a -> a

uncons :: Vector a -> Maybe (a, Vector a)

last :: Vector a -> a

tail :: Vector a -> Vector a

init :: Vector a -> Vector a

null :: Vector a -> Bool

length :: Vector a -> Int

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

rigidMap :: (a -> a) -> Vector a -> Vector a

reverse :: Vector a -> Vector a

intersperse :: a -> Vector a -> Vector a

concat :: ListLike full' (Vector a) => full' -> Vector a

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

rigidConcatMap :: (a -> Vector a) -> Vector a -> Vector a

any :: (a -> Bool) -> Vector a -> Bool

all :: (a -> Bool) -> Vector a -> Bool

maximum :: Vector a -> a

minimum :: Vector a -> a

replicate :: Int -> a -> Vector a

take :: Int -> Vector a -> Vector a

drop :: Int -> Vector a -> Vector a

splitAt :: Int -> Vector a -> (Vector a, Vector a)

takeWhile :: (a -> Bool) -> Vector a -> Vector a

dropWhile :: (a -> Bool) -> Vector a -> Vector a

dropWhileEnd :: (a -> Bool) -> Vector a -> Vector a

span :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

break :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

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

inits :: ListLike full' (Vector a) => Vector a -> full'

tails :: ListLike full' (Vector a) => Vector a -> full'

isPrefixOf :: Vector a -> Vector a -> Bool

isSuffixOf :: Vector a -> Vector a -> Bool

isInfixOf :: Vector a -> Vector a -> Bool

stripPrefix :: Vector a -> Vector a -> Maybe (Vector a)

stripSuffix :: Vector a -> Vector a -> Maybe (Vector a)

elem :: a -> Vector a -> Bool

notElem :: a -> Vector a -> Bool

find :: (a -> Bool) -> Vector a -> Maybe a

filter :: (a -> Bool) -> Vector a -> Vector a

partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

index :: Vector a -> Int -> a

elemIndex :: a -> Vector a -> Maybe Int

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

findIndex :: (a -> Bool) -> Vector a -> Maybe Int

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

sequence :: (Monad m, ListLike fullinp (m a)) => fullinp -> m (Vector a)

mapM :: (Monad m, ListLike full' item') => (a -> m item') -> Vector a -> m full'

rigidMapM :: Monad m => (a -> m a) -> Vector a -> m (Vector a)

nub :: Vector a -> Vector a

delete :: a -> Vector a -> Vector a

deleteFirsts :: Vector a -> Vector a -> Vector a

union :: Vector a -> Vector a -> Vector a

intersect :: Vector a -> Vector a -> Vector a

sort :: Vector a -> Vector a

insert :: a -> Vector a -> Vector a

toList' :: Vector a -> [a]

fromList' :: [a] -> Vector a

fromListLike :: ListLike full' a => Vector a -> full'

nubBy :: (a -> a -> Bool) -> Vector a -> Vector a

deleteBy :: (a -> a -> Bool) -> a -> Vector a -> Vector a

deleteFirstsBy :: (a -> a -> Bool) -> Vector a -> Vector a -> Vector a

unionBy :: (a -> a -> Bool) -> Vector a -> Vector a -> Vector a

intersectBy :: (a -> a -> Bool) -> Vector a -> Vector a -> Vector a

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

sortBy :: (a -> a -> Ordering) -> Vector a -> Vector a

insertBy :: (a -> a -> Ordering) -> a -> Vector a -> Vector a

genericLength :: Num a0 => Vector a -> a0

genericTake :: Integral a0 => a0 -> Vector a -> Vector a

genericDrop :: Integral a0 => a0 -> Vector a -> Vector a

genericSplitAt :: Integral a0 => a0 -> Vector a -> (Vector a, Vector a)

genericReplicate :: Integral a0 => a0 -> a -> Vector a

ListLike (Vector a) a

Defined in Data.ListLike.Vector.Vector

Methods

empty :: Vector a

singleton :: a -> Vector a

cons :: a -> Vector a -> Vector a

snoc :: Vector a -> a -> Vector a

append :: Vector a -> Vector a -> Vector a

head :: Vector a -> a

uncons :: Vector a -> Maybe (a, Vector a)

last :: Vector a -> a

tail :: Vector a -> Vector a

init :: Vector a -> Vector a

null :: Vector a -> Bool

length :: Vector a -> Int

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

rigidMap :: (a -> a) -> Vector a -> Vector a

reverse :: Vector a -> Vector a

intersperse :: a -> Vector a -> Vector a

concat :: ListLike full' (Vector a) => full' -> Vector a

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

rigidConcatMap :: (a -> Vector a) -> Vector a -> Vector a

any :: (a -> Bool) -> Vector a -> Bool

all :: (a -> Bool) -> Vector a -> Bool

maximum :: Vector a -> a

minimum :: Vector a -> a

replicate :: Int -> a -> Vector a

take :: Int -> Vector a -> Vector a

drop :: Int -> Vector a -> Vector a

splitAt :: Int -> Vector a -> (Vector a, Vector a)

takeWhile :: (a -> Bool) -> Vector a -> Vector a

dropWhile :: (a -> Bool) -> Vector a -> Vector a

dropWhileEnd :: (a -> Bool) -> Vector a -> Vector a

span :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

break :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

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

inits :: ListLike full' (Vector a) => Vector a -> full'

tails :: ListLike full' (Vector a) => Vector a -> full'

isPrefixOf :: Vector a -> Vector a -> Bool

isSuffixOf :: Vector a -> Vector a -> Bool

isInfixOf :: Vector a -> Vector a -> Bool

stripPrefix :: Vector a -> Vector a -> Maybe (Vector a)

stripSuffix :: Vector a -> Vector a -> Maybe (Vector a)

elem :: a -> Vector a -> Bool

notElem :: a -> Vector a -> Bool

find :: (a -> Bool) -> Vector a -> Maybe a

filter :: (a -> Bool) -> Vector a -> Vector a

partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)

index :: Vector a -> Int -> a

elemIndex :: a -> Vector a -> Maybe Int

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

findIndex :: (a -> Bool) -> Vector a -> Maybe Int

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

sequence :: (Monad m, ListLike fullinp (m a)) => fullinp -> m (Vector a)

mapM :: (Monad m, ListLike full' item') => (a -> m item') -> Vector a -> m full'

rigidMapM :: Monad m => (a -> m a) -> Vector a -> m (Vector a)

nub :: Vector a -> Vector a

delete :: a -> Vector a -> Vector a

deleteFirsts :: Vector a -> Vector a -> Vector a

union :: Vector a -> Vector a -> Vector a

intersect :: Vector a -> Vector a -> Vector a

sort :: Vector a -> Vector a

insert :: a -> Vector a -> Vector a

toList' :: Vector a -> [a]

fromList' :: [a] -> Vector a

fromListLike :: ListLike full' a => Vector a -> full'

nubBy :: (a -> a -> Bool) -> Vector a -> Vector a

deleteBy :: (a -> a -> Bool) -> a -> Vector a -> Vector a

deleteFirstsBy :: (a -> a -> Bool) -> Vector a -> Vector a -> Vector a

unionBy :: (a -> a -> Bool) -> Vector a -> Vector a -> Vector a

intersectBy :: (a -> a -> Bool) -> Vector a -> Vector a -> Vector a

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

sortBy :: (a -> a -> Ordering) -> Vector a -> Vector a

insertBy :: (a -> a -> Ordering) -> a -> Vector a -> Vector a

genericLength :: Num a0 => Vector a -> a0

genericTake :: Integral a0 => a0 -> Vector a -> Vector a

genericDrop :: Integral a0 => a0 -> Vector a -> Vector a

genericSplitAt :: Integral a0 => a0 -> Vector a -> (Vector a, Vector a)

genericReplicate :: Integral a0 => a0 -> a -> Vector a

(Integral i, Ix i) => ListLike (Array i e) e

Defined in Data.ListLike.Instances

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 :: (Monad m, ListLike fullinp (m e)) => fullinp -> m (Array i e)

mapM :: (Monad 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

type ListOps full = ListLike full (Item full)

A version of ListLike with a single type parameter, the item type is obtained using the Item type function from IsList.

The FoldableLL class

class FoldableLL full item | full -> item

This is the primary class for structures that are to be considered foldable. A minimum complete definition provides foldl and foldr.

Instances of FoldableLL can be folded, and can be many and varied.

These functions are used heavily in Data.ListLike.

Minimal complete definition

foldl, foldr

Instances

FoldableLL ByteString Word8

Defined in Data.ListLike.Instances

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

Defined in Data.ListLike.Instances

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 Builder Char

Defined in Data.ListLike.Text.Builder

Methods

foldl :: (a -> Char -> a) -> a -> Builder -> a

foldl' :: (a -> Char -> a) -> a -> Builder -> a

foldl1 :: (Char -> Char -> Char) -> Builder -> Char

foldr :: (Char -> b -> b) -> b -> Builder -> b

foldr' :: (Char -> b -> b) -> b -> Builder -> b

foldr1 :: (Char -> Char -> Char) -> Builder -> Char

FoldableLL Text Char

Defined in Data.ListLike.Text.TextLazy

Methods

foldl :: (a -> Char -> a) -> a -> Text -> a

foldl' :: (a -> Char -> a) -> a -> Text -> a

foldl1 :: (Char -> Char -> Char) -> Text -> Char

foldr :: (Char -> b -> b) -> b -> Text -> b

foldr' :: (Char -> b -> b) -> b -> Text -> b

foldr1 :: (Char -> Char -> Char) -> Text -> Char

FoldableLL Text Char

Defined in Data.ListLike.Text.Text

Methods

foldl :: (a -> Char -> a) -> a -> Text -> a

foldl' :: (a -> Char -> a) -> a -> Text -> a

foldl1 :: (Char -> Char -> Char) -> Text -> Char

foldr :: (Char -> b -> b) -> b -> Text -> b

foldr' :: (Char -> b -> b) -> b -> Text -> b

foldr1 :: (Char -> Char -> Char) -> Text -> Char

FoldableLL CharStringLazy Char

Defined in Data.ListLike.CharString

Methods

foldl :: (a -> Char -> a) -> a -> CharStringLazy -> a

foldl' :: (a -> Char -> a) -> a -> CharStringLazy -> a

foldl1 :: (Char -> Char -> Char) -> CharStringLazy -> Char

foldr :: (Char -> b -> b) -> b -> CharStringLazy -> b

foldr' :: (Char -> b -> b) -> b -> CharStringLazy -> b

foldr1 :: (Char -> Char -> Char) -> CharStringLazy -> Char

FoldableLL CharString Char

Defined in Data.ListLike.CharString

Methods

foldl :: (a -> Char -> a) -> a -> CharString -> a

foldl' :: (a -> Char -> a) -> a -> CharString -> a

foldl1 :: (Char -> Char -> Char) -> CharString -> Char

foldr :: (Char -> b -> b) -> b -> CharString -> b

foldr' :: (Char -> b -> b) -> b -> CharString -> b

foldr1 :: (Char -> Char -> Char) -> CharString -> Char

FoldableLL Chars Char

Defined in Data.ListLike.Chars

Methods

foldl :: (a -> Char -> a) -> a -> Chars -> a

foldl' :: (a -> Char -> a) -> a -> Chars -> a

foldl1 :: (Char -> Char -> Char) -> Chars -> Char

foldr :: (Char -> b -> b) -> b -> Chars -> b

foldr' :: (Char -> b -> b) -> b -> Chars -> b

foldr1 :: (Char -> Char -> Char) -> Chars -> Char

FoldableLL [a] a

Defined in Data.ListLike.FoldableLL

Methods

foldl :: (a0 -> a -> a0) -> a0 -> [a] -> a0

foldl' :: (a0 -> a -> a0) -> a0 -> [a] -> a0

foldl1 :: (a -> a -> a) -> [a] -> a

foldr :: (a -> b -> b) -> b -> [a] -> b

foldr' :: (a -> b -> b) -> b -> [a] -> b

foldr1 :: (a -> a -> a) -> [a] -> a

Vector v a => FoldableLL (v a) a

Defined in Data.ListLike.Vector.Generic

Methods

foldl :: (a0 -> a -> a0) -> a0 -> v a -> a0

foldl' :: (a0 -> a -> a0) -> a0 -> v a -> a0

foldl1 :: (a -> a -> a) -> v a -> a

foldr :: (a -> b -> b) -> b -> v a -> b

foldr' :: (a -> b -> b) -> b -> v a -> b

foldr1 :: (a -> a -> a) -> v a -> a

FoldableLL (Seq a) a

Defined in Data.ListLike.Instances

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

FoldableLL (FMList a) a

Defined in Data.ListLike.FMList

Methods

foldl :: (a0 -> a -> a0) -> a0 -> FMList a -> a0

foldl' :: (a0 -> a -> a0) -> a0 -> FMList a -> a0

foldl1 :: (a -> a -> a) -> FMList a -> a

foldr :: (a -> b -> b) -> b -> FMList a -> b

foldr' :: (a -> b -> b) -> b -> FMList a -> b

foldr1 :: (a -> a -> a) -> FMList a -> a

FoldableLL (DList a) a

Defined in Data.ListLike.DList

Methods

foldl :: (a0 -> a -> a0) -> a0 -> DList a -> a0

foldl' :: (a0 -> a -> a0) -> a0 -> DList a -> a0

foldl1 :: (a -> a -> a) -> DList a -> a

foldr :: (a -> b -> b) -> b -> DList a -> b

foldr' :: (a -> b -> b) -> b -> DList a -> b

foldr1 :: (a -> a -> a) -> DList a -> a

FoldableLL (UTF8 ByteString) Char

Defined in Data.ListLike.UTF8

Methods

foldl :: (a -> Char -> a) -> a -> UTF8 ByteString -> a

foldl' :: (a -> Char -> a) -> a -> UTF8 ByteString -> a

foldl1 :: (Char -> Char -> Char) -> UTF8 ByteString -> Char

foldr :: (Char -> b -> b) -> b -> UTF8 ByteString -> b

foldr' :: (Char -> b -> b) -> b -> UTF8 ByteString -> b

foldr1 :: (Char -> Char -> Char) -> UTF8 ByteString -> Char

FoldableLL (UTF8 ByteString) Char

Defined in Data.ListLike.UTF8

Methods

foldl :: (a -> Char -> a) -> a -> UTF8 ByteString -> a

foldl' :: (a -> Char -> a) -> a -> UTF8 ByteString -> a

foldl1 :: (Char -> Char -> Char) -> UTF8 ByteString -> Char

foldr :: (Char -> b -> b) -> b -> UTF8 ByteString -> b

foldr' :: (Char -> b -> b) -> b -> UTF8 ByteString -> b

foldr1 :: (Char -> Char -> Char) -> UTF8 ByteString -> Char

Storable a => FoldableLL (Vector a) a

Defined in Data.ListLike.Vector.Storable

Methods

foldl :: (a0 -> a -> a0) -> a0 -> Vector a -> a0

foldl' :: (a0 -> a -> a0) -> a0 -> Vector a -> a0

foldl1 :: (a -> a -> a) -> Vector a -> a

foldr :: (a -> b -> b) -> b -> Vector a -> b

foldr' :: (a -> b -> b) -> b -> Vector a -> b

foldr1 :: (a -> a -> a) -> Vector a -> a

Unbox a => FoldableLL (Vector a) a

Defined in Data.ListLike.Vector.Unboxed

Methods

foldl :: (a0 -> a -> a0) -> a0 -> Vector a -> a0

foldl' :: (a0 -> a -> a0) -> a0 -> Vector a -> a0

foldl1 :: (a -> a -> a) -> Vector a -> a

foldr :: (a -> b -> b) -> b -> Vector a -> b

foldr' :: (a -> b -> b) -> b -> Vector a -> b

foldr1 :: (a -> a -> a) -> Vector a -> a

FoldableLL (Vector a) a

Defined in Data.ListLike.Vector.Vector

Methods

foldl :: (a0 -> a -> a0) -> a0 -> Vector a -> a0

foldl' :: (a0 -> a -> a0) -> a0 -> Vector a -> a0

foldl1 :: (a -> a -> a) -> Vector a -> a

foldr :: (a -> b -> b) -> b -> Vector a -> b

foldr' :: (a -> b -> b) -> b -> Vector a -> b

foldr1 :: (a -> a -> a) -> Vector a -> a

Ix i => FoldableLL (Array i e) e

Defined in Data.ListLike.Instances

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

The StringLike class

class IsString s => StringLike s

An extension to ListLike for those data types that are similar to a String. Minimal complete definition is toString and fromString.

Minimal complete definition

toString

Instances

StringLike String

Defined in Data.ListLike.Instances

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

StringLike Builder

Defined in Data.ListLike.Text.Builder

Methods

toString :: Builder -> String

lines :: ListLike full Builder => Builder -> full

words :: ListLike full Builder => Builder -> full

unlines :: ListLike full Builder => full -> Builder

unwords :: ListLike full Builder => full -> Builder

show :: Show a => a -> Builder

fromStringLike :: StringLike s' => Builder -> s'

fromText :: Text -> Builder

fromLazyText :: Text -> Builder

StringLike Text

Defined in Data.ListLike.Text.TextLazy

Methods

toString :: Text -> String

lines :: ListLike full Text => Text -> full

words :: ListLike full Text => Text -> full

unlines :: ListLike full Text => full -> Text

unwords :: ListLike full Text => full -> Text

show :: Show a => a -> Text

fromStringLike :: StringLike s' => Text -> s'

fromText :: Text0 -> Text

fromLazyText :: Text -> Text

StringLike Text

Defined in Data.ListLike.Text.Text

Methods

toString :: Text -> String

lines :: ListLike full Text => Text -> full

words :: ListLike full Text => Text -> full

unlines :: ListLike full Text => full -> Text

unwords :: ListLike full Text => full -> Text

show :: Show a => a -> Text

fromStringLike :: StringLike s' => Text -> s'

fromText :: Text -> Text

fromLazyText :: Text0 -> Text

StringLike CharStringLazy

Defined in Data.ListLike.CharString

Methods

toString :: CharStringLazy -> String

lines :: ListLike full CharStringLazy => CharStringLazy -> full

words :: ListLike full CharStringLazy => CharStringLazy -> full

unlines :: ListLike full CharStringLazy => full -> CharStringLazy

unwords :: ListLike full CharStringLazy => full -> CharStringLazy

show :: Show a => a -> CharStringLazy

fromStringLike :: StringLike s' => CharStringLazy -> s'

fromText :: Text -> CharStringLazy

fromLazyText :: Text -> CharStringLazy

StringLike CharString

Defined in Data.ListLike.CharString

Methods

toString :: CharString -> String

lines :: ListLike full CharString => CharString -> full

words :: ListLike full CharString => CharString -> full

unlines :: ListLike full CharString => full -> CharString

unwords :: ListLike full CharString => full -> CharString

show :: Show a => a -> CharString

fromStringLike :: StringLike s' => CharString -> s'

fromText :: Text -> CharString

fromLazyText :: Text -> CharString

StringLike Chars

Defined in Data.ListLike.Chars

Methods

toString :: Chars -> String

lines :: ListLike full Chars => Chars -> full

words :: ListLike full Chars => Chars -> full

unlines :: ListLike full Chars => full -> Chars

unwords :: ListLike full Chars => full -> Chars

show :: Show a => a -> Chars

fromStringLike :: StringLike s' => Chars -> s'

fromText :: Text -> Chars

fromLazyText :: Text -> Chars

(Eq (v Char), Vector v Char) => StringLike (v Char)

Defined in Data.ListLike.Vector.Generic

Methods

toString :: v Char -> String

lines :: ListLike full (v Char) => v Char -> full

words :: ListLike full (v Char) => v Char -> full

unlines :: ListLike full (v Char) => full -> v Char

unwords :: ListLike full (v Char) => full -> v Char

show :: Show a => a -> v Char

fromStringLike :: StringLike s' => v Char -> s'

fromText :: Text -> v Char

fromLazyText :: Text -> v Char

StringLike (Seq Char)

Defined in Data.ListLike.Instances

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

StringLike (FMList Char)

Defined in Data.ListLike.FMList

Methods

toString :: FMList Char -> String

lines :: ListLike full (FMList Char) => FMList Char -> full

words :: ListLike full (FMList Char) => FMList Char -> full

unlines :: ListLike full (FMList Char) => full -> FMList Char

unwords :: ListLike full (FMList Char) => full -> FMList Char

show :: Show a => a -> FMList Char

fromStringLike :: StringLike s' => FMList Char -> s'

fromText :: Text -> FMList Char

fromLazyText :: Text -> FMList Char

StringLike (DList Char)

Defined in Data.ListLike.DList

Methods

toString :: DList Char -> String

lines :: ListLike full (DList Char) => DList Char -> full

words :: ListLike full (DList Char) => DList Char -> full

unlines :: ListLike full (DList Char) => full -> DList Char

unwords :: ListLike full (DList Char) => full -> DList Char

show :: Show a => a -> DList Char

fromStringLike :: StringLike s' => DList Char -> s'

fromText :: Text -> DList Char

fromLazyText :: Text -> DList Char

StringLike (UTF8 ByteString)

Defined in Data.ListLike.UTF8

Methods

toString :: UTF8 ByteString -> String

lines :: ListLike full (UTF8 ByteString) => UTF8 ByteString -> full

words :: ListLike full (UTF8 ByteString) => UTF8 ByteString -> full

unlines :: ListLike full (UTF8 ByteString) => full -> UTF8 ByteString

unwords :: ListLike full (UTF8 ByteString) => full -> UTF8 ByteString

show :: Show a => a -> UTF8 ByteString

fromStringLike :: StringLike s' => UTF8 ByteString -> s'

fromText :: Text -> UTF8 ByteString

fromLazyText :: Text -> UTF8 ByteString

StringLike (UTF8 ByteString)

Defined in Data.ListLike.UTF8

Methods

toString :: UTF8 ByteString -> String

lines :: ListLike full (UTF8 ByteString) => UTF8 ByteString -> full

words :: ListLike full (UTF8 ByteString) => UTF8 ByteString -> full

unlines :: ListLike full (UTF8 ByteString) => full -> UTF8 ByteString

unwords :: ListLike full (UTF8 ByteString) => full -> UTF8 ByteString

show :: Show a => a -> UTF8 ByteString

fromStringLike :: StringLike s' => UTF8 ByteString -> s'

fromText :: Text -> UTF8 ByteString

fromLazyText :: Text -> UTF8 ByteString

StringLike (Vector Char)

Defined in Data.ListLike.Vector.Storable

Methods

toString :: Vector Char -> String

lines :: ListLike full (Vector Char) => Vector Char -> full

words :: ListLike full (Vector Char) => Vector Char -> full

unlines :: ListLike full (Vector Char) => full -> Vector Char

unwords :: ListLike full (Vector Char) => full -> Vector Char

show :: Show a => a -> Vector Char

fromStringLike :: StringLike s' => Vector Char -> s'

fromText :: Text -> Vector Char

fromLazyText :: Text -> Vector Char

StringLike (Vector Char)

Defined in Data.ListLike.Vector.Unboxed

Methods

toString :: Vector Char -> String

lines :: ListLike full (Vector Char) => Vector Char -> full

words :: ListLike full (Vector Char) => Vector Char -> full

unlines :: ListLike full (Vector Char) => full -> Vector Char

unwords :: ListLike full (Vector Char) => full -> Vector Char

show :: Show a => a -> Vector Char

fromStringLike :: StringLike s' => Vector Char -> s'

fromText :: Text -> Vector Char

fromLazyText :: Text -> Vector Char

StringLike (Vector Char)

Defined in Data.ListLike.Vector.Vector

Methods

toString :: Vector Char -> String

lines :: ListLike full (Vector Char) => Vector Char -> full

words :: ListLike full (Vector Char) => Vector Char -> full

unlines :: ListLike full (Vector Char) => full -> Vector Char

unwords :: ListLike full (Vector Char) => full -> Vector Char

show :: Show a => a -> Vector Char

fromStringLike :: StringLike s' => Vector Char -> s'

fromText :: Text -> Vector Char

fromLazyText :: Text -> Vector Char

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

Defined in Data.ListLike.Instances

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

The InfiniteListLike class

class ListLike full item => InfiniteListLike full item | full -> item

An extension to ListLike for those data types that are capable of dealing with infinite lists. Some ListLike functions are capable of working with finite or infinite lists. The functions here require infinite list capability in order to work at all.

Instances

InfiniteListLike [a] a

Defined in Data.ListLike.Instances

Methods

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

repeat :: a -> [a]

cycle :: [a] -> [a]

InfiniteListLike (FMList a) a

Defined in Data.ListLike.FMList

Methods

iterate :: (a -> a) -> a -> FMList a

repeat :: a -> FMList a

cycle :: FMList a -> FMList a