We almost always explain higher-kinded polyomrphism (a.k.a. type constructor polymorphism) in Haskell with an example involving type classes such as `Monad`

. It is natural to involve type classes because type classes were the motivation to support type constructor polymoprhism in Haskell. However, it is good to have an example that highlights the advantage of having higher-kinded polymorphism, because type constructor variables are not only useful for defining type classes. Here is an example I used in my recent draft of a paper to describe what type constructor polymorphism is and how they are useful.

```
data Tree c a = Leaf a | Node (c (Tree c a))
newtype Pair a = Pair (a,a)
type BTree a = Tree Pair a
type RTree a = Tree [] a
```

The ability to abstract over type constructors empowers us
to define more generic data structures, such as `Tree`

,
that can be instantiated to well-knwon data structures,
such as `BTree`

(binary tree) or `RTree`

(rose tree).
The `Tree`

datatype is parametrized by `c :: * -> *`

,
which determines the branching structure at the nodes,
and `a :: *`

, which determines the type of elemenets
hanging on the leaves. By instantiating the type construcor variable `c`

, we get concrete tree data structures, which
we would define sparately as follows without type constructor polymophism, but only with type polymorphism:

```
data BTree a = BLeaf a | BNode (BTree a, BTree a)
data RTree a = RLeaf a | RNode [RTree a]
```