On 17 Apr 2005 09:27:34 -0700, "Kay Schluehr" <[EMAIL PROTECTED]> wrote:
>> Exactly. Except the above example is from the day-old-bread
>items-tuple-returning version of :: ;-)
>> And with an ordered dict subtype there is no need for the generator
>expression either,
>> since there is a values method for dicts (which in the subtype would
>preserve order). E.g.,
>>
>> x = property(*seq) where:
>> seq = (::
>> def get_x():
>> return self.__x
>> def set_x(value):
>> self.__x = value
>> del_x = None
>> doc = "I'm the 'x' property." ).values())
>>
>> Or more directly:
>>
>> x = property(*(::
>> def get_x():
>> return self.__x
>> def set_x(value):
>> self.__x = value
>> del_x = None
>> doc = "I'm the 'x' property." ).values())
>
>Hmmm ... now You eliminate "where" completely in favor for '::'. This
>may be reasonable because '::' is stronger and less context dependent.
>But on the other hand it may be also reasonable to eliminate '::'
>towards a stronger "where" ;)
>
>
>x = property(**kw) where kw:
> doc = "I'm the 'x' property."
> def fget(self):
> return self.__x
>
>
>x = property(*args) where args:
> def fget(self):
> return self.__x
> fset = None
> fdel = None
> doc = "I'm the 'x' property."
>
I like this. But how would you put "where args:" and "where kw:" if you needed
both?
also, is it looking back to see the '*' or '**' to do (::x=1).values vs. (::x=1)
and how about (::x=1).keys() or (::x=1).items() ? And what if you wanted to pass
(::x=1) as a dict object without ** expansion into a keyword dict?
Maybe we need asterisks on both ends. e.g.,
foo(dct, values, *args, **kw):
where **dct:
x=1
where *values:
x=2
where *args:
x=3
where **kw:
x=4
But that still doesn't give you, e.g.,
foo(keys) where:
keys=sorted((::
from interesting.module import *
).keys())
I like clean sugar, but I still want to be able to
get at the general primitives to compose them in ways
that can't be anticipated until a use case comes up.
And then if the primitives are inaccessible, one is
out of luck or doomed to workaround hacking ;-)
>
>Put definitions into a list:
>
>l = list(*args) where args:
> def fget(self):
> return self.__x
> doc = "I'm the 'x' property."
>
>
>Nest suites:
>
>x = property(*args) where args:
> t = tuple(*t) where t:
> def fget(self):
> return self.__x
> fset = None
> fdel = None
> doc = "I'm the 'x' property."
>
>
>Evaluate conditions:
>
>if f(*args)==1 where args:
> x = 1
> y = 2
>
>I think this version is more mainstream syntax ( and without braces and
>additional punctuation ) than the unary prefix operator '::' which
>drops statements into expressions within expressions.
>
I like this mainstream syntax for ordinary use cases, but as mentioned,
I'd still like to have primitives accessible. I don't see why both
couldn't live in harmony ;-)
Regards,
Bengt Richter
--
http://mail.python.org/mailman/listinfo/python-list
