Mutable references and arrays

[ppolesiuk]

The library is not complete yet:

• Some useful methods are missing, like map or foldLeft
• There are not tests of the implementation
• The documentation is missing,

But I would like to someone review the general approach, and in particular, to make sure that it fits well to our effect system and philosophy.

[Foxinio]

While some minor changes can be made, and a lot of functionality is missing, i think it's a great addition and i didn't manage to break it so that's good.

[Foxinio]

I think we should "raise" some sort of an error if user tries to create array with negative length, because that's a mistake and i think user should know that he's making it.
Maybe use standard `re and let user handle it himself

[ppolesiuk]

I thought about it, and the decision was hard. Should we allow function f to also call pureInitArray, in order to create matrices? If yes, it should be able to raise some effects in f. However, this implementation will behave incorrectly if we allow function f to do some non-linear effects, like backtracking, and therefore I restricted its effect to just [E].

In order to allow f to raise some effects, we have to make sure that these effects are linear. For a moment, I thought that we could have some standard RE effect signature in Prelude like the following.

data RE (effect E) =
  { raise : {type T, ?msg : String } -> Unit ->[E] T }

However, its not true that all instances of this effect are linear. Having re : RE StdRE, we can write:

let badRE = RE {effect=[StdRE, BT], raise = re.raise }

to have the instance of RE with nonlinear effect (it contains backtracking).

[Foxinio]

While we are using ocaml for evaluation, we might want to restrict length of arrays, to one we are allowed to create in ocaml (Sys.max_array_length).

[ppolesiuk]

That's a good point. But what should we do when the user tries to create too large array?

[forell]

In a discussion @ppolesiuk suggested that we could take an approach similar to OCaml and expose the maximum array length for when the programmer requires this kind of assurance. I think this is reasonable, given that oversized allocations are uncommon and recovery from out of memory situations is rarely needed/desirable (at least for such a high level language). However, perhaps we still want to check the size somewhere, to display a custom error instead of OCaml's.

[forell]

Missing functionality aside, I think the interface exposed by this library looks like it'll be nice to use and fits the rest of Fram well enough.

These changes seem to motivate some form of linear effects down the line, but since that might require considerable design and implementation effort, I think these additions should be merged before that's addressed.

[forell]

In a discussion @ppolesiuk suggested that we could take an approach similar to OCaml and expose the maximum array length for when the programmer requires this kind of assurance. I think this is reasonable, given that oversized allocations are uncommon and recovery from out of memory situations is rarely needed/desirable (at least for such a high level language). However, perhaps we still want to check the size somewhere, to display a custom error instead of OCaml's.

[forell]

Naming this method set has a funny consequence for the (:=) operator.

> (a := 3) 42;;
: Unit
= <ctor>
> a.get 3;;
: Int
= 42

This is pretty unintuitive. We could rename the method that (:=) desugars to, rename this method on arrays, or remove it altogether (then we still have at for modification).

[ppolesiuk]

Maybe rename this method to setAt?

[ppolesiuk]

The implementation of arrays is ready. There is still missing functionality, and maximum size of an array is not implemented, but I think these things can be done as a separate issue.

[forell]

I believe this PR is ready for merging now. As discussed, the handlers that are currently expressed as higher-order functions should be changed to first-class handlers once they can be annotated properly.

[Foxinio]

Only change I would maybe want to see (being array length constant) can be done in separate PR.