DevTut

# Function composition

# Right-to-left composition

(.) lets us compose two functions, feeding output of one as an input to the other:

(f . g) x = f (g x)

For example, if we want to square the successor of an input number, we can write

((^2) . succ) 1        --    4

There is also (<<<) which is an alias to (.). So,

(+ 1) <<< sqrt $ 25    --    6

# Composition with binary function

The regular composition works for unary functions. In the case of binary, we can define

(f .: g) x y = f (g x y)          -- which is also
             = f ((g x) y)
             = (f . g x) y        -- by definition of (.)
             = (f .) (g x) y
             = ((f .) . g) x y

Thus, (f .: g) = ((f .) . g) by eta-contraction, and furthermore,

(.:) f g    = ((f .) . g)
            = (.) (f .) g
            = (.) ((.) f) g
            = ((.) . (.)) f g

so (.:) = ((.) . (.)), a semi-famous definition.

Examples:

(map (+1) .: filter) even [1..5]      --  [3,5]
(length   .: filter) even [1..5]      --  2

# Left-to-right composition

Control.Category defines (>>>) (opens new window), which, when specialized to functions, is

-- (>>>) :: Category cat => cat a b -> cat b c -> cat a c  
-- (>>>) :: (->) a b -> (->) b c -> (->) a c 
-- (>>>) :: (a -> b) -> (b -> c) -> (a -> c) 
( f >>> g ) x = g (f x)

Example:

sqrt >>> (+ 1) $ 25    --    6.0

# Remarks

Function composition operator (.) is defined as

(.) :: (b -> c) -> (a -> b) ->  (a -> c)
(.)       f           g          x =  f (g x)     -- or, equivalently,  

(.)       f           g     =   \x -> f (g x)     
(.)       f     =    \g     ->  \x -> f (g x)      
(.) =    \f     ->   \g     ->  \x -> f (g x)      
(.) =    \f     ->  (\g     -> (\x -> f (g x) ) )

The type (b -> c) -> (a -> b) -> (a -> c) can be written as (b -> c) -> (a -> b) -> a -> c because the -> in type signatures "associates" to the right, corresponding to the function application associating to the left,


f g x y z ...    ==    (((f g) x) y) z ...

So the "dataflow" is from the right to the left: x "goes" into g, whose result goes into f, producing the final result:

(.)       f           g          x =  r
                                      where r = f (g x)  
-- g :: a -> b
-- f ::      b -> c
-- x :: a      
-- r ::           c   

(.)       f           g     =    q
                                 where q = \x -> f (g x) 
-- g :: a -> b
-- f ::      b -> c
-- q :: a      -> c

....

Syntactically, the following are all the same:

(.) f g x  =  (f . g) x  =  (f .) g x  =  (. g) f x

which is easy to grasp as the "three rules of operator sections (opens new window)", where the "missing argument" just goes into the empty slot near the operator:

(.) f g    =  (f . g)    =  (f .) g    =  (. g) f   
--         1             2             3

The x, being present on both sides of the equation, can be omitted. This is known as eta-contraction. Thus, the simple way to write down the definition for function composition is just

(f . g) x   =   f (g x)

This of course refers to the "argument" x; whenever we write just (f . g) without the x it is known as point-free style.

← Databases →