Monad m => (a -> b) -> a -> m b

liftM :: Monad m => (a1 -> r) -> m a1 -> m r

Promote a function to a monad.

ap :: Monad m => m (a -> b) -> m a -> m b

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

($) :: (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.

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.

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.

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), ...]

map :: (a -> b) -> IntMap a -> IntMap b

containers Data.IntMap.Strict, containers Data.IntMap.Lazy

O(n). Map a function over all values in the map. > map (++ "x") (fromList [(5,"a"), (3,"b")]) == fromList [(3, "bx"), (5, "ax")]

mapMonotonic :: (a -> b) -> Set a -> Set b

containers Data.Set

O(n). The mapMonotonic f s == map f s, but works only when f is monotonic. The precondition is not checked. Semi-formally, we have: > and [x < y ==> f x < f y | x <- ls, y <- ls] > ==> mapMonotonic f s == map f s >

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, ...]

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

($|) :: (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.

(<*>) :: Applicative f => f (a -> b) -> f a -> f b

base Control.Applicative

iterateN :: Int -> (a -> a) -> a -> Seq a

containers Data.Sequence

O(n). Constructs a sequence by repeated application of a function to a seed value. > iterateN n f x = fromList (Prelude.take n (Prelude.iterate f x))

until :: (a -> Bool) -> (a -> a) -> a -> a

base Prelude

until p f yields the result of applying f until p holds.

Show more results