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

Flexible type extension

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

The elemIndices function extends elemIndex, by returning the indices of all elements equal to the query element, in ascending order.

Substitute various time-related information for each %-code in the string, as per formatCharacter.
For all types (note these three are done here, not by formatCharacter):
* *%%* %
* *%t* tab
* *%n* newline
glibc-style modifiers can be used before the letter (here marked as z):
* *%-z* no padding
* *%_z* pad with spaces
* *%0z* pad with zeros
* *%^z* convert to upper case
* *%#z* convert to lower case (consistently, unlike glibc)
For TimeZone (and ZonedTime and UTCTime):
* *%z* timezone offset in the format -HHMM.
* *%Z* timezone name
For LocalTime (and ZonedTime and UTCTime):
* *%c* as dateTimeFmt locale (e.g. %a %b %e %H:%M:%S %Z %Y)
For TimeOfDay (and LocalTime and ZonedTime and UTCTime):
* *%R* same as %H:%M
* *%T* same as %H:%M:%S
* *%X* as timeFmt locale (e.g. %H:%M:%S)
* *%r* as time12Fmt locale (e.g. %I:%M:%S %p)
* *%P* day-half of day from (amPm locale), converted to lowercase, am, pm
* *%p* day-half of day from (amPm locale), AM, PM
* *%H* hour of day (24-hour), 0-padded to two chars, 00 - 23
* *%k* hour of day (24-hour), space-padded to two chars, 0 - 23
* *%I* hour of day-half (12-hour), 0-padded to two chars, 01 - 12
* *%l* hour of day-half (12-hour), space-padded to two chars, 1 - 12
* *%M* minute of hour, 0-padded to two chars, 00 - 59
* *%S* second of minute (without decimal part), 0-padded to two chars, 00 - 60
* *%q* picosecond of second, 0-padded to twelve chars, 000000000000 - 999999999999.
* *%Q* decimal point and fraction of second, up to 12 second decimals, without trailing zeros. For a whole number of seconds, %Q produces the empty string.
For UTCTime and ZonedTime:
* *%s* number of whole seconds since the Unix epoch. For times before the Unix epoch, this is a negative number. Note that in %s.%q and %s%Q the decimals are positive, not negative. For example, 0.9 seconds before the Unix epoch is formatted as -1.1 with %s%Q.
For Day (and LocalTime and ZonedTime and UTCTime):
* *%D* same as %m/%d/%y
* *%F* same as %Y-%m-%d
* *%x* as dateFmt locale (e.g. %m/%d/%y)
* *%Y* year, no padding. Note %0y and %_y pad to four chars
* *%y* year of century, 0-padded to two chars, 00 - 99
* *%C* century, no padding. Note %0C and %_C pad to two chars
* *%B* month name, long form (fst from months locale), January - December
* *%b, %h* month name, short form (snd from months locale), Jan - Dec
* *%m* month of year, 0-padded to two chars, 01 - 12
* *%d* day of month, 0-padded to two chars, 01 - 31
* *%e* day of month, space-padded to two chars, 1 - 31
* *%j* day of year, 0-padded to three chars, 001 - 366
* *%G* year for Week Date format, no padding. Note %0G and %_G pad to four chars
* *%g* year of century for Week Date format, 0-padded to two chars, 00 - 99
* *%f* century for Week Date format, no padding. Note %0f and %_f pad to two chars
* *%V* week of year for Week Date format, 0-padded to two chars, 01 - 53
* *%u* day of week for Week Date format, 1 - 7
* *%a* day of week, short form (snd from wDays locale), Sun - Sat
* *%A* day of week, long form (fst from wDays locale), Sunday - Saturday
* *%U* week of year sundayStartWeek), 0-padded to two chars, 00 - 53
* *%w* day of week number, 0 (= Sunday) - 6 (= Saturday)
* *%W* week of year mondayStartWeek), 0-padded to two chars, 00 - 53

The zipWith3 function takes a function which combines three elements, as well as three lists and returns a list of their point-wise combination, analogous to zipWith.

The foldM function is analogous to foldl, except that its result is encapsulated in a monad. Note that foldM works from left-to-right over the list arguments. This could be an issue
commutative.
> foldM f a1 [x1, x2, ..., xm]
==
> do
> a2 <- f a1 x1
> a3 <- f a2 x2
> ...
> f am xm
If right-to-left evaluation is required, the input list should be reversed.

Lift a binary function to actions.

Like foldM, but discards the result.

Extend a generic reader

Lift a ternary function to actions.

Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.

Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.

Promote a function to a monad, scanning the monadic arguments from left to right. For example,
> liftM2 (+) [0,1] [0,2] = [0,2,1,3]
> liftM2 (+) (Just 1) Nothing = Nothing

applies lookup to an interval