On 2011-09-28 07:23, Arnaud Delobelle wrote:
A hybrid approach would be possible, taking from both approaches (decorator and keyword):
* a keyword to declare in the body of the function that a variable is of the "own" kind. * function objects would grow an __own__ attribute which is a dict-like object: - f.__own__["i"] would return the contents of the cell that the own variable "i" refers to - f.__own__["i"] = 42 would set the cell contents of the own variable "i" to 42 (or some other equivalent mechanism) * then one could create a kind of "inject" decorator.
Here's an example:
def setown(**kwargs): def decorator(f): for k, v in kwargs.items(): f.__own__[k] = v return decorator
@setown(i=42) def foo(x): own i i += 1 return i
I like this idea, but I think we should at least consider using "nonlocal" instead of "own" as the keyword (and __nonlocal__ instead of __own__ for the dict-like object). Pros: - No new keyword needed, just a change in how "nonlocal x" is treated when there is no 'x' variable in the defining scope. (Today this is a SyntaxError). Cons: - No way to define an "own" variable with the same name as a variable in the defining scope. - Ambiguity as to exactly what the lifetime of the nonlocal is. (If an outer function with no "x" variable in scope defines two inner functions that both use "nonlocal x", do they see the same "x"?) Ok, so I don't actually like repurposing nonlocal for this. +1 to your "own" suggestion. - Jacob