The most common pattern by far; piping the output of a [[Functions|function]] into the input of the next.

```haskell
compose :: forall a b c. (b -> c) -> (a -> b) -> (a -> c)
compose g f a = g (f a)
```

`compose` (infix as `<<<`) accepts 2 functions; `f` which is `a -> b` and `g`; `b -> c`. `compose` returns a new function `a -> c` that "glues" the 2 functions together; piping the output of `f` into `g`.

e.g.

consider a function `normalizedPathSegments :: String -> Array String`

This function would normalize a file path, removing trailing / leading slashes and resolving relative paths, then split the path by its segments.

A very good approach would be to split this function into separate single-purpose components, e.g.

- `stripLeadingSlash :: String -> String`
- `stripTrailingSlash :: String -> String`
- `splitPath :: String -> Array String`
- `normalizePathSegments :: Array String -> Array String`

then define `normalizedPathSegments` like so:

```haskell
normalizedPathSegments :: String -> Array String
normalizedPathSegments =
  normalizePathSegments
  <<< splitPath
  <<< stripTrailingSlash
  <<< stripLeadingSlash
```