ListLike-4.7.8.2: Generalized support for list-like structures

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

Data.ListLike.Base

Description

Generic operations over list-like structures

Written by John Goerzen, jgoerzen@complete.org

Synopsis

- class (IsList full, item ~ Item full, FoldableLL full item, Monoid full) => ListLike full item | full -> item where
  - empty :: full
  - singleton :: item -> full
  - cons :: item -> full -> full
  - snoc :: full -> item -> full
  - append :: full -> full -> full
  - head :: full -> item
  - uncons :: full -> Maybe (item, full)
  - last :: full -> item
  - tail :: full -> full
  - init :: full -> full
  - null :: full -> Bool
  - length :: full -> Int
  - map :: ListLike full' item' => (item -> item') -> full -> full'
  - rigidMap :: (item -> item) -> full -> full
  - reverse :: full -> full
  - intersperse :: item -> full -> full
  - concat :: ListLike full' full => full' -> full
  - concatMap :: ListLike full' item' => (item -> full') -> full -> full'
  - rigidConcatMap :: (item -> full) -> full -> full
  - any :: (item -> Bool) -> full -> Bool
  - all :: (item -> Bool) -> full -> Bool
  - maximum :: full -> item
  - minimum :: full -> item
  - replicate :: Int -> item -> full
  - take :: Int -> full -> full
  - drop :: Int -> full -> full
  - splitAt :: Int -> full -> (full, full)
  - takeWhile :: (item -> Bool) -> full -> full
  - dropWhile :: (item -> Bool) -> full -> full
  - dropWhileEnd :: (item -> Bool) -> full -> full
  - span :: (item -> Bool) -> full -> (full, full)
  - break :: (item -> Bool) -> full -> (full, full)
  - group :: (ListLike full' full, Eq item) => full -> full'
  - inits :: ListLike full' full => full -> full'
  - tails :: ListLike full' full => full -> full'
  - isPrefixOf :: full -> full -> Bool
  - isSuffixOf :: full -> full -> Bool
  - isInfixOf :: full -> full -> Bool
  - stripPrefix :: full -> full -> Maybe full
  - stripSuffix :: full -> full -> Maybe full
  - elem :: item -> full -> Bool
  - notElem :: item -> full -> Bool
  - find :: (item -> Bool) -> full -> Maybe item
  - filter :: (item -> Bool) -> full -> full
  - partition :: (item -> Bool) -> full -> (full, full)
  - index :: full -> Int -> item
  - elemIndex :: item -> full -> Maybe Int
  - elemIndices :: (Eq item, ListLike result Int) => item -> full -> result
  - findIndex :: (item -> Bool) -> full -> Maybe Int
  - findIndices :: ListLike result Int => (item -> Bool) -> full -> result
  - sequence :: (Applicative m, ListLike fullinp (m item)) => fullinp -> m full
  - mapM :: (Applicative m, ListLike full' item') => (item -> m item') -> full -> m full'
  - rigidMapM :: Monad m => (item -> m item) -> full -> m full
  - nub :: full -> full
  - delete :: item -> full -> full
  - deleteFirsts :: full -> full -> full
  - union :: full -> full -> full
  - intersect :: full -> full -> full
  - sort :: full -> full
  - insert :: item -> full -> full
  - toList' :: full -> [item]
  - fromList' :: [item] -> full
  - fromListLike :: ListLike full' item => full -> full'
  - nubBy :: (item -> item -> Bool) -> full -> full
  - deleteBy :: (item -> item -> Bool) -> item -> full -> full
  - deleteFirstsBy :: (item -> item -> Bool) -> full -> full -> full
  - unionBy :: (item -> item -> Bool) -> full -> full -> full
  - intersectBy :: (item -> item -> Bool) -> full -> full -> full
  - groupBy :: (ListLike full' full, Eq item) => (item -> item -> Bool) -> full -> full'
  - sortBy :: (item -> item -> Ordering) -> full -> full
  - insertBy :: (item -> item -> Ordering) -> item -> full -> full
  - genericLength :: Num a => full -> a
  - genericTake :: Integral a => a -> full -> full
  - genericDrop :: Integral a => a -> full -> full
  - genericSplitAt :: Integral a => a -> full -> (full, full)
  - genericReplicate :: Integral a => a -> item -> full
- type ListOps full = ListLike full (Item full)
- toList :: IsList l => l -> [Item l]
- fromList :: IsList l => [Item l] -> l
- class ListLike full item => InfiniteListLike full item | full -> item where
  - iterate :: (item -> item) -> item -> full
  - repeat :: item -> full
  - cycle :: full -> full
- zip :: (ListLike full item, ListLike fullb itemb, ListLike result (item, itemb)) => full -> fullb -> result
- zipWith :: (ListLike full item, ListLike fullb itemb, ListLike result resultitem) => (item -> itemb -> resultitem) -> full -> fullb -> result
- sequence_ :: (Monad m, FoldableLL full (m item)) => full -> m ()

# Documentation

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

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

Methods

empty :: full #

The empty list

singleton :: item -> full #

Creates a single-element list out of an element

cons :: item -> full -> full #

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

snoc :: full -> item -> full #

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

append :: full -> full -> full #

Combines two lists. Like (++).

head :: full -> item #

Extracts the first element of a `ListLike`.

uncons :: full -> Maybe (item, full) #

Extract head and tail, return Nothing if empty

last :: full -> item #

Extracts the last element of a `ListLike`.

tail :: full -> full #

Gives all elements after the head.

init :: full -> full #

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

null :: full -> Bool #

Tests whether the list is empty.

length :: full -> Int #

Length of the list. See also `genericLength`.

map :: 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 :: (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 :: full -> full #

Reverse the elements in a list.

intersperse :: item -> full -> full #

Add an item between each element in the structure

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

Flatten the structure.

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

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

rigidConcatMap :: (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.

any :: (item -> Bool) -> full -> Bool #

True if any items satisfy the function

all :: (item -> Bool) -> full -> Bool #

True if all items satisfy the function

maximum :: full -> item #

The maximum value of the list

minimum :: full -> item #

The minimum value of the list

replicate :: Int -> item -> full #

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

take :: Int -> full -> full #

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

drop :: Int -> full -> full #

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

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

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

takeWhile :: (item -> Bool) -> full -> full #

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

dropWhile :: (item -> Bool) -> full -> full #

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

dropWhileEnd :: (item -> Bool) -> full -> full #

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

span :: (item -> Bool) -> full -> (full, full) #

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

break :: (item -> Bool) -> full -> (full, full) #

The equivalent of ``span` (`not` . f)`

group :: (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' full => full -> full' #

All initial segments of the list, shortest first

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

All final segnemts, longest first

isPrefixOf :: full -> full -> Bool #

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

isSuffixOf :: full -> full -> Bool #

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

isInfixOf :: full -> full -> Bool #

True when the first list is wholly containted within the second

stripPrefix :: full -> full -> Maybe full #

Remove a prefix from a listlike if possible

stripSuffix :: full -> full -> Maybe full #

Remove a suffix from a listlike if possible

elem :: item -> full -> Bool #

True if the item occurs in the list

notElem :: item -> full -> Bool #

True if the item does not occur in the list

find :: (item -> Bool) -> full -> Maybe item #

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

filter :: (item -> Bool) -> full -> full #

Returns only the elements that satisfy the function.

partition :: (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)`

index :: full -> Int -> item #

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

elemIndex :: item -> full -> Maybe Int #

Returns the index of the element, if it exists.

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

Returns the indices of the matching elements. See also `findIndices`

findIndex :: (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 result Int => (item -> Bool) -> full -> result #

Returns the indices of all elements satisfying the function

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

Evaluate each action in the sequence and collect the results

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

A map in monad space. Same as ``sequence` . `map``

See also `rigidMapM`

rigidMapM :: 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.

nub :: full -> full #

Removes duplicate elements from the list. See also `nubBy`

delete :: item -> full -> full #

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

deleteFirsts :: full -> full -> full #

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

union :: 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 :: full -> full -> full #

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

sort :: 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 :: 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`.

toList' :: full -> [item] #

Converts the structure to a list. This is logically equivolent to `fromListLike`, but may have a more optimized implementation. These two functions are now retired in favor of the methods of IsList, but they are retained here because some instances still use this implementation.

fromList' :: [item] -> full #

Generates the structure from a list.

fromListLike :: ListLike full' item => full -> full' #

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

nubBy :: (item -> item -> Bool) -> full -> full #

Generic version of `nub`

deleteBy :: (item -> item -> Bool) -> item -> full -> full #

Generic version of `deleteBy`

deleteFirstsBy :: (item -> item -> Bool) -> full -> full -> full #

Generic version of `deleteFirsts`

unionBy :: (item -> item -> Bool) -> full -> full -> full #

Generic version of `union`

intersectBy :: (item -> item -> Bool) -> full -> full -> full #

Generic version of `intersect`

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

Generic version of `group`.

sortBy :: (item -> item -> Ordering) -> full -> full #

Sort function taking a custom comparison function

insertBy :: (item -> item -> Ordering) -> item -> full -> full #

Like `insert`, but with a custom comparison function

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

Length of the list

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

Generic version of `take`

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

Generic version of `drop`

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

Generic version of `splitAt`

genericReplicate :: Integral a => a -> item -> full #

Generic version of `replicate`

#### Instances

Instances details

ListLike CharString Char # |

Instance details

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 :: (Applicative m, ListLike fullinp (m Char)) => fullinp -> m CharString #

mapM :: (Applicative 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 CharStringLazy Char # |

Instance details

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 :: (Applicative m, ListLike fullinp (m Char)) => fullinp -> m CharStringLazy #

mapM :: (Applicative 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 Chars Char # |

Instance details

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 :: (Applicative m, ListLike fullinp (m Char)) => fullinp -> m Chars #

mapM :: (Applicative 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 ByteString Word8 # |

Instance details

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

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

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

nub :: ByteString -> ByteString #

delete :: Word8 -> ByteString -> ByteString #

deleteFirsts :: ByteString -> ByteString -> ByteString #

union :: ByteString -> ByteString -> ByteString #

intersect :: ByteString -> ByteString -> ByteString #

sort :: ByteString -> ByteString #

insert :: Word8 -> ByteString -> ByteString #

toList' :: ByteString -> [Word8] #

fromList' :: [Word8] -> ByteString #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ListLike ByteString Word8 # |

Instance details

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

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

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

nub :: ByteString -> ByteString #

delete :: Word8 -> ByteString -> ByteString #

deleteFirsts :: ByteString -> ByteString -> ByteString #

union :: ByteString -> ByteString -> ByteString #

intersect :: ByteString -> ByteString -> ByteString #

sort :: ByteString -> ByteString #

insert :: Word8 -> ByteString -> ByteString #

toList' :: ByteString -> [Word8] #

fromList' :: [Word8] -> ByteString #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ListLike Text Char # |

Instance details

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 :: (Applicative m, ListLike fullinp (m Char)) => fullinp -> m Text #

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

Instance details

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 :: (Applicative m, ListLike fullinp (m Char)) => fullinp -> m Builder #

mapM :: (Applicative 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 # |

Instance details

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 :: (Applicative m, ListLike fullinp (m Char)) => fullinp -> m Text #

mapM :: (Applicative 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 (Seq a) a # |

Instance details

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

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

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

nub :: Seq a -> Seq a #

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

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

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

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

sort :: Seq a -> Seq a #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ListLike (DList a) a # |

Instance details

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 :: (Applicative m, ListLike fullinp (m a)) => fullinp -> m (DList a) #

mapM :: (Applicative 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 (FMList a) a # |

Instance details

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 :: (Applicative m, ListLike fullinp (m a)) => fullinp -> m (FMList a) #

mapM :: (Applicative 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 (UTF8 ByteString) Char # |

Instance details

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 :: (Applicative m, ListLike fullinp (m Char)) => fullinp -> m (UTF8 ByteString) #

mapM :: (Applicative 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 # |

Instance details

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 :: (Applicative m, ListLike fullinp (m Char)) => fullinp -> m (UTF8 ByteString) #

mapM :: (Applicative 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 (Vector a) a # |

Instance details

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 :: (Applicative m, ListLike fullinp (m a)) => fullinp -> m (Vector a) #

mapM :: (Applicative 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 #

Storable a => ListLike (Vector a) a # |

Instance details

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 :: (Applicative m, ListLike fullinp (m a)) => fullinp -> m (Vector a) #

mapM :: (Applicative 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 # |

Instance details

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 :: (Applicative m, ListLike fullinp (m a)) => fullinp -> m (Vector a) #

mapM :: (Applicative 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 [a] a # |

Instance details

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 :: (Applicative m, ListLike fullinp (m a)) => fullinp -> m [a] #

mapM :: (Applicative 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 # |

Instance details

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 :: (Applicative m, ListLike fullinp (m a)) => fullinp -> m (v a) #

mapM :: (Applicative 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 #

(Integral i, Ix i) => ListLike (Array i e) e # |

Instance details

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 :: (Applicative m, ListLike fullinp (m e)) => fullinp -> m (Array i e) #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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`.

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`

class ListLike full item => InfiniteListLike full item | full -> item where #

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.

Minimal complete definition

Nothing

Methods

iterate :: (item -> item) -> item -> full #

An infinite list of repeated calls of the function to args

repeat :: item -> full #

An infinite list where each element is the same

cycle :: full -> full #

Converts a finite list into a circular one

#### Instances

Instances details

InfiniteListLike (FMList a) a # |
Instance details Defined in Data.ListLike.FMList Methods iterate :: (a -> a) -> a -> FMList a # repeat :: a -> FMList a # cycle :: FMList a -> FMList a #
InfiniteListLike [a] a # |
Instance details Defined in Data.ListLike.Instances Methods iterate :: (a -> a) -> a -> [a] # repeat :: a -> [a] # cycle :: [a] -> [a] #

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

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

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