**Packages**- base
- QuickCheck
- text
- fgl
- cgi

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.

replicateM n act performs the action n times, gathering the results.

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"

replicate n x is a list of length n with x the value of every element. It is an instance of the more general Data.List.genericReplicate, in which n may be of any integral type.

The non-overloaded version of insert.

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.

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.

The deleteFirstsBy function takes a predicate and two lists and returns the first list with the first occurrence of each element of the second list removed.

The intersectBy function is the non-overloaded version of intersect.

scanl is similar to foldl, but returns a list of successive reduced values from the left:
> scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
Note that
> last (scanl f z xs) == foldl f z xs.

The insert function takes an element and a list and inserts the element into the list at the last position or equal to the next element. In particular, if the list is sorted before the call, the result will also be sorted. It is a special case of insertBy, which allows the programmer to supply their own comparison function.

delete x removes the first occurrence of x from its list argument. For example,
> delete 'a' "banana" == "bnana"
It is a special case of deleteBy, which allows the programmer to supply their own equality test.

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.

The genericReplicate function is an overloaded version of replicate, which accepts any Integral value as the number of repetitions to make.

Like replicateM, but discards the result.

Replaces all instances of a value in a list by another value.

Outputs indented XHTML. Because space matters in HTML, the output is quite messy.

zipWith generalises zip by zipping with the function given as the first argument, instead of a tupling function. For example, zipWith (+) is applied to two lists to produce the list of corresponding sums.

The \\ function is list difference ((non-associative). In the result of xs \\ ys, the first occurrence of each element of ys in turn (if any) has been removed from xs. Thus
> (xs ++ ys) \\ xs == ys.
It is a special case of deleteFirstsBy, which allows the programmer to supply their own equality test.

The intersect function takes the list intersection of two lists. For example,
> [1,2,3,4] `intersect` [2,4,6,8] == [2,4]
If the first list contains duplicates, so will the result.
> [1,2,2,3,4] `intersect` [6,4,4,2] == [2,2,4]
It is a special case of intersectBy, which allows the programmer to supply their own equality test.

The union function returns the list union of the two lists. For example,
> "dog" `union` "cow" == "dogcw"
Duplicates, and elements of the first list, are removed from the the second list, but if the first list contains duplicates, so will the result. It is a special case of unionBy, which allows the programmer to supply their own equality test.