a -> (a -> a) -> [a]
iterate f x returns an infinite list of repeated applications of f to x:
> iterate f x == [x, f x, f (f x), ...]
Apply a transformation everywhere in bottom-up manner
Apply a transformation everywhere in top-down manner
until p f yields the result of applying f until p holds.
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, ...]
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] == 
This function maps one exception into another as proposed in the paper "A semantics for imprecise exceptions".
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.
Extend a generic transformation by a type-specific case
The maybe function takes a default value, a function, and a Maybe value. If the Maybe value is Nothing, the function returns the default value. Otherwise, it applies the function to the value inside the Just and returns the result.
A combination of parList and map, encapsulating a common pattern:
> parMap strat f = withStrategy (parList strat) . map f
This function may be used as a value for fmap in a Functor instance.
Lift a function to actions. This function may be used as a value for fmap in a Functor instance.
The sortWith function sorts a list of elements using the user supplied function to project something out of each element
Direct MonadPlus equivalent of filter filter = (mfilter:: (a -> Bool) -> [a] -> [a] applicable to any MonadPlus, for example mfilter odd (Just 1) == Just 1 mfilter odd (Just 2) == Nothing
Make a generic transformation; start from a type-specific case; preserve the term otherwise
Show more results