# (a -> b) -> [a] -> [b] -html

map f xs is the list obtained by applying f to each element of xs, i.e., > map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] > map f [x1, x2, ...] == [f x1, f x2, ...]
A combination of parList and map, encapsulating a common pattern: > parMap strat f = withStrategy (parList strat) . map f
Lift a function to actions. This function may be used as a value for fmap in a Functor instance.
This function may be used as a value for fmap in a Functor instance.
An infix synonym for fmap.
Promote a function to a monad.
A variant of <*> with the arguments reversed.
iterate f x returns an infinite list of repeated applications of f to x: > iterate f x == [x, f x, f (f x), ...]
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] == []
Application operator. This operator is redundant, since ordinary application (f x) means the same as (f \$ x). However, \$ has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example: > f \$ g \$ h x = f (g (h x)) It is also useful in higher-order situations, such as map (\$ 0) xs, or Data.List.zipWith (\$) fs xs.
Strict (call-by-value) application, defined in terms of seq.
Applied to a predicate and a list, all determines if all elements of the list satisfy the predicate. For the result to be True, the list must be finite; False, however, results from a False value for the predicate applied to an element at a finite index of a finite or infinite list.
Applied to a predicate and a list, any determines if any element of the list satisfies the predicate. For the result to be False, the list must be finite; True, however, results from a True value for the predicate applied to an element at a finite index of a finite or infinite list.
In many situations, the liftM operations can be replaced by uses of ap, which promotes function application. > return f `ap` x1 `ap` ... `ap` xn is equivalent to > liftMn f x1 x2 ... xn
The sortWith function sorts a list of elements using the user supplied function to project something out of each element
This function may be used as a value for Data.Foldable.foldMap in a Foldable instance.