ListLike-4.7.8.2: Generalized support for list-like structures

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

Data.ListLike

Contents

- Introduction
- Creation & Basic Functions
- List transformations
  - Conversions
- Reducing lists (folds), from FoldableLL
  - Special folds
- Building lists
  - Scans
  - Accumulating maps
  - Infinite lists
  - Unfolding
- Sublists
  - Extracting sublists
  - Predicates
  - Modify based on predicate
- Searching lists
  - Searching by equality
  - Searching with a predicate
- Indexing lists
- Zipping and unzipping lists
- Monadic Operations
- Input and Output
- Special lists
  - Strings
  - "Set" operations
  - Ordered lists
- Generalized functions
  - The "By" operations
    - User-supplied equality (replacing an Eq context)
    - User-supplied comparison (replacing an Ord context)
  - The "generic" operations
- Notes on specific instances
  - Lists
  - Arrays
  - ByteStrings
- Base Typeclasses
  - The ListLike class
  - The FoldableLL class
  - The StringLike class
  - The InfiniteListLike class

Description

Generic operations over list-like structures

Written by John Goerzen, jgoerzen@complete.org

Please start with the introduction at Data.ListLike.

Synopsis

- empty :: ListLike full item => full
- singleton :: ListLike full item => item -> full
- cons :: ListLike full item => item -> full -> full
- snoc :: ListLike full item => full -> item -> full
- append :: ListLike full item => full -> full -> full
- uncons :: ListLike full item => full -> Maybe (item, full)
- head :: ListLike full item => full -> item
- last :: ListLike full item => full -> item
- tail :: ListLike full item => full -> full
- init :: ListLike full item => full -> full
- null :: ListLike full item => full -> Bool
- length :: ListLike full item => full -> Int
- map :: (ListLike full item, ListLike full' item') => (item -> item') -> full -> full'
- rigidMap :: ListLike full item => (item -> item) -> full -> full
- reverse :: ListLike full item => full -> full
- intersperse :: ListLike full item => item -> full -> full
- toList :: IsList l => l -> [Item l]
- fromList :: IsList l => [Item l] -> l
- fromListLike :: (ListLike full item, ListLike full' item) => full -> full'
- foldl :: FoldableLL full item => (a -> item -> a) -> a -> full -> a
- foldl' :: FoldableLL full item => (a -> item -> a) -> a -> full -> a
- foldl1 :: FoldableLL full item => (item -> item -> item) -> full -> item
- foldr :: FoldableLL full item => (item -> b -> b) -> b -> full -> b
- foldr' :: FoldableLL full item => (item -> b -> b) -> b -> full -> b
- foldr1 :: FoldableLL full item => (item -> item -> item) -> full -> item
- concat :: (ListLike full item, ListLike full' full) => full' -> full
- concatMap :: (ListLike full item, ListLike full' item') => (item -> full') -> full -> full'
- rigidConcatMap :: ListLike full item => (item -> full) -> full -> full
- and :: ListLike full Bool => full -> Bool
- or :: ListLike full Bool => full -> Bool
- any :: ListLike full item => (item -> Bool) -> full -> Bool
- all :: ListLike full item => (item -> Bool) -> full -> Bool
- sum :: (Num a, ListLike full a) => full -> a
- product :: (Num a, ListLike full a) => full -> a
- maximum :: (ListLike full item, Ord item) => full -> item
- minimum :: (ListLike full item, Ord item) => full -> item
- fold :: (FoldableLL full item, Monoid item) => full -> item
- foldMap :: (FoldableLL full item, Monoid m) => (item -> m) -> full -> m
- iterate :: InfiniteListLike full item => (item -> item) -> item -> full
- repeat :: InfiniteListLike full item => item -> full
- replicate :: ListLike full item => Int -> item -> full
- cycle :: InfiniteListLike full item => full -> full
- take :: ListLike full item => Int -> full -> full
- drop :: ListLike full item => Int -> full -> full
- splitAt :: ListLike full item => Int -> full -> (full, full)
- takeWhile :: ListLike full item => (item -> Bool) -> full -> full
- dropWhile :: ListLike full item => (item -> Bool) -> full -> full
- dropWhileEnd :: ListLike full item => (item -> Bool) -> full -> full
- span :: ListLike full item => (item -> Bool) -> full -> (full, full)
- break :: ListLike full item => (item -> Bool) -> full -> (full, full)
- group :: (ListLike full item, ListLike full' full, Eq item) => full -> full'
- inits :: (ListLike full item, ListLike full' full) => full -> full'
- tails :: (ListLike full item, ListLike full' full) => full -> full'
- isPrefixOf :: (ListLike full item, Eq item) => full -> full -> Bool
- isSuffixOf :: (ListLike full item, Eq item) => full -> full -> Bool
- isInfixOf :: (ListLike full item, Eq item) => full -> full -> Bool
- stripPrefix :: (ListLike full item, Eq item) => full -> full -> Maybe full
- stripSuffix :: (ListLike full item, Eq item) => full -> full -> Maybe full
- elem :: (ListLike full item, Eq item) => item -> full -> Bool
- notElem :: (ListLike full item, Eq item) => item -> full -> Bool
- find :: ListLike full item => (item -> Bool) -> full -> Maybe item
- filter :: ListLike full item => (item -> Bool) -> full -> full
- partition :: ListLike full item => (item -> Bool) -> full -> (full, full)
- index :: ListLike full item => full -> Int -> item
- elemIndex :: (ListLike full item, Eq item) => item -> full -> Maybe Int
- elemIndices :: (ListLike full item, Eq item, ListLike result Int) => item -> full -> result
- findIndex :: ListLike full item => (item -> Bool) -> full -> Maybe Int
- findIndices :: (ListLike full item, ListLike result Int) => (item -> Bool) -> full -> result
- 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
- unzip :: (ListLike full (itema, itemb), ListLike ra itema, ListLike rb itemb) => full -> (ra, rb)
- sequence :: (ListLike full item, Applicative m, ListLike fullinp (m item)) => fullinp -> m full
- sequence_ :: (Monad m, FoldableLL full (m item)) => full -> m ()
- mapM :: (ListLike full item, Applicative m, ListLike full' item') => (item -> m item') -> full -> m full'
- rigidMapM :: (ListLike full item, Monad m) => (item -> m item) -> full -> m full
- mapM_ :: (Monad m, FoldableLL full item) => (item -> m b) -> full -> m ()
- class ListLike full item => ListLikeIO full item | full -> item where
  - hGetLine :: Handle -> IO full
  - hGetContents :: Handle -> IO full
  - hGet :: Handle -> Int -> IO full
  - hGetNonBlocking :: Handle -> Int -> IO full
  - hPutStr :: Handle -> full -> IO ()
  - hPutStrLn :: Handle -> full -> IO ()
  - getLine :: IO full
  - getContents :: IO full
  - putStr :: full -> IO ()
  - putStrLn :: full -> IO ()
  - interact :: (full -> full) -> IO ()
  - readFile :: FilePath -> IO full
  - writeFile :: FilePath -> full -> IO ()
  - appendFile :: FilePath -> full -> IO ()
- toString :: StringLike s => s -> String
- fromString :: IsString a => String -> a
- lines :: (StringLike s, ListLike full s) => s -> full
- words :: (StringLike s, ListLike full s) => s -> full
- show :: (StringLike s, Show a) => a -> s
- fromStringLike :: (StringLike s, StringLike s') => s -> s'
- fromText :: (StringLike s, StringLike Text) => Text -> s
- fromLazyText :: (StringLike s, StringLike Text) => Text -> s
- nub :: (ListLike full item, Eq item) => full -> full
- delete :: (ListLike full item, Eq item) => item -> full -> full
- deleteFirsts :: (ListLike full item, Eq item) => full -> full -> full
- union :: (ListLike full item, Eq item) => full -> full -> full
- intersect :: (ListLike full item, Eq item) => full -> full -> full
- sort :: (ListLike full item, Ord item) => full -> full
- insert :: (ListLike full item, Ord item) => item -> full -> full
- nubBy :: ListLike full item => (item -> item -> Bool) -> full -> full
- deleteBy :: ListLike full item => (item -> item -> Bool) -> item -> full -> full
- deleteFirstsBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full
- unionBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full
- intersectBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full
- groupBy :: (ListLike full item, ListLike full' full, Eq item) => (item -> item -> Bool) -> full -> full'
- sortBy :: ListLike full item => (item -> item -> Ordering) -> full -> full
- insertBy :: ListLike full item => (item -> item -> Ordering) -> item -> full -> full
- genericLength :: (ListLike full item, Num a) => full -> a
- genericTake :: (ListLike full item, Integral a) => a -> full -> full
- genericDrop :: (ListLike full item, Integral a) => a -> full -> full
- genericSplitAt :: (ListLike full item, Integral a) => a -> full -> (full, full)
- genericReplicate :: (ListLike full item, Integral a) => a -> item -> full
- data Chars
  - = B Builder
  - | T Text
- newtype CharString = CS {
  - unCS :: ByteString
  }
- newtype CharStringLazy = CSL {
  - unCSL :: ByteString
  }
- class (IsList full, item ~ Item full, FoldableLL full item, Monoid full) => ListLike full item | full -> item
- type ListOps full = ListLike full (Item full)
- class FoldableLL full item | full -> item
- class IsString s => StringLike s
- class ListLike full item => InfiniteListLike full item | full -> item

# 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] #

fromList :: IsList l => [Item l] -> 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, Applicative 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, Applicative 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

Instances details

ListLikeIO CharString Char # |

Instance details

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 CharStringLazy Char # |

Instance details

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 Chars Char # |

Instance details

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 ByteString Word8 # |

Instance details

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 # |

Instance details

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 Text Char # |

Instance details

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

Instance details

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 # |

Instance details

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 String Char # |

Instance details

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 (Seq Char) Char # |

Instance details

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 # |

Instance details

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 # |

Instance details

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 # |

Instance details

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

Instances details

StringLike Chars # |

Instance details

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 #

IsString Chars # |
Instance details Defined in Data.ListLike.Chars Methods fromString :: String -> Chars #
Monoid Chars # |
Instance details Defined in Data.ListLike.Chars Methods mempty :: Chars mappend :: Chars -> Chars -> Chars mconcat :: [Chars] -> Chars
Semigroup Chars # |
Instance details Defined in Data.ListLike.Chars Methods (<>) :: Chars -> Chars -> Chars sconcat :: NonEmpty Chars -> Chars stimes :: Integral b => b -> Chars -> Chars
IsList Chars # |
Instance details Defined in Data.ListLike.Chars Associated Types type Item Chars Methods fromList :: [Item Chars] -> Chars # fromListN :: Int -> [Item Chars] -> Chars toList :: Chars -> [Item Chars] #
Show Chars # |
Instance details Defined in Data.ListLike.Chars Methods showsPrec :: Int -> Chars -> ShowS show :: Chars -> String showList :: [Chars] -> ShowS
NFData Chars # |
Instance details Defined in Data.ListLike.Chars Methods rnf :: Chars -> ()
Eq Chars # |
Instance details Defined in Data.ListLike.Chars Methods (==) :: Chars -> Chars -> Bool (/=) :: Chars -> Chars -> Bool
Ord Chars # |
Instance details 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
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 #

FoldableLL Chars Char # |
Instance details 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 #
ListLikeIO Chars Char # |

Instance details

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 # |
Instance details 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

Instances details

StringLike CharString # |

Instance details

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 #

IsString CharString # |
Instance details Defined in Data.ListLike.CharString Methods fromString :: String -> CharString #
Monoid CharString # |
Instance details Defined in Data.ListLike.CharString Methods mempty :: CharString mappend :: CharString -> CharString -> CharString mconcat :: [CharString] -> CharString
Semigroup CharString # |
Instance details Defined in Data.ListLike.CharString Methods (<>) :: CharString -> CharString -> CharString sconcat :: NonEmpty CharString -> CharString stimes :: Integral b => b -> CharString -> CharString
IsList CharString # |
Instance details Defined in Data.ListLike.CharString Associated Types type Item CharString Methods fromList :: [Item CharString] -> CharString # fromListN :: Int -> [Item CharString] -> CharString toList :: CharString -> [Item CharString] #
Read CharString # |
Instance details Defined in Data.ListLike.CharString Methods readsPrec :: Int -> ReadS CharString readList :: ReadS [CharString] readPrec :: ReadPrec CharString readListPrec :: ReadPrec [CharString]
Show CharString # |
Instance details Defined in Data.ListLike.CharString Methods showsPrec :: Int -> CharString -> ShowS show :: CharString -> String showList :: [CharString] -> ShowS
Eq CharString # |
Instance details Defined in Data.ListLike.CharString Methods (==) :: CharString -> CharString -> Bool (/=) :: CharString -> CharString -> Bool
Ord CharString # |
Instance details 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
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 #

FoldableLL CharString Char # |
Instance details 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 #
ListLikeIO CharString Char # |

Instance details

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 # |
Instance details 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

Instances details

StringLike CharStringLazy # |

Instance details

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 #

IsString CharStringLazy # |
Instance details Defined in Data.ListLike.CharString Methods fromString :: String -> CharStringLazy #
Monoid CharStringLazy # |
Instance details Defined in Data.ListLike.CharString Methods mempty :: CharStringLazy mappend :: CharStringLazy -> CharStringLazy -> CharStringLazy mconcat :: [CharStringLazy] -> CharStringLazy
Semigroup CharStringLazy # |
Instance details Defined in Data.ListLike.CharString Methods (<>) :: CharStringLazy -> CharStringLazy -> CharStringLazy sconcat :: NonEmpty CharStringLazy -> CharStringLazy stimes :: Integral b => b -> CharStringLazy -> CharStringLazy
IsList CharStringLazy # |
Instance details Defined in Data.ListLike.CharString Associated Types type Item CharStringLazy Methods fromList :: [Item CharStringLazy] -> CharStringLazy # fromListN :: Int -> [Item CharStringLazy] -> CharStringLazy toList :: CharStringLazy -> [Item CharStringLazy] #
Read CharStringLazy # |
Instance details Defined in Data.ListLike.CharString Methods readsPrec :: Int -> ReadS CharStringLazy readList :: ReadS [CharStringLazy] readPrec :: ReadPrec CharStringLazy readListPrec :: ReadPrec [CharStringLazy]
Show CharStringLazy # |
Instance details Defined in Data.ListLike.CharString Methods showsPrec :: Int -> CharStringLazy -> ShowS show :: CharStringLazy -> String showList :: [CharStringLazy] -> ShowS
Eq CharStringLazy # |
Instance details Defined in Data.ListLike.CharString Methods (==) :: CharStringLazy -> CharStringLazy -> Bool (/=) :: CharStringLazy -> CharStringLazy -> Bool
Ord CharStringLazy # |

Instance details

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

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 #

FoldableLL CharStringLazy Char # |

Instance details

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 #

ListLikeIO CharStringLazy Char # |

Instance details

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 # |
Instance details 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

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

## 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

Instances details

FoldableLL CharString Char # |
Instance details 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 CharStringLazy Char # |

Instance details

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 Chars Char # |
Instance details 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 ByteString Word8 # |
Instance details 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 # |
Instance details 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 Text Char # |
Instance details 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 Builder Char # |
Instance details 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 # |
Instance details 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 (Seq a) a # |
Instance details 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 (DList a) a # |
Instance details 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 (FMList a) a # |
Instance details 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 (UTF8 ByteString) Char # |

Instance details

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 # |

Instance details

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 (Vector a) a # |
Instance details 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 #
Storable a => FoldableLL (Vector a) a # |
Instance details 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 # |
Instance details 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 [a] a # |
Instance details 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 # |
Instance details 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 #
Ix i => FoldableLL (Array i e) e # |
Instance details 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

Instances details

StringLike CharString # |

Instance details

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 CharStringLazy # |

Instance details

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 Chars # |

Instance details

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 #

StringLike Text # |

Instance details

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

Instance details

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 # |

Instance details

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 String # |

Instance details

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 (Seq Char) # |

Instance details

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 (DList Char) # |

Instance details

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 (FMList Char) # |

Instance details

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 (UTF8 ByteString) # |

Instance details

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

Instance details

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

Instance details

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 #

StringLike (Vector Char) # |

Instance details

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

Instance details

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 #

(Eq (v Char), Vector v Char) => StringLike (v Char) # |

Instance details

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 #

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

Instance details

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

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] #