"where" keyword and Python as pseudo-code

There has been much discussion lately about what is now a series of blogs by Guido van Rossum (see Optional Static Typing -- Stop the Flames! for the latest discussion) about optional static typing in Python and related extensions to the language. A recent post
comp.lang.python by Andrey Tatarinov about using where as a new keyword in the absence of anonymous functions gave me some ideas about how such a new keyword could be useful in rendering pythonic the addition of optional static typing. However, I do not use where in the same context as Tatarinov.

Python is often described as executable pseudo-code. Therefore, rather than explaining in words my ideas, I will let the code (examples taken from Python's BDFL blogs) speak for itself. Note that the amount of code versus type declarations is not really representative of real life in the following examples. I also deliberately did not add blank lines, which could have made this more readable.

1. Optional typing.

def gcd(a, b):

   where:

      a: int, b: int

      return c where:

          c: int

   while a:

      a, b = b%a, a

   return b

2. Optional typing with pre- and post- conditions.

def gcd(a, b):

   where:

       a: int, b: int

       a > 0, b > 0

       return c where:

           c: int

           c > 0

           c <= a and c <= b

    while a:             

        a, b = b%a, a

        return b       

3. Interfaces

interface I:

   def foo(x):

       where:

           x: int

           x > 0

           return r where:

               r: str



class C(object; I):   # derived from object; implements I

   def foo(self, x):

       return str(x)

4. More interfaces

interface I1(I2, I3):

   def foo(a: t1, b: t2):

       where:

           a: t1, b: t2

           return c where:

               c: t3



class C(C1, C2; I1):    # derived from C1, C2; implements I1

   def foo(a, b):

       return a+b

5. Formerly anonymous functions.

list_of_powers = [ powers(x) for x in my_list]:

   def powers(x):

       return (x, x*x, x*x*x)

6. Formerly anonymous functions with typing information

list_of_powers = [ powers(x) for x in my_list]:

   def powers(x):

        where:

           x: int

           return (a, b, c) where:

               a: int, b: int, c: int

        return (x, x*x, x*x*x)

7. Other optional typing style, meant to be equivalent to above

def type_safe_gcd(a, b):

   where:

       a: int, b: int

       return c where:

           c: int



def gcd(a, b):

   where type_safe_gcd(a, b);

   while a:

       a, b = b%a, a

   return b

If you "grok" the above, I have made my point. If not, feel free to comment!