Add a couple more cases to constraintgen

Author: kennknowles

README.md

@@ -3,10 +3,40 @@ A Type Language for Python
 
 https://github.com/kennknowles/python-typelanguage
 
-This module provides a type language for communicating about Python programs and values. Humans
-communicating to other humans, humans communicating to the computer, and even the computer
+This module provides a type language for communicating about Python programs and values. 
+
+Humans communicating to other humans, humans communicating to the computer, and even the computer
 communicating to humans (via type inference and run-time contract checking).
 
+
+The Types
+---------
+
+This type language provides the following concepts:
+
+ * Atomic types `int`, `long`, `float`, `complex`, `str`, `unicode`
+ * Compound types for tuples, lists, dictionaries, written `(int, str)`,  `[int]`, {int: str}
+ * Object types `object(field1: int, field2: string) `
+ * Function types like `int -> int`, `str` (they can get much more complex in Python, though - see below)
+ * Polymorphic types like `forall a. [a] -> [a]`
+
+Function Types
+--------------
+
+The basic type of e.g. `str -> str` is pretty easy. But what about named args? `*args`? `**kwargs`?
+We try to re-use the function call / declaration syntax also in the types, so they can look like this:
+
+(int, *[int], **{int: str}) -> str 
+
+Type Inference
+--------------
+
+In the spirit of Python and dynamic languages, type inference is best-effort. Based
+on the program, this module can discover constraints between types present at different
+parts of the program. This constraint set may well be undecidable, especially if your
+program gets crazy. In most sane code, types will be almost entirely inferrable.
+
+
 Further Reading:
 ----------------
 

tests/samples/literal_long.py

@@ -0,0 +1 @@
+3L

tests/test_constraintgen.py

@@ -8,5 +8,14 @@ class TestConstraintGen(unittest.TestCase):
     def parse_expr(self, expr_string):
         return ast.parse(expr_string).body[0].value
 
-    def test_literals(self):
+    def test_atomic_literals(self):
         assert constraintgen.constraints_expr(self.parse_expr('"hello"')).type == types.AtomicType('str')
+        assert constraintgen.constraints_expr(self.parse_expr('u"hello"')).type == types.AtomicType('str')
+        assert constraintgen.constraints_expr(self.parse_expr('3')).type == types.AtomicType('int')
+        assert constraintgen.constraints_expr(self.parse_expr('3L')).type == types.AtomicType('long')
+        assert constraintgen.constraints_expr(self.parse_expr('-2.5')).type == types.AtomicType('float')
+        assert constraintgen.constraints_expr(self.parse_expr('7.40J')).type == types.AtomicType('complex')
+
+    def test_list_literals(self):
+        for expr in ['[]', '[3]', '["hello"]', '[[]]' ]:
+            assert isinstance(constraintgen.constraints_expr(self.parse_expr(expr)).type, types.ListType)

typelanguage/constraintgen.py

@@ -54,7 +54,7 @@ def constraints(pyast, env=None):
 
     elif isinstance(pyast, ast.Expression):
         expr_ty = constraints_expr(pyast.body, env=env)
-        return Constrained_env(env=env, constraints=expr_ty.constraints)
+        return ConstrainedEnv(env=env, constraints=expr_ty.constraints)
 
     else:
         raise Exception('Unknown ast node: %s' % pyast)
@@ -129,16 +129,29 @@ def constraints_expr(expr, env=None):
     env = env or {}
 
     if isinstance(expr, ast.Name) and isinstance(expr.ctx, ast.Load):
-        if expr.id in env:
+        if expr.id in ['False', 'True']: # Unlike other literals, these are actually just global identifiers
+            return ConstrainedType(type=types.AtomicType('bool'))
+        elif expr.id in env:
             return ConstrainedType(type=env[expr.id])
         else:
             raise Exception('Variable not found in environment: %s' % expr.id)
 
     elif isinstance(expr, ast.Num):
-        return ConstrainedType(type=types.AtomicType('num'))
+        # The python ast module already chose the type of the num
+        if isinstance(expr.n, int):
+            return ConstrainedType(type=types.AtomicType('int'))
+        elif isinstance(expr.n, long):
+            return ConstrainedType(type=types.AtomicType('long'))
+        elif isinstance(expr.n, float):
+            return ConstrainedType(type=types.AtomicType('float'))
+        elif isinstance(expr.n, complex):
+            return ConstrainedType(type=types.AtomicType('complex'))
 
     elif isinstance(expr, ast.Str):
         return ConstrainedType(type=types.AtomicType('str'))
+
+    elif isinstance(expr, ast.List):
+        return ConstrainedType(type=types.ListType(elem_ty=types.fresh()))
 
     elif isinstance(expr, ast.BinOp):
         left = constraints_expr(expr.left, env=env)
@@ -161,5 +174,7 @@ def constraints_expr(expr, env=None):
 if __name__ == '__main__':
     with open(sys.argv[1]) as fh:
         proggy = ast.parse(fh.read())
+
+    print ast.dump(proggy)
 
-    print constraints({}, proggy).pretty()
+    print constraints(proggy).pretty()

typelanguage/types.py

@@ -1,5 +1,23 @@
 from collections import namedtuple, defaultdict
-    
+
+# Kinds
+
+class Kind(object): pass
+
+# The kind of types
+class Type(Kind): pass
+
+# The kind of record field names
+class Label(Kind): pass
+
+class FunctionKind(Kind):
+    def __init__(self, dom, rng):
+        self.dom = dom
+        self.rng = rng
+
+        
+## Types proper
+
 class Type(object): pass
 
 class AtomicType(Type):
@@ -14,6 +32,20 @@ def __str__(self):
 
     def __eq__(self, other):
         return isinstance(other, AtomicType) and other.name == self.name
+
+# TODO: Make into a higher-kinded type? Maybe that's just a headache?
+class ListType(Type):
+    def __init__(self, elem_ty):
+        self.elem_ty = elem_ty
+
+    def substitute(self, substitution):
+        return ListType(self.elem_ty.substitue(substitution))
+
+    def __str__(self):
+        return '[%s]' % self.elem_ty
+
+    def __eq__(self):
+        return isinstance(other, ListType) and other.elem_ty == self.elem_ty
 
 class TypeVariable(Type):
     def __init__(self, name):
@@ -69,6 +101,9 @@ class UnionType(Type):
     def __init__(self, types):
         self.types = types
 
+
+# Fresh variable supply
+
 used_vars = defaultdict(lambda: 0)
 def fresh(prefix=None):
     global used_vars