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", 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.