# Row polymorphism crash course

--

With type inference, structural records types can make a statically typed language feel almost like a scripting language, without giving up type safety:

`// Works for any record with the fields width, height : Floatarea2d v = v.width * v.height`

Row polymorphism can be used to implement this, and can also be used for polymorphic variants, effect systems and stack types in concatenative languages. This post gives a few quick examples of how it works.

Suppose we have two functions that work on row polymorphic records:

`f : forall row1. {a: Int, …row1} -> Intg : forall row2. {b: String, …row2} -> Int`

And we want to figure out the type of the following function:

`h x = f x + g x`

As usual, we instantiate the forall-bound variables — in this case row variables by replacing them with fresh row variables.
The instantiated types for the occurrences of f and g here are thus:

`f : {a: Int, …row3} -> Intg : {b: String, …row4} -> Int`

Since x occurs as the argument of both f and g, we know two things about it:

`x : {a: Int, …row3}x : {b: String, …row4}`

Thus we must perform unification on those two types:

`{a: Int, …row3} = {b: String, …row4}`

To solve this, we create a substitution where each of the row variables contain the opposite records fields, as well as a fresh row variable row5:

`row3 = {b: String, …row5}row4 = {a: Int, …row5}`

Applying this substitution to the equation above gives us:

`{a: Int, b: String, …row5} = {b: String, a: Int, …row5}`

Sorting the fields lexicographically by field name gives us syntactically equality:

`{a: Int, b: String, …row5} = {a: Int, b: String, …row5}`

The final type for h is thus (after generalization):

`h : forall row5. {a: Int, b: String, …row5} -> Int`

And thus we have inferred a row polymorphic record type by hand.

One thing I like about using row polymorphism for inferring structural types is that it only involves equalities — no inequalities as you get with subtyping, which are much harder to solve for.

Now, what if f and g instead had the same field name, but with different types?

`f : {a: Int, …row3} -> Intg : {a: String, …row4} -> Int`

Then we’d need to unify these:

`{a: Int, …row3} = {a: String, …row4}`

When unifying two records, the types of the common fields are unified, and not included in the substitution of row3 and row4.

In this case, there is exactly one common field a, with a different type on each side. That leads to a unification failure, and thus a type error:

`Int = String`

We’ve discovered an error in our program! The field a can’t be both an Int and a String.