Function composition#

Function composition means to combine simple functions into a more complicated function. The composition of f1 and f2 is defined as: f2 ∘ f1. This new function’s application is:

1
(f2 ∘ f1) x := f2 (f1 x)

Here the function names f1 and f2 imply the order of being applied. f2 ∘ f1 can also be read as f2 after f1.

Again, it is perfectly nature normal thing to chain 2 function application together, by using the first function’s output as the second function’s input:

1
double x = 1;
2
double y = Math.Sqrt(Math.Abs(x));

The following is a more complicated function, combined by 2 simple functions:

1
Func<double, double> absAndSqrt = x => Math.Sqrt(Math.Abs(x));

So absAndSqrt is a composition of Math.Abs and Math.Sqrt.

Generally, a function of type Func<T1, T2> and a function of type Func<T2, T3> can be composed to a new function of type Func<T1, T3>:

1
public static partial class FuncExtensions
2
{
3
    public static Func<T1, T3> o<T1, T2, T3>
4
        (this Func<T2, T3> function2, Func<T1, T2> function1) =>
5
            arg => function2(function1(arg));
6
}

Unfortunately, in C# there is no place to define custom function operators, so extension method has to be used. This method is named o to mimic the ∘ operator. Also, in lambda calculus, functions are curried, so this one extension method is good enough.

1
(.) :: (b -> c) -> (a -> b) -> a -> c
2
f2 . f1 = \x -> f2 (f1 x)

1
let inline (>>) f1 f2 x = f2 (f1 x)

1
let inline (<<) f2 f1 x = f2 (f1 x)

Properties#

Function composition has 2 important properties

1
((f3 ∘ f2) ∘ f1) (x)
2
≡ (f3 ∘ f2) (f1 (x))
3
≡ f3 (f2 (f1 (x)))

1
f3 ∘ (f2 ∘ f1)
2
≡ f3 ∘ (f2 (f1 (x)))
3
≡ f3 (f2 (f1 (x)))

1
Id := λx.x

1
f ∘ Id ≡ f

1
Id ∘ f ≡ f

1
public static partial class FuncExtensions
2
{
3
    public static T Id<T>
4
        (T value) => value;
5
}