[Python-Dev] PEP 435 - ref impl disc 2

[Glenn Linderman]

On 5/4/2013 11:31 PM, Glenn Linderman wrote:
> So I have a class based on Nick's Named Values, that has been extended 
> to propagate names into expressions, so that if you have named values  
> 'x' and 'y', when you   x + y, the result is a named value whose name 
> is '(x + y)'.
>
> Seems pretty awkward to integrate this with Enum. Maybe I'm missing 
> something.  Here's carved down code with just one operator defined for 
> brevity.  The third item from each print statement should be the same, 
> as far as I understand... but isn't.
>
> class NamedInt( int ):
>     _count = 0
>     def __new__( cls, *args, **kwds ):
>         name, *args = args
>         if len( args ) == 0:
>             args = [ cls._count ]
>             cls._count += 1
>         self = super().__new__( cls, *args, **kwds )
>         self._name = name
>         return self
>     def __init__( self, *args, **kwds ):
>         name, *args = args
>         super().__init__()
>     @property
>     def __name__( self ):
>         return self._name
>     def __repr__( self ):
>         # repr() is updated to include the name and type info
>         return "{}({!r}, {})".format(type(self).__name__,
>                                      self.__name__,
>                                      super().__repr__())
>     def __str__( self ):
>         # str() is unchanged, even if it relies on the repr() fallback
>         base = super()
>         base_str = base.__str__
>         if base_str.__objclass__ is object:
>             return base.__repr__()
>         return base_str()
>
>     # for simplicity, we only define one operator that propagates 
> expressions
>     def __add__(self, other):
>         temp = int( self ) + int( other )
>         if isinstance( self, NamedInt ) and isinstance( other, NamedInt ):
>             return NamedInt(
>                 '({0} + {1})'.format(self.__name__, other.__name__),
>                 temp )
>         else:
>             return temp
>
> x = NamedInt('the-x', 1 )
> y = NamedInt('the-y', 2 )
> # demonstrate that NamedInt propagates the names into an expression syntax
> print( repr( x ), repr( y ), repr( x+y ))
>
> from ref435 import Enum
>
> # requires redundant names, but loses names in the expression
> class NEI( NamedInt, Enum ):
>     x = NamedInt('the-x', 1 )
>     y = NamedInt('the-y', 2 )
>
> print( repr( NEI( 1 )), repr( NEI( 2 )), repr( NEI(1) + NEI(2)))
>
> # looks redundant, and still loses the names in the expression
> class NEI2( NamedInt, Enum ):
>     x = x
>     y = y
>
> print( repr( NEI2( x )), repr( NEI2( x )), repr( NEI2(x) + NEI2(y)))

I've tried some more variations, without success:

print( repr( NEI( x )), repr( NEI( y )), repr( NEI( x ) + NEI( y )))
print( repr( NEI.x ), repr( NEI.y ), repr( NEI.x + NEI.y))
print( repr( NEI2.x ), repr( NEI2.y ), repr( NEI2.x + NEI2.y ))

Somehow, the overloading is not finding the __add__ operator in the 
NamedInt class, when the NamedInt's are wrapped in enumerations.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-dev/attachments/20130504/8cdb8ab0/attachment.html>