[Python-ideas] Explicit variable capture list

[Greg Ewing]

Steven D'Aprano wrote:
> Outside of such toys, we often find ourselves closing 
> over at least one variable which is derived from the loop variable, but 
> not the loop variable itself:

Terry's idea of a variant of the for-loop whose body
is a nested scope (with everything that implies) would
address that, because any name assigned within the body
(and not declared nonlocal) would be part of the captured
scope.

> I would not like to see "new" become a keyword.

I'm open to alternatives. Would "foreach" be better
keyword material? We could say

   foreach i in things:
     ...

although the difference between "for" and "foreach"
would be far from obvious.

I'd like to do something with "let", which is famliar
from other languages as a binding-creation construct,
and it doesn't seem a likely choice for a variable
namne.

Maybe if we had a general statement for introducing
a new scope, independent of looping:

   let:
     ...

Then loops other than for-loops could be treated like
this:

   i = 0
   while i < n:
     let:
       x = things[i]
       funcs.append(lambda: process(x))

The for-loop is a special case, because it assigns a
variable in a place where we can't capture it in a
let-block. So we introduce a variant:

   for let x in things:
     funcs.append(lambda: process(x))

Refinements"

1) Other special cases could be provided, but I don't
think any other special cases are strictly needed. For
example, you might want:

   with open(filename) as let f:
     process(f)

but that could be written as

   with open(filename) as f:
     let:
       g = f
       process(g)

2) It may be desirable to allow assignments on the
same line as "let", e.g.

   with open(filename) as f:
     let g = f:
       process(g)

which seems marginally more readable. Also, the
RHS of the assignment would be evaluated outside
the scope being created, allowing

   with open(filename) as f:
     let f = f:
       process(f)

although I'm not sure that's a style that should be
encouraged. Code that apparently assigns something
to itself always looks a bit wanky to me. :-(

-- 
Greg