[Python-ideas] [Python-Dev] hello, new dict addition for new eve ?

[Terry Reedy]

> On Fri, Dec 30, 2011 at 7:26 AM, julien tayon
> <julien at tayon.net
> <mailto:julien at 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