Data.ListLike

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

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

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

Flatten the structure.

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

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

Returns True if all elements are True

Returns True if any element is True

True if any items satisfy the function

True if all items satisfy the function

The sum of the list

The product of the list

The maximum value of the list

The minimum value of the list

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

Map each element to a monoid, then combine the results

An infinite list of repeated calls of the function to args

An infinite list where each element is the same

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

Converts a finite list into a circular one

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

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

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

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

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

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

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

The equivalent of span (not . f)

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.

All initial segments of the list, shortest first

All final segnemts, longest first

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

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

True when the first list is wholly containted within the second

Remove a prefix from a listlike if possible

Remove a suffix from a listlike if possible

True if the item occurs in the list

True if the item does not occur in the list

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

Returns only the elements that satisfy the function.

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

Converts the structure to a String

Breaks a string into a list of strings

Breaks a string into a list of words

Generalize the Show method t return any StringLike.

Override this to avoid extra String conversions.

Override this to avoid extra String conversions.

Removes duplicate elements from the list. See also nubBy

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

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

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

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

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.

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.

Generic version of nub

Generic version of deleteBy

Generic version of deleteFirsts

Generic version of union

Generic version of intersect

Generic version of group.

Sort function taking a custom comparison function

Like insert, but with a custom comparison function

Length of the list

Generic version of take

Generic version of drop

Generic version of splitAt

Generic version of replicate

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

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

The class implementing list-like functions.

It is worth noting that types such as Data.Map.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

A version of ListLike with a single type parameter, the item type is obtained using the Item type function from IsList.

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.

An extension to ListLike for those data types that are similar to a String. Minimal complete definition is toString and fromString.

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.