Fresh new name

Author: kennknowles

typelanguage/__init__.py renamed to rightarrow/__init__.py

@@ -49,18 +49,18 @@ def enforce(self, val):
             return False # TODO: when we actually have nominal (abstract) types, do some check here
 
 # TODO: Make into a higher-kinded type? Maybe that's just a headache?
-class ListType(Type):
+class List(Type):
     def __init__(self, elem_ty):
         self.elem_ty = elem_ty
 
     def substitute(self, substitution):
-        return ListType(self.elem_ty.substitute(substitution))
+        return List(self.elem_ty.substitute(substitution))
 
     def __str__(self):
         return '[%s]' % self.elem_ty
 
     def __eq__(self, other):
-        return isinstance(other, ListType) and other.elem_ty == self.elem_ty
+        return isinstance(other, List) and other.elem_ty == self.elem_ty
 
     def enforce(self, val):
         if type(val) != list:
@@ -69,21 +69,21 @@ def enforce(self, val):
             return [self.elem_ty.enforce(x) for x in val] # This could be slooooow
 
 
-class DictType(Type):
+class Dict(Type):
     def __init__(self, key_ty, value_ty):
         self.key_ty = key_ty
         self.value_ty = value_ty
 
     def substitute(self, substitution):
-        return DictType(key_ty=self.key_ty.substitute(substitution),
+        return Dict(key_ty=self.key_ty.substitute(substitution),
                         value_ty=self.value_ty.substitute(substitution))
 
 
     def __str__(self):
         return '{%s:%s}' % (self.key_ty, self.value_ty)
 
     def __eq__(self, other):
-        return isinstance(other, DictType) and other.key_ty == self.key_ty and other.value_ty == self.value_ty
+        return isinstance(other, Dict) and other.key_ty == self.key_ty and other.value_ty == self.value_ty
 
     def enforce(self, val):
         if type(val) != dict:
@@ -92,7 +92,7 @@ def enforce(self, val):
             return dict([(self.key_ty.enforce(key), self.value_ty.enforce(value)) for key, value in val.items()])
 
 
-class TypeVariable(Type):
+class Variable(Type):
     def __init__(self, name):
         self.name = name
 
@@ -106,9 +106,9 @@ def __str__(self):
         return '?%s' % self.name
 
     def __eq__(self, other):
-        return isinstance(other, TypeVariable) and  other.name == self.name
+        return isinstance(other, Variable) and  other.name == self.name
 
-class FunctionType(Type):
+class Function(Type):
     def __init__(self, arg_types, return_type, vararg_type=None, kwonly_arg_types=None, kwarg_type=None):
         self.arg_types = arg_types
         self.return_type = return_type
@@ -117,7 +117,7 @@ def __init__(self, arg_types, return_type, vararg_type=None, kwonly_arg_types=No
         self.kwonly_arg_types = kwonly_arg_types
 
     def substitute(self, substitution):
-        return FunctionType(arg_types = [ty.substitute(substitution) for ty in self.arg_types],
+        return Function(arg_types = [ty.substitute(substitution) for ty in self.arg_types],
                             return_type = self.return_type.substitute(substitution),
                             vararg_type = None if self.vararg_type is None else self.vararg_type.substitute(substitution),
                             kwonly_arg_types = None if self.kwonly_arg_types is None else [ty.substitute(substitution) for ty in self.kwonly_arg_types],
@@ -174,26 +174,26 @@ def __str__(self):
         return '%s -> %s' % (argument_list, self.return_type)
 
     def __eq__(self, other):
-        return isinstance(other, FunctionType) and other.vararg_type == self.vararg_type and other.kwarg_type == self.kwarg_type \
+        return isinstance(other, Function) and other.vararg_type == self.vararg_type and other.kwarg_type == self.kwarg_type \
           and other.arg_types == self.arg_types and other.kwonly_arg_types == self.kwonly_arg_types
 
-class TypeApplication(Type):
+class Application(Type):
     def __init__(self, fn, args):
         self.fn = fn
         self.args = args
 
     def substitute(self, substitution):
-        return TypeApplication(self.fn.substitute(substitution), [ty.substitute(substitution) for ty in self.args])
+        return Application(self.fn.substitute(substitution), [ty.substitute(substitution) for ty in self.args])
 
-class UnionType(Type):
+class Union(Type):
     def __init__(self, types):
         self.types = types
 
     def __str__(self):
         return '|'.join([str(ty) for ty in self.types])
 
     def __eq__(self, other):
-        return isinstance(other, UnionType) and self.types == other.types
+        return isinstance(other, Union) and self.types == other.types
 
     def enforce(self, val):
         for ty in self.types:
@@ -204,7 +204,7 @@ def enforce(self, val):
 
         raise TypeError('Type check failed: %s does not have type %s' % (val, self))
 
-class ObjectType(Type):
+class Object(Type):
     def __init__(self, self_ty_name, **field_tys):
         self.self_ty_name = self_ty_name
         self.field_tys = field_tys 
@@ -213,7 +213,7 @@ def __str__(self):
         return 'object(%s)' % ','.join([self.self_ty_name] + ['%s:%s' % (name, ty) for name, ty in self.field_tys.items()])
 
     def __eq__(self, other):
-        return isinstance(other, ObjectType) and self.self_ty_name == other.self_ty_name and self.field_tys == other.field_tys
+        return isinstance(other, Object) and self.self_ty_name == other.self_ty_name and self.field_tys == other.field_tys
 
     def enforce(self, val):
         # TODO: bind the self type
@@ -227,12 +227,12 @@ def enforce(self, val):
             setattr(newval, field, ty.enforce(getattr(val, field)))
         return newval
 
-class AnyType(Type):
+class Any(Type):
     def __str__(self):
         return '??'
 
     def __eq__(self, other):
-        return isinstance(other, AnyType)
+        return isinstance(other, Any)
 
     def substitute(self, substitution):
         return self
@@ -248,7 +248,7 @@ def fresh(prefix=None):
     global used_vars
     prefix = prefix or 'X'
     used_vars[prefix] = used_vars[prefix] + 1
-    return TypeVariable(prefix + str(used_vars[prefix]))
+    return Variable(prefix + str(used_vars[prefix]))
 
 # TODO: Give these names a definition that they can be unfolded to.
 bool_t = NamedType('bool')
@@ -260,6 +260,6 @@ def fresh(prefix=None):
 str_t = NamedType('str')
 unicode_t = NamedType('unicode')
 
-numeric_t = UnionType([int_t, long_t, complex_t, float_t])
+numeric_t = Union([int_t, long_t, complex_t, float_t])
 
-any_t = AnyType()
+any_t = Any()

typelanguage/types.py renamed to rightarrow/annotations.py

@@ -3,7 +3,7 @@
 import copy
 from collections import namedtuple
 
-from typelanguage import types
+from rightarrow.annotations import *
 
 class Constraint(object):
     "A type constraint of the form `S <: T`"
@@ -81,15 +81,15 @@ def fn_env(arguments):
 
     for arg in arguments.args:
         if isinstance(arg, ast.Name) and isinstance(arg.ctx, ast.Param):
-            new_env[arg.id] = types.fresh() # TODO: ??
+            new_env[arg.id] = fresh() # TODO: ??
         else:
             raise Exception('Arg is not a name in Param context!? %s' % arg) 
 
     if arguments.vararg:
-        new_env[arguments.vararg] = types.fresh() # TODO: sub/superty of list
+        new_env[arguments.vararg] = fresh() # TODO: sub/superty of list
 
     if arguments.kwarg:
-        new_env[arguments.kwarg] = types.fresh() # TODO: sub/superty of dict
+        new_env[arguments.kwarg] = fresh() # TODO: sub/superty of dict
 
     return new_env
 
@@ -99,7 +99,7 @@ def union(left, right):
     elif right is None:
         return left
     else:
-        return types.UnionType([right, left])
+        return Union([right, left])
 
 def constraints_stmt(stmt, env=None):
     """
@@ -122,8 +122,8 @@ def constraints_stmt(stmt, env=None):
             constraints += cs.constraints
             return_type = union(return_type, cs.return_type)
 
-        env[stmt.name] = types.FunctionType(arg_types=[arg_env[arg.id] for arg in stmt.args.args],
-                                            return_type=return_type)
+        env[stmt.name] = Function(arg_types=[arg_env[arg.id] for arg in stmt.args.args],
+                                  return_type=return_type)
 
         return ConstrainedEnv(env=env, constraints=constraints)
 
@@ -136,8 +136,8 @@ def constraints_stmt(stmt, env=None):
             expr_result = constraints_expr(stmt.value, env=env)
             return ConstrainedEnv(env=env, constraints=expr_result.constraints, return_type=expr_result.type)
         else:
-            result = types.fresh()
-            return ConstrainedEnv(env=env, constraints=[Constraint(subtype=result, supertype=types.NamedType('NoneType'))])
+            result = fresh()
+            return ConstrainedEnv(env=env, constraints=[Constraint(subtype=result, supertype=NamedType('NoneType'))])
 
     elif isinstance(stmt, ast.Assign):
         if len(stmt.targets) > 1:
@@ -149,7 +149,7 @@ def constraints_stmt(stmt, env=None):
         # For an assignment, we actually generate a fresh variable so that it can be the union of all things assigned
         # to it. We do not do any typestate funkiness.
         if target not in env:
-            env[target] = types.fresh()
+            env[target] = fresh()
 
         return ConstrainedEnv(env=env, 
                               constraints = expr_result.constraints + [Constraint(subtype=expr_result.type, 
@@ -163,7 +163,7 @@ def constraints_expr(expr, env=None):
 
     if isinstance(expr, ast.Name) and isinstance(expr.ctx, ast.Load):
         if expr.id in ['False', 'True']: # Unlike other literals, these are actually just global identifiers
-            return ConstrainedType(type=types.bool_t)
+            return ConstrainedType(type=bool_t)
         elif expr.id in env:
             return ConstrainedType(type=env[expr.id])
         else:
@@ -172,31 +172,31 @@ def constraints_expr(expr, env=None):
     elif isinstance(expr, ast.Num):
         # The python ast module already chose the type of the num
         if isinstance(expr.n, int):
-            return ConstrainedType(type=types.int_t)
+            return ConstrainedType(type=int_t)
         elif isinstance(expr.n, long):
-            return ConstrainedType(type=types.long_t)
+            return ConstrainedType(type=long_t)
         elif isinstance(expr.n, float):
-            return ConstrainedType(type=types.float_t)
+            return ConstrainedType(type=float_t)
         elif isinstance(expr.n, complex):
-            return ConstrainedType(type=types.complex_t)
+            return ConstrainedType(type=complex_t)
 
     elif isinstance(expr, ast.Str):
-        return ConstrainedType(type=types.str_t)
+        return ConstrainedType(type=str_t)
 
     elif isinstance(expr, ast.List):
-        return ConstrainedType(type=types.ListType(elem_ty=types.fresh()))
+        return ConstrainedType(type=List(elem_ty=fresh()))
 
     elif isinstance(expr, ast.BinOp):
         left = constraints_expr(expr.left, env=env)
         right = constraints_expr(expr.right, env=env)
-        ty = types.fresh()
+        ty = fresh()
 
         if isinstance(expr.op, ast.Mult):
             # TODO: consider whether all types should match (forces coercions to be explicit; a good thing)
             # Note: though strings and bools can be used in mult, forget it!
-            op_constraints = [Constraint(subtype=left.type, supertype=types.numeric_t),
-                              Constraint(subtype=right.type, supertype=types.numeric_t),
-                              Constraint(subtype=ty, supertype=types.numeric_t)]
+            op_constraints = [Constraint(subtype=left.type, supertype=numeric_t),
+                              Constraint(subtype=right.type, supertype=numeric_t),
+                              Constraint(subtype=ty, supertype=numeric_t)]
         else:
             raise NotImplementedError('BinOp') # TODO: just use function application constraint gen
 

typelanguage/constraintgen.py renamed to rightarrow/constraintgen.py

@@ -3,8 +3,8 @@
 import logging
 import copy
 
-from typelanguage import constraintgen
-from typelanguage.types import *
+from rightarrow import constraintgen
+from rightarrow.types import *
 
 logger = logging.getLogger(__name__)
 
@@ -37,7 +37,7 @@ def reconcile(constraint):
                 return {}
             else:
                 return Refutation('Cannot reconcile different atomic types: %s' % constraint)
-        elif isinstance(constraint.supertype, TypeVariable):
+        elif isinstance(constraint.supertype, Variable):
             return {constraint.supertype.name: contraint.subtype}
         else:
             return Refutation('Cannot reconcile atomic type with non-atomic type: %s' % constraint)
@@ -48,12 +48,12 @@ def reconcile(constraint):
                 return {}
             else:
                 return Refutation('Cannot reconcile different atomic types: %s' % constraint)
-        elif isinstance(constraint.subtype, TypeVariable):
+        elif isinstance(constraint.subtype, Variable):
             return {constraint.subtype.name: constraint.supertype}
         else:
             return Refutation('Cannot reconcile non-atomic type with atomic type: %s' % constraint)
 
-    elif isinstance(constraint.supertype, UnionType):
+    elif isinstance(constraint.supertype, Union):
         # Lots of stuff could happen here; unsure if there's research to bring to bear
         if constraint.subtype in constraint.supertype.types:
             return {}

typelanguage/constraintsolve.py renamed to rightarrow/constraintsolve.py

@@ -1,11 +1,11 @@
 
-from typelanguage.parser import TypeParser
+from rightarrow.parser import Parser
 
 def check(ty, val):
     "Checks that `val` adheres to type `ty`"
 
     if isinstance(ty, basestring):
-        ty = TypeParser().parse(ty)
+        ty = Parser().parse(ty)
 
     return ty.enforce(val)
 

typelanguage/enforce.py renamed to rightarrow/enforce.py

@@ -5,7 +5,7 @@
 
 logger = logging.getLogger(__name__)
 
-class TypeLexer(object):
+class Lexer(object):
     '''
     A Lexical analyzer for Python Typelanguage.
     '''
@@ -70,6 +70,6 @@ def t_error(self, t):
 
 if __name__ == '__main__':
     logging.basicConfig()
-    lexer = TypeLexer(debug=True)
+    lexer = Lexer(debug=True)
     for token in lexer.tokenize(sys.stdin.read()):
         print '%-20s%s' % (token.value, token.type)