Add a Collection type

[ruuda]

Background

I want to add an unpack operator, so you can write [..xs] instead of [for x in xs: x], possibly to replace the union operator too. But to be able to propagate type expectations into collection literals, I need a way to express “List[T] or Set[T]”.

Solution

Defines a new type, Collection[T]. In the lattice, it is the meet of List[T] and Set[T]. I have a feeling that it will make typechecking the union operator more elegant as well, so maybe we can keep | after all. The new type fits in very naturally to the existing typechecking machinery, which is some evidence that the current iteration of #26 is a good approach.

To do

• Ensure documentation is up to date.
• Ensure test coverage.
• Ensure the fuzzer discovers the new code paths.
• Check existing error messages and docs for confusing use of the word “collection”.

[ruuda]

#50 has been merged, but this is not entirely obsolete. In some cases the typechecker expects a collection, it needs to handle that. And also, when it extracts an element type from a collection, now it’s no longer sufficient to match on the type, we have to look inside the union for candidates too.

[ruuda]

Note to self, previously I wanted to add .. syntax for unpacking, and use it for dicts, lists, and sets. But that creates a complication in the typechecker: is xs a dict or set?

let xs = { ..ys };

That would depend on whether ys is a dict or a set, so what expectation does the typechecker provide when checking ys? We can do Any, or maybe Union[Dict[Any, Any], Collection[Any]], but the former may lead to worse errors and the latter may lead to complex/confusing errors. So instead, we could add two operators: .. for unpacking collections, and ... for unpacking key-value pairs. There is precedent for it, Python also distinguishes between * and ** for unpacking.

// This is a dict, that follows syntactically.
let xs = { ...ys };
// This is a set.
let xs = { ..ys };
// This is of course a list.
let xs = [..ys];
// And this is a syntax error, key-value unpack is only valid in a dict literal.
let xs = [...ys];

Though now that I’m writing this, maybe it is not that hard to just support .. in the typechecker. That would be ideal; I think people would be annoyed by the difference between .. and ... even if it is completely regular and overloading .. is in a sense more complex.