On 6/7/2016 10:40 PM, Steven D'Aprano wrote:
On Tue, Jun 07, 2016 at 12:53:23AM +0200, M.-A. Lemburg wrote:
On 07.06.2016 00:32, Barry Warsaw wrote:
On Jun 01, 2016, at 03:53 PM, M.-A. Lemburg wrote:
This could be done via a decorator:
@recordbinding x = obj
to result in the compiler generating the following code:
x = obj obj.recordbinding('x', 2)
I don't understand the purpose of the second argument, given as 2. Earlier you say that it's the line number. Why is that needed?
I don't see how this actually solves the problem. Apply it to namedtuple:
Record = namedtuple('Record', fields)
If you naively try the decorator:
@recordbinding Record = namedtuple(fields)
that gets converted to:
Record = namedtuple(fields) # TypeError Record.recordbinding('Record') # AttributeError
I think we might need some helpers, and a slight change to the specifics. I'd have:
@binding_method x = obj
result in: x = binding_method('x', obj)
Then you could just say:
@namedtuple Point = 'x y z'
Which would become:
Point = namedtuple('Point', 'x y z')
(or equivalently in this case: @namedtuple Point = ['x', 'y', 'z'] )
As has been pointed out, it's possible a different signature would be needed (not sure about line numbers, but qualname seems desirable). In that case, "namedtuple" above might not be "collections.namedtuple", but some helper.
The question for me is: do we want to have something that tells the compiler that "binding_method" or "namedtuple" above are special, or is this just what the compiler does for all uses of what looks like a decorated assignment statement?
There's no point in calling a special method on the RHS object, as that requires the object to have been constructed before the method can be called. And that requires the name. So your recordbinding decorator gets called too late.
Even if it worked, I strongly dislike that this turns a one-line expression into a two line statement.
# Status quo: x = sympy.Symbol('x')
# Becomes: @recordbinding x = sympy.Symbol()
which doesn't seem like an improvement to me.
This would work as well and indeed reads better, but you'd need to have the compiler generate:
x = obj recordbinding(obj, 'x', 2)
ie. pass in the object, the bound name and the line number and recordbinding would then have to decide what to do with the parameters.
Again, this is called too late. Your namedtuple needs its name when it is constructed, it can't be constructed first and then the name injected in, even if recordbinding() knew where to inject the name.