Skip to main content

A language for describing Python programs with concise higher-order annotations like "(a -> a) -> [a] -> [a]" but don't you dare call them "types"

Project description

_          _       _     _
\\        (_)     | |   | |
 \\   _ __ _  __ _| |__ | |_ __ _ _ __ _ __ _____      __
  \\ | '__| |/ _` | '_ \| __/ _` | '__| '__/ _ \ \ /\ / /
   \\| |  | | (_| | | | | || (_| | |  | | | (_) \ V  V /
    \\_|  |_|\__, |_| |_|\__\__,_|_|  |_|  \___/ \_/\_/
             __/ |
            |___/

https://github.com/kennknowles/python-rightarrow

Build status

This library provides a language for concise higher-order annotations for Python programs, inspired by the syntax for higher-order contracts and types in advanced languages. Functionality akin to contract checking, type checking, and type inference is a work-in-progress.

This project has a “duck-typed” status: Whatever you can use it for, it is ready for :-)

Here is a more concrete list of implemented and intended features:

  • yes - Definition of a the language.

  • yes - Parsing and printing.

  • yes - Run-time monitoring of adherence for monomorphic annotations.

  • upcoming - Monitoring of adherence for polymorphic annotations.

  • upcoming - Generation of constraints between annotations in a program.

  • upcoming - Best-effort inference of suitable annotations.

  • upcoming - More precise annotations to support full higher-order design-by-contract.

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!

And there are cool things happening in other dynamic languages!

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

Contributors

Project details


Release history Release notifications | RSS feed

This version

0.4

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

rightarrow-0.4.tar.gz (17.5 kB view details)

Uploaded Source

File details

Details for the file rightarrow-0.4.tar.gz.

File metadata

  • Download URL: rightarrow-0.4.tar.gz
  • Upload date:
  • Size: 17.5 kB
  • Tags: Source
  • Uploaded using Trusted Publishing? No

File hashes

Hashes for rightarrow-0.4.tar.gz
Algorithm Hash digest
SHA256 d30eb414365cdb400d11bdb473493dd432b402bd6912773982f975707b31ef22
MD5 e40c8fd868153d959428bdacb1d1c3e5
BLAKE2b-256 b6298845fb00b1f0021af4122ee287fd1266044609497668f8d310b75d8003b9

See more details on using hashes here.

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page