Safe Haskell | Safe-Infered |
---|

- (.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
- (.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
- (.**) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
- (.***) :: (d -> e) -> (a -> a1 -> b -> c -> d) -> a -> a1 -> b -> c -> e
- (.****) :: (d -> e) -> (a -> a1 -> a2 -> b -> c -> d) -> a -> a1 -> a2 -> b -> c -> e
- (.*****) :: (d -> e) -> (a -> a1 -> a2 -> a3 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> b -> c -> e
- (.******) :: (d -> e) -> (a -> a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> a4 -> b -> c -> e
- (.*******) :: (d -> e) -> (a -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e
- (.********) :: (d -> e) -> (a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> e
- compose2 :: (c -> d) -> (a -> b -> c) -> a -> b -> d
- compose3 :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
- compose4 :: (d -> e) -> (a -> a1 -> b -> c -> d) -> a -> a1 -> b -> c -> e
- compose5 :: (d -> e) -> (a -> a1 -> a2 -> b -> c -> d) -> a -> a1 -> a2 -> b -> c -> e
- compose6 :: (d -> e) -> (a -> a1 -> a2 -> a3 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> b -> c -> e
- compose7 :: (d -> e) -> (a -> a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> a4 -> b -> c -> e
- compose8 :: (d -> e) -> (a -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e
- compose9 :: (d -> e) -> (a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> e

# Documentation

(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> dSource

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)

(.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> dSource

Equivalent to `.:`

The pattern of appending asterisks is
more 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) -> (a -> a1 -> a2 -> a3 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> b -> c -> eSource

(.******) :: (d -> e) -> (a -> a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> a4 -> b -> c -> eSource

(.*******) :: (d -> e) -> (a -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> eSource

(.********) :: (d -> e) -> (a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> eSource

compose6 :: (d -> e) -> (a -> a1 -> a2 -> a3 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> b -> c -> eSource

compose7 :: (d -> e) -> (a -> a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a -> a1 -> a2 -> a3 -> a4 -> b -> c -> eSource