Documentation

Test whether a Container is empty.

Create a singleton Container; i.e. size (singleton x) == 1).

Add a value to the Container. If this is also a Sequence, then it should be a "cons" operation (i.e. insert the value at the beginning of the Sequence).

The container membership predicate, usually written in infix form, e.g., v elem c.

The negated version of elem.

Delete the first value of the Container that matches the predicate.

Delete all values in the Container that match the predicate.

When applied to a predicate and a Container, filter returns the Container containing just those elements that satisfy the predicate (preserving order where applicable).

Applied to a binary operator, a starting value and a Container, reduce the Container using the binary operator. For Sequence instances, this should be a right fold.

A variant of fold with no starting value, and thus must be applied to non-empty Containers.

Returns the size of the Container.

Returns the size of the Container as an Int. Typically more efficient than genericSize.

Applied to a predicate and a Container, all determines if all elements of the Container satisfy the predicate.

Returns the conjunction of a Container containing Boolean values. For the result to be True, the Container must be finite; False, however, results from a False value occurring within a finite position within the order utilised by fold.

Applied to a predicate and a Container, any determines if any element of the Container satisfies the predicate.

Returns the disjunction of a Container containing Boolean values. For the result to be False, the Container must be finite; True, however, results from a True value occurring within a finite position within the order utilised by fold.

Computes the product of a finite Container of numbers.

Computes the sum of a finite Container of numbers.

A type-preserving mapping function, where the resulting Container is obtained by applying the provided function on every element of the Container. For instances of CFunctor, rigidMap = map suffices.

An inverse to insert. Should obey the following:

• isNothing (splitElem c) == null c

• If splitElem c = Just (v,c'), then c == v `'insert'` c'.
• If c is an instance of Sequence, then the returned value should be the first one.

Returns the maximum value of a non-empty, finite Container.

Returns the minimum value of a non-empty, finite Container.

Apply the provided function on every element of the Container.

Append the value to the end of the Sequence.

Applied to a binary operator, a starting value and a Sequence, reduce the Sequence using the binary operator from left to right.

The default definition is modelled after Data.List.foldl' rather than Data.List.foldl.

A variant of foldl with no starting value, and thus must be applied to non-empty Sequencess.

An inverse to snoc (equivalent to (init xs, 'last xs') for non-empty Sequences). Should obey the following:

• isNothing (viewR xs) == null xs

• If viewR xs = Just (x,xs'), then xs == xs' `'snoc'` x.

The first element of a non-empty Sequence.

Everything except the first element of a non-empty Sequence. Consider instead using 'drop 1'.

The last element of a non-empty Sequence.

Everything except the last value of a non-empty Sequence.

Return the first n elements of a Sequence, or the entire Sequence if its length is less than n.

A variant of genericTake where n has to be an Int, and is usually more efficient.

When applied to a predicate p and a Sequence xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p.

dropWhile p xs returns the suffix remaining after takeWhile p xs.

genericDrop n xs returns the suffix of xs after the first n elements, or empty if n > length xs.

A variant of genericDrop where n has to be an Int, and is usually more efficient.

reverse xs returns the elements of xs in reverse order. xs must be finite.

When applied to a predicate p and a Sequence xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that satisfy p and second element is the remainder of the Sequence.

When applied to a predicate p and a Sequence xs, returns a tuple where first element is longest prefix (possibly empty) of xs of elements that do not satisfy p and second element is the remainder of the Sequence.

break p is equivalent to span (not . p).

genericSplitAt n xs returns a tuple where the first element is the prefix of length n of xs and the second element is the rest of the Sequence. It is equivalent to (genericTake n xs, genericDrop n xs).

A variant of genericSplitAt where n has to be an Int, and is usually more efficient.

genericReplicate n x is a Sequence of length n where every element is x.

A variant of genericReplicate where n has to be an Int, and is usually more efficient.

lines breaks a string up into a Sequence of Strings at newline characters. The resulting Strings do not contain newlines.

unlines is an inverse operation to lines. It joins lines, after appending a terminating newline to each.

words breaks a String up into a Sequence of words, which were delimited by white space.

unwords is an inverse operation to words. It joins words with separating spaces.

repeat x is an infinite Stream, with x the value of every element.

cycle ties a finite Stream into a circular one, or equivalently, the infinite repetition of the original Stream. It is the identity on infinite Streams.

iterate f x returns an infinite Stream of repeated applications of f to x:

 iterate f x = x `cons` f x `cons` f (f x) `cons` ...