Arrow Types aka Viewpoints

When we talked about reference capability composition and viewpoint adaptation, we dealt with cases where we know the reference capability of the origin. However, sometimes we don’t know the precise reference capability of the origin.

When that happens, we can write a viewpoint adapted type, which we call an arrow type because we write it with an ->.

Using this-> as a viewpoint

A function with a box receiver can be called with a ref receiver or a val receiver as well since those are both subtypes of box. Sometimes, we want to be able to talk about a type to take this into account. For example:

class Wombat
  var _friend: Wombat

  fun friend(): this->Wombat => _friend

Here, we have a Wombat, and every Wombat has a friend that’s also a Wombat (lucky Wombat). In fact, it’s a Wombat ref, since ref is the default reference capability for a Wombat (since we didn’t specify one). We also have a function that returns that friend. It’s got a box receiver (because box is the default receiver reference capability for a function if we don’t specify it).

So the return type would normally be a Wombat box. Why’s that? Because, as we saw earlier, when we read a ref field from a box origin, we get a box. In this case, the origin is the receiver, which is a box.

But wait! What if we want a function that can return a Wombat ref when the receiver is a ref, a Wombat val when the receiver is a val, and a Wombat box when the receiver is a box? We don’t want to have to write the function three times.

We use this->! In this case, this->Wombat. It means “a Wombat ref as seen by the receiver”.

We know at the call site what the real reference capability of the receiver is. So when the function is called, the compiler knows everything it needs to know to get this right.

Using a type parameter as a viewpoint

We haven’t covered generics yet, so this may seem a little weird. We’ll cover this again when we talk about generics (i.e. parameterised types), but we’re mentioning it here for completeness.

Another time we don’t know the precise reference capability of something is if we are using a type parameter. Here’s an example from the standard library:

class ListValues[A, N: ListNode[A] box] is Iterator[N->A]

Here, we have a ListValues type that has two type parameters, A and N. In addition, N has a constraint: it has to be a subtype of ListNode[A] box. That’s all fine and well, but we also say the ListValues[A, N] provides Iterator[N->A]. That’s the interesting bit: we provide an interface that let’s us iterate over values of the type N->A.

That means we’ll be returning objects of the type A, but the reference capability will be the same as an object of type N would see an object of type A.

Using box-> as a viewpoint

There’s one more way we use arrow types, and it’s also related to generics. Sometimes we want to talk about a type parameter as it is seen by some unknown type, as long as that type can read the type parameter.

In other words, the unknown type will be a subtype of box, but that’s all we know. Here’s an example from the standard library:

interface Comparable[A: Comparable[A] box]
  fun eq(that: box->A): Bool => this is that
  fun ne(that: box->A): Bool => not eq(that)

Here, we say that something is Comparable[A] if and only if it has functions eq and ne and those functions have a single parameter of type box->A and return a Bool. In other words, whatever A is bound to, we only need to be able to read it.