Version 5 (modified by benl, 9 years ago) (diff) |
---|

# Closure Typing

## Region sharing

Consider the following function:

f () = do x = 5 g () = x g

Without closure information this function would have the following extended type:

f :: forall %r. () -> () -> Int %r

Remember that the `forall %r` at the front of the type is supposed to indicate that the return value is freshly allocated. This is certainly true if we apply both arguments:

twoSeparateInts :: Tuple2 %r1 (Int %r2, Int %r3) twoSeparateInts = (f () (), f () ())

In the type of `twoSeparateInts`, the different regions variables on each of the `Int` constructors means that they do not alias. This in turn means that it is safe to treat one as `Const` and the other as `Mutable`.

But what happens if we partially apply `f`? The standard type system will re-generalize the type for the new binding and we're left with:

f_unit :: forall %r1. () -> Int %r1 f_unit = f ()

We've now got a function which returns the *same* `Int` every time we call it, but the type says it's supposed to be fresh! The problem here is that `x` was free in our original definition of `g` so is shared between applications of it.

## Closure typing for region sharing

Closure typing is used to track the sharing of regions between function calls.

The type inferred for `f` is actually:

f :: forall %r0 . () -> () -($c0)> Int %r0 :- $c0 = x : %r0

The `$c0` annotation tells us that this function has a object free in its closure, and that the object contains region `%r0`. The `x : %r0` syntax gives a name to this term, and is pronounced "x *of* region zero".

If we use this new type and apply the first argument we have:

f_unit :: () -($c0)> Int %r0 :- $c0 = x : %r0

This type says that `f_unit` is a function that takes a unit value and returns an `Int`, but the `Int` is free in its closure so is shared by all calls to it. The type system does not generalise regions which are free in these closures.