composition-1.0.0.1: Combinators for unorthodox function composition

Data.Composition

Synopsis

• (.:) :: (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 -> b -> c -> d) -> a -> b -> c -> eSource

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

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

(.*****) :: (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

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

compose3 :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> eSource

compose4 :: (d -> e) -> (a -> a1 -> b -> c -> d) -> a -> a1 -> b -> c -> eSource

compose5 :: (d -> e) -> (a -> a1 -> a2 -> b -> c -> d) -> a -> a1 -> a2 -> 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

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

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