composition-1.0.2.2: Combinators for unorthodox function composition

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

(∘) :: (b -> c) -> (a -> b) -> a -> c infixr 9 Source #

The mathematical symbol for function composition.

# Colons and dots

(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d infixr 8 Source #

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 Source #

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 -> b -> c -> d) -> a1 -> a2 -> b -> c -> e infixr 8 Source #

(.::.) :: (d -> e) -> (a1 -> a2 -> a3 -> b -> c -> d) -> a1 -> a2 -> a3 -> b -> c -> e infixr 8 Source #

(.:::) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e infixr 8 Source #

(.:::.) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e infixr 8 Source #

(.::::) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> e infixr 8 Source #

(.::::.) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> e infixr 8 Source #

# Asterisks

(.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d infixr 8 Source #

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) -> (a -> b -> c -> d) -> a -> b -> c -> e infixr 8 Source #

(.***) :: (d -> e) -> (a1 -> a2 -> b -> c -> d) -> a1 -> a2 -> b -> c -> e infixr 8 Source #

(.****) :: (d -> e) -> (a1 -> a2 -> a3 -> b -> c -> d) -> a1 -> a2 -> a3 -> b -> c -> e infixr 8 Source #

(.*****) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e infixr 8 Source #

(.******) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e infixr 8 Source #

(.*******) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> e infixr 8 Source #

(.********) :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> e infixr 8 Source #

# composeN

compose1 :: (b -> c) -> (a -> b) -> a -> c Source #

composeN f g means give g N inputs and then pass its result to f.

compose2 :: (c -> d) -> (a -> b -> c) -> a -> b -> d Source #

compose3 :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e Source #

compose4 :: (d -> e) -> (a1 -> a2 -> b -> c -> d) -> a1 -> a2 -> b -> c -> e Source #

compose5 :: (d -> e) -> (a1 -> a2 -> a3 -> b -> c -> d) -> a1 -> a2 -> a3 -> b -> c -> e Source #

compose6 :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> b -> c -> e Source #

compose7 :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> b -> c -> e Source #

compose8 :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> b -> c -> e Source #

compose9 :: (d -> e) -> (a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> d) -> a1 -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> b -> c -> e Source #