diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/case-lambda.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/case-lambda.rkt
index 2e3a5f0cd..2d06c91c0 100644
--- a/typed-racket-lib/typed-racket/static-contracts/combinators/case-lambda.rkt
+++ b/typed-racket-lib/typed-racket/static-contracts/combinators/case-lambda.rkt
@@ -45,12 +45,15 @@
        (arr-seq-sc-map f (combinator-args v))
        (void))
      (define (sc->contract v f)
-       (match v
-        [(arr-combinator (arr-seq args rest range))
-         (with-syntax ([(arg-stx ...) (map f args)]
-                       [(rest-stx ...) (if rest #`(#:rest #,(f rest)) #'())]
-                       [range-stx (if range #`(values #,@(map f range)) #'any)])
-           #'(arg-stx ... rest-stx ... . -> . range-stx))]))
+       (match-define (arr-combinator (arr-seq args rest range)) v)
+       (with-syntax ([(arg-stx ...) (map f args)]
+                     [(rest-stx ...) (if rest
+                                         #`(#:rest #,(f rest))
+                                         #'())]
+                     [range-stx (if range
+                                    #`(values #,@(map f range))
+                                    #'any)])
+         #'(arg-stx ... rest-stx ... . -> . range-stx)))
      (define (sc->constraints v f)
        (merge-restricts* 'chaperone (map f (arr-seq->list (combinator-args v)))))])
 
@@ -66,20 +69,18 @@
 
 
 (define (arr-seq-sc-map f seq)
-  (match seq
-    [(arr-seq args rest range)
-     (arr-seq
-       (map (λ (a) (f a 'contravariant)) args)
-       (and rest (f rest 'contravariant))
-       (and range (map (λ (a) (f a 'covariant)) range)))]))
+  (match-define (arr-seq args rest range) seq)
+  (arr-seq (map (λ (a) (f a 'contravariant)) args)
+           (and rest (f rest 'contravariant))
+           (and range (map (λ (a) (f a 'covariant)) range))))
 
 (define (arr-seq->list seq)
-  (match seq
-    [(arr-seq args rest range)
-     (append
-       args
-       (if rest (list rest) empty)
-       (or range empty))]))
+  (match-define (arr-seq args rest range) seq)
+  (append args
+          (if rest
+              (list rest)
+              empty)
+          (or range empty)))
 
 
 (struct arr-seq (args rest range)
diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/control.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/control.rkt
index 0b35fc476..7eec8f2ac 100644
--- a/typed-racket-lib/typed-racket/static-contracts/combinators/control.rkt
+++ b/typed-racket-lib/typed-racket/static-contracts/combinators/control.rkt
@@ -24,14 +24,12 @@
        (pt-seq-map f (combinator-args v))
        (void))
      (define (sc->contract v f)
-       (match v
-        [(prompt-tag-combinator (pt-seq vals call-cc))
-         (with-syntax ([(vals-stx ...) (map f vals)]
-                       [(call-cc-stx ...)
-                        (if call-cc
-                            #`(#:call/cc (values #,@(map f call-cc)))
-                            empty)])
-           #'(prompt-tag/c vals-stx ... call-cc-stx ...))]))
+       (match-define (prompt-tag-combinator (pt-seq vals call-cc)) v)
+       (with-syntax ([(vals-stx ...) (map f vals)]
+                     [(call-cc-stx ...) (if call-cc
+                                            #`(#:call/cc (values #,@(map f call-cc)))
+                                            empty)])
+         #'(prompt-tag/c vals-stx ... call-cc-stx ...)))
      (define (sc->constraints v f)
        (merge-restricts* 'chaperone (map f (pt-seq->list (combinator-args v)))))])
 
@@ -52,16 +50,11 @@
 
 
 (define (pt-seq-map f seq)
-  (match seq
-   [(pt-seq vals call-cc)
-    (define (f* a) (f a 'invariant))
-    (pt-seq
-      (map f* vals)
-      (and call-cc (map f* call-cc)))]))
+  (match-define (pt-seq vals call-cc) seq)
+  (define (f* a)
+    (f a 'invariant))
+  (pt-seq (map f* vals) (and call-cc (map f* call-cc))))
 
 (define (pt-seq->list seq)
-  (match seq
-   [(pt-seq vals call-cc)
-    (append
-      vals
-      (or call-cc empty))]))
+  (match-define (pt-seq vals call-cc) seq)
+  (append vals (or call-cc empty)))
diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/dep-function.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/dep-function.rkt
index 9a819f23c..5d7bbcbc9 100644
--- a/typed-racket-lib/typed-racket/static-contracts/combinators/dep-function.rkt
+++ b/typed-racket-lib/typed-racket/static-contracts/combinators/dep-function.rkt
@@ -25,64 +25,63 @@
   #:property prop:combinator-name "dep->/sc"
   #:methods gen:sc
   [(define (sc->contract v rec)
-     (match v
-       [(->i/sc typed-side? ids dom/scs dom-deps pre pre-deps rng/scs rng-deps)
-        (with-syntax ([(id ...) ids]
-                      [(c ...) (for/list ([d/sc (in-list dom/scs)]
-                                          [dep-ids (in-list dom-deps)])
-                                 (cond
-                                   [(not (null? dep-ids))
-                                    (parameterize ([static-contract-may-contain-free-ids? #t])
-                                      (rec d/sc))]
-                                   [else (rec d/sc)]))]
-                      [(dep ...) dom-deps]
-                      [(r-deps ...) rng-deps]
-                      [(p-deps ...) pre-deps])
-          #`(->i ([id dep c] ...)
-                 #,@(cond
-                      [(not pre) #'()]
-                      [else #`(#:pre (p-deps ...)
-                               #,(cond
-                                   [(not (null? pre-deps))
-                                    (parameterize ([static-contract-may-contain-free-ids? #t])
-                                      (rec pre))]
-                                   [else (rec pre)]))])
-                 #,(cond
-                     [(and typed-side? (andmap any/sc? rng-deps)) #'any]
-                     [(null? rng-deps)
-                      #`[_ () (values #,@(map rec rng/scs))]]
-                     [else
-                      (parameterize ([static-contract-may-contain-free-ids? #t])
-                        #`[_ (r-deps ...) (values #,@(map rec rng/scs))])])))]))
+     (match-define (->i/sc typed-side? ids dom/scs dom-deps pre pre-deps rng/scs rng-deps) v)
+     (with-syntax ([(id ...) ids]
+                   [(c ...) (for/list ([d/sc (in-list dom/scs)]
+                                       [dep-ids (in-list dom-deps)])
+                              (cond
+                                [(not (null? dep-ids))
+                                 (parameterize ([static-contract-may-contain-free-ids? #t])
+                                   (rec d/sc))]
+                                [else (rec d/sc)]))]
+                   [(dep ...) dom-deps]
+                   [(r-deps ...) rng-deps]
+                   [(p-deps ...) pre-deps])
+       #`(->i ([id dep c] ...)
+              #,@(cond
+                   [(not pre) #'()]
+                   [else
+                    #`(#:pre (p-deps ...)
+                             #,(cond
+                                 [(not (null? pre-deps))
+                                  (parameterize ([static-contract-may-contain-free-ids? #t])
+                                    (rec pre))]
+                                 [else (rec pre)]))])
+              #,(cond
+                  [(and typed-side? (andmap any/sc? rng-deps)) #'any]
+                  [(null? rng-deps) #`[_ () (values #,@(map rec rng/scs))]]
+                  [else
+                   (parameterize ([static-contract-may-contain-free-ids? #t])
+                     #`[_ (r-deps ...) (values #,@(map rec rng/scs))])]))))
    (define (sc-map v f)
-     (match v
-       [(->i/sc typed-side? ids dom/scs dom-deps pre pre-deps rng/scs rng-deps)
-        (->i/sc typed-side?
-                ids
-                (for/list ([d/sc (in-list dom/scs)])
-                  (f d/sc 'contravariant))
-                dom-deps
-                (and pre (f pre 'contravariant))
-                pre-deps
-                (for/list ([r/sc (in-list rng/scs)])
-                  (f r/sc 'covariant))
-                rng-deps)]))
+     (match-define (->i/sc typed-side? ids dom/scs dom-deps pre pre-deps rng/scs rng-deps) v)
+     (->i/sc typed-side?
+             ids
+             (for/list ([d/sc (in-list dom/scs)])
+               (f d/sc 'contravariant))
+             dom-deps
+             (and pre (f pre 'contravariant))
+             pre-deps
+             (for/list ([r/sc (in-list rng/scs)])
+               (f r/sc 'covariant))
+             rng-deps))
    (define (sc-traverse v f)
-     (match v
-       [(->i/sc _ _ dom/scs _ pre _ rng/scs _)
-        (for ([d/sc (in-list dom/scs)])
-          (f d/sc 'contravariant))
-        (when pre (f pre 'contravariant))
-        (for ([r/sc (in-list rng/scs)])
-          (f r/sc 'covariant))]))
+     (match-define (->i/sc _ _ dom/scs _ pre _ rng/scs _) v)
+     (for ([d/sc (in-list dom/scs)])
+       (f d/sc 'contravariant))
+     (when pre
+       (f pre 'contravariant))
+     (for ([r/sc (in-list rng/scs)])
+       (f r/sc 'covariant)))
    (define (sc-terminal-kind v) 'impersonator)
    (define (sc->constraints v f)
-     (match v
-       [(->i/sc _ _ dom/scs _ pre _ rng/scs _)
-        (merge-restricts* 'impersonator
-                          (append (if pre (list (f pre)) (list))
-                                  (map f rng/scs)
-                                  (map f dom/scs)))]))])
+     (match-define (->i/sc _ _ dom/scs _ pre _ rng/scs _) v)
+     (merge-restricts* 'impersonator
+                       (append (if pre
+                                   (list (f pre))
+                                   (list))
+                               (map f rng/scs)
+                               (map f dom/scs))))])
 
 (require-for-cond-contract "proposition.rkt")
 
diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt
index 0f16fc24f..fd14ce2a6 100644
--- a/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt
+++ b/typed-racket-lib/typed-racket/static-contracts/combinators/exist.rkt
@@ -29,12 +29,10 @@
    (define (sc->contract v f)
      (match-define (exist-combinator (list names doms rngs)) v)
      (parameterize ([static-contract-may-contain-free-ids? #t])
-       (define a
-         (with-syntax ([doms-stx (f doms)]
-                       [rngs-stx (f rngs)]
-                       [n (car names)])
-           #'(->i ([n doms-stx]) (_ (n) rngs-stx))))
-       a))
+       (with-syntax ([doms-stx (f doms)]
+                     [rngs-stx (f rngs)]
+                     [n (car names)])
+         #'(->i ([n doms-stx]) (_ (n) rngs-stx)))))
    (define (sc->constraints v f)
      (simple-contract-restrict 'flat))])
 
diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/function.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/function.rkt
index 6535c1aa9..d67f007ee 100644
--- a/typed-racket-lib/typed-racket/static-contracts/combinators/function.rkt
+++ b/typed-racket-lib/typed-racket/static-contracts/combinators/function.rkt
@@ -146,13 +146,10 @@
   (match-define (function-combinator args indices mand-kws opt-kws typed-side?) v)
   (define-values (mand-args opt-args mand-kw-args opt-kw-args rest-arg range-args)
     (apply split-function-args args indices))
-  (if (and (not rest-arg)
-           (null? (append mand-kw-args mand-args opt-kw-args opt-args))
-           typed-side?)
-      ;; currently we only handle this trivial case
-      ;; we could probably look at the actual kind of `range-args` as well
-      (if (not range-args) 'flat #f)
-      #f))
+  (and (and (not rest-arg) (null? (append mand-kw-args mand-args opt-kw-args opt-args)) typed-side?)
+       ;; currently we only handle this trivial case
+       ;; we could probably look at the actual kind of `range-args` as well
+       (if (not range-args) 'flat #f)))
 
 
 (define (function-sc-constraints v f)
diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/object.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/object.rkt
index aaf0e2ecf..85502d02e 100644
--- a/typed-racket-lib/typed-racket/static-contracts/combinators/object.rkt
+++ b/typed-racket-lib/typed-racket/static-contracts/combinators/object.rkt
@@ -42,14 +42,12 @@
   #:property prop:combinator-name "class/sc"
   #:methods gen:sc
     [(define (sc-map v f)
-       (match v
-         [(class-combinator args opaque absents)
-          (class-combinator (member-seq-sc-map f args) opaque absents)]))
+       (match-define (class-combinator args opaque absents) v)
+       (class-combinator (member-seq-sc-map f args) opaque absents))
      (define (sc-traverse v f)
-       (match v
-         [(class-combinator args opaque absents)
-          (member-seq-sc-map f args)
-          (void)]))
+       (match-define (class-combinator args opaque absents) v)
+       (member-seq-sc-map f args)
+       (void))
      (define (sc->contract v f)
        (class/sc->contract v f))
      (define (sc->constraints v f)
@@ -60,20 +58,17 @@
   #:property prop:combinator-name "instanceof/sc"
   #:methods gen:sc
     [(define (sc-map v f)
-       (match v
-         [(instanceof-combinator (list class))
-          (instanceof-combinator (list (f class 'covariant)))]))
+       (match-define (instanceof-combinator (list class)) v)
+       (instanceof-combinator (list (f class 'covariant))))
      (define (sc-traverse v f)
-       (match v
-         [(instanceof-combinator (list class))
-          (f class 'covariant)
-          (void)]))
+       (match-define (instanceof-combinator (list class)) v)
+       (f class 'covariant)
+       (void))
      (define (sc->contract v f)
        (instance/sc->contract v f))
      (define (sc->constraints v f)
-       (match v
-         [(instanceof-combinator (list class))
-          (f class)]))])
+       (match-define (instanceof-combinator (list class)) v)
+       (f class))])
 
 
 (define member-seq->list
@@ -86,13 +81,10 @@
    #:property prop:sequence member-seq->list)
 
 (define (member-seq-sc-map f seq)
-  (match seq
-    [(member-seq vals)
-     (member-seq
-       (for/list ([v (in-list vals)])
-          (match v
-            [(member-spec mod id sc)
-             (member-spec mod id (and sc (f sc 'invariant)))])))]))
+  (match-define (member-seq vals) seq)
+  (member-seq (for/list ([v (in-list vals)])
+                (match v
+                  [(member-spec mod id sc) (member-spec mod id (and sc (f sc 'invariant)))]))))
 
 ;; TODO make this the correct subset
 (define object-member-spec? member-spec?)
@@ -105,14 +97,15 @@
   (instanceof-combinator (list class)))
 
 (define ((member-spec->form f) v)
-  (match v
-    [(member-spec modifier id sc)
-     (with-syntax ([id/ctc (if sc #`(#,id #,(f sc)) id)])
-       (case modifier
-         [(method) #'id/ctc]
-         [(inner) #'(inner id/ctc)]
-         [(init) #'(init id/ctc)]
-         [(field) #'(field id/ctc)]))]))
+  (match-define (member-spec modifier id sc) v)
+  (with-syntax ([id/ctc (if sc
+                            #`(#,id #,(f sc))
+                            id)])
+    (case modifier
+      [(method) #'id/ctc]
+      [(inner) #'(inner id/ctc)]
+      [(init) #'(init id/ctc)]
+      [(field) #'(field id/ctc)])))
 
 (define (spec->id/ctc f modifier vals)
   (for/lists (_1 _2)
@@ -122,50 +115,39 @@
             (f (member-spec-sc spec)))))
 
 (define (object/sc->contract v f)
-  (match v
-   [(object-combinator (member-seq vals) opaque?)
-    #`(#,(if opaque?
-             #'object/c-opaque
-             #'object/c)
-       #,@(map (member-spec->form f) vals))]))
-
-(define (class/sc->contract v f) 
-  (match v
-   [(class-combinator (member-seq vals) opaque absents)
-    (define-values (override-names override-ctcs)
-      (spec->id/ctc f 'override vals))
-    (define-values (pubment-names pubment-ctcs)
-      (spec->id/ctc f 'pubment vals))
-    (define/with-syntax (override-temp ...)
-      (generate-temporaries override-ctcs))
-    (define/with-syntax (pubment-temp ...)
-      (generate-temporaries pubment-ctcs))
-    (define/with-syntax (override-name ...) override-names)
-    (define/with-syntax (pubment-name ...) pubment-names)
-    (define/with-syntax (override-ctc ...) override-ctcs)
-    (define/with-syntax (pubment-ctc ...) pubment-ctcs)
-    (define vals-rest
-      (filter (λ (spec)
-                (not (memq (member-spec-modifier spec)
-                           '(override pubment))))
-              vals))
-    #`(let ([override-temp override-ctc] ...
-            [pubment-temp pubment-ctc] ...)
-        (class/c #,@(if opaque '(#:opaque #:ignore-local-member-names) null)
-                 #,@(map (member-spec->form f) vals-rest)
-                 [override-name override-temp] ...
-                 (override [override-name override-temp] ...)
-                 (super [override-name override-temp] ...)
-                 (inherit [override-name override-temp] ...)
-                 [pubment-name pubment-temp] ...
-                 (augment [pubment-name pubment-temp] ...)
-                 (inherit [pubment-name pubment-temp] ...)
-                 (absent #,@absents)))]))
+  (match-define (object-combinator (member-seq vals) opaque?) v)
+  #`(#,(if opaque? #'object/c-opaque #'object/c) #,@(map (member-spec->form f) vals)))
+
+(define (class/sc->contract v f)
+  (match-define (class-combinator (member-seq vals) opaque absents) v)
+  (define-values (override-names override-ctcs) (spec->id/ctc f 'override vals))
+  (define-values (pubment-names pubment-ctcs) (spec->id/ctc f 'pubment vals))
+  (define/with-syntax (override-temp ...) (generate-temporaries override-ctcs))
+  (define/with-syntax (pubment-temp ...) (generate-temporaries pubment-ctcs))
+  (define/with-syntax (override-name ...) override-names)
+  (define/with-syntax (pubment-name ...) pubment-names)
+  (define/with-syntax (override-ctc ...) override-ctcs)
+  (define/with-syntax (pubment-ctc ...) pubment-ctcs)
+  (define vals-rest
+    (filter (λ (spec) (not (memq (member-spec-modifier spec) '(override pubment)))) vals))
+  #`(let ([override-temp override-ctc] ...
+          [pubment-temp pubment-ctc] ...)
+      (class/c #,@(if opaque
+                      '(#:opaque #:ignore-local-member-names)
+                      null)
+               #,@(map (member-spec->form f) vals-rest)
+               [override-name override-temp] ...
+               (override [override-name override-temp] ...)
+               (super [override-name override-temp] ...)
+               (inherit [override-name override-temp] ...)
+               [pubment-name pubment-temp] ...
+               (augment [pubment-name pubment-temp] ...)
+               (inherit [pubment-name pubment-temp] ...)
+               (absent #,@absents))))
 
 (define (instance/sc->contract v f)
-  (match v
-   [(instanceof-combinator (list class))
-    #`(instanceof/c #,(f class))]))
+  (match-define (instanceof-combinator (list class)) v)
+  #`(instanceof/c #,(f class)))
 
 (define (make-class-shape/sc init* field* public* augment*)
   (define-values [pubment* override*] (partition (lambda (nm) (memq nm augment*)) public*))
diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/prefab.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/prefab.rkt
index c167925ad..c407981fd 100644
--- a/typed-racket-lib/typed-racket/static-contracts/combinators/prefab.rkt
+++ b/typed-racket-lib/typed-racket/static-contracts/combinators/prefab.rkt
@@ -23,33 +23,27 @@
   #:property prop:combinator-name "prefab/sc"
   #:methods gen:sc
     [(define (sc-map v f)
-       (match v
-        [(prefab-combinator args key field-mutability)
-         (prefab-combinator (map (λ (a mut?) (f a (if mut? 'invariant 'covariant)))
-                                 args
-                                 field-mutability)
-                            key
-                            field-mutability)]))
+       (match-define (prefab-combinator args key field-mutability) v)
+       (prefab-combinator
+        (map (λ (a mut?) (f a (if mut? 'invariant 'covariant))) args field-mutability)
+        key
+        field-mutability))
      (define (sc-traverse v f)
-       (match v
-        [(prefab-combinator args key field-mutability)
-         (for-each (λ (a mut?) (f a (if mut? 'invariant 'covariant)))
-                   args
-                   field-mutability)
-         (void)]))
+       (match-define (prefab-combinator args key field-mutability) v)
+       (for-each (λ (a mut?) (f a (if mut? 'invariant 'covariant))) args field-mutability)
+       (void))
      (define (sc->contract v f)
-       (match v
-        [(prefab-combinator args key _)
-         #`(prefab/c (quote #,(abbreviate-prefab-key key)) #,@(map f args))]))
+       (match-define (prefab-combinator args key _) v)
+       #`(prefab/c (quote #,(abbreviate-prefab-key key)) #,@(map f args)))
      (define (sc->constraints v f)
-       (match v
-        [(prefab-combinator args _ field-mutability)
-         (merge-restricts*
-           (if (ormap values field-mutability) 'chaperone 'flat)
-           (map (λ (a mut?)
-                  (if (not mut?) (add-constraint (f a) 'chaperone) (f a)))
-                args
-                field-mutability))]))])
+       (match-define (prefab-combinator args _ field-mutability) v)
+       (merge-restricts* (if (ormap values field-mutability) 'chaperone 'flat)
+                         (map (λ (a mut?)
+                                (if (not mut?)
+                                    (add-constraint (f a) 'chaperone)
+                                    (f a)))
+                              args
+                              field-mutability)))])
 
 (define (prefab/sc key fields)
   (prefab-combinator fields key (prefab-key->field-mutability key)))
diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/struct.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/struct.rkt
index 05da781aa..2e10062a9 100644
--- a/typed-racket-lib/typed-racket/static-contracts/combinators/struct.rkt
+++ b/typed-racket-lib/typed-racket/static-contracts/combinators/struct.rkt
@@ -26,28 +26,23 @@
   #:property prop:combinator-name "struct/sc"
   #:methods gen:sc
     [(define (sc-map v f)
-       (match v
-        [(struct-combinator args name mut?)
-         (struct-combinator (map (λ (a) (f a (if mut? 'invariant 'covariant))) args)
-                            name mut?)]))
+       (match-define (struct-combinator args name mut?) v)
+       (struct-combinator (map (λ (a) (f a (if mut? 'invariant 'covariant))) args) name mut?))
      (define (sc-traverse v f)
-       (match v
-        [(struct-combinator args name mut?)
-         (for-each (λ (a) (f a (if mut? 'invariant 'covariant))) args)
-         (void)]))
+       (match-define (struct-combinator args name mut?) v)
+       (for-each (λ (a) (f a (if mut? 'invariant 'covariant))) args)
+       (void))
      (define (sc->contract v f)
-       (match v
-         [(struct-combinator args name _)
-          #`(struct/c #,name #,@(map f args))]))
+       (match-define (struct-combinator args name _) v)
+       #`(struct/c #,name #,@(map f args)))
      (define (sc->constraints v f)
-       (match v
-        [(struct-combinator args _ mut?)
-         (merge-restricts* (if mut? 'chaperone 'flat)
-                           (map (lambda (a)
-                                  (if (not mut?)
-                                      (add-constraint (f a) 'chaperone)
-                                      (f a)))
-                                args))]))])
+       (match-define (struct-combinator args _ mut?) v)
+       (merge-restricts* (if mut? 'chaperone 'flat)
+                         (map (lambda (a)
+                                (if (not mut?)
+                                    (add-constraint (f a) 'chaperone)
+                                    (f a)))
+                              args)))])
 
 (define (struct/sc name mut? fields)
   (struct-combinator fields name mut?))
@@ -64,21 +59,18 @@
   #:property prop:combinator-name "struct-type/sc"
   #:methods gen:sc
     [(define (sc-map v f)
-       (match v
-         [(struct-type/sc args)
-          (struct-type/sc (map (λ (a) (f a 'covariant)) args))]))
+       (match-define (struct-type/sc args) v)
+       (struct-type/sc (map (λ (a) (f a 'covariant)) args)))
      (define (sc-traverse v f)
-       (match v
-         [(struct-type/sc args)
-          (for-each (λ (a) (f a 'covariant)) args)
-          (void)]))
+       (match-define (struct-type/sc args) v)
+       (for-each (λ (a) (f a 'covariant)) args)
+       (void))
      (define (sc->contract v f)
-       (match v
-         [(struct-type/sc args)
-          #`(struct-type/c #f)]))
+       (match-define (struct-type/sc args) v)
+       #`(struct-type/c #f))
      (define (sc->constraints v f)
-       (match v
-         [(struct-type/sc args) (simple-contract-restrict 'chaperone)]))])
+       (match-define (struct-type/sc args) v)
+       (simple-contract-restrict 'chaperone))])
 
 (define-match-expander struct-type/sc:
   (syntax-parser
diff --git a/typed-racket-lib/typed-racket/static-contracts/combinators/unit.rkt b/typed-racket-lib/typed-racket/static-contracts/combinators/unit.rkt
index 766f66666..8ea8181bf 100644
--- a/typed-racket-lib/typed-racket/static-contracts/combinators/unit.rkt
+++ b/typed-racket-lib/typed-racket/static-contracts/combinators/unit.rkt
@@ -16,15 +16,13 @@
         #:transparent
         #:property prop:combinator-name "unit/sc"
         #:methods gen:sc
-        [(define (sc-map v f) 
-           (match v
-             [(unit-combinator unit-spec)
-              (unit-combinator (unit-spec-sc-map f unit-spec))]))
+        [(define (sc-map v f)
+           (match-define (unit-combinator unit-spec) v)
+           (unit-combinator (unit-spec-sc-map f unit-spec)))
          (define (sc-traverse v f)
-           (match v
-             [(unit-combinator unit-spec)
-              (unit-spec-sc-map f unit-spec)
-              (void)]))
+           (match-define (unit-combinator unit-spec) v)
+           (unit-spec-sc-map f unit-spec)
+           (void))
          (define (sc->contract v f)
            (unit/sc->contract v f))
          (define (sc->constraints v f)
@@ -44,53 +42,41 @@
         #:property prop:sequence unit-spec->list)
 
 (define (unit-spec-sc-map f seq)
-  (match seq
-    [(unit-spec imports exports init-depends invokes)
-     (unit-spec
-      (map (signature-spec-sc-map f) imports)
-      (map (signature-spec-sc-map f) exports)
-      ;; leave init-depends alone since they don't contain contracts
-      init-depends
-      (map (lambda (invoke) (and invoke (f invoke 'covariant))) invokes))]))
+  (match-define (unit-spec imports exports init-depends invokes) seq)
+  (unit-spec (map (signature-spec-sc-map f) imports)
+             (map (signature-spec-sc-map f) exports)
+             ;; leave init-depends alone since they don't contain contracts
+             init-depends
+             (map (lambda (invoke) (and invoke (f invoke 'covariant))) invokes)))
 
 (define ((signature-spec-sc-map f) seq)
-  (match seq
-    [(signature-spec name (list ids ...) (list scs ...))
-     (signature-spec
-      name
-      ids
-      (map (lambda (sc) (and sc (f sc 'invariant))) scs))]))
+  (match-define (signature-spec name (list ids ...) (list scs ...)) seq)
+  (signature-spec name ids (map (lambda (sc) (and sc (f sc 'invariant))) scs)))
 
 
 (define (unit/sc->contract v f)
-  (match v
-    [(unit-combinator 
-      (unit-spec (list imports ...)
-                 (list exports ...)
-                 (list deps ...)
-                 (list invoke/scs ...)))
-     
-     (define (sig-spec->syntax sig-spec)
-       (match sig-spec
-         [(signature-spec name members scs)
-          (define member-stx
-            (map (lambda (id sc) #`(#,id #,(f sc))) members scs))
-          #`(#,name #,@member-stx)]))
-     
-     (define (invokes->contract lst)
-       (cond
-        ;; just a single contract
-        [(= 1 (length lst))
-         #`#,(f (first lst))]
-        ;; values contract
-        [else 
-         #`(values #,@(map f lst))]))
-     
-     #`(unit/c
-        (import #,@(map sig-spec->syntax imports))
-        (export #,@(map sig-spec->syntax exports))
-        (init-depend #,@deps)
-        #,(invokes->contract invoke/scs))]))
+  (match-define (unit-combinator (unit-spec (list imports ...)
+                                            (list exports ...)
+                                            (list deps ...)
+                                            (list invoke/scs ...)))
+    v)
+  (define (sig-spec->syntax sig-spec)
+    (match sig-spec
+      [(signature-spec name members scs)
+       (define member-stx (map (lambda (id sc) #`(#,id #,(f sc))) members scs))
+       #`(#,name #,@member-stx)]))
+
+  (define (invokes->contract lst)
+    (cond
+      ;; just a single contract
+      [(= 1 (length lst)) #`#,(f (first lst))]
+      ;; values contract
+      [else #`(values #,@(map f lst))]))
+
+  #`(unit/c (import #,@(map sig-spec->syntax imports))
+            (export #,@(map sig-spec->syntax exports))
+            (init-depend #,@deps)
+            #,(invokes->contract invoke/scs)))
 
 (define (unit/sc imports exports init-depends invoke)
   (unit-combinator (unit-spec imports exports init-depends invoke)))
diff --git a/typed-racket-test/external/tr-random-testing.rkt b/typed-racket-test/external/tr-random-testing.rkt
index cdb13b790..453bf089a 100644
--- a/typed-racket-test/external/tr-random-testing.rkt
+++ b/typed-racket-test/external/tr-random-testing.rkt
@@ -334,11 +334,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/main.rkt b/typed-racket-test/main.rkt
index 85f66a8fb..e4b860b04 100644
--- a/typed-racket-test/main.rkt
+++ b/typed-racket-test/main.rkt
@@ -32,17 +32,15 @@
 
 
 (define (exn-pred p)
-  (let ([sexp (with-handlers
-                  ([exn:fail? (lambda _ #f)])
-                (call-with-input-file*
-                 p
-                 (lambda (prt)
-                   (read-line prt 'any) (read prt))))])
-    (match sexp
-      [(list-rest 'exn-pred e)
-       (eval `(exn-matches . ,e) (namespace-anchor->namespace a))]
-      [_
-       (exn-matches ".*Type Checker.*" exn:fail:syntax?)])))
+  (define sexp
+    (with-handlers ([exn:fail? (lambda _ #f)])
+      (call-with-input-file* p
+                             (lambda (prt)
+                               (read-line prt 'any)
+                               (read prt)))))
+  (match sexp
+    [(list-rest 'exn-pred e) (eval `(exn-matches . ,e) (namespace-anchor->namespace a))]
+    [_ (exn-matches ".*Type Checker.*" exn:fail:syntax?)]))
 
 (define-runtime-path src-dir ".")
 
@@ -61,21 +59,19 @@
                              (not (set-member? excl (path->string (file-name-from-path p*))))))
 
         (define-values [p*-base p*-name _] (split-path p*))
-        (define prm (list p*-base p*-name
-                          (if (places)
-                              (delay/thread
-                                (begin0 (run-in-other-place p* error?)
-                                        (when (zero? (modulo i 10))
-                                          (eprintf "."))))
-                              (delay
-                                (parameterize ([read-accept-reader #t]
-                                               [current-load-relative-directory p*-base]
-                                               [current-directory p*-base]
-                                               [current-output-port (open-output-nowhere)])
-                                  (begin0 (dr p*-name)
-                                          (when (zero? (modulo i 10))
-                                            (eprintf "."))))))))
-        prm))
+        (list p*-base
+              p*-name
+              (if (places)
+                  (delay/thread (begin0 (run-in-other-place p* error?)
+                                  (when (zero? (modulo i 10))
+                                    (eprintf "."))))
+                  (delay (parameterize ([read-accept-reader #t]
+                                        [current-load-relative-directory p*-base]
+                                        [current-directory p*-base]
+                                        [current-output-port (open-output-nowhere)])
+                           (begin0 (dr p*-name)
+                             (when (zero? (modulo i 10))
+                               (eprintf ".")))))))))
     (define tests
       (for/list ([e prms])
         (match-define (list path p prm) e)
@@ -114,15 +110,14 @@
   (define shootout (collection-path "tests" "racket" "benchmarks" "shootout" "typed"))
   (define common (collection-path "tests" "racket" "benchmarks" "common" "typed"))
   (define (mk dir)
-    (let ((promised-results
-            (for/hash ([file (in-list (directory-list dir))]
-                        #:when (scheme-file? file))
-              (values (path->string file)
-                      (delay/thread (compile-path (build-path dir file)))))))
-      (make-test-suite (path->string dir)
-        (for/list ([(name results) promised-results])
-           (test-suite name
-              (check-not-exn (λ () (force results))))))))
+    (define promised-results
+      (for/hash ([file (in-list (directory-list dir))]
+                 #:when (scheme-file? file))
+        (values (path->string file) (delay/thread (compile-path (build-path dir file))))))
+    (make-test-suite (path->string dir)
+                     (for/list ([(name results) promised-results])
+                       (test-suite name
+                         (check-not-exn (λ () (force results)))))))
 
 
   (test-suite "Compiling Benchmark tests"
@@ -164,23 +159,19 @@
 
 (define (just-one p*)
   (define-values (path p b) (split-path p*))
+  (define dir (path->string path))
   (define f
-    (let ([dir (path->string path)])
-      (cond [(regexp-match? #rx"fail/" dir )
-             (lambda (p thnk)
-               (define-values (pred info) (exn-pred p))
-               (parameterize ([error-display-handler void])
-                 (with-check-info
-                  (['predicates info])
-                  (check-exn pred thnk))))]
-            [(regexp-match? #rx"succeed/" dir)
-             (lambda (p thnk) (check-not-exn thnk))]
-            [(regexp-match? #rx"optimizer/tests/$" dir)
-             (lambda (p* thnk) (test-opt p))]
-            [(regexp-match? #rx"optimizer/missed-optimizations/$" dir)
-             (lambda (p* thnk) (test-missed-optimization p))]
-            [else
-              (error 'just-one "Unknown test kind for test: ~a" p*)])))
+    (cond
+      [(regexp-match? #rx"fail/" dir)
+       (lambda (p thnk)
+         (define-values (pred info) (exn-pred p))
+         (parameterize ([error-display-handler void])
+           (with-check-info (['predicates info]) (check-exn pred thnk))))]
+      [(regexp-match? #rx"succeed/" dir) (lambda (p thnk) (check-not-exn thnk))]
+      [(regexp-match? #rx"optimizer/tests/$" dir) (lambda (p* thnk) (test-opt p))]
+      [(regexp-match? #rx"optimizer/missed-optimizations/$" dir)
+       (lambda (p* thnk) (test-missed-optimization p))]
+      [else (error 'just-one "Unknown test kind for test: ~a" p*)]))
   (test-suite
    (path->string p)
    (f
@@ -271,20 +262,37 @@
                                 (run-unit-test-suite (or (places) 1))
                                 0))
 
-  (if (and (nightly?) (eq? 'cgc (system-type 'gc)))
-      (printf "Skipping Typed Racket tests.\n")
-      (let ([to-run (cond [(single) (list (single))]
-                          [else
-                           (append (if (int?)        (list (int-tests (excl)))          '())
-                                   (if (gui?)        (list (gui-tests))                 '())
-                                   (if (external?)   (list (external-tests))            '())
-                                   (if (opt?)        (list (optimization-tests))        '())
-                                   (if (missed-opt?) (list (missed-optimization-tests)) '())
-                                   (if (bench?)      (list (compile-benchmarks))        '())
-                                   (if (math?)       (list (compile-math))              '()))])])
-        (unless (and (= unit-test-retcode 0) (= 0 ((exec) to-run)))
-          (eprintf "Typed Racket Tests did not pass.\n")
-          (exit 1)))))
+  (cond
+    [(and (nightly?) (eq? 'cgc (system-type 'gc))) (printf "Skipping Typed Racket tests.\n")]
+    [else
+     (define to-run
+       (cond
+         [(single) (list (single))]
+         [else
+          (append (if (int?)
+                      (list (int-tests (excl)))
+                      '())
+                  (if (gui?)
+                      (list (gui-tests))
+                      '())
+                  (if (external?)
+                      (list (external-tests))
+                      '())
+                  (if (opt?)
+                      (list (optimization-tests))
+                      '())
+                  (if (missed-opt?)
+                      (list (missed-optimization-tests))
+                      '())
+                  (if (bench?)
+                      (list (compile-benchmarks))
+                      '())
+                  (if (math?)
+                      (list (compile-math))
+                      '()))]))
+     (unless (and (= unit-test-retcode 0) (= 0 ((exec) to-run)))
+       (eprintf "Typed Racket Tests did not pass.\n")
+       (exit 1))]))
 
 ;; nightly tests in `run.rkt` for drdr chart continuity
 (module test racket/base)
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/places.rkt b/typed-racket-test/places.rkt
index 3c26d4f39..6eace20df 100644
--- a/typed-racket-test/places.rkt
+++ b/typed-racket-test/places.rkt
@@ -35,12 +35,13 @@
 
 (define (dr p)
   (parameterize ([current-namespace (make-base-empty-namespace)])
-    (let* ([root-module `(file ,(if (string? p) p (path->string p)))]
-           [submodule-test `(submod ,root-module test)]
-           [module-path (if (module-declared? submodule-test #t)
-                            submodule-test
-                            root-module)])
-      (dynamic-require module-path #f))))
+    (define root-module
+      `(file ,(if (string? p)
+                  p
+                  (path->string p))))
+    (define submodule-test `(submod ,root-module test))
+    (define module-path (if (module-declared? submodule-test #t) submodule-test root-module))
+    (dynamic-require module-path #f)))
 
 
 (define (start-worker get-ch name)
diff --git a/typed-racket-test/send-places.rkt b/typed-racket-test/send-places.rkt
index 4e2b2545d..fc0b5641b 100644
--- a/typed-racket-test/send-places.rkt
+++ b/typed-racket-test/send-places.rkt
@@ -50,9 +50,9 @@
            (define-values (res-ch res-ch*) (place-channel))
            (place-channel-put enq-ch (vector 'log name dir res-ch*))
            (define res (place-channel-get res-ch))
-           (if (s-exn? res)
-               (raise (deserialize-exn res))
-               res)]
+           (when (s-exn? res)
+             (raise (deserialize-exn res)))
+           res]
           [else
            (generate-log/place name dir)])))
 
@@ -61,8 +61,8 @@
          (define-values (res-ch res-ch*) (place-channel))
          (place-channel-put enq-ch (vector 'compile file res-ch*))
          (define res (place-channel-get res-ch))
-         (if (s-exn? res)
-             (raise (deserialize-exn res))
-             res)]
+         (when (s-exn? res)
+           (raise (deserialize-exn res)))
+         res]
         [else
          (compile-path/place file)]))