Maybe a -> (a -> b) -> b

maybe :: b -> (a -> b) -> Maybe a -> b
base Prelude, base Data.Maybe
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 -> 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.
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
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.
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
base Control.Monad
Promote a function to a monad.
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.
($|) :: (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
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
base Control.Applicative
A variant of <*> with the arguments reversed.
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
base Control.Applicative
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

Show more results