rightarrow 0.4

The Annotations

This language is built from the following concepts:

• Named types: int, long, float, complex, str, unicode, file, YourClassNameHere, …

• Lists: [int], [[long]], …

• Tuples: (int, long), (float, (int, Regex)), …

• Dictionaries: {string: float}, { (str, str) : [complex] }, …

• Unions: int|long|float, str|file, …

• “Anything goes”: ??

• Functions, after which this library is named :-)

  • str -> int

  • (int) -> int

  • (int, int) -> int

  • ( (int, int) ) -> int

  • ( str|file ) -> SomeClass

  • (int, *[str]) -> [(str, int)]

  • (int, *[int], **{int: str}) -> str

• Objects: object(self_type, field1: int, field2: str, ...)

• Polymorphic types (where ~a, ~b, ~c range over any other type. Syntax subject to change; no preference really)

  • ~a -> ~a

  • [~a] -> [~a]

  • ( (~a, ~b) ) -> ~a

Run-time checking

The module typelanguage.enforce contains functions for using these annotations as run-time monitors.

Applied directly:

>>> check('{string: int}', {"hello" : "there"})

Wrapping a function to protect it from funky input is more interesting. For example, putting better error checking on Python’s unicode/str interactions (at least in Python 2)

>>> '\xa3'.encode('utf-8')
...
UnicodeDecodeError: 'ascii' codec can't decode byte 0xa3 in position 0: ordinal not in range(128)

>>> @guard('unicode -> str')
... def safe_encode(s):
...    return s.encode('utf-8')

>>> safe_encode(u'hello')
'hello'
>>> safe_encode('\xa3')
TypeError: Type check failed: ? does not have type unicode

If you are familiar with notions of “blame” for higher-order contracts, pull-requests welcome :-)

Inferring Annotations

Inference is a work-in-progress, definitely planned, and almost certainly will always be “best effort” only. It works like so:

1. By traversing the code, we can discover a bunch of constraints between different missing annotations.

2. Some of these constraints are going to be very easy to solve, so we can just propagate the results.

3. Some of these constraints are not going to be practical to try to solve, so we can just drop them or insert some enforcement code if we like.

More to explore

There are many other projects that check contracts or types for Python in some way. They are all different, many are prototypes or research projects, and none seem to serve the need that motivates this library. Still, check them out!

• PEP 316 (deferred)

• RPython and PyPy (compilation-oriented)

• pySonar and mini-pysonar (way cool)

• Pyntch

• typechecker

• pycontract

• python-dbc and one pyDBC and another pydbc and yet another pyDBC

• python-type-inference (no code, but has a great list of papers and even more tools)

And there are cool things happening in other dynamic languages!

• Contracts in Racket and Typed Racket

• Typescript aka a slightly gradually-typed Javascript and Javascript++ (sort of gradually-typed Javascript) and javascript-contracts and cerny

• Este (statically-typed coffeescript) and Uberscript (gradually-typed coffeescript) and contracts.coffee

• Contracts.ruby

And this library draw inspiration from such a huge amount of academic work it cannot possibly all be mentioned, but special thanks to these research efforts

• Higher-order contracts (too numerous to mention them all!):

• Contracts for higher-order functions by Robert Bruce Findler & Matthias Felleisen.

• Relationally-parametric polymorphic contracts by Arjun Guha, Jacob Matthews, Robert Bruce Findler, and Shriram Krishnamurthi. DLS 2007.

• Gradual typing:

• Gradual typing for functional languages by Jeremy Siek & Walid Taha. 2006

• Gradual Typing for Objects by Jeremy Siek and Walid Taha. ECOOP 2007.

• Gradual typing with unification based inference by Jeremy Siek and Manish Vachharajani. DLS 2008.

• Blame for all by Amal Ahmed, Robert Bruce Findler, Jacob Matthews, and Philip Wadler. STOP 2009.

• The ins and outs of of gradual type inference by Aseem Rastogi, Avik Chaudhuri, and Basil Hosmer. POPL 2012.

• Always available static and dynamic feedback by Michael Bayne, Richard Cook, and Michael D. Ernst. ICSE 2011.

• Hybrid Type Checking (full disclosure; I did some of this work):

• Hybrid type checking by Kenneth Knowles & Cormac Flanagan 2006/2010;

• Type reconstruction for general refinement types by Kenneth Knowles & Cormac Flanagan, 2007.

Contributors

• Kenn Knowles (@kennknowles)

Copyright and License

Copyright 2012- Kenneth Knowles

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.