| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell98 |
Data.Composition
Description
This module is for convenience and demonstrative purposes more than it is for providing actual value. I do not recommend that you rely on this module for performance-sensitive code. Because this module is not based on Prelude's (.), some chances at optimization might be missed by your compiler.
Synopsis
- (∘) :: (b -> c) -> (a -> b) -> a -> c
- (.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
- (.:.) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
- (.::) :: (d -> e) -> (a1 -> a2 -> b -> c -> d) -> a1 -> a2 -> b -> c -> e
- (.::.) :: (d -> e) -> (a1 -> a2 -> a3 -> b -> c -> d) -> a1 -> a2 -> a3 -> b -> c -> e
- (.:::) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e
- (.:::.) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e
- (.::::) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> e
- (.::::.) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> e
- (.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
- (.**) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
- (.***) :: (d -> e) -> (a1 -> a2 -> b -> c -> d) -> a1 -> a2 -> b -> c -> e
- (.****) :: (d -> e) -> (a1 -> a2 -> a3 -> b -> c -> d) -> a1 -> a2 -> a3 -> b -> c -> e
- (.*****) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e
- (.******) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e
- (.*******) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> e
- (.********) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> e
- compose1 :: (b -> c) -> (a -> b) -> a -> c
- compose2 :: (c -> d) -> (a -> b -> c) -> a -> b -> d
- compose3 :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
- compose4 :: (d -> e) -> (a1 -> a2 -> b -> c -> d) -> a1 -> a2 -> b -> c -> e
- compose5 :: (d -> e) -> (a1 -> a2 -> a3 -> b -> c -> d) -> a1 -> a2 -> a3 -> b -> c -> e
- compose6 :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e
- compose7 :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e
- compose8 :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> e
- compose9 :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> e
Math
Colons and dots
(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d infixr 8 #
Compose two functions. f .: g is similar to f . g
except that g will be fed two arguments instead of one
before handing its result to f.
This function is defined as
(f .: g) x y = f (g x y)
Example usage:
concatMap :: (a -> b) -> [a] -> [b] concatMap = concat .: map
Notice how two arguments
(the function and the list)
will be given to map before the result
is passed to concat. This is equivalent to:
concatMap f xs = concat (map f xs)
(.:.) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e infixr 8 #
One compact pattern for composition operators is to
"count the dots after the first one",
which begins with the common .:, and proceeds by first
appending another . and then replacing it with :
(.:::) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e infixr 8 #
(.:::.) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e infixr 8 #
(.::::) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> e infixr 8 #
(.::::.) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> e infixr 8 #
Asterisks
(.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d infixr 8 #
Equivalent to .:
The pattern of appending asterisks is
straightforward to extend to similar functions:
(compose2 = .*, compose3 = .**, etc).
However, .: has been commonly adopted amongst Haskellers,
and the need for compose3 and beyond is rare in practice.
(.*****) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e infixr 8 #
(.******) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e infixr 8 #
(.*******) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> e infixr 8 #
(.********) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> e infixr 8 #
composeN
compose1 :: (b -> c) -> (a -> b) -> a -> c #
composeN f g means give g N inputs
and then pass its result to f.
compose6 :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e #
compose7 :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e #