ap -bytestring +base

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
appendFile :: FilePath -> String -> IO ()
base Prelude, base System.IO
The computation appendFile file str function appends the string str, to the file file. Note that writeFile and appendFile write a literal string to a file. To write a value of any printable type, as with print, use the show function to convert the value to a string first. > main = appendFile "squares" (show [(x,x*x) | x <- [0,0.1..2]])
app :: ArrowApply a => a (a b c, b) c
base Control.Arrow
appEndo :: Endo a -> a -> a
base Data.Monoid
approxRational :: RealFrac a => a -> a -> Rational
base Data.Ratio
approxRational, applied to two real fractional numbers x and epsilon, returns the simplest rational number within epsilon of x. A rational number y is said to be simpler than another y' if * abs (numerator y) <= abs (numerator y'), and * denominator y <= denominator y'. Any real interval contains a unique simplest rational; in particular, note that 0/1 is the simplest rational of all.
AppendMode :: IOMode
base System.IO
class Functor f => Applicative f
base Control.Applicative
A functor with application. Instances should satisfy the following laws: * identity pure id <*> v = v * composition pure (.) <*> u <*> v <*> w = u <*> (v <*> w) * homomorphism pure f <*> pure x = pure (f x) * interchange u <*> pure y = pure ($ y) <*> u * ignore left value u *> v = pure (const id) <*> u <*> v * ignore right value u <* v = pure const <*> u <*> v The Functor instance should satisfy > fmap f x = pure f <*> x If f is also a Monad, define pure = return and (<*>) = ap. Minimal complete definition: pure and <*>.
module Control.Applicative
base Control.Applicative
This module describes a structure intermediate between a functor and a monad: it provides pure expressions and sequencing, but no binding. (Technically, a strong lax monoidal functor.) For more details, see Applicative Programming with Effects, by Conor McBride and Ross Paterson, online at http://www.soi.city.ac.uk/~ross/papers/Applicative.html. This interface was introduced for parsers by Niklas Röjemo, because it admits more sharing than the monadic interface. The names here are mostly based on recent parsing work by Doaitse Swierstra. This class is also useful with instances of the Data.Traversable.Traversable class.
aP_STACK_SPLIM :: Int
base GHC.Constants
concatMap :: (a -> [b]) -> [a] -> [b]
base Prelude, base Data.List
Map a function over a list and concatenate the results.
fmap :: Functor f => (a -> b) -> f a -> f b
base Prelude, base Data.Functor, base Control.Monad, base Control.Monad.Instances
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, ...]
mapM :: Monad m => (a -> m b) -> [a] -> m [b]
base Prelude, base Control.Monad
mapM f is equivalent to sequence . map f.
mapM_ :: Monad m => (a -> m b) -> [a] -> m ()
base Prelude, base Control.Monad
mapM_ f is equivalent to sequence_ . map f.
class Arrow a => ArrowApply a
base Control.Arrow
Some arrows allow application of arrow inputs to other inputs.
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
base Data.Foldable
Map a function over all the elements of a container and concatenate the resulting lists.
dynApp :: Dynamic -> Dynamic -> Dynamic
base Data.Dynamic
dynApply :: Dynamic -> Dynamic -> Maybe Dynamic
base Data.Dynamic
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.
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
base Data.Foldable

Show more results