[WIP] Immutable ordered finite maps and sets

[jiribenes]

I've been sitting on this code for almost 9 months now, it's about time we finalise it.
This PR adds immutable ordered maps and sets based on BB[α]-trees into the standard library.

Important caveat: These structures work only on the JS backend because it's the only one with a generic comparison primitive (#394).

Note that it might take a while before I'm happy with this code, I just want to put it out here in case someone wants to help out / to prevent somebody else from spending too much time on reimplementing this.

TODO:

• add unit tests for the map
• add unit tests for the set
• add unit tests for the shift operators
• add a few more complex functional tests
• fix TODOs in code
• improve the docs
• use /// for doc strings
• improve the function names (insert in Set vs put/add in Map?)
• add intersection!
• check that the via combinators in Set actually inline

[marvinborner]

maybe we could use empty? here?

[jiribenes]

Thanks!
In general, feel free to suggest better names everywhere, I really just took the first idea I had every time :)

[b-studios]

We should do this change consistently across the stdlib, if we decide for it

[jiribenes]

In #488, we agreed to use constructors like $collection_name for array, ref, and bytes. For example:

// Creates a new Array of size `size` filled with the value `init`
extern global def array[T](size: Int, init: T): Array[T]
 
// Allocates new bytes with the given `capacity`, setting its values to `0`.
extern io def bytes(capacity: Int): Bytes

// Creates a new reference with the initial value `init`.
extern global def ref[T](init: T): Ref[T]

There are two main ways to make a map / set:

• empty map/set
• map/set created from a (possibly unordered) list

Does the convention mention above apply anywhere here? Personally, I'd always use these namespaced: map::empty() and map::fromList([...]), but I'm interested in what y'all think.

[jiribenes]

Here's a place where newtypes would be nice: I never want to leak the type Map[A, Unit] outside, otherwise type Set[A] = Map[A, Unit] would do. But packing it into a record might have some unpleasant consequences when benchmarking. Any ideas?

[b-studios]

You can use extern type Set[A] with identity coercions, but that might get into the way of optimizations.

[jiribenes]

Rebased on current master.

[jiribenes]

Blocked on #629, I'll fix it there and then rebase. :)