diff --git a/collects/tests/typed-racket/unit-tests/contract-tests.rkt b/collects/tests/typed-racket/unit-tests/contract-tests.rkt
index 8272dea4..5f38803f 100644
--- a/collects/tests/typed-racket/unit-tests/contract-tests.rkt
+++ b/collects/tests/typed-racket/unit-tests/contract-tests.rkt
@@ -4,9 +4,7 @@
          (for-syntax scheme/base)
          (for-template scheme/base)
          (private type-contract)
-         (rep type-rep filter-rep object-rep)
-         (types utils union convenience)
-         (utils tc-utils)
+         (types abbrev numeric-tower)
          rackunit)
 
 (define-syntax-rule (t e)
diff --git a/collects/tests/typed-racket/unit-tests/infer-tests.rkt b/collects/tests/typed-racket/unit-tests/infer-tests.rkt
index f37b2aee..0b0bfe73 100644
--- a/collects/tests/typed-racket/unit-tests/infer-tests.rkt
+++ b/collects/tests/typed-racket/unit-tests/infer-tests.rkt
@@ -2,7 +2,7 @@
 (require "test-utils.rkt" (for-syntax scheme/base))
 (require (rep type-rep)
          (r:infer infer)
-         (types convenience union utils abbrev)
+         (types numeric-tower union utils abbrev)
          rackunit)
 
 
diff --git a/collects/tests/typed-racket/unit-tests/parse-type-tests.rkt b/collects/tests/typed-racket/unit-tests/parse-type-tests.rkt
index 8ce81f5b..93b52fe9 100644
--- a/collects/tests/typed-racket/unit-tests/parse-type-tests.rkt
+++ b/collects/tests/typed-racket/unit-tests/parse-type-tests.rkt
@@ -3,7 +3,7 @@
          (utils tc-utils)
          (env type-alias-env type-env-structs tvar-env type-name-env init-envs)
          (rep type-rep)
-         (rename-in (types subtype union utils convenience)
+         (rename-in (types subtype union utils abbrev numeric-tower)
                     [Un t:Un] [-> t:->] [->* t:->*])
          (base-env base-types base-types-extra colon)
          (for-template (base-env base-types base-types-extra base-env colon))
diff --git a/collects/tests/typed-racket/unit-tests/remove-intersect-tests.rkt b/collects/tests/typed-racket/unit-tests/remove-intersect-tests.rkt
index f13e8a6d..70376f21 100644
--- a/collects/tests/typed-racket/unit-tests/remove-intersect-tests.rkt
+++ b/collects/tests/typed-racket/unit-tests/remove-intersect-tests.rkt
@@ -2,7 +2,7 @@
 (require "test-utils.rkt" (for-syntax scheme/base)
          (rep type-rep)
          (r:infer infer infer-dummy)
-         (types convenience subtype union remove-intersect)
+         (types abbrev numeric-tower subtype union remove-intersect)
          rackunit)
 
 (define-syntax (over-tests stx)
diff --git a/collects/tests/typed-racket/unit-tests/special-env-typecheck-tests.rkt b/collects/tests/typed-racket/unit-tests/special-env-typecheck-tests.rkt
index c0a0717a..820fc067 100644
--- a/collects/tests/typed-racket/unit-tests/special-env-typecheck-tests.rkt
+++ b/collects/tests/typed-racket/unit-tests/special-env-typecheck-tests.rkt
@@ -4,7 +4,7 @@
          (for-syntax scheme/base)
          (for-template scheme/base)
          (rep type-rep filter-rep object-rep)
-         (for-syntax (rename-in (types utils union convenience abbrev filter-ops)
+         (for-syntax (rename-in (types utils union numeric-tower abbrev filter-ops)
                                 [Un t:Un]
                                 [true-lfilter -true-lfilter]
                                 [true-filter -true-filter]
@@ -12,12 +12,12 @@
          (except-in (utils tc-utils utils) infer)
          typed-racket/infer/infer-dummy typed-racket/infer/infer
          (utils mutated-vars)
-         
+
          rackunit rackunit/text-ui
-         syntax/parse         
+         syntax/parse
          racket/file racket/port
          (for-syntax syntax/kerncase syntax/parse racket/syntax
-                     (types abbrev convenience utils)
+                     (types abbrev numeric-tower utils)
                      (utils mutated-vars)
                      (utils tc-utils) (typecheck typechecker))
          typed-racket/base-env/prims
diff --git a/collects/tests/typed-racket/unit-tests/subtype-tests.rkt b/collects/tests/typed-racket/unit-tests/subtype-tests.rkt
index 7e2887ba..0566a45b 100644
--- a/collects/tests/typed-racket/unit-tests/subtype-tests.rkt
+++ b/collects/tests/typed-racket/unit-tests/subtype-tests.rkt
@@ -1,7 +1,7 @@
 #lang scheme/base
 
 (require "test-utils.rkt"
-         (types subtype convenience union utils abbrev)
+         (types subtype numeric-tower union utils abbrev)
          (rep type-rep)
          (env init-envs type-env-structs)
          (r:infer infer infer-dummy)
@@ -18,9 +18,9 @@
   (syntax-case stx ()
     [(_ cl ...)
      (with-syntax ([(new-cl ...) (map single-test (syntax->list #'(cl ...)))])
-		  (syntax/loc stx
-			      (begin (test-suite "Tests for subtyping"
-						 new-cl ...))))]))
+                  (syntax/loc stx
+                              (begin (test-suite "Tests for subtyping"
+                                                 new-cl ...))))]))
 
 (infer-param infer)
 
@@ -112,9 +112,9 @@
    [(->* (list -Number -Number) -Boolean -Number) (->* (list -Number -Number -Boolean -Boolean) -Number)]
 
    [(-poly (a) (cl-> [() a]
-		     [(-Number) a]))
+                     [(-Number) a]))
     (cl-> [() (-pair -Number (-v b))]
-	  [(-Number) (-pair -Number (-v b))])]
+          [(-Number) (-pair -Number (-v b))])]
 
    [(-values (list -Number)) (-values (list Univ))]
 
diff --git a/collects/tests/typed-racket/unit-tests/typecheck-tests.rkt b/collects/tests/typed-racket/unit-tests/typecheck-tests.rkt
index 4f6dc1b0..d09b28af 100644
--- a/collects/tests/typed-racket/unit-tests/typecheck-tests.rkt
+++ b/collects/tests/typed-racket/unit-tests/typecheck-tests.rkt
@@ -14,7 +14,7 @@
           define lambda λ)
          (typecheck typechecker)
          (rep type-rep filter-rep object-rep)
-         (rename-in (types utils union convenience abbrev filter-ops)
+         (rename-in (types utils union numeric-tower abbrev filter-ops)
                     [Un t:Un]
                     [true-lfilter -true-lfilter]
                     [true-filter -true-filter]
diff --git a/collects/typed-racket/base-env/base-env-indexing-abs.rkt b/collects/typed-racket/base-env/base-env-indexing-abs.rkt
index e9bf0878..5b9d911e 100644
--- a/collects/typed-racket/base-env/base-env-indexing-abs.rkt
+++ b/collects/typed-racket/base-env/base-env-indexing-abs.rkt
@@ -4,7 +4,7 @@
  "../utils/utils.rkt"
  (for-template racket/base racket/list racket/unsafe/ops racket/flonum)
  (utils tc-utils) 
- (rename-in (types union convenience) [-Number N] [-Boolean B] [-Symbol Sym]))
+ (rename-in (types union abbrev numeric-tower) [-Number N] [-Boolean B] [-Symbol Sym]))
 
 (provide indexing)
 
diff --git a/collects/typed-racket/base-env/base-env-indexing.rkt b/collects/typed-racket/base-env/base-env-indexing.rkt
index cfb9a658..cfcdb8e5 100644
--- a/collects/typed-racket/base-env/base-env-indexing.rkt
+++ b/collects/typed-racket/base-env/base-env-indexing.rkt
@@ -2,7 +2,7 @@
 
 (require
  (rename-in "../utils/utils.rkt" [infer r:infer])
- (types convenience) (env init-envs) (r:infer infer-dummy infer)
+ (types numeric-tower) (env init-envs) (r:infer infer-dummy infer)
  "base-env-indexing-abs.rkt")
 
 (define e (parameterize ([infer-param infer]) (indexing -Integer)))
diff --git a/collects/typed-racket/base-env/base-env-numeric.rkt b/collects/typed-racket/base-env/base-env-numeric.rkt
index 55b45852..b7856987 100644
--- a/collects/typed-racket/base-env/base-env-numeric.rkt
+++ b/collects/typed-racket/base-env/base-env-numeric.rkt
@@ -5,7 +5,7 @@
    racket/list racket/math racket/flonum racket/unsafe/ops
    (for-template racket/flonum racket/fixnum racket/math racket/unsafe/ops racket/base
                  (only-in "../types/numeric-predicates.rkt" index?))
-   (only-in (types convenience) [-Number N] [-Boolean B] [-Symbol Sym] [-Real R] [-PosInt -Pos]))
+   (only-in (types abbrev numeric-tower) [-Number N] [-Boolean B] [-Symbol Sym] [-Real R] [-PosInt -Pos]))
 
   ;; TODO having definitions only at the top is really inconvenient.
 
diff --git a/collects/typed-racket/base-env/base-env.rkt b/collects/typed-racket/base-env/base-env.rkt
index fc987f35..6951e078 100644
--- a/collects/typed-racket/base-env/base-env.rkt
+++ b/collects/typed-racket/base-env/base-env.rkt
@@ -25,8 +25,11 @@
   (only-in racket/match/runtime match:error matchable? match-equality-test))
  racket/file
  (only-in racket/private/pre-base new-apply-proc)
- (only-in (types convenience) [-Number N] [-Boolean B] [-Symbol Sym])
+ (only-in (types abbrev) [-Boolean B] [-Symbol Sym])
+ (only-in (types numeric-tower) [-Number N])
  (only-in (rep type-rep)
+          make-Name
+          make-ValuesDots
           make-MPairTop
           make-BoxTop make-ChannelTop make-VectorTop
           make-ThreadCellTop
@@ -38,7 +41,7 @@
 ;Section 9.2
 
 [raise (cl->* (Univ . -> . (Un))
-	      (Univ Univ . -> . (Un)))]
+              (Univ Univ . -> . (Un)))]
 
 [error
  (cl->* (-> Sym (Un))
@@ -247,8 +250,8 @@
 
 
 [assert (-poly (a b) (cl->*
-		      (Univ (make-pred-ty (list a) Univ b) . -> . b)
-		      (-> (Un a (-val #f)) a)))]
+                      (Univ (make-pred-ty (list a) Univ b) . -> . b)
+                      (-> (Un a (-val #f)) a)))]
 [defined? (->* (list Univ) -Boolean : (-FS (-not-filter -Undefined 0 null) (-filter -Undefined 0 null)))]
 
 
@@ -389,12 +392,12 @@
 [list (-poly (a) (->* '() a (-lst a)))]
 [procedure? (make-pred-ty top-func)]
 [map (-polydots (c a b)
-		(cl->*
-		 (-> (-> a c) (-pair a (-lst a)) (-pair c (-lst c)))
-		((list
-		  ((list a) (b b) . ->... . c)
-		  (-lst a))
-		 ((-lst b) b) . ->... .(-lst c))))]
+                (cl->*
+                 (-> (-> a c) (-pair a (-lst a)) (-pair c (-lst c)))
+                ((list
+                  ((list a) (b b) . ->... . c)
+                  (-lst a))
+                 ((-lst b) b) . ->... .(-lst c))))]
 [for-each (-polydots (c a b) ((list ((list a) (b b) . ->... . Univ) (-lst a))
                               ((-lst b) b) . ->... . -Void))]
 #;[fold-left (-polydots (c a b) ((list ((list c a) (b b) . ->... . c) c (-lst a))
@@ -1457,8 +1460,8 @@
 
 [tcp-abandon-port (-Port . -> . -Void)]
 [tcp-addresses (cl->*
-		(-Port [(-val #f)] . ->opt . (-values (list -String -String)))
-		(-Port (-val #t) . -> . (-values (list -String -Index -String -Index))))]
+                (-Port [(-val #f)] . ->opt . (-values (list -String -String)))
+                (-Port (-val #t) . -> . (-values (list -String -Index -String -Index))))]
 
 [tcp-port? (asym-pred Univ B (-FS (-filter (Un -Input-Port -Output-Port) 0) -top))]
 
@@ -1750,8 +1753,8 @@
 
 ;; probably the most useful cases
 [curry (-poly (a b c)
-	      (cl->* ((a b . -> . c) a . -> . (b . -> . c))
-		     ((a b . -> . c) . -> . (a . -> . (b . -> . c)))))]
+              (cl->* ((a b . -> . c) a . -> . (b . -> . c))
+                     ((a b . -> . c) . -> . (a . -> . (b . -> . c)))))]
 ;; mutable pairs
 [mcons (-poly (a b) (-> a b (-mpair a b)))]
 [mcar (-poly (a b)
diff --git a/collects/typed-racket/base-env/base-special-env.rkt b/collects/typed-racket/base-env/base-special-env.rkt
index 51f0a310..baab79d4 100644
--- a/collects/typed-racket/base-env/base-special-env.rkt
+++ b/collects/typed-racket/base-env/base-special-env.rkt
@@ -11,8 +11,7 @@
  (utils tc-utils)
  (env init-envs)
  (except-in (rep filter-rep object-rep type-rep) make-arr)
- (types convenience union)
- (only-in (types convenience) [make-arr* make-arr])
+ (rename-in (types abbrev numeric-tower union) [make-arr* make-arr])
  (for-syntax racket/base syntax/parse (only-in racket/syntax syntax-local-eval)))
 
 (define-syntax (define-initial-env stx)
diff --git a/collects/typed-racket/base-env/base-structs.rkt b/collects/typed-racket/base-env/base-structs.rkt
index 96139755..b5f0a209 100644
--- a/collects/typed-racket/base-env/base-structs.rkt
+++ b/collects/typed-racket/base-env/base-structs.rkt
@@ -5,8 +5,7 @@
  (utils tc-utils)
  (env init-envs)
  (except-in (rep filter-rep object-rep type-rep) make-arr)
- (types convenience union)
- (only-in (types convenience) [make-arr* make-arr])
+ (rename-in (types abbrev numeric-tower union) [make-arr* make-arr])
  (typecheck tc-structs)
  ;;For tests
  (prefix-in k: '#%kernel))
diff --git a/collects/typed-racket/base-env/base-types.rkt b/collects/typed-racket/base-env/base-types.rkt
index fec210c6..186b1c62 100644
--- a/collects/typed-racket/base-env/base-types.rkt
+++ b/collects/typed-racket/base-env/base-types.rkt
@@ -6,7 +6,7 @@
 ;; I don't understand this at all. :(
 ;; -- STH, 6/26/12
 (require (for-syntax "../env/global-env.rkt"))
-(require "../types/convenience.rkt" "../rep/type-rep.rkt")
+(require "../types/abbrev.rkt" "../types/numeric-tower.rkt" "../rep/type-rep.rkt")
 
 [Complex -Number]
 [Number -Number]
diff --git a/collects/typed-racket/base-env/env-lang.rkt b/collects/typed-racket/base-env/env-lang.rkt
index 93425065..26f68da7 100644
--- a/collects/typed-racket/base-env/env-lang.rkt
+++ b/collects/typed-racket/base-env/env-lang.rkt
@@ -7,9 +7,8 @@
          (env init-envs)
          (r:infer infer)
          (only-in (r:infer infer-dummy) infer-param)
-         (except-in (rep object-rep filter-rep type-rep) make-arr)
-         (types convenience union filter-ops)
-         (only-in (types convenience) [make-arr* make-arr]))
+         (types abbrev numeric-tower union filter-ops)
+         (rep object-rep filter-rep type-rep))
 
 (define-syntax (-#%module-begin stx)
   (define-syntax-class clause
@@ -17,15 +16,15 @@
     (pattern [id:identifier ty]))
   (syntax-parse stx #:literals (require begin)
     [(mb (~optional (~and extra (~or (begin . _) (require . args))))
-	 ~! :clause ...)
+         ~! :clause ...)
      #'(#%plain-module-begin
-	(begin
-	  extra
-	  (define e
-	    (parameterize ([infer-param infer])
-	      (make-env [id (λ () ty)] ...)))
-	  (define (init)
-	   (initialize-type-env e))
+        (begin
+          extra
+          (define e
+            (parameterize ([infer-param infer])
+              (make-env [id (λ () ty)] ...)))
+          (define (init)
+           (initialize-type-env e))
           (provide init)))]
     [(mb . rest)
      #'(mb (begin) . rest)]))
@@ -34,4 +33,4 @@
          require
          (except-out (all-from-out racket/base) #%module-begin)
          types rep private utils
-         (types-out convenience union filter-ops))
+         (types-out abbrev numeric-tower union filter-ops))
diff --git a/collects/typed-racket/core.rkt b/collects/typed-racket/core.rkt
index 3212e4a8..d2a8ae40 100644
--- a/collects/typed-racket/core.rkt
+++ b/collects/typed-racket/core.rkt
@@ -6,7 +6,7 @@
          (private with-types type-contract parse-type)
          (except-in syntax/parse id)
          racket/match racket/syntax unstable/match racket/list
-         (types utils convenience generalize)
+         (types utils abbrev generalize)
          (typecheck provide-handling tc-toplevel tc-app-helper)
          (rep type-rep)
          (env env-req)
diff --git a/collects/typed-racket/env/init-envs.rkt b/collects/typed-racket/env/init-envs.rkt
index 9c1125ee..bc628182 100644
--- a/collects/typed-racket/env/init-envs.rkt
+++ b/collects/typed-racket/env/init-envs.rkt
@@ -7,9 +7,9 @@
          "type-alias-env.rkt"
          (rep type-rep object-rep filter-rep rep-utils)
          (for-template (rep type-rep object-rep filter-rep)
-                       (types union convenience)
+                       (types union abbrev)
                        racket/shared racket/base)
-         (types union convenience)
+         (types abbrev)
          racket/syntax
          mzlib/pconvert racket/match)
 
diff --git a/collects/typed-racket/env/lexical-env.rkt b/collects/typed-racket/env/lexical-env.rkt
index 391c9406..9b9509df 100644
--- a/collects/typed-racket/env/lexical-env.rkt
+++ b/collects/typed-racket/env/lexical-env.rkt
@@ -7,17 +7,17 @@
 ;; but split here for performance
 
 (require "../utils/utils.rkt"
-	 "type-env-structs.rkt"
+         "type-env-structs.rkt"
          "global-env.rkt"
          "../types/kw-types.rkt"
-	 syntax/id-table
+         syntax/id-table
          racket/keyword-transform racket/list
          (for-syntax syntax/parse syntax/parse/experimental/contract racket/base)
          (only-in racket/contract ->* -> or/c any/c listof cons/c)
          (utils tc-utils mutated-vars)
          (only-in (rep type-rep) Type/c)
          (typecheck tc-metafunctions)
-	 (except-in (types utils convenience) -> ->*))
+         (except-in (types utils abbrev) -> ->*))
 
 (provide lexical-env with-lexical-env with-lexical-env/extend
          with-lexical-env/extend/props update-type/lexical)
diff --git a/collects/typed-racket/infer/constraints.rkt b/collects/typed-racket/infer/constraints.rkt
index a811159b..5636f86f 100644
--- a/collects/typed-racket/infer/constraints.rkt
+++ b/collects/typed-racket/infer/constraints.rkt
@@ -1,7 +1,7 @@
 #lang racket/unit
 
 (require "../utils/utils.rkt"
-	 (types convenience utils union subtype)
+	 (types abbrev utils union subtype)
 	 (rep type-rep)
 	 (utils tc-utils)
 	 unstable/sequence unstable/hash
diff --git a/collects/typed-racket/infer/infer-unit.rkt b/collects/typed-racket/infer/infer-unit.rkt
index 1f29b896..a05f16c6 100644
--- a/collects/typed-racket/infer/infer-unit.rkt
+++ b/collects/typed-racket/infer/infer-unit.rkt
@@ -4,8 +4,8 @@
          (except-in
           (combine-in
            (utils tc-utils)
-           (rep free-variance type-rep filter-rep rep-utils)
-           (types utils convenience union subtype remove-intersect resolve
+           (rep free-variance type-rep filter-rep object-rep rep-utils)
+           (types utils abbrev numeric-tower union subtype remove-intersect resolve
                   substitute generalize)
            (env type-name-env index-env tvar-env))
           make-env -> ->* one-of/c)
diff --git a/collects/typed-racket/infer/promote-demote.rkt b/collects/typed-racket/infer/promote-demote.rkt
index 60c79b43..5e9f33e8 100644
--- a/collects/typed-racket/infer/promote-demote.rkt
+++ b/collects/typed-racket/infer/promote-demote.rkt
@@ -2,7 +2,7 @@
 
 (require "../utils/utils.rkt")
 (require (rep type-rep rep-utils)
-	 (types convenience union utils)
+         (types abbrev union utils)
          "signatures.rkt"
          racket/list racket/match)
 
diff --git a/collects/typed-racket/optimizer/list.rkt b/collects/typed-racket/optimizer/list.rkt
index 04cbe827..e6965a58 100644
--- a/collects/typed-racket/optimizer/list.rkt
+++ b/collects/typed-racket/optimizer/list.rkt
@@ -4,7 +4,7 @@
          "../utils/utils.rkt"
          (utils tc-utils)
          (rep type-rep)
-         (types convenience utils type-table)
+         (types abbrev utils type-table)
          (optimizer utils logging)
          (for-template racket/base racket/unsafe/ops))
 
diff --git a/collects/typed-racket/optimizer/sequence.rkt b/collects/typed-racket/optimizer/sequence.rkt
index 841990a4..08241833 100644
--- a/collects/typed-racket/optimizer/sequence.rkt
+++ b/collects/typed-racket/optimizer/sequence.rkt
@@ -5,7 +5,7 @@
          (for-template racket/base racket/unsafe/ops)
          "../utils/utils.rkt" "../utils/tc-utils.rkt"
          (rep type-rep)
-         (types convenience type-table utils)
+         (types abbrev type-table utils)
          (optimizer utils logging string
                     float)) ; for int-expr
 
diff --git a/collects/typed-racket/optimizer/string.rkt b/collects/typed-racket/optimizer/string.rkt
index 0a6d3de2..04f2d259 100644
--- a/collects/typed-racket/optimizer/string.rkt
+++ b/collects/typed-racket/optimizer/string.rkt
@@ -4,7 +4,7 @@
          (for-template racket/base racket/unsafe/ops)
          "../utils/utils.rkt"
          (utils tc-utils)
-         (types convenience)
+         (types abbrev)
          (optimizer utils logging))
 
 (provide string-opt-expr string-expr bytes-expr)
diff --git a/collects/typed-racket/private/parse-type.rkt b/collects/typed-racket/private/parse-type.rkt
index 3b46d9a3..7afd00da 100644
--- a/collects/typed-racket/private/parse-type.rkt
+++ b/collects/typed-racket/private/parse-type.rkt
@@ -1,8 +1,8 @@
 #lang racket/base
 
 (require "../utils/utils.rkt"
-	 (except-in (rep type-rep) make-arr)
-         (rename-in (types convenience union utils printer filter-ops resolve)
+         (except-in (rep type-rep object-rep filter-rep) make-arr)
+         (rename-in (types abbrev union utils printer filter-ops resolve)
                     [make-arr* make-arr])
          (utils tc-utils stxclass-util)
          syntax/stx (prefix-in c: racket/contract)
@@ -40,10 +40,10 @@
      (parse-type #'ty)]
     [(x ...)
      #:fail-unless (= 1 (length
-			 (for/list ([i (syntax->list #'(x ...))]
-				    #:when (and (identifier? i)
-						(free-identifier=? i #'t:->)))
-				   i)))
+                         (for/list ([i (syntax->list #'(x ...))]
+                                    #:when (and (identifier? i)
+                                                (free-identifier=? i #'t:->)))
+                                   i)))
      #f
      (parse-type s)]))
 
diff --git a/collects/typed-racket/private/type-annotation.rkt b/collects/typed-racket/private/type-annotation.rkt
index 338990cd..182e349d 100644
--- a/collects/typed-racket/private/type-annotation.rkt
+++ b/collects/typed-racket/private/type-annotation.rkt
@@ -4,7 +4,7 @@
 	 (rep type-rep)
 	 (utils tc-utils)
 	 (env global-env)
-         (except-in (types subtype union convenience resolve utils generalize) -> ->* one-of/c)
+         (except-in (types subtype union resolve utils generalize))
          (private parse-type)
          (contract-req)
          racket/match)
diff --git a/collects/typed-racket/private/type-contract.rkt b/collects/typed-racket/private/type-contract.rkt
index 3e2463a2..ea22a5ea 100644
--- a/collects/typed-racket/private/type-contract.rkt
+++ b/collects/typed-racket/private/type-contract.rkt
@@ -10,14 +10,14 @@
  (utils tc-utils require-contract)
  (env type-name-env)
  (types resolve utils)
- (prefix-in t: (types convenience))
+ (prefix-in t: (types abbrev numeric-tower))
  (private parse-type)
  racket/match unstable/match syntax/struct syntax/stx racket/syntax racket/list
  (only-in racket/contract -> ->* case-> cons/c flat-rec-contract provide/contract any/c)
  (for-template racket/base racket/contract racket/set (utils any-wrap)
                (prefix-in t: (types numeric-predicates))
                (only-in unstable/contract sequence/c)
-	       (only-in racket/class object% is-a?/c subclass?/c object-contract class/c init object/c class?)))
+               (only-in racket/class object% is-a?/c subclass?/c object-contract class/c init object/c class?)))
 
 (define (define/fixup-contract? stx)
   (or (syntax-property stx 'typechecker:contract-def)
@@ -95,14 +95,14 @@
                             [(list r) r]
                             [_ #`(values #,@rngs*)])]
                     [rst* rst])
-		 ;; Garr, I hate case->!
-		 (if (and (pair? (syntax-e #'(opt-dom* ...))) case->)
-		     (exit (fail))
-		     (if (or rst (pair? (syntax-e #'(opt-dom* ...))))
-			 (if case->
-			     #'(dom* ... #:rest (listof rst*) . -> . rng*)
-			     #'((dom* ...) (opt-dom* ...) #:rest (listof rst*) . ->* . rng*))
-			 #'(dom* ... . -> . rng*)))))
+                 ;; Garr, I hate case->!
+                 (if (and (pair? (syntax-e #'(opt-dom* ...))) case->)
+                     (exit (fail))
+                     (if (or rst (pair? (syntax-e #'(opt-dom* ...))))
+                         (if case->
+                             #'(dom* ... #:rest (listof rst*) . -> . rng*)
+                             #'((dom* ...) (opt-dom* ...) #:rest (listof rst*) . ->* . rng*))
+                         #'(dom* ... . -> . rng*)))))
              (unless (no-duplicates (for/list ([t arrs])
                                       (match t
                                         [(arr: dom _ _ _ _) (length dom)]
@@ -185,7 +185,7 @@
                ([cnts (append (map t->c vars) (map t->c notvars))])
              #'(or/c . cnts)))]
         [(and t (Function: _)) (t->c/fun t)]
-	[(Set: t) #`(set/c #,(t->c t))]
+        [(Set: t) #`(set/c #,(t->c t))]
         [(Sequence: ts) #`(sequence/c #,@(map t->c ts))]
         [(Vector: t)
          (when flat? (exit (fail)))
@@ -202,7 +202,7 @@
          #`(flat-named-contract (quote #,(syntax-e p?)) #,(cert p?))]
         [(F: v) (cond [(assoc v (vars)) => second]
                       [else (int-err "unknown var: ~a" v)])]
-	[(Poly: vs b)
+        [(Poly: vs b)
          (if from-typed?
              ;; in positive position, no checking needed for the variables
              (parameterize ([vars (append (for/list ([v vs]) (list v #'any/c)) (vars))])
@@ -286,7 +286,7 @@
         [(Syntax: t) #`(syntax/c #,(t->c t))]
         [(Value: v) #`(flat-named-contract #,(format "~a" v) (lambda (x) (equal? x '#,v)))]
         [(Param: in out) #`(parameter/c #,(t->c out))]
-	[(Hashtable: k v)
+        [(Hashtable: k v)
          (when flat? (exit (fail)))                  
          #`(hash/c #,(t->c k) #,(t->c v) #:immutable 'dont-care)]
         [else
diff --git a/collects/typed-racket/private/with-types.rkt b/collects/typed-racket/private/with-types.rkt
index 4621ddf8..9cdd3c25 100644
--- a/collects/typed-racket/private/with-types.rkt
+++ b/collects/typed-racket/private/with-types.rkt
@@ -9,20 +9,18 @@
          "../tc-setup.rkt"
          syntax/parse racket/match
          unstable/sequence  "../base-env/base-types-extra.rkt"
-         (except-in (path-up "env/type-name-env.rkt"
-                             "env/type-alias-env.rkt"
-                             "infer/infer-dummy.rkt"
-                             "private/parse-type.rkt"
-                             "private/type-contract.rkt"
-                             "typecheck/typechecker.rkt"
-                             "env/type-env-structs.rkt"
-                             "env/global-env.rkt"
-                             "env/tvar-env.rkt"
-                             "infer/infer.rkt"
-                             "utils/tc-utils.rkt"
-                             "types/utils.rkt"
-                             "types/convenience.rkt")
-                    ->)
+         (path-up "env/type-name-env.rkt"
+                  "env/type-alias-env.rkt"
+                  "infer/infer-dummy.rkt"
+                  "private/parse-type.rkt"
+                  "private/type-contract.rkt"
+                  "typecheck/typechecker.rkt"
+                  "env/type-env-structs.rkt"
+                  "env/global-env.rkt"
+                  "env/tvar-env.rkt"
+                  "infer/infer.rkt"
+                  "utils/tc-utils.rkt"
+                  "types/utils.rkt")
          (except-in (path-up "utils/utils.rkt") infer))
 
 (provide wt-core)
diff --git a/collects/typed-racket/tc-setup.rkt b/collects/typed-racket/tc-setup.rkt
index 5cb006fb..a466f880 100644
--- a/collects/typed-racket/tc-setup.rkt
+++ b/collects/typed-racket/tc-setup.rkt
@@ -4,7 +4,7 @@
          (except-in syntax/parse id)
          racket/pretty racket/promise
          (private type-contract)
-         (types utils convenience)
+         (types utils)
          (typecheck typechecker provide-handling tc-toplevel)
          (env tvar-env type-name-env type-alias-env env-req)
          (r:infer infer)
diff --git a/collects/typed-racket/typecheck/check-below.rkt b/collects/typed-racket/typecheck/check-below.rkt
index c11c9c4b..473d0733 100644
--- a/collects/typed-racket/typecheck/check-below.rkt
+++ b/collects/typed-racket/typecheck/check-below.rkt
@@ -2,9 +2,9 @@
 
 (require (rename-in "../utils/utils.rkt" [private private-in])
          racket/match (prefix-in - racket/contract)
-         (types utils convenience union subtype remove-intersect type-table filter-ops)
+         (types utils union subtype remove-intersect type-table filter-ops)
          (private-in parse-type type-annotation)
-         (rep type-rep)
+         (rep type-rep object-rep filter-rep)
          (only-in (infer infer) restrict)
          (except-in (utils tc-utils stxclass-util))
          (env lexical-env type-env-structs tvar-env index-env)
diff --git a/collects/typed-racket/typecheck/check-subforms-unit.rkt b/collects/typed-racket/typecheck/check-subforms-unit.rkt
index 6929a3af..088ea6e9 100644
--- a/collects/typed-racket/typecheck/check-subforms-unit.rkt
+++ b/collects/typed-racket/typecheck/check-subforms-unit.rkt
@@ -1,14 +1,14 @@
 #lang racket/unit
 
 (require "../utils/utils.rkt"
-	 syntax/kerncase
-	 syntax/parse
+         syntax/kerncase
+         syntax/parse
          racket/match
          "signatures.rkt" "tc-metafunctions.rkt"
          "tc-funapp.rkt" "tc-subst.rkt"
-         (types utils convenience union subtype)
-	 (utils tc-utils)
-	 (rep type-rep))
+         (types utils abbrev union subtype)
+         (utils tc-utils)
+         (rep type-rep))
 
 (import tc-if^ tc-lambda^ tc-app^ tc-let^ tc-expr^)
 (export check-subforms^)
@@ -69,8 +69,8 @@
          (set! body-stx form)
          (set! body-ty (tc-expr form))]
         [(a . b)
-	 (loop #'a)
-	 (loop #'b)]
+         (loop #'a)
+         (loop #'b)]
         [_ (void)])))
   (apply combine-types body-ty handler-tys))
 
diff --git a/collects/typed-racket/typecheck/tc-app-helper.rkt b/collects/typed-racket/typecheck/tc-app-helper.rkt
index bc4f0227..3f4454ae 100644
--- a/collects/typed-racket/typecheck/tc-app-helper.rkt
+++ b/collects/typed-racket/typecheck/tc-app-helper.rkt
@@ -6,7 +6,7 @@
          "check-below.rkt" "tc-subst.rkt"
          (utils tc-utils)
          (rep type-rep object-rep)
-         (types utils union convenience subtype))
+         (types utils union abbrev subtype))
 
 (provide (all-defined-out))
 
@@ -40,7 +40,7 @@
                                  ta))])
          (define-values (t-r f-r o-r)
            (for/lists (t-r f-r o-r)
-             ([r (in-list results)])             
+             ([r (in-list results)])
              (open-Result r o-a t-a)))
          (ret t-r f-r o-r)))]
     [((arr: _ _ _ drest '()) _)
diff --git a/collects/typed-racket/typecheck/tc-app.rkt b/collects/typed-racket/typecheck/tc-app.rkt
index 79b5e9aa..11bb950a 100644
--- a/collects/typed-racket/typecheck/tc-app.rkt
+++ b/collects/typed-racket/typecheck/tc-app.rkt
@@ -15,7 +15,7 @@
          ;; end fixme
          (for-syntax syntax/parse racket/base (utils tc-utils))
          (private type-annotation)
-         (types utils union subtype resolve convenience
+         (types utils union subtype resolve abbrev
                 type-table substitute generalize)
          (utils tc-utils)
          (except-in (env type-env-structs tvar-env index-env) extend)
diff --git a/collects/typed-racket/typecheck/tc-app/tc-app-hetero.rkt b/collects/typed-racket/typecheck/tc-app/tc-app-hetero.rkt
index d940ab76..435f501d 100644
--- a/collects/typed-racket/typecheck/tc-app/tc-app-hetero.rkt
+++ b/collects/typed-racket/typecheck/tc-app/tc-app-hetero.rkt
@@ -15,7 +15,7 @@
          ;; end fixme
          (for-syntax syntax/parse scheme/base (utils tc-utils))
          (private type-annotation)
-         (types utils abbrev union subtype resolve convenience type-table substitute generalize)
+         (types utils abbrev numeric-tower union subtype resolve type-table substitute generalize)
          (utils tc-utils)
          (only-in srfi/1 alist-delete)
          (except-in (env type-env-structs tvar-env index-env) extend)
diff --git a/collects/typed-racket/typecheck/tc-apply.rkt b/collects/typed-racket/typecheck/tc-apply.rkt
index 8966a556..7859aedf 100644
--- a/collects/typed-racket/typecheck/tc-apply.rkt
+++ b/collects/typed-racket/typecheck/tc-apply.rkt
@@ -5,7 +5,7 @@
          racket/match racket/list
          (for-syntax (utils tc-utils))
          (private type-annotation)
-         (types utils union subtype resolve convenience type-table substitute)
+         (types utils union subtype resolve abbrev type-table substitute)
          (utils tc-utils)
          (only-in srfi/1 alist-delete)
          (except-in (env type-env-structs tvar-env index-env) extend)
diff --git a/collects/typed-racket/typecheck/tc-envops.rkt b/collects/typed-racket/typecheck/tc-envops.rkt
index fe64ee0a..795b9317 100644
--- a/collects/typed-racket/typecheck/tc-envops.rkt
+++ b/collects/typed-racket/typecheck/tc-envops.rkt
@@ -1,12 +1,12 @@
 #lang racket/base
 
 (require (rename-in "../utils/utils.rkt" [infer infer-in]))
-(require (rename-in (types subtype convenience remove-intersect union)
+(require (rename-in (types subtype abbrev remove-intersect union)
                     [-> -->]
                     [->* -->*]
                     [one-of/c -one-of/c])
          (infer-in infer)
-         (rep type-rep object-rep)
+         (rep type-rep filter-rep object-rep)
          (utils tc-utils)
          (types resolve)
          (only-in (env type-env-structs lexical-env)
diff --git a/collects/typed-racket/typecheck/tc-expr-unit.rkt b/collects/typed-racket/typecheck/tc-expr-unit.rkt
index 93244d34..735814ca 100644
--- a/collects/typed-racket/typecheck/tc-expr-unit.rkt
+++ b/collects/typed-racket/typecheck/tc-expr-unit.rkt
@@ -5,10 +5,10 @@
          racket/match (prefix-in - racket/contract)
          "signatures.rkt" "tc-envops.rkt" "tc-metafunctions.rkt" "tc-subst.rkt"
          "check-below.rkt" "tc-funapp.rkt" "tc-app-helper.rkt" "../types/kw-types.rkt"
-         (types utils convenience union subtype remove-intersect 
+         (types utils abbrev numeric-tower union subtype remove-intersect 
                 type-table filter-ops generalize)
          (private-in parse-type type-annotation)
-         (rep type-rep)
+         (rep type-rep filter-rep object-rep)
          (only-in (infer infer) restrict)
          (except-in (utils tc-utils stxclass-util))
          (env lexical-env type-env-structs tvar-env index-env)
@@ -35,7 +35,7 @@
       [i:exp expected]
       [i:boolean (-val (syntax-e #'i))]
       [i:identifier (-val (syntax-e #'i))]
-      
+
       ;; Numbers
       [0 -Zero]
       [1 -One]
diff --git a/collects/typed-racket/typecheck/tc-funapp.rkt b/collects/typed-racket/typecheck/tc-funapp.rkt
index ed306a43..05ad935d 100644
--- a/collects/typed-racket/typecheck/tc-funapp.rkt
+++ b/collects/typed-racket/typecheck/tc-funapp.rkt
@@ -13,8 +13,7 @@
          ;; end fixme
          (for-syntax syntax/parse racket/base (utils tc-utils))
          (private type-annotation)
-         (types utils union subtype resolve convenience type-table
-                substitute)
+         (types utils union subtype resolve abbrev type-table substitute)
          (utils tc-utils)
          (except-in (env type-env-structs tvar-env index-env) extend)
          (rep type-rep filter-rep rep-utils)
diff --git a/collects/typed-racket/typecheck/tc-if.rkt b/collects/typed-racket/typecheck/tc-if.rkt
index cb107ed5..4e385cb7 100644
--- a/collects/typed-racket/typecheck/tc-if.rkt
+++ b/collects/typed-racket/typecheck/tc-if.rkt
@@ -2,7 +2,7 @@
 (require (rename-in "../utils/utils.rkt" [infer r:infer])
          "signatures.rkt" "check-below.rkt"
          (rep type-rep filter-rep object-rep)
-         (types convenience subtype union utils filter-ops)
+         (types abbrev subtype union utils filter-ops)
          (env lexical-env type-env-structs)
          (r:infer infer)
          (utils tc-utils)
diff --git a/collects/typed-racket/typecheck/tc-lambda-unit.rkt b/collects/typed-racket/typecheck/tc-lambda-unit.rkt
index 2199780e..f9ff0443 100644
--- a/collects/typed-racket/typecheck/tc-lambda-unit.rkt
+++ b/collects/typed-racket/typecheck/tc-lambda-unit.rkt
@@ -9,7 +9,7 @@
          racket/syntax unstable/struct syntax/stx
          (rename-in racket/contract [-> -->] [->* -->*] [one-of/c -one-of/c])
          (except-in (rep type-rep) make-arr)
-         (rename-in (types convenience utils union)
+         (rename-in (types abbrev utils union)
                     [make-arr* make-arr])
          (private type-annotation)
          (env type-env-structs lexical-env tvar-env index-env)
diff --git a/collects/typed-racket/typecheck/tc-let-unit.rkt b/collects/typed-racket/typecheck/tc-let-unit.rkt
index 5d218045..1ce3b795 100644
--- a/collects/typed-racket/typecheck/tc-let-unit.rkt
+++ b/collects/typed-racket/typecheck/tc-let-unit.rkt
@@ -3,10 +3,10 @@
 (require (rename-in "../utils/utils.rkt" [infer r:infer])
          "signatures.rkt" "tc-metafunctions.rkt" "tc-subst.rkt"
          "check-below.rkt"
-         (types utils convenience)
+         (types utils abbrev)
          (private type-annotation parse-type)
-	 (env lexical-env type-alias-env global-env type-env-structs)
-         (rep type-rep)
+         (env lexical-env type-alias-env global-env type-env-structs)
+         (rep type-rep filter-rep object-rep)
          syntax/free-vars
          racket/match (prefix-in c: racket/contract)
          (except-in racket/contract -> ->* one-of/c)
diff --git a/collects/typed-racket/typecheck/tc-metafunctions.rkt b/collects/typed-racket/typecheck/tc-metafunctions.rkt
index 56f43203..6b8f869b 100644
--- a/collects/typed-racket/typecheck/tc-metafunctions.rkt
+++ b/collects/typed-racket/typecheck/tc-metafunctions.rkt
@@ -1,11 +1,11 @@
 #lang racket/base
 
 (require "../utils/utils.rkt"
-         (rename-in (types subtype convenience remove-intersect union utils filter-ops)
+         (rename-in (types subtype abbrev remove-intersect union utils filter-ops)
                     [-> -->]
                     [->* -->*]
                     [one-of/c -one-of/c])
-         (rep type-rep filter-rep rep-utils) racket/list
+         (rep type-rep filter-rep object-rep rep-utils) racket/list
          racket/contract racket/match unstable/match
          (for-syntax racket/base))
 
diff --git a/collects/typed-racket/typecheck/tc-structs.rkt b/collects/typed-racket/typecheck/tc-structs.rkt
index dcb599ce..201a770d 100644
--- a/collects/typed-racket/typecheck/tc-structs.rkt
+++ b/collects/typed-racket/typecheck/tc-structs.rkt
@@ -1,9 +1,9 @@
 #lang racket/base
 
 (require "../utils/utils.rkt"
-         (except-in (rep type-rep free-variance) Dotted)
+         (rep type-rep object-rep free-variance)
          (private parse-type)
-         (types convenience utils union resolve substitute type-table)
+         (types abbrev utils union resolve substitute type-table)
          (env global-env type-env-structs type-name-env tvar-env)
          (utils tc-utils)
          "def-binding.rkt"
diff --git a/collects/typed-racket/typecheck/tc-subst.rkt b/collects/typed-racket/typecheck/tc-subst.rkt
index 902bd74c..d5aa368b 100644
--- a/collects/typed-racket/typecheck/tc-subst.rkt
+++ b/collects/typed-racket/typecheck/tc-subst.rkt
@@ -1,11 +1,11 @@
 #lang racket/base
 
 (require "../utils/utils.rkt")
-(require (rename-in (types subtype convenience remove-intersect union utils filter-ops)
+(require (rename-in (types subtype abbrev remove-intersect union utils filter-ops)
                     [-> -->]
                     [->* -->*]
                     [one-of/c -one-of/c])
-         (rep type-rep filter-rep rep-utils) racket/list
+         (rep type-rep object-rep filter-rep rep-utils) racket/list
          racket/contract racket/match unstable/match
          (for-syntax racket/base)
          "tc-metafunctions.rkt")
@@ -42,9 +42,9 @@
   (define (st t) (subst-type t k o polarity))
   (define/cond-contract (sf fs) (FilterSet? . -> . FilterSet?) (subst-filter-set fs k o polarity))
   (type-case (#:Type st
-	      #:Filter sf
-	      #:Object (lambda (f) (subst-object f k o polarity)))
-	      t
+              #:Filter sf
+              #:Object (lambda (f) (subst-object f k o polarity)))
+              t
               [#:arr dom rng rest drest kws
                      ;; here we have to increment the count for the domain, where the new bindings are in scope
                      (let* ([arg-count (+ (length dom) (if rest 1 0) (if drest 1 0) (length kws))]
@@ -64,12 +64,12 @@
     [(Empty:) t]
     [(Path: p i)
      (if (name-ref=? i k)
-	 (match o
-	   [(Empty:) (make-Empty)]
-	   ;; the result is not from an annotation, so it isn't a NoObject
-	   [(NoObject:) (make-Empty)]
-	   [(Path: p* i*) (make-Path (append p p*) i*)])
-	 t)]))
+         (match o
+           [(Empty:) (make-Empty)]
+           ;; the result is not from an annotation, so it isn't a NoObject
+           [(NoObject:) (make-Empty)]
+           [(Path: p* i*) (make-Path (append p p*) i*)])
+         t)]))
 
 ;; this is the substitution metafunction
 (define/cond-contract (subst-filter f k o polarity)
@@ -79,17 +79,17 @@
     (match o
       [(or (Empty:) (NoObject:))
        (cond [(name-ref=? i k)
-	      (if polarity -top -bot)]
-	     [(index-free-in? k t) (if polarity -top -bot)]
+              (if polarity -top -bot)]
+             [(index-free-in? k t) (if polarity -top -bot)]
              [else f])]
       [(Path: p* i*)
        (cond [(name-ref=? i k)
-	      (maker
-	       (subst-type t k o polarity)
-	       i*
+              (maker
+               (subst-type t k o polarity)
+               i*
                (append p p*))]
-	     [(index-free-in? k t) (if polarity -top -bot)]
-	     [else f])]))
+             [(index-free-in? k t) (if polarity -top -bot)]
+             [else f])]))
   (match f
     [(ImpFilter: ant consq)
      (make-ImpFilter (subst-filter ant k o (not polarity)) (ap consq))]
@@ -107,28 +107,28 @@
    return
    (define (for-object o)
      (object-case (#:Type for-type)
-		  o
-		  [#:Path p i
-			  (if (name-ref=? i k)
-			      (return #t)
-			      o)]))
+                  o
+                  [#:Path p i
+                          (if (name-ref=? i k)
+                              (return #t)
+                              o)]))
    (define (for-filter o)
      (filter-case (#:Type for-type
-		   #:Filter for-filter)
-		  o
-		  [#:NotTypeFilter t p i
-				   (if (name-ref=? i k)
-				       (return #t)
-				       o)]
-		  [#:TypeFilter t p i
-				(if (name-ref=? i k)
-				    (return #t)
-				    o)]))
+                   #:Filter for-filter)
+                  o
+                  [#:NotTypeFilter t p i
+                                   (if (name-ref=? i k)
+                                       (return #t)
+                                       o)]
+                  [#:TypeFilter t p i
+                                (if (name-ref=? i k)
+                                    (return #t)
+                                    o)]))
    (define (for-type t)
      (type-case (#:Type for-type
-		 #:Filter for-filter
-		 #:Object for-object)
-		t
+                 #:Filter for-filter
+                 #:Object for-object)
+                t
                 [#:arr dom rng rest drest kws
                        ;; here we have to increment the count for the domain, where the new bindings are in scope
                        (let* ([arg-count (+ (length dom) (if rest 1 0) (if drest 1 0) (length kws))]
diff --git a/collects/typed-racket/typecheck/tc-toplevel.rkt b/collects/typed-racket/typecheck/tc-toplevel.rkt
index f7009ce0..bee996f0 100644
--- a/collects/typed-racket/typecheck/tc-toplevel.rkt
+++ b/collects/typed-racket/typecheck/tc-toplevel.rkt
@@ -11,10 +11,10 @@
          ;; to appease syntax-parse
          "internal-forms.rkt"
          (rep type-rep)
-         (types utils convenience type-table)
+         (types utils abbrev type-table)
          (private parse-type type-annotation type-contract)
          (env global-env init-envs type-name-env type-alias-env lexical-env env-req)
-	 syntax/id-table
+         syntax/id-table
          (utils tc-utils mutated-vars)
          "provide-handling.rkt"
          "def-binding.rkt"
@@ -50,9 +50,9 @@
   (parameterize ([current-orig-stx form])
     (syntax-parse form
       #:literals (values define-type-alias-internal define-typed-struct-internal define-type-internal
-			 define-typed-struct/exec-internal :-internal assert-predicate-internal
-			 require/typed-internal declare-refinement-internal
-			 define-values quote-syntax #%plain-app begin define-syntaxes)
+                         define-typed-struct/exec-internal :-internal assert-predicate-internal
+                         require/typed-internal declare-refinement-internal
+                         define-values quote-syntax #%plain-app begin define-syntaxes)
       ;#:literal-sets (kernel-literals)
 
       ;; forms that are handled in other ways
@@ -60,7 +60,7 @@
        #:when (or (syntax-property form 'typechecker:ignore)
                   (syntax-property form 'typechecker:ignore-some))
        (list)]
-      
+
       [((~literal module) n:id spec ((~literal #%plain-module-begin) body ...))
        (list)]
        ;; module* is not expanded, so it doesn't have a `#%plain-module-begin`
@@ -153,10 +153,10 @@
            [else
             (match (get-type/infer vars #'expr tc-expr tc-expr/check)
               [(tc-results: ts)
-	       (for/list ([i (in-list vars)] [t (in-list ts)])
-		 (register-type i t)
-		 (free-id-table-set! unann-defs i #t)
-		 (make-def-binding i t))])]))]
+               (for/list ([i (in-list vars)] [t (in-list ts)])
+                 (register-type i t)
+                 (free-id-table-set! unann-defs i #t)
+                 (make-def-binding i t))])]))]
 
       ;; to handle the top-level, we have to recur into begins
       [(begin . rest)
@@ -205,8 +205,8 @@
        (void)]
       [(define-values () (begin (quote-syntax (define-typed-struct-internal . rest)) (#%plain-app values)))
        (void)]
-      
-      ;; submodules take care of themselves:      
+
+      ;; submodules take care of themselves:
       [(module n spec (#%plain-module-begin body ...))
        (void)]
       ;; module* is not expanded, so it doesn't have a `#%plain-module-begin`
@@ -343,12 +343,12 @@
      (values
       #`(begin
           (begin-for-syntax
-            (module* #%type-decl #f    
+            (module* #%type-decl #f
               (require typed-racket/types/numeric-tower typed-racket/env/type-name-env
                        typed-racket/env/global-env typed-racket/env/type-alias-env
                        typed-racket/types/type-table)
-              #,(env-init-code syntax-provide? provide-tbl def-tbl)              
-              #,(talias-env-init-code)              
+              #,(env-init-code syntax-provide? provide-tbl def-tbl)
+              #,(talias-env-init-code)
               #,(tname-env-init-code)
               #,(make-struct-table-code)
               #,@(for/list ([a (in-list aliases)])
diff --git a/collects/typed-racket/types/abbrev.rkt b/collects/typed-racket/types/abbrev.rkt
index 1c9754b9..e1a04d78 100644
--- a/collects/typed-racket/types/abbrev.rkt
+++ b/collects/typed-racket/types/abbrev.rkt
@@ -25,6 +25,9 @@
 
 
 (provide (except-out (all-defined-out) make-Base)
+         (all-from-out "base-abbrev.rkt")
+         ;; TODO change the uses of this export to Un
+         (rename-out (Un *Un))
          (rename-out [make-Listof -lst]
                      [make-MListof -mlst]))
 
diff --git a/collects/typed-racket/types/filter-ops.rkt b/collects/typed-racket/types/filter-ops.rkt
index 249339f3..29e3fe0a 100644
--- a/collects/typed-racket/types/filter-ops.rkt
+++ b/collects/typed-racket/types/filter-ops.rkt
@@ -4,7 +4,7 @@
          (rep type-rep filter-rep object-rep rep-utils)
          (utils tc-utils) (only-in (infer infer) restrict)
          (only-in racket/contract [-> -->] listof)
-         (types union subtype utils remove-intersect convenience)
+         (types union subtype utils remove-intersect abbrev)
          racket/list racket/match
          (for-syntax syntax/parse racket/base)
          syntax/id-table racket/dict
diff --git a/collects/typed-racket/types/generalize.rkt b/collects/typed-racket/types/generalize.rkt
index c03ba9f0..9956769f 100644
--- a/collects/typed-racket/types/generalize.rkt
+++ b/collects/typed-racket/types/generalize.rkt
@@ -3,7 +3,8 @@
 (require "../utils/utils.rkt"
          (rep type-rep filter-rep object-rep rep-utils)
          (utils tc-utils)
-         "convenience.rkt" "subtype.rkt" "substitute.rkt" "union.rkt"
+         "abbrev.rkt" "subtype.rkt" "substitute.rkt" "union.rkt"
+         "numeric-tower.rkt"
          racket/match
          (for-syntax syntax/parse racket/base)
          syntax/id-table racket/dict)
diff --git a/collects/typed-racket/types/kw-types.rkt b/collects/typed-racket/types/kw-types.rkt
index fe4140af..a1e0a307 100644
--- a/collects/typed-racket/types/kw-types.rkt
+++ b/collects/typed-racket/types/kw-types.rkt
@@ -1,6 +1,6 @@
 #lang racket/base
 
-(require "convenience.rkt" "../rep/type-rep.rkt"
+(require "abbrev.rkt" "../rep/type-rep.rkt"
          "union.rkt" "../utils/tc-utils.rkt"
          racket/list racket/dict racket/match)
 
diff --git a/collects/typed-racket/types/printer.rkt b/collects/typed-racket/types/printer.rkt
index 3243878f..0fea0d5a 100644
--- a/collects/typed-racket/types/printer.rkt
+++ b/collects/typed-racket/types/printer.rkt
@@ -3,10 +3,12 @@
 (require racket/require racket/match unstable/sequence racket/string racket/promise
          (prefix-in s: srfi/1)
          (path-up "rep/type-rep.rkt" "rep/filter-rep.rkt" "rep/object-rep.rkt"
-                  "rep/rep-utils.rkt" "types/convenience.rkt" "types/subtype.rkt"
+                  "rep/rep-utils.rkt" "types/abbrev.rkt" "types/subtype.rkt"
                   "utils/utils.rkt"
                   "utils/tc-utils.rkt"))
 
+;;TODO try to remove requirement on abbrev once promise is fixed
+
 ;; do we attempt to find instantiations of polymorphic types to print?
 ;; FIXME - currently broken
 (define print-poly-types? #t)
diff --git a/collects/typed-racket/types/remove-intersect.rkt b/collects/typed-racket/types/remove-intersect.rkt
index 9e7a0f71..4065e9e3 100644
--- a/collects/typed-racket/types/remove-intersect.rkt
+++ b/collects/typed-racket/types/remove-intersect.rkt
@@ -2,7 +2,7 @@
 
 (require "../utils/utils.rkt"
          (rep type-rep rep-utils)
-         (types union subtype resolve convenience utils)
+         (types abbrev union subtype resolve utils)
          racket/match)
 
 (provide (rename-out [*remove remove]) overlap)
diff --git a/collects/typed-racket/types/subtype.rkt b/collects/typed-racket/types/subtype.rkt
index 5f51a5b7..5b95ed2e 100644
--- a/collects/typed-racket/types/subtype.rkt
+++ b/collects/typed-racket/types/subtype.rkt
@@ -7,9 +7,13 @@
          (only-in (infer infer-dummy) unify)
          racket/match unstable/match
          racket/function
+         unstable/lazy-require
          (prefix-in c: racket/contract)
          (for-syntax racket/base syntax/parse))
 
+(lazy-require
+  ("union.rkt" (Un)))
+
 ;; exn representing failure of subtyping
 ;; s,t both types
 
@@ -193,7 +197,7 @@
        [(not (apply = (length dom1) (map length dom))) #f]
        [(not (for/and ([rng2 (in-list rng)]) (type-equal? rng1 rng2)))
         #f]
-       [else (make-arr (apply map *Un (cons dom1 dom)) rng1 #f #f '())])]
+       [else (make-arr (apply map Un (cons dom1 dom)) rng1 #f #f '())])]
     [_ #f]))
 
 (define-match-expander NameStruct:
diff --git a/collects/typed/rackunit/type-env-ext.rkt b/collects/typed/rackunit/type-env-ext.rkt
index e65f6a89..c77616b6 100644
--- a/collects/typed/rackunit/type-env-ext.rkt
+++ b/collects/typed/rackunit/type-env-ext.rkt
@@ -7,8 +7,7 @@
           (utils tc-utils)
           (env init-envs)
           (except-in (rep filter-rep object-rep type-rep) make-arr)
-          (types convenience union)
-          (only-in (types convenience) [make-arr* make-arr])))
+          (rename-in (types abbrev union) [make-arr* make-arr])))
 
 (define-for-syntax unit-env
   (make-env