[Python-ideas] explicitation lines in python ?

G

geremy condra

The availability of "nonlocal" binding semantics also makes the
semantics much easier to define than they were in those previous
discussions (the lack of clear semantics for name binding statements
with an attached local namespace was the major factor blocking
creation of a reference implementation for this proposal back then).

For example:

 c = sqrt(a*a + b*b) where:
   a = retrieve_a()
   b = retrieve_b()

could translate to something like:

 def _anon(): # *(see below)
   nonlocal c
   a = retrieve_a()
   b = retrieve_b()
   c = sqrt(a*a + b*b)
 _anon()

*(unlike Python code, the compiler can make truly anonymous functions
by storing them solely on the VM stack. It already does this when
executing class definitions):

I like this idea, but I would tweak it slightly. Maybe we should say

EXPRESSION where:
   BLOCK

is equivalent to

def _():
   BLOCK
   return EXPRESSION
_()

That way, c = a where: a = 7 would be equivalent to

def _():
  a = 7
  return a
c = _()

One advantage of this equivalence is it would make it easier to work
around a longstanding scoping gotcha. A naïve coder might expect this
code to print out numbers 0 to 4:

   >>> fs = []
   >>> for n in range(5):
   ...     def f():
   ...         print(item)
   ...     fs.append(f)
   ...
   >>> [f() for f in fs]
   4
   4
   4
   4
   4
   [None, None, None, None, None]

I think we all have enough experience to know this isn’t a totally
unrealistic scenario. I personally stumbled into when I was trying to
create a class by looping through a set of method names.

To get around it, one could use a where clause like so:

fs = []
for n in range(5):
   fs.append(f) where:
       shadow = n
       def f():
           print(shadow)

This would print out 0 to 4 as expected and be equivalent to

   >>> fs = []
   >>> for n in range(5):
   ...     def _():
   ...         shadow = n
   ...         def f():
   ...             print(shadow)
   ...         fs.append(f)
   ...     _()
   ...
   >>> [f() for f in fs]
   0
   1
   2
   3
   4
   [None, None, None, None, None]

I think a where-clause with def-like namespace semantics would be a
positive addition to Python, once the moratorium is up.

-- Carl Johnson

+1 from me, FWIW

Geremy Condra
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

Forum statistics

Threads
473,787
Messages
2,569,627
Members
45,328
Latest member
66Teonna9

Latest Threads

Top