**Packages**- base

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

Return all the elements of a list except the last one. The list must be non-empty.

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

Extract the elements after the head of a list, which must be non-empty.

A list producer that can be fused with foldr. This function is merely
> augment g xs = g (:) xs
but GHC's simplifier will transform an expression of the form foldr k z (augment g xs), which may arise after inlining, to g k (foldr k z xs), which avoids producing an intermediate list.

The sortWith function sorts a list of elements using the user supplied function to project something out of each element

scanl1 is a variant of scanl that has no starting value argument:
> scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]

The nubBy function behaves just like nub, except it uses a user-supplied equality predicate instead of the overloaded == function.

dropWhile p xs returns the suffix remaining after takeWhile p xs:
> dropWhile (< 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
> dropWhile (< 9) [1,2,3] == []
> dropWhile (< 0) [1,2,3] == [1,2,3]

filter, applied to a predicate and a list, returns the list of those elements that satisfy the predicate; i.e.,
> filter p xs = [ x | x <- xs, p x]

takeWhile, applied to a predicate p and a list xs, returns the longest prefix (possibly empty) of xs of elements that satisfy p:
> takeWhile (< 3) [1,2,3,4,1,2,3,4] == [1,2]
> takeWhile (< 9) [1,2,3] == [1,2,3]
> takeWhile (< 0) [1,2,3] == []

The genericDrop function is an overloaded version of drop, which accepts any Integral value as the number of elements to drop.

The genericTake function is an overloaded version of take, which accepts any Integral value as the number of elements to take.

The intersperse function takes an element and a list and `intersperses' that element between the elements of the list. For example,
> intersperse ',' "abcde" == "a,b,c,d,e"

drop n xs returns the suffix of xs after the first n elements, or [] if n > length xs:
> drop 6 "Hello World!" == "World!"
> drop 3 [1,2,3,4,5] == [4,5]
> drop 3 [1,2] == []
> drop 3 [] == []
> drop (-1) [1,2] == [1,2]
> drop 0 [1,2] == [1,2]
It is an instance of the more general Data.List.genericDrop, in which n may be of any integral type.

take n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n > length xs:
> take 5 "Hello World!" == "Hello"
> take 3 [1,2,3,4,5] == [1,2,3]
> take 3 [1,2] == [1,2]
> take 3 [] == []
> take (-1) [1,2] == []
> take 0 [1,2] == []
It is an instance of the more general Data.List.genericTake, in which n may be of any integral type.

Append two lists, i.e.,
> [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
> [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
If the first list is not finite, the result is the first list.

intercalate xs xss is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.