diff --git a/typed-racket-lib/typed-racket/private/parse-classes.rkt b/typed-racket-lib/typed-racket/private/parse-classes.rkt
index f4dbe796a..70bb1032d 100644
--- a/typed-racket-lib/typed-racket/private/parse-classes.rkt
+++ b/typed-racket-lib/typed-racket/private/parse-classes.rkt
@@ -1,8 +1,8 @@
 #lang racket/base
 
-(require syntax/parse/pre
-         "../utils/literal-syntax-class.rkt"
-         (for-label "../base-env/base-types-extra.rkt"))
+(require (for-label "../base-env/base-types-extra.rkt")
+         syntax/parse/pre
+         "../utils/literal-syntax-class.rkt")
 (provide star ddd ddd/bound omit-parens)
 
 (define-literal-syntax-class #:for-label ->)
diff --git a/typed-racket-lib/typed-racket/private/parse-type.rkt b/typed-racket-lib/typed-racket/private/parse-type.rkt
index 81497c8d1..9a91c0db5 100644
--- a/typed-racket-lib/typed-racket/private/parse-type.rkt
+++ b/typed-racket-lib/typed-racket/private/parse-type.rkt
@@ -183,8 +183,8 @@
 ;; (Syntax -> Type) -> Syntax Any -> Syntax
 ;; See `parse-type/id`. This is a curried generalization.
 (define ((parse/id p) loc datum)
-  (let* ([stx* (datum->syntax loc datum loc loc)])
-    (p stx*)))
+  (define stx* (datum->syntax loc datum loc loc))
+  (p stx*))
 
 (define (parse-literal-alls stx)
   (syntax-parse stx
@@ -1507,10 +1507,9 @@
   ;; Merge all the non-duplicate entries from the parent types
   (define (merge-clause parent-clause clause)
     (for/fold ([clause clause])
-              ([(k v) (in-dict parent-clause)])
-      (if (dict-has-key? clause k)
-          clause
-          (dict-set clause k v))))
+              ([(k v) (in-dict parent-clause)]
+               #:unless (dict-has-key? clause k))
+      (dict-set clause k v)))
 
   (define (match-parent-type parent-type)
     (define resolved (resolve parent-type))
@@ -1655,12 +1654,12 @@
             ;; of init arguments.
             (define parent-inits (get-parent-inits parent/init-type))
 
-            (define class-type
-              (make-Class row-var
-                          (append given-inits parent-inits)
-                          fields methods augments given-init-rest))
-
-            class-type]
+            (make-Class row-var
+                        (append given-inits parent-inits)
+                        fields
+                        methods
+                        augments
+                        given-init-rest)]
            [else
             ;; Conservatively assume that if there *are* #:implements
             ;; clauses, then the current type alias will be recursive
diff --git a/typed-racket-lib/typed-racket/private/shallow-rewrite.rkt b/typed-racket-lib/typed-racket/private/shallow-rewrite.rkt
index 91dad491f..a0d2280c0 100644
--- a/typed-racket-lib/typed-racket/private/shallow-rewrite.rkt
+++ b/typed-racket-lib/typed-racket/private/shallow-rewrite.rkt
@@ -222,36 +222,48 @@
                           [check-formal*
                             (let protect-loop ([args #'formals]
                                                [dom* dom*])
-                              (if (or (identifier? args)
-                                      (null? args)
-                                      (and (syntax? args) (null? (syntax-e args))))
-                                '()
-                                (let*-values ([(fst rst)
-                                               (cond
-                                                 [(pair? args)
-                                                  (values (car args) (cdr args))]
-                                                 [(syntax? args)
-                                                  (let ((e (syntax-e args)))
-                                                    (values (car e) (cdr e)))]
-                                                 [else
-                                                   (raise-syntax-error 'shallow-rewrite-top "#%plain-lambda formals" #'formals args)])]
-                                              [(check*)
-                                               (let ((dom+
-                                                     (for/fold ((acc '()))
-                                                               ((dom (in-list dom*)))
-                                                       (if (pair? dom) (cons (cdr dom) acc) acc))))
-                                                 (protect-loop rst dom+))]
-                                              [(fst-ty)
-                                               (let ((ann-ty (and (type-annotation fst #:infer #f) (get-type fst #:infer #t #:default Univ))))
-                                                 (if (and ann-ty (not (Error? ann-ty)))
-                                                   ann-ty
-                                                   (apply Un (for/list ((dom (in-list dom*)) #:when (pair? dom)) (car dom)))))]
-                                              [(ex* fst+)
-                                               (if skip-dom?
-                                                 (values '() #f)
-                                                 (protect-domain fst-ty fst (build-source-location-list fst) ctc-cache))])
-                                  (void (register-extra-defs! ex*))
-                                  (if fst+ (cons fst+ check*) check*))))])
+                              (cond
+                                [(or (identifier? args)
+                                     (null? args)
+                                     (and (syntax? args) (null? (syntax-e args))))
+                                 '()]
+                                [else
+                                 (define-values (fst rst)
+                                   (cond
+                                     [(pair? args) (values (car args) (cdr args))]
+                                     [(syntax? args)
+                                      (let ([e (syntax-e args)]) (values (car e) (cdr e)))]
+                                     [else
+                                      (raise-syntax-error 'shallow-rewrite-top
+                                                          "#%plain-lambda formals"
+                                                          #'formals
+                                                          args)]))
+                                 (define check*
+                                   (let ([dom+ (for/fold ([acc '()]) ([dom (in-list dom*)])
+                                                 (if (pair? dom)
+                                                     (cons (cdr dom) acc)
+                                                     acc))])
+                                     (protect-loop rst dom+)))
+                                 (define fst-ty
+                                   (let ([ann-ty (and (type-annotation fst #:infer #f)
+                                                      (get-type fst #:infer #t #:default Univ))])
+                                     (if (and ann-ty (not (Error? ann-ty)))
+                                         ann-ty
+                                         (apply Un
+                                                (for/list ([dom (in-list dom*)]
+                                                           #:when (pair? dom))
+                                                  (car dom))))))
+                                 (define-values (ex* fst+)
+                                   (if skip-dom?
+                                       (values '() #f)
+                                       (protect-domain fst-ty
+                                                       fst
+                                                       (build-source-location-list fst)
+                                                       ctc-cache)))
+                                 (void (register-extra-defs! ex*))
+                                 (if fst+
+                                     (cons fst+ check*)
+                                     check*)]))])
                      (if (null? check-formal*)
                        body+
                        (cons
@@ -272,11 +284,11 @@
                             ;; no type
                             (quasisyntax/loc formals [#,formals . #,body])]
                            [else
+                             (define len (formals-length formals))
                              (define matching-dom*
-                               (let ([len (formals-length formals)])
-                                 (for/list ((dom (in-list all-dom*))
-                                            #:when (= len (length dom)))
-                                   dom)))
+                               (for/list ([dom (in-list all-dom*)]
+                                          #:when (= len (length dom)))
+                                 dom))
                              (quasisyntax/loc stx
                                [#,formals .
                                 #,(let* ([body+
@@ -284,38 +296,50 @@
                                          [check-formal*
                                            (let protect-loop ([args formals]
                                                               [dom* matching-dom*])
-                                             (if (or (identifier? args)
-                                                     (null? args)
-                                                     (and (syntax? args) (null? (syntax-e args))))
-                                               '()
-                                               (let*-values ([(fst rst)
-                                                              (cond
-                                                                [(pair? args)
-                                                                 (values (car args) (cdr args))]
-                                                                [(syntax? args)
-                                                                 (let ((e (syntax-e args)))
-                                                                   (values (car e) (cdr e)))]
-                                                                [else
-                                                                  (raise-syntax-error 'shallow-rewrite-top "#%plain-lambda formals" formals args)])]
-                                                             [(check*)
-                                                              (let ((dom+
-                                                                    (for/fold ((acc '()))
-                                                                              ((dom (in-list dom*)))
-                                                                      (if (pair? dom) (cons (cdr dom) acc) acc))))
-                                                                (protect-loop rst dom+))]
-                                                             [(fst-ty)
-                                                              (if (type-annotation fst #:infer #f)
-                                                                (get-type fst #:infer #t #:default Univ)
-                                                                (apply Un
-                                                                       (for/fold ((acc '()))
-                                                                                 ((dom (in-list dom*)))
-                                                                         (if (pair? dom) (cons (car dom) acc) acc))))]
-                                                             [(ex* fst+)
-                                                              (if skip-dom?
-                                                                (values '() #f)
-                                                                (protect-domain fst-ty fst (build-source-location-list fst) ctc-cache))])
-                                                 (void (register-extra-defs! ex*))
-                                                 (if fst+ (cons fst+ check*) check*))))])
+                                             (cond
+                                               [(or (identifier? args)
+                                                    (null? args)
+                                                    (and (syntax? args) (null? (syntax-e args))))
+                                                '()]
+                                               [else
+                                                (define-values (fst rst)
+                                                  (cond
+                                                    [(pair? args) (values (car args) (cdr args))]
+                                                    [(syntax? args)
+                                                     (let ([e (syntax-e args)])
+                                                       (values (car e) (cdr e)))]
+                                                    [else
+                                                     (raise-syntax-error 'shallow-rewrite-top
+                                                                         "#%plain-lambda formals"
+                                                                         formals
+                                                                         args)]))
+                                                (define check*
+                                                  (let ([dom+ (for/fold ([acc '()])
+                                                                        ([dom (in-list dom*)])
+                                                                (if (pair? dom)
+                                                                    (cons (cdr dom) acc)
+                                                                    acc))])
+                                                    (protect-loop rst dom+)))
+                                                (define fst-ty
+                                                  (if (type-annotation fst #:infer #f)
+                                                      (get-type fst #:infer #t #:default Univ)
+                                                      (apply Un
+                                                             (for/fold ([acc '()])
+                                                                       ([dom (in-list dom*)])
+                                                               (if (pair? dom)
+                                                                   (cons (car dom) acc)
+                                                                   acc)))))
+                                                (define-values (ex* fst+)
+                                                  (if skip-dom?
+                                                      (values '() #f)
+                                                      (protect-domain fst-ty
+                                                                      fst
+                                                                      (build-source-location-list fst)
+                                                                      ctc-cache)))
+                                                (void (register-extra-defs! ex*))
+                                                (if fst+
+                                                    (cons fst+ check*)
+                                                    check*)]))])
                                    (if (null? check-formal*)
                                      body+
                                      (cons
@@ -415,9 +439,9 @@
   stx)
 
 (define (maybe-add-typeof-expr new-stx old-stx)
-  (let ((old-type (maybe-type-of old-stx)))
-    (when old-type
-      (add-typeof-expr new-stx old-type))))
+  (define old-type (maybe-type-of old-stx))
+  (when old-type
+    (add-typeof-expr new-stx old-type)))
 
 (define (maybe-add-test-position new-stx old-stx)
   (maybe-add-test-true new-stx old-stx)
@@ -425,9 +449,9 @@
   (void))
 
 (define (maybe-add-scoped-tvar new-stx old-stx)
-  (let ([old-layer (lookup-scoped-tvar-layer old-stx)])
-    (when old-layer
-      (add-scoped-tvars new-stx old-layer))))
+  (define old-layer (lookup-scoped-tvar-layer old-stx))
+  (when old-layer
+    (add-scoped-tvars new-stx old-layer)))
 
 (define (maybe-add-test-true new-stx old-stx)
   (when (test-position-takes-true-branch old-stx)
@@ -449,20 +473,15 @@
 
 (define (formals-fold init f stx)
   (let loop ((v stx))
-    (if (or (identifier? v)
-            (null? v)
-            (and (syntax? v) (null? (syntax-e v))))
-      init
-      (let*-values (((fst rst)
-                     (cond
-                       [(pair? v)
-                        (values (car v) (cdr v))]
-                       [(syntax? v)
-                        (let ((e (syntax-e v)))
-                          (values (car e) (cdr e)))]
-                       [else
-                         (raise-syntax-error 'formals-fold "lambda formals" stx)])))
-        (f (loop rst) fst)))))
+    (cond
+      [(or (identifier? v) (null? v) (and (syntax? v) (null? (syntax-e v)))) init]
+      [else
+       (define-values (fst rst)
+         (cond
+           [(pair? v) (values (car v) (cdr v))]
+           [(syntax? v) (let ([e (syntax-e v)]) (values (car e) (cdr e)))]
+           [else (raise-syntax-error 'formals-fold "lambda formals" stx)]))
+       (f (loop rst) fst)])))
 
 ;; is-application? : Syntax -> Boolean
 ;; Returns #true if `stx` is a function application (an app that may need dynamic checking)
@@ -629,12 +648,10 @@
     (λ (mpi)
       (hash-ref! cache mpi
         (λ () ;; Typed Racket always installs a `#%type-decl` submodule
-          (let* ([mpi+ (module-path-index-join '(submod "." #%type-decl) mpi)])
-            (parameterize ([current-namespace (make-base-namespace)])
-              (with-handlers ([exn:fail:contract? (lambda (exn) #f)])
-                (and mpi+
-                     (dynamic-require mpi+ #f)
-                     #t)))))))))
+          (define mpi+ (module-path-index-join '(submod "." #%type-decl) mpi))
+          (parameterize ([current-namespace (make-base-namespace)])
+            (with-handlers ([exn:fail:contract? (lambda (exn) #f)])
+              (and mpi+ (dynamic-require mpi+ #f) #t))))))))
 
 (define (protect-domain dom-type dom-stx ctx ctc-cache)
   (define-values [extra-def* ctc-stx]
@@ -714,10 +731,7 @@
     [(eq? t Univ)
      (values '() #f)]
     [else
-     (define (fail #:reason r)
-       (raise-user-error 'type->flat-contract "failed to convert type ~a to flat contract because ~a" t r))
-     (match-define (list defs ctc)
-       (type->contract t fail #:typed-side 'both #:cache ctc-cache))
+     (match-define (list defs ctc) (type->contract t fail #:typed-side 'both #:cache ctc-cache))
      (match t
       [(Refine: _ _)
        ;; do not lift defs; they may use a local var
diff --git a/typed-racket-lib/typed-racket/private/syntax-properties.rkt b/typed-racket-lib/typed-racket/private/syntax-properties.rkt
index ff753e9a6..7ffd48f85 100644
--- a/typed-racket-lib/typed-racket/private/syntax-properties.rkt
+++ b/typed-racket-lib/typed-racket/private/syntax-properties.rkt
@@ -1,7 +1,8 @@
 #lang racket/base
-(require
-  syntax/parse/pre
-  (for-syntax racket/base syntax/parse/pre racket/syntax))
+(require (for-syntax racket/base
+                     racket/syntax
+                     syntax/parse/pre)
+         syntax/parse/pre)
 
 (define-syntax define-matcher
   (syntax-parser
diff --git a/typed-racket-lib/typed-racket/private/type-annotation.rkt b/typed-racket-lib/typed-racket/private/type-annotation.rkt
index c714b5805..a826de157 100644
--- a/typed-racket-lib/typed-racket/private/type-annotation.rkt
+++ b/typed-racket-lib/typed-racket/private/type-annotation.rkt
@@ -89,46 +89,49 @@
    (listof tc-result?))
   (match stxs
     [(list stx ...)
-     (let ([anns (for/list ([s (in-list stxs)])
-                   (cond
-                     ;; if the lhs identifier is the rest parameter, its type is
-                     ;; (Listof ty), where ty is the annotated type
-                     [(rst-arg-property s)
-                      (make-Listof (type-annotation s #:infer #t))]
-                     [else (type-annotation s #:infer #t)]))])
-       (if (for/and ([a (in-list anns)]) a)
-           (match (tc-expr/check expr (ret anns))
-             [(tc-results: tcrs _) tcrs])
-           (match (tc-expr expr)
-             [(tc-any-results: _)
-              (tc-error/expr
-               #:return (map (λ _ (-tc-result -Bottom)) stxs)
-               "Expression should produce ~a values, but produces an unknown number of values"
-               (length stxs))]
-             [(tc-result1: (== -Bottom))
-              (for/list ([_ (in-range (length stxs))])
-                (-tc-result -Bottom))]
-             [(tc-results: tcrs _)
-              (cond
-                [(not (= (length stxs) (length tcrs)))
-                 (tc-error/expr #:return (map (λ _ (-tc-result -Bottom)) stxs)
-                                "Expression should produce ~a values, but produces ~a values of types ~a"
-                                (length stxs)
-                                (length tcrs)
-                                (stringify (map tc-result-t tcrs)))]
-                [else
-                 (for/list ([stx (in-list stxs)]
-                            [tcr (in-list tcrs)]
-                            [a   (in-list anns)])
-                   (match tcr
-                     [(tc-result: ty ps o)
-                      (cond [a (check-type stx ty a)
-                               (-tc-result a ps o)]
-                            ;; mutated variables get generalized, so that we don't
-                            ;; infer too small a type
-                            [(is-var-mutated? stx)
-                             (-tc-result (generalize ty) ps o)]
-                            [else (-tc-result ty ps o)])]))])])))]))
+     (define anns
+       (for/list ([s (in-list stxs)])
+         (cond
+           ;; if the lhs identifier is the rest parameter, its type is
+           ;; (Listof ty), where ty is the annotated type
+           [(rst-arg-property s) (make-Listof (type-annotation s #:infer #t))]
+           [else (type-annotation s #:infer #t)])))
+     (if (for/and ([a (in-list anns)])
+           a)
+         (match (tc-expr/check expr (ret anns))
+           [(tc-results: tcrs _) tcrs])
+         (match (tc-expr expr)
+           [(tc-any-results: _)
+            (tc-error/expr
+             #:return (map (λ _ (-tc-result -Bottom)) stxs)
+             "Expression should produce ~a values, but produces an unknown number of values"
+             (length stxs))]
+           [(tc-result1: (== -Bottom))
+            (for/list ([_ (in-range (length stxs))])
+              (-tc-result -Bottom))]
+           [(tc-results: tcrs _)
+            (cond
+              [(not (= (length stxs) (length tcrs)))
+               (tc-error/expr
+                #:return (map (λ _ (-tc-result -Bottom)) stxs)
+                "Expression should produce ~a values, but produces ~a values of types ~a"
+                (length stxs)
+                (length tcrs)
+                (stringify (map tc-result-t tcrs)))]
+              [else
+               (for/list ([stx (in-list stxs)]
+                          [tcr (in-list tcrs)]
+                          [a (in-list anns)])
+                 (match tcr
+                   [(tc-result: ty ps o)
+                    (cond
+                      [a
+                       (check-type stx ty a)
+                       (-tc-result a ps o)]
+                      ;; mutated variables get generalized, so that we don't
+                      ;; infer too small a type
+                      [(is-var-mutated? stx) (-tc-result (generalize ty) ps o)]
+                      [else (-tc-result ty ps o)])]))])]))]))
 
 ;; check that e-type is compatible with ty in context of stx
 ;; otherwise, error
diff --git a/typed-racket-lib/typed-racket/private/type-contract.rkt b/typed-racket-lib/typed-racket/private/type-contract.rkt
index 988018b7b..5cfcf2e09 100644
--- a/typed-racket-lib/typed-racket/private/type-contract.rkt
+++ b/typed-racket-lib/typed-racket/private/type-contract.rkt
@@ -239,10 +239,11 @@
 (define (change-contract-fixups forms [ctc-cache (make-hash)])
   (with-new-name-tables
    (for/list ((e (in-list forms)))
-     (if (not (has-contract-def-property? e))
-         e
-         (begin (set-box! include-extra-requires? #t)
-                (generate-contract-def e ctc-cache))))))
+     (cond
+       [(not (has-contract-def-property? e)) e]
+       [else
+        (set-box! include-extra-requires? #t)
+        (generate-contract-def e ctc-cache)]))))
 
 ;; TODO: These are probably all in a specific place, which could avoid
 ;;       the big traversal
@@ -386,8 +387,8 @@
         (loop t (flip-side typed-side) recursive-values))
       (define (t->sc/both t #:recursive-values (recursive-values recursive-values))
         (loop t 'both recursive-values))
-      (define (t->sc/fun t #:maybe-existential [opt-exi #f]) (t->sc/function t fail typed-side recursive-values loop #f #:maybe-existential opt-exi))
-      (define (t->sc/meth t) (t->sc/method t fail typed-side recursive-values loop))
+      (define (t->sc/meth t)
+        (t->sc/method t fail typed-side recursive-values loop))
 
       (define (struct->recursive-sc name-base key flds sc-ctor)
         (define key* (generate-temporary name-base))
@@ -554,13 +555,11 @@
         ;; Avoid putting (-> any T) contracts on struct predicates (where Boolean <: T)
         ;; Optimization: if the value is typed, we can assume it's not wrapped
         ;;  in a type-unsafe chaperone/impersonator and use the unsafe contract
-        (let* ([unsafe-spp/sc (flat/sc #'struct-predicate-procedure?)]
-               [safe-spp/sc (flat/sc #'struct-predicate-procedure?/c)]
-               [optimized/sc (if (from-typed? typed-side)
-                                 unsafe-spp/sc
-                                 safe-spp/sc)]
-               [spt-pred-procedure?/sc (flat/sc #'struct-type-property-predicate-procedure?)])
-          (or/sc optimized/sc spt-pred-procedure?/sc (t->sc/fun t)))]
+        (define unsafe-spp/sc (flat/sc #'struct-predicate-procedure?))
+        (define safe-spp/sc (flat/sc #'struct-predicate-procedure?/c))
+        (define optimized/sc (if (from-typed? typed-side) unsafe-spp/sc safe-spp/sc))
+        (define spt-pred-procedure?/sc (flat/sc #'struct-type-property-predicate-procedure?))
+        (or/sc optimized/sc spt-pred-procedure?/sc (t->sc/fun t))]
        [(? Fun? t) (t->sc/fun t)]
        [(? DepFun? t) (t->sc/fun t)]
        [(Set: t) (set/sc (t->sc t))]
@@ -835,10 +834,10 @@
            [else (is-flat-type/sc (obj->sc o) sc)])]
         [(NotTypeProp: o t)
          (define sc (t->sc t bound-all-vars))
-         (cond
-           [(not (equal? flat-sym (get-max-contract-kind sc)))
-            (raise-user-error 'type->static-contract/shallow "proposition contract generation not supported for non-flat types")]
-           [else (not-flat-type/sc (obj->sc o) sc)])]
+         (unless (equal? flat-sym (get-max-contract-kind sc))
+           (raise-user-error 'type->static-contract/shallow
+                             "proposition contract generation not supported for non-flat types"))
+         (not-flat-type/sc (obj->sc o) sc)]
         [(LeqProp: (app obj->sc lhs) (app obj->sc rhs))
          (leq/sc lhs rhs)]
         [(AndProp: ps)
@@ -1136,28 +1135,25 @@
 (define (t->sc/function f fail typed-side recursive-values loop method? #:maybe-existential [opt-exi #f])
   (define (t->sc t #:recursive-values (recursive-values recursive-values))
     (loop t typed-side recursive-values))
-  (define (t->sc/neg t #:recursive-values (recursive-values recursive-values))
-    (loop t (flip-side typed-side) recursive-values))
-
   (define (arr-params->exist/sc exi dom rst kw rng prop+type)
     (define (occur? t)
-      (if (or (not t) (empty? t)) #f
+      (if (or (not t) (empty? t))
+          #f
           (set-member? (free-vars-names (free-vars* t)) exi)))
-
+  
     (match* (rng prop+type)
       [((Fun: (list (Arrow: (list-rest (F: n1) a ... _) rst_i kw_i _))) (F: n1))
-       #:when (and (not (ormap occur? (list rst kw rst_i kw_i)))
-                   (eq? n1 exi))
+       #:when (and (not (ormap occur? (list rst kw rst_i kw_i))) (eq? n1 exi))
        (void)]
-      [(_ _) (fail #:reason
-                   "contract generation only supports Some Type in this form: (Some (X) (-> ty1 ... (-> X ty ... ty2) : X)) or (-> ty1 ... (Some (X) (-> X ty ... ty2) : X))")])
-
+      [(_ _)
+       (fail
+        #:reason
+        "contract generation only supports Some Type in this form: (Some (X) (-> ty1 ... (-> X ty ... ty2) : X)) or (-> ty1 ... (Some (X) (-> X ty ... ty2) : X))")])
+  
     (define/with-syntax name exi)
     (define lhs (t->sc/neg dom))
     (define eq-name (flat/sc #'(eq/c name)))
-    (define rhs (t->sc rng
-                       #:recursive-values (hash-set recursive-values exi
-                                                    (same eq-name))))
+    (define rhs (t->sc rng #:recursive-values (hash-set recursive-values exi (same eq-name))))
     (exist/sc (list #'name) lhs rhs))
 
 
@@ -1165,10 +1161,8 @@
   ;; Match the range of an arr and determine if a contract can be generated
   ;; and call the given thunk or raise an error
   (define (handle-arrow-range arrow proceed)
-    (match arrow
-      [(or (Arrow: _ _ _ rng)
-           (DepFun: _ _ rng))
-       (handle-range rng proceed)]))
+    (match-define (or (Arrow: _ _ _ rng) (DepFun: _ _ rng)) arrow)
+    (handle-range rng proceed))
   (define (handle-range rng proceed)
     (match rng
       [(Values: (list (Result: _
@@ -1267,8 +1261,7 @@
              (when (and (not (empty? kws)))
                (fail #:reason (~a "cannot generate contract for case function type"
                                   " with optional keyword arguments")))
-             (when (ormap (lambda (n-exi)
-                            (> n-exi 0))
+             (when (ormap positive?
                           n-exis)
                (fail #:reason (~a "cannot generate contract for case function type with existentials")))
 
@@ -1287,51 +1280,35 @@
             (handle-arrow-range (first arrows)
                                 (lambda ()
                                   (convert-single-arrow (first arrows))))
-            (case->/sc (map (lambda (arr)
-                              (handle-arrow-range arr (lambda ()
-                                                        (convert-one-arrow-in-many arr))))
-                            arrows)))])]
+            (case->/sc (for/list ([arr (in-list arrows)])
+                         (handle-arrow-range arr (lambda () (convert-one-arrow-in-many arr))))))])]
     [(DepFun/ids: ids dom pre rng)
      (define (continue)
-       (match rng
-         [(Values: (list (Result: rngs _ _) ...))
-          (define (dom-id? id) (member id ids free-identifier=?))
-          (define-values (dom* dom-deps)
-            (for/lists (_1 _2) ([d (in-list dom)])
-              (values (t->sc/neg d)
-                      (filter dom-id? (free-ids d)))))
-          (define pre* (if (TrueProp? pre) #f (t->sc/neg pre)))
-          (define pre-deps (filter dom-id? (free-ids pre)))
-          (define rng* (map t->sc rngs))
-          (define rng-deps (filter dom-id?
-                                   (remove-duplicates
-                                    (apply append (map free-ids rngs))
-                                    free-identifier=?)))
-          (->i/sc (from-typed? typed-side)
-                  ids
-                  dom*
-                  dom-deps
-                  pre*
-                  pre-deps
-                  rng*
-                  rng-deps)]))
+       (match-define (Values: (list (Result: rngs _ _) ...)) rng)
+       (define (dom-id? id)
+         (member id ids free-identifier=?))
+       (define-values (dom* dom-deps)
+         (for/lists (_1 _2) ([d (in-list dom)]) (values (t->sc/neg d) (filter dom-id? (free-ids d)))))
+       (define pre*
+         (if (TrueProp? pre)
+             #f
+             (t->sc/neg pre)))
+       (define pre-deps (filter dom-id? (free-ids pre)))
+       (define rng* (map t->sc rngs))
+       (define rng-deps
+         (filter dom-id? (remove-duplicates (apply append (map free-ids rngs)) free-identifier=?)))
+       (->i/sc (from-typed? typed-side) ids dom* dom-deps pre* pre-deps rng* rng-deps))
      (handle-range rng continue)]))
 
 ;; Generate a contract for a object/class method clause
 ;; Precondition: type is a valid method type
 (define (t->sc/method type fail typed-side recursive-values loop)
   ;; helper for mutually recursive calls in Poly cases
-  (define (rec body #:recursive-values rv)
-    (t->sc/method body fail typed-side rv loop))
   (match type
-    [(? Poly?)
-     (t->sc/poly type fail typed-side recursive-values rec)]
-    [(? PolyDots?)
-     (t->sc/polydots type fail typed-side recursive-values rec)]
-    [(? PolyRow?)
-     (t->sc/polyrow type fail typed-side recursive-values rec)]
-    [(? Fun?)
-     (t->sc/function type fail typed-side recursive-values loop #t)]
+    [(? Poly?) (t->sc/poly type fail typed-side recursive-values rec)]
+    [(? PolyDots?) (t->sc/polydots type fail typed-side recursive-values rec)]
+    [(? PolyRow?) (t->sc/polyrow type fail typed-side recursive-values rec)]
+    [(? Fun?) (t->sc/function type fail typed-side recursive-values loop #t)]
     [_ (fail #:reason "invalid method type")]))
 
 (define (is-a-function-type? initial)
@@ -1546,11 +1523,16 @@
   (require racket/extflonum)
   (provide nonnegative? nonpositive?
            extflonum? extflzero? extflnonnegative? extflnonpositive?)
-  (define nonnegative? (lambda (x) (>= x 0)))
-  (define nonpositive? (lambda (x) (<= x 0)))
-  (define extflzero? (lambda (x) (extfl= x 0.0t0)))
-  (define extflnonnegative? (lambda (x) (extfl>= x 0.0t0)))
-  (define extflnonpositive? (lambda (x) (extfl<= x 0.0t0))))
+  (define (nonnegative? x)
+    (>= x 0))
+  (define (nonpositive? x)
+    (<= x 0))
+  (define (extflzero? x)
+    (extfl= x 0.0t0))
+  (define (extflnonnegative? x)
+    (extfl>= x 0.0t0))
+  (define (extflnonpositive? x)
+    (extfl<= x 0.0t0)))
 
 (module numeric-contracts racket/base
   (require
diff --git a/typed-racket-lib/typed-racket/private/user-defined-type-constr.rkt b/typed-racket-lib/typed-racket/private/user-defined-type-constr.rkt
index 0f9f51ee3..6f3d1ce2d 100644
--- a/typed-racket-lib/typed-racket/private/user-defined-type-constr.rkt
+++ b/typed-racket-lib/typed-racket/private/user-defined-type-constr.rkt
@@ -1,7 +1,7 @@
 #lang racket/base
-(require "../rep/type-constr.rkt"
+(require racket/lazy-require
          racket/match
-         racket/lazy-require)
+         "../rep/type-constr.rkt")
 
 (lazy-require ["../types/substitute.rkt"
                (subst-all make-simple-substitution)])
@@ -30,7 +30,8 @@
     [_ #f]))
 
 (define (recursive-type-constr? constr)
-  (match constr
-    [(struct* TypeConstructor
-              ([real-trep-constr (struct* user-defined-type-op ([recursive? recursive?]))]))
-     recursive?]))
+  (match-define (struct* TypeConstructor
+                         ([real-trep-constr
+                           (struct* user-defined-type-op ([recursive? recursive?]))]))
+    constr)
+  recursive?)
diff --git a/typed-racket-lib/typed-racket/private/with-types.rkt b/typed-racket-lib/typed-racket/private/with-types.rkt
index 316273273..ebdfb1156 100644
--- a/typed-racket-lib/typed-racket/private/with-types.rkt
+++ b/typed-racket-lib/typed-racket/private/with-types.rkt
@@ -1,46 +1,85 @@
 #lang racket/base
 
-(require "../utils/utils.rkt"
-         "../base-env/base-types-extra.rkt"
+(require (for-template (except-in racket/base
+                                  for
+                                  for*
+                                  with-handlers
+                                  with-handlers*
+                                  lambda
+                                  λ
+                                  define
+                                  let
+                                  let*
+                                  letrec
+                                  letrec-values
+                                  let-values
+                                  let*-values
+                                  let/cc
+                                  let/ec
+                                  do
+                                  case-lambda
+                                  case-λ
+                                  struct
+                                  define-struct
+                                  default-continuation-prompt-tag
+                                  for/list
+                                  for/vector
+                                  for/hash
+                                  for/hasheq
+                                  for/hasheqv
+                                  for/hashalw
+                                  for/and
+                                  for/or
+                                  for/sum
+                                  for/product
+                                  for/lists
+                                  for/first
+                                  for/last
+                                  for/fold
+                                  for/foldr
+                                  for*/list
+                                  for*/lists
+                                  for*/vector
+                                  for*/hash
+                                  for*/hasheq
+                                  for*/hasheqv
+                                  for*/hashalw
+                                  for*/and
+                                  for*/or
+                                  for*/sum
+                                  for*/product
+                                  for*/first
+                                  for*/last
+                                  for*/fold
+                                  for*/foldr)
+                       (prefix-in c: racket/contract/region)
+                       "../base-env/prims.rkt")
+         (for-label racket/base
+                    "../base-env/base-types-extra.rkt")
+         racket/promise
+         racket/sequence
+         racket/syntax
+         syntax/flatten-begin
+         syntax/parse
          (except-in "../base-env/prims.rkt" with-handlers λ lambda define)
-         "../env/type-name-env.rkt"
-         "../env/type-alias-env.rkt"
+         "../base-env/base-types-extra.rkt"
          "../env/global-env.rkt"
-         "parse-type.rkt"
-         "type-contract.rkt"
-         "syntax-properties.rkt"
+         "../env/type-alias-env.rkt"
+         "../env/type-name-env.rkt"
+         "../standard-inits.rkt"
+         "../tc-setup.rkt"
          "../typecheck/tc-toplevel.rkt"
          "../typecheck/typechecker.rkt"
          "../types/utils.rkt"
-         "../utils/lift.rkt"
-         "../utils/tc-utils.rkt"
-         "../utils/disarm.rkt"
          "../utils/arm.rkt"
+         "../utils/disarm.rkt"
+         "../utils/lift.rkt"
          "../utils/literal-syntax-class.rkt"
-         racket/promise
-         racket/syntax
-         syntax/flatten-begin
-         syntax/parse
-         racket/sequence
-         "../tc-setup.rkt"
-         "../standard-inits.rkt"
-         (for-template
-          (except-in racket/base for for* with-handlers with-handlers*
-                     lambda λ define
-                     let let* letrec letrec-values let-values let*-values
-                     let/cc let/ec do case-lambda case-λ struct define-struct
-                     default-continuation-prompt-tag
-                     for/list for/vector for/hash for/hasheq for/hasheqv for/hashalw
-                     for/and for/or for/sum for/product for/lists
-                     for/first for/last for/fold for/foldr for*/list for*/lists
-                     for*/vector for*/hash for*/hasheq for*/hasheqv for*/hashalw
-                     for*/and
-                     for*/or for*/sum for*/product for*/first for*/last
-                     for*/fold for*/foldr)
-          "../base-env/prims.rkt"
-          (prefix-in c: racket/contract/region))
-         (for-label racket/base
-                    "../base-env/base-types-extra.rkt"))
+         "../utils/tc-utils.rkt"
+         "../utils/utils.rkt"
+         "parse-type.rkt"
+         "syntax-properties.rkt"
+         "type-contract.rkt")
 
 (define-literal-syntax-class #:for-label Values)
 (define-literal-syntax-class #:for-label values)
@@ -50,7 +89,7 @@
 (define (with-type-helper stx body fvids fvtys exids extys resty expr? ctx te-mode)
   (define old-context (unbox typed-context?))
   (define old-te-mode (unbox type-enforcement-mode))
-  (unless (not old-context)
+  (when old-context
     (tc-error/stx stx (format "with-type cannot be used in a typed module. ~a " old-context)))
   (set-box! typed-context? #t)
   (set-box! type-enforcement-mode te-mode)
diff --git a/typed-racket-lib/typed/private/no-check-helper.rkt b/typed-racket-lib/typed/private/no-check-helper.rkt
index e57fc733f..ab0f88c41 100644
--- a/typed-racket-lib/typed/private/no-check-helper.rkt
+++ b/typed-racket-lib/typed/private/no-check-helper.rkt
@@ -2,12 +2,16 @@
 
 ;; This module provides compatibility macros for no-check mode
 
-(require
- (except-in typed-racket/base-env/prims
-            require/typed require/opaque-type require-typed-struct require/typed/provide)
- typed-racket/base-env/base-types-extra
- (for-syntax racket/base syntax/parse syntax/struct
-             syntax/parse/experimental/template))
+(require (for-syntax racket/base
+                     syntax/parse
+                     syntax/parse/experimental/template
+                     syntax/struct)
+         typed-racket/base-env/base-types-extra
+         (except-in typed-racket/base-env/prims
+                    require/typed
+                    require/opaque-type
+                    require-typed-struct
+                    require/typed/provide))
 (provide (all-from-out racket/base)
          (all-defined-out)
          (all-from-out typed-racket/base-env/prims
diff --git a/typed-racket-lib/typed/private/rewriter.rkt b/typed-racket-lib/typed/private/rewriter.rkt
index 7bd43150d..9b16c28cb 100644
--- a/typed-racket-lib/typed/private/rewriter.rkt
+++ b/typed-racket-lib/typed/private/rewriter.rkt
@@ -1,5 +1,8 @@
 #lang racket/base
-(require (for-syntax syntax/parse racket/base syntax/id-table racket/dict))
+(require (for-syntax racket/base
+                     racket/dict
+                     syntax/id-table
+                     syntax/parse))
 
 (define-for-syntax code-insp
   (variable-reference->module-declaration-inspector
@@ -7,7 +10,7 @@
 
 (define-for-syntax (rewrite stx tbl from)
   (define (rw stx)
-     (syntax-parse (syntax-disarm stx code-insp) #:literal-sets (kernel-literals)
+     (syntax-parse stx #:literal-sets (kernel-literals)
        [i:identifier
         (dict-ref tbl #'i #'i)]
        ;; no expressions here
diff --git a/typed-racket-test/external/historical-counterexamples.rkt b/typed-racket-test/external/historical-counterexamples.rkt
index 82b1cf92e..215c1bbae 100644
--- a/typed-racket-test/external/historical-counterexamples.rkt
+++ b/typed-racket-test/external/historical-counterexamples.rkt
@@ -1,6 +1,9 @@
 #lang racket/base
 
-(require "tr-random-testing.rkt" racket/runtime-path racket/file racket/list)
+(require racket/file
+         racket/list
+         racket/runtime-path
+         "tr-random-testing.rkt")
 
 ;; list of all the counterexamples that the random tester found on drdr,
 ;; as of drdr run #32529
diff --git a/typed-racket-test/external/tr-random-testing.rkt b/typed-racket-test/external/tr-random-testing.rkt
index cdb13b790..495fd2074 100644
--- a/typed-racket-test/external/tr-random-testing.rkt
+++ b/typed-racket-test/external/tr-random-testing.rkt
@@ -2,16 +2,19 @@
 
 ;; Random testing of the TR numeric base environment, and numeric optimizations
 
-(require redex/reduction-semantics
-         racket/flonum racket/unsafe/ops
-         racket/runtime-path racket/sandbox racket/cmdline
+(require racket/cmdline
+         racket/flonum
+         racket/runtime-path
+         racket/sandbox
+         racket/unsafe/ops
+         redex/reduction-semantics
          "random-real.rkt")
 
-(require typed-racket/utils/utils
-         typed-racket/typecheck/typechecker
-         typed-racket/utils/tc-utils
+(require typed-racket/typecheck/typechecker
          typed-racket/types/subtype
-         typed-racket/types/utils)
+         typed-racket/types/utils
+         typed-racket/utils/tc-utils
+         typed-racket/utils/utils)
 
 (require (prefix-in b: typed-racket/base-env/base-env)
          (prefix-in n: typed-racket/base-env/base-env-numeric))
@@ -334,11 +337,11 @@
           )))
   (or both-failed?
       (and (not racket-failed?)
-           (if (same-result? racket-result racketbc-result)
-               #t
-               (begin (printf "not same as bc: racketcs: ~s racketbc: ~s\n"
-                              racket-result racketbc-result)
-                      #f)))))
+           (cond
+             [(same-result? racket-result racketbc-result) #t]
+             [else
+              (printf "not same as bc: racketcs: ~s racketbc: ~s\n" racket-result racketbc-result)
+              #f]))))
 
 (define num-exceptions 0)
 
diff --git a/typed-racket-test/optimizer/known-bugs.rkt b/typed-racket-test/optimizer/known-bugs.rkt
index a31e8bcbc..3a92dfdf4 100644
--- a/typed-racket-test/optimizer/known-bugs.rkt
+++ b/typed-racket-test/optimizer/known-bugs.rkt
@@ -1,14 +1,14 @@
 #lang racket/base
 
-(require
-  rackunit
-  racket/sandbox
-  racket/flonum racket/fixnum racket/unsafe/ops
-  racket/math
-  syntax/srcloc
-  (for-syntax
-    racket/base
-    syntax/parse))
+(require (for-syntax racket/base
+                     syntax/parse)
+         racket/fixnum
+         racket/flonum
+         racket/math
+         racket/sandbox
+         racket/unsafe/ops
+         rackunit
+         syntax/srcloc)
 
 (provide tests)
 
diff --git a/typed-racket-test/optimizer/reset-port.rkt b/typed-racket-test/optimizer/reset-port.rkt
index 913fb5678..a0859be36 100644
--- a/typed-racket-test/optimizer/reset-port.rkt
+++ b/typed-racket-test/optimizer/reset-port.rkt
@@ -5,7 +5,7 @@
 (provide read-syntax)
 
 (define (read-syntax name port)
-  (read-line port)
+  (read-line port 'any)
   (when (port-counts-lines? port)
     (set-port-next-location! port 1 0 1))
   (make-special-comment 'typed-racket/optimizer/reset-port))
diff --git a/typed-racket-test/optimizer/run.rkt b/typed-racket-test/optimizer/run.rkt
index 4795a01b9..ad861a575 100644
--- a/typed-racket-test/optimizer/run.rkt
+++ b/typed-racket-test/optimizer/run.rkt
@@ -1,6 +1,8 @@
 #lang racket
-(require racket/runtime-path compiler/compiler
-         rackunit rackunit/text-ui
+(require compiler/compiler
+         racket/runtime-path
+         rackunit
+         rackunit/text-ui
          typed-racket/optimizer/logging
          "../send-places.rkt")
 
@@ -11,7 +13,7 @@
 (define (get-expected-results file)
   (with-input-from-file file #:mode 'text
     (lambda () ; from the test file
-      (read-line) ; skip the #;#;
+      (read-line (current-input-port) 'any) ; skip the #;#;
       (values (for/list ((l (in-lines (open-input-string (read))))) l)
               (read)))))
 
diff --git a/typed-racket-test/optimizer/transform.rkt b/typed-racket-test/optimizer/transform.rkt
index dced57d72..a9e778b28 100644
--- a/typed-racket-test/optimizer/transform.rkt
+++ b/typed-racket-test/optimizer/transform.rkt
@@ -1,6 +1,7 @@
 #lang racket
 
-(require "run.rkt" "../send-places.rkt")
+(require "../send-places.rkt"
+         "run.rkt")
 
 (module test racket/base
   (displayln "run as program for tests"))
@@ -21,7 +22,7 @@
   (define source-code
     (call-with-input-file* (build-path dir file)
       (lambda (in)
-        (read-line in) ; drop the #;#;
+        (read-line in 'any) ; drop the #;#;
         (read in) ; drop the old expected tr log
         (read in) ; drop the old expected output
         (port->string in))))
@@ -32,13 +33,12 @@
       (for ((entry new-tr-log))
         (write-stringln entry))
       (write-stringln "END")
-      (if (regexp-match "\n" new-output)
-          (begin
-            (write-stringln "#<<END")
-            (write-stringln new-output)
-            (write-stringln "END"))
-          (begin
-            (write new-output)))
+      (cond
+        [(regexp-match "\n" new-output)
+         (write-stringln "#<<END")
+         (write-stringln new-output)
+         (write-stringln "END")]
+        [else (write new-output)])
           (write-string source-code))))
 
 ;; proc returns the list of tests to be run on each file
diff --git a/typed-racket-test/performance/infer-timing.rkt b/typed-racket-test/performance/infer-timing.rkt
index 72e09b02b..c095da01e 100644
--- a/typed-racket-test/performance/infer-timing.rkt
+++ b/typed-racket-test/performance/infer-timing.rkt
@@ -64,10 +64,8 @@
   ;; once we have a set of props that are true/false based on reaching
   ;; a certain point, this will be more useful
   (define (fx-from-cases . cases)
-    (apply from-cases (map (lambda (x)
-                             (add-unconditional-prop-all-args
-                              x -Fixnum))
-                           (flatten cases))))
+    (apply from-cases (for/list ([x (in-list (flatten cases))])
+                        (add-unconditional-prop-all-args x -Fixnum))))
 
   (define (binop t [r t])
     (t t . -> . r))
@@ -407,7 +405,8 @@
   (displayln `(big ,n))
   (define ty-list (append ts ts))
   (collect-garbage) (collect-garbage) (collect-garbage)
-  (define run (λ () (void (bigcall n ty-list))))
+  (define (run)
+    (void (bigcall n ty-list)))
   (cond [hsbencher
          (define-values (vs t r gc)
            (time-apply run null))
diff --git a/typed-racket-test/succeed/shallow/type-printer-single-level.rkt b/typed-racket-test/succeed/shallow/type-printer-single-level.rkt
index e408bcd94..8a0b25c36 100644
--- a/typed-racket-test/succeed/shallow/type-printer-single-level.rkt
+++ b/typed-racket-test/succeed/shallow/type-printer-single-level.rkt
@@ -3,8 +3,8 @@
 ;; Make sure that the type printer expands only a single
 ;; level for (:type ...)
 
-(require rackunit
-         racket/sandbox)
+(require racket/sandbox
+         rackunit)
 
 (define out (open-output-string))