I'm just going to throw myself in the conversation obtusely.I felt we
needed some real code. These are literally the first two samples I had on
hand.
!!! OUT OF CONTEXT REAL CODE ALERT !!!
###################################
formatter = formatter.format(**color).replace("(","{").replace(")","}")
print("\n\n".join(formatter.format(**d) for d in db))
# vs #
formatter = formatter.format(::(),
::color).replace("(","{").replace(")","}")
print("\n\n".join(formatter.format(::(), ::d) for d in db))
# What do we do for "format(**kwargs)"?
# With the current guess of mine, I'm thinking "what does ::() do?" and
"why are there two double-colons?".
# Aside from that it looks not much different/worse.
# and #
def checkLoad(self, *args, **kwargs):
if getattr(self, x) == None: getattr(self, loadx)()
if fakeself:
return function(getattr(self, x), *args, **kwargs)
else:
return function(self, *args, **kwargs)
return checkLoad
# vs #
def checkLoad(self, tuple::args, dict::kwargs):
if getattr(self, x) == None: getattr(self, loadx)()
if fakeself:
return function(getattr(self, x), ::args, ::kwargs)
else:
return function(self, ::args, ::kwargs)
return checkLoad
# It looks much the same, but how does it benefit me?
# "*args" is very distinct from "**kwargs" in my opinion. "tuple"/"dict"
doesn't have that.
# That said, the second works better with my syntax highlighter (although
pylint then swears at me).
#############################################################
Before I actually put the syntax in context I hated this. Now I just really
dislike it.
There is one big thing bugging me: How do I do: "foo(**kwargs)"? My
solution was to use "foo(::(), ::kwargs)", but it's obviously not a great
alternative.
There is another, smaller one. Wrapper functions often just want to pass
values straight through them. They don't care that it's a tuple. They don't
care that it's a dict. They're just going to throw it across. Without "def
foo(::args)" syntax, that's just a waste of a lookup. With "def
foo(::args)" syntax you lose the discrimination of args and kwargs,
resulting in the same problem above. Finally, it's uglier when without.
I do have one suggestion:
foo(*args, **kwargs): pass
foo(tuple(*) args, dict(**) kwargs): pass
foo(dict(**) kwargs): pass
foo(*, bar="spam"): pass
# this is illegal because unbound "catchalls" don't catch anything, as they
do today
foo(tuple(*), bar="spam"): pass
I'll leave you to guess how it works. If you can't it's obviously not
obvious enough.
Advantages:
"*" means a catchall, as it should.
"*" is distinct from "**".
With syntax highlighting, it's pretty obvious what is going on.
It's backwards compatible (the main reason it's not "tuple(*):args").
*My main problem is: use case? I've had none at all.*
If only 1% of users want it, it's not right to make the 99% change. Saving *one
line and 50 microseconds* per hundred uses of (*/**) is not a valid
argument.And don't make us all change all our code just to satisfy that.
The only argument you can make is readability, but (*/**) is more explicit
than a lookup, just because it's not dependant on position (args/kwargs
argument) and it's always a real tuple and dict.
def tuple(): 1/0
--
http://mail.python.org/mailman/listinfo/python-list
