Teaching an old Python keyword new tricks

In my last post, I provided some additional thoughts about maintaining Python's pseudocode appearance while adding static typing information. The notation I suggested also allowed for easy inclusion of pre-conditions and post-conditions. However, this came as a cost of adding where as a new keyword to Python. After giving some more thoughts to this idea I realise that a new keyword was not needed at all. This can be seen starting from the following example using the keyword where as introduced before:

01    def gcd(a, b):

02        where:

03            assert isinstance(a, int)

04            assert isinstance(b, int)

05        '''Returns the Greatest Common Divisor,

06           implementing Euclid's algorithm.

07           Input arguments must be integers.'''

08        while a:

09            a, b = b%a, a

10        return b

If we remove the line with where: and change the indentation level, we have essentially valid (today!) Python syntax, but with many (two in this case) lines starting with the keyword assert. If we allow this keyword to introduce the beginning of a bloc of statements, we could then write:

01    def gcd(a, b):

02        assert:

03            isinstance(a, int)

04            isinstance(b, int)

05        '''Returns the Greatest Common Divisor,

06           implementing Euclid's algorithm.

07           Input arguments must be integers.'''

08        while a:

09            a, b = b%a, a

10        return b

The idea of a keyword that allows both a bloc structure with a colon, as well as a single line expression is not new: it has been introduced in Python with the addition of list comprehensions. For example, we can have

01    for i in range(10):

02        ...

03        ...

as well as

a = [i for i in range(10)]

With this suggested syntax, pre-conditions can easily be added.

01    def gcd(a, b):

02        assert:

03            isinstance(a, int)

04            isinstance(b, int)

05            a != 0 and b != 0    # fake pre-condition

06        '''Returns the Greatest Common Divisor,

07           implementing Euclid's algorithm.

08           Input arguments must be integers.'''

09        while a:

10            a, b = b%a, a

11        return b

Keeping this block structure in mind, we can add type information on return values as follows:

01    def gcd(a, b):

02        assert:

03            isinstance(a, int)

04            isinstance(b, int)

05            return c assert:

06                isinstance(c, int)

07        '''Returns the Greatest Common Divisor,

08           implementing Euclid's algorithm.

09           Input arguments must be integers;

10           return value is an integer.'''

11        while a:

12            a, b = b%a, a

13        return b

as well as adding pre- and post-conditions:

01    def gcd(a, b):

02        assert:

03            isinstance(a, int)

04            isinstance(b, int)

05            a != 0 and b != 0    # fake pre-condition

06            return c assert:

07                isinstance(c, int)

08                c != 0           # fake post-condition

09        '''Returns the Greatest Common Divisor,

10           implementing Euclid's algorithm.

11           Input arguments must be integers;

12           return value is an integer.'''

13        while a:

14            a, b = b%a, a

15        return b

To move further towards something similar to what I suggested in my previous post, we need to identify, as Guido van Rossum had himself suggested, the statement

isinstance(object, class-or-type-or-tuple)

with

object: class-or-type-or-tuple

Doing so allows us to rewrite the last example as

01    def gcd(a, b):

02        assert:

03            a: int

04            b: int

05            a != 0 and b != 0  # fake pre-condition

06            return c assert:

07                c: int

08                c != 0         # fake post-condition

09        '''Returns the Greatest Common Divisor,

10           implementing Euclid's algorithm.

11           Input arguments must be integers;

12           return value is an integer.'''

13        while a:

14            a, b = b%a, a

15        return b

which is essentially what was written in the previous post, but with the replacement of a new keyword (where) by an old one (assert). The general form would be:

01    def foo(...):

02        assert:

.             type information and/or

.             pre-conditions

.             return [...] assert:

.                 type information and/or

.                 post-conditions

.         '''docstring'''

.         ...body...

As this post is already long enough, I will not discuss the interface issue here; the ideas introduced in the previous two posts are easily translated by replacing where by assert everywhere.