Which polymorphism types are supported in Haskell?

Question

Reading the Wikipedia definition of polymorphism, I come with a question:

Which polymorphism types are supported in Haskell and which are not?

Looks like Wikipedia do not contain a description for some polymorphism types like Levity Polymorphism which is new for me and supported in Haskell.

I wondering to have an extended list of Haskell Polymorphism followed with examples to explore deeply.

Looks like the main two are:

• Parametric polymorphism
• Ad-hoc polymorphism

Answer 1

There are at least four things that can count as polymorphism in current Haskell:

• Parametric polymorphism. (Also kind polymorphism, polymorphism in the kinds instead of the types. Which I guess is parametric polymorphism one level above, so I'm not counting it as a separate entry.)
• Ad-hoc polymorphism, the one enabled by typeclasses. Introduced in the How to make ad-hoc polymorphism less ad hoc paper.
• Structural polymorphism. This is the one enabled by generics. A function can work over multiple data types that have different number of fields and constructors. For example, a generic equality function for records.
• Levity polymorphism. Polymorphism over calling conventions / runtime representations of types. Described in the Levity Polymorphism paper.

There are two more types of polymorphism that might be introduced in future versions of Haskell:

• Matchability polymorphism. Would allow higher-order type families to work with both type constructors and type families as arguments. Described in the paper Higher-order Type-level Programming in Haskell.

• Multiplicity polymorphism. Would allow higher-order functions to work with both normal functions and linear functions as arguments. Described in the paper Linear Haskell Practical Linearity in a Higher-Order Polymorphic Language.

One might ask, why this whole panoply of polymorphisms? There seems to exist an overall design principle in Haskell that, whenever some challenge could be solved with either subtyping or polymorphism, polymorphism should be preferred.

For example, from the levity polymorphism paper:

We can now present the main idea of the paper: replace sub-kinding with kind polymorphism.

From the paper introducing matchability polymorphism:

At first you might think that we need subtyping, but instead we turn to polymorphism

From the linear Haskell paper:

The lack of subtyping is a deliberate choice in our design

Simon Peyton Jones himself makes the point at 47:00 in this talk.

Whenever you want to use subtyping, use polymorphism instead.