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

map :: (a -> b) -> [a] -> [b]
base Prelude, base Data.List
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, ...]
parMap :: Strategy b -> (a -> b) -> [a] -> [b]
parallel Control.Parallel.Strategies
A combination of parList and map, encapsulating a common pattern: > parMap strat f = withStrategy (parList strat) . map f
liftA :: Applicative f => (a -> b) -> f a -> f b
base Control.Applicative
Lift a function to actions. This function may be used as a value for fmap in a Functor instance.
fmapDefault :: Traversable t => (a -> b) -> t a -> t b
base Data.Traversable
This function may be used as a value for fmap in a Functor instance.
fmap :: Functor f => (a -> b) -> f a -> f b
base Prelude, base Data.Functor, base Control.Monad, base Control.Monad.Instances
(<$>) :: Functor f => (a -> b) -> f a -> f b
base Data.Functor, base Control.Applicative
An infix synonym for fmap.
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
base Control.Monad
Promote a function to a monad.
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
base Control.Applicative
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
base Control.Applicative
A variant of <*> with the arguments reversed.
iterate :: (a -> a) -> a -> [a]
base Prelude, base Data.List
iterate f x returns an infinite list of repeated applications of f to x: > iterate f x == [x, f x, f (f x), ...]
dropWhile :: (a -> Bool) -> [a] -> [a]
base Prelude, base Data.List
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 :: (a -> Bool) -> [a] -> [a]
base Prelude, base Data.List
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 :: (a -> Bool) -> [a] -> [a]
base Prelude, base Data.List
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] == []
($) :: (a -> b) -> a -> b
base Prelude, base Data.Function
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.
($!) :: (a -> b) -> a -> b
base Prelude
Strict (call-by-value) application, defined in terms of seq.
all :: (a -> Bool) -> [a] -> Bool
base Prelude, base Data.List
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.
any :: (a -> Bool) -> [a] -> Bool
base Prelude, base Data.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.
ap :: Monad m => m (a -> b) -> m a -> m b
base Control.Monad
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
sortWith :: Ord b => (a -> b) -> [a] -> [a]
base GHC.Exts
The sortWith function sorts a list of elements using the user supplied function to project something out of each element
foldMapDefault :: (Traversable t, Monoid m) => (a -> m) -> t a -> m
base Data.Traversable
This function may be used as a value for Data.Foldable.foldMap in a Foldable instance.
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
base Data.Foldable
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
base Control.Monad
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
gmapQ :: Data a => (forall d. Data d => d -> u) -> a -> [u]
base Data.Data
($|) :: (a -> b) -> Strategy a -> a -> b
parallel Control.Parallel.Strategies
Sequential function application. The argument is evaluated using the given strategy before it is given to the function.
($||) :: (a -> b) -> Strategy a -> a -> b
parallel Control.Parallel.Strategies
Parallel function application. The argument is evaluated using the given strategy, in parallel with the function application.
($!!) :: NFData a => (a -> b) -> a -> b
deepseq Control.DeepSeq
the deep analogue of $!. In the expression f $!! x, x is fully evaluated before the function f is applied to it.
everywhere :: (forall a. Data a => a -> a) -> (forall a. Data a => a -> a)
syb Data.Generics.Schemes
Apply a transformation everywhere in bottom-up manner
everywhere' :: (forall a. Data a => a -> a) -> (forall a. Data a => a -> a)
syb Data.Generics.Schemes
Apply a transformation everywhere in top-down manner
all :: Foldable t => (a -> Bool) -> t a -> Bool
base Data.Foldable
Determines whether all elements of the structure satisfy the predicate.
any :: Foldable t => (a -> Bool) -> t a -> Bool
base Data.Foldable
Determines whether any element of the structure satisfies the predicate.
groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
base GHC.Exts
The groupWith function uses the user supplied function which projects an element out of every list element in order to to first sort the input list and then to form groups by equality on these projected elements
extQ :: (Typeable a, Typeable b) => (a -> q) -> (b -> q) -> a -> q
syb Data.Generics.Aliases
Extend a generic query by a type-specific case
until :: (a -> Bool) -> (a -> a) -> a -> a
base Prelude
until p f yields the result of applying f until p holds.
ext1Q :: (Data d, Typeable1 t) => (d -> q) -> (forall e. Data e => t e -> q) -> d -> q
syb Data.Generics.Aliases
Type extension of queries for type constructors
ext2Q :: (Data d, Typeable2 t) => (d -> q) -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q) -> d -> q
syb Data.Generics.Aliases
Type extension of queries for type constructors
(.) :: (b -> c) -> (a -> b) -> a -> c
base Prelude, base Data.Function
Function composition.
(<<) :: HTML a => (Html -> b) -> a -> b
html Text.Html
(<<) :: HTML a => (Html -> b) -> a -> b
xhtml Text.XHtml.Strict, xhtml Text.XHtml.Frameset, xhtml Text.XHtml.Transitional
Put something inside an HTML element.
gmapQi :: Data a => Int -> (forall d. Data d => d -> u) -> a -> u
base Data.Data
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
base Data.Function
(*) `on` f = \x y -> f x * f y. Typical usage: Data.List.sortBy (compare `on` fst). Algebraic properties: * (*) `on` id = (*) (if (*) {¥, const ¥}) * (*) `on` f) `on` g = (*) `on` (f . *  on f . flip on g = flip on (g . >  

Show more results