I do not expect this idea to gain much traction but it has been an idea rolling around in my head for a year or two, so I decided to write it all down and see what other thought. Abstract: Python does not currently support static typing of variables, which is something I like, but there are times it would be nice to have static typing for variables, or method/function return values. Static Ducks should be able to run along side or imported to code that does not use Static Ducks. Actual runtime enforcement of Static Ducks should be off by default and require activation either via the command line or at the top of a file (similar to the __future__ requirement) where it would affect only that file (and any Static Ducks imported to it) Design Goals: The new syntax should * Be simple to read * Make it obvious what is happening; at the very least it should be obvious that new users can safely ignore it when writing their own code * Allow future compilers to optimize for Static Typing. * Work within a function or method definition to ensure a passed variable is the proper type * Allow Functions/Methods return values to be typed and checked * Raise an TypeError exception when the variable is set to something improper, or the function/method tries to return an improper value Issues: If this PEP is implemented it may conflict with PEP 362 (Function Signature Object) Use Cases: Python to C compilers could be enhanced by allowing static ducks. IDE's code complete could be enhanced by having static ducks available IDE's issues prediction could be enhanced to detect type issues for code that uses static ducks (Like any static typed language) Syntax Idea: """$type variable = value $returnType def function($type variable): #do stuff return value $returnType def function($type variable): #do stuff return value class test: $type variable = value $returnType def method(self, $type variable): #do stuff return value""" The reason I selected $type is because I couldn't think of anything else that $ was used for and I wanted a syntax similar to Decorators and similar to other statically typed languages. All types allow None or their proper type when setting, this so people can have typed variables that can be "undefined" for checking Example: $int count = 0 $bool def check($string testValue): return testValue.lower() == "true" class test: $string _name = None $string def get_name(self): return self._name def set_name(self, $string name): self._name = name Usage Details: When a variable has been statically type, any time it is set later its type needs to be verified. I see this working in a similar way to how properties work. Also using this style would allow people to create their own static ducks. """psudo-code class StaticDuckBase(object): _value = None class IntTypeClass(StaticDuckBase): def _get_value(self): return self._value def _set_value(self, val): if isinstance(val, (int, type(None))): self._value = val else: try: val = int(val) self._value = val except: raise TypeError("Expected int, got " + str(type(val)) + " instead!") value = property(_get_value, _set_value, None) class MyTypeClass(StaticDuckBase): def _get_value(self): return self._value def _set_value(self, val): if isinstance(val, MyType)): self._value = val else: raise TypeError("Expected MyType, got " + str(type(val)) + " instead!") value = property(_get_value, _set_value, None) staticducks.add('mytype', MyTypeClass) """ Though there will need to be some way to check if a variable is statically typed so that when you do $int count = 0 then later count = 5 it uses the static typing. Also if no static duck is specified it should revert to nonstatic but emit a warning that is only show when run with the -W option Type List: Base Types: $int $float $bool $string $tuple $namedtuple $list $set $frozenset $dict $byte $bytearray $memoryview $nonstatic # This means treat it as if it were not statically typed Composite type $bytes -> $byte | $bytearray $number -> $int | $float | Decimal $seq -> $tuple | $list | $set | $frozenset | $namedtuple $sets -> $set | $frozenset Special Cases #lets you require a specific type for keys and values $dict($type key[, $type value]) """eg $dict($int, $string) tmp = {} # creates a dict that requires ints as keys and strings as values $dict($nonstatic, $bool) tmp = {} # creates a dict that requires values to be bool, but keys can be anything """ $tuple($type value) # lets you specify the type for the tuples values $list($type value) # lets you specify the type for the lists values $set($type value) # lets you specify the type for the sets values $frozenset($type value) # lets you specify the type for the sets values $sets($type value) # lets you specify the type for the sets values $seq($type value) # lets you specify the type for the sequence values $string(encoding="UTF-8", normalized=False) $normalized # This would be equiv of doing $string(normalized=True) $normalized(encoding="UTF-8")