CorrespondenceMutator + assignment to item operator

[@lucaswerkmeister] Summary: Polymorphic operator support for array[index] = val; map[key] = item;.

I suggest that we add the following interfaces

shared interface CorrespondenceMutator<in Key,in Item>
        given Key satisfies Object {
    shared formal void set(Key key, Item item);
}

shared interface MutableCorrespondence<in Key,Item>
        satisfies Correspondence<Key,Item> & CorrespondenceMutator<Key,Item>
        given Key satisfies Object {}

and define that for

• any expression cor of type CorrespondenceMutator<Key, Item>,
  • (given that cor is on the operator precedence level of “member invocation and selection, index, subrange, postfix increment, postfix decrement” or a Primary, i. e., that it’s syntactically sound to write cor[key])
• any expression key of type Key, and
• any expression item of type Item,

an assignment operator expression with the left-hand side cor[key] and the right-hand side item is syntactical sugar for cor.set(key, newValue), where newValue is

• item for an “assign” expression (=)
• oldValue OP item for any of the other assignment expressions (+=, *=, &=, etc.), where
  • oldValue is cor[key],
  • cor must therefore also be of type Correspondence<Key, Item> (typically MutableCorrespondence<Key, Item>),
  • OP is the operator of the assignment (+, *, &, etc.), and
  • that operator therefore places additional restrictions on the type of Item (Summable, Numeric, Set, etc.),

and that this also “carries over” to increment or decrement operators (which are already defined in terms of an “assign” expression).

This would, for example, allow code that operates on arrays to look very similar to its Java counterpart:

array[index] = val;
array[index += step] += increment;

but it would also be useful for other kinds of correspondences:

list[index] = val;
map[key] = item;

References:

• C♯ supports this via “Indexers”: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx
• The -Mutator pattern is taken from ceylon.collection, which has ListMutator, SetMutator, MapMutator – a neat trick to allow better type parameter variance (MutableList.Element is invariant, but a MutableList<Element> is a List<Element>&ListMutator<Element>, where the former offers a covariant (out) Element type parameter and the latter offers a contravariant (in) Element type parameter). https://github.com/ceylon/ceylon-sdk/blob/a827b28ad529f96e2e9ad894e872c249f6f27615/source/ceylon/collection/MutableList.ceylon#L31

[Migrated from ceylon/ceylon-spec#1042]

[gavinking]

I mean, there’s no point having this feature if ListMutator isn’t a CorrespondenceMutator.

[jvasileff]

May I open a different issue asking for this to change?

Too late @Zambonifofex #4517 😄