(a -> Text) -> [a] -> Text

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
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, ...]
($) :: (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.
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
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
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.
until :: (a -> Bool) -> (a -> a) -> a -> a
base Prelude
until p f yields the result of applying f until p holds.
($|) :: (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.
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), ...]
(.) :: (b -> c) -> (a -> b) -> a -> c
base Prelude, base Data.Function
Function composition.
extQ :: (Typeable a, Typeable b) => (a -> q) -> (b -> q) -> a -> q
syb Data.Generics.Aliases
Extend a generic query by a type-specific case
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

Show more results