Base tests pass.

@dolio go ahead and merge if you're ready

Yeah, I'm making a couple of additions before merging. Paul wanted a way to access byte array contents.

Okay. The new additions are

1. Pinned.contents : Pinned g -> Ptr Nat8 – gets the pointer to the bytes of a pinned byte array (getting a pointer to a non-pinned array is unsafe because they can move).
2. IO.keepAlive : a -> '{IO} b ->{IO} b – this is necessary if you want to guarantee that a byte array (a) doesn't get garbage collected while you're working with its corresponding pointer in a loop (second argument).

I don't know if I get the need for the keepAlive function. It seems like if you're willing to call that function, you could also just keep the original pinned byte array around.

Like you could literally just define it in pure Unison and it would just ignore its first argument and force the second:

keepAlive bytes loop = loop()

Or is there more to it than that?

That function doesn't work. It tail calls loop, which means that the keepAlive frame no longer exists, and bytes isn't on the stack, except possibly incidentally.

The builtin tail calls loop with a continuation that has a special frame that contains the first argument, so that it stays live until you return back up the stack.

Gotcha. Okay cool. At first I was thinking I could write something like this:

keepAlive keep logic = 
  r = logic()
  _ = 1 + 1
  r

Now logic is no longer a tail call, and keep remains on the stack in the meantime that logic is being forced.

However, I can appreciate that in the future, a fancier Unison runtime optimizer might do something else here that lets keep be garbage collected, so having a primitive for it is better.