On Fri, Dec 30, 2011 at 7:26 AM, julien tayon <julien@tayon.net <mailto:julien@tayon.net>> wrote:

I quite noticed people were 1) wanting to have a new dict for Xmas

Someone has proposed a modified version of the current dict type. The questions are whether a) it will behave correctly in all situations; b) give better overall performance; and c) be as easily maintainable.

2) strongly resenting dict addition.

This strikes me as a nonsensical statement. As noted below, we already have a type of 'dict addition' -- and even 'dict subtraction'. Counterfactual negative statements like this lead to the impression that you are trolling, even if you do not intend to.

I propose the following code to validate my point of view regarding the dictionnatry addition as a proof of concept : https://github.com/jul/ADictAdd_iction/blob/master/test.py

This link any gives the tests, not the accu_dict itself. So there is no way to know from the above exactly what you are proposing. From what Guido wrote in his next response, I am guessing that it is something like collections.Counter, which is an implementation of the multiset idea.

c = Counter(a=3, b=1) d = Counter(a=1, b=2) c + d # add two counters together: c[x] + d[x] Counter({'a': 4, 'b': 3})

c - d # subtract (keeping only positive counts) Counter({'a': 2})

Tagging numbers by keys is a generalization of tagging them by position (index). So this is generalized vector arithmetic and that is what your tests test. ------------------------ You have mixed up some of the terminology. def test_add_permut(self): """( a + b ) + c = a + ( b + c )""" This is the associative law, not 'permutative'. def test_permut_scal_mul(self): """ ( an_int * other_scalar ) * a = an_int ( other_scalar * a )""" Again, associativity (of scalar multiplication). --- def test_other_mul_scal_commut(self): """ ( an_int + other_scalar ) a = an_int * a + other_scalar * a """ This is a distributive law. def test_scal_lin_combo(self): """ an_int ( a + b) = an_int *a + an_int * b """ So is this. --- def test_permutation(self): """a + b = b + a """ This is commutivity, which you had right earlier in the file: def test_commutativity(self): """ a + b = b + a """ --- def test_neutral(self): """ a + neutral = a """ Not exactly incorrect, but this is a test of the additive identify, which is usually called 'zero' rather than 'neutral'. def test_neutral_mul_scal(self): """ 1 * a = a """ while this tests the scalar multiplicative identify -- Terry Jan Reedy