Automated Resyntax fixes

This is an automated change generated by Resyntax.

#### Pass 1

Applied 1 fix to [`typed-racket-lib/typed-racket/types/tc-error.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/tc-error.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.

Applied 10 fixes to [`typed-racket-lib/typed-racket/types/printer.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/printer.rkt)

  * Line 135, `quasiquote-to-list`: This quasiquotation is equialent to a simple `list` call.
  * Line 152, `single-clause-match-to-match-define`: This `match` expression can be simplified using `match-define`.
  * Line 163, `single-clause-match-to-match-define`: This `match` expression can be simplified using `match-define`.
  * Line 320, `define-values-values-to-define`: This use of `define-values` is unnecessary.
  * Line 327, `for/fold-result-keyword`: Only one of the `for/fold` expression's result values is used. Use the `#:result` keyword to return just that result.
  * Line 367, `single-clause-match-to-match-define`: This `match` expression can be simplified using `match-define`.
  * Line 464, `apply-append-for-loop-to-for-loop`: Instead of using `(apply append ...)` to flatten a list of lists, consider using `for*/list` to flatten the list.
  * Line 480, `single-clause-match-to-match-define`: This `match` expression can be simplified using `match-define`.
  * Line 515, `quasiquote-to-list`: This quasiquotation is equialent to a simple `list` call.
  * Line 519, `quasiquote-to-list`: This quasiquotation is equialent to a simple `list` call.

Applied 2 fixes to [`typed-racket-lib/typed-racket/types/tc-result.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/tc-result.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 158, `single-clause-match-to-match-define`: This `match` expression can be simplified using `match-define`.

Applied 1 fix to [`typed-racket-lib/typed/private/no-check-helper.rkt`](../blob/HEAD/typed-racket-lib/typed/private/no-check-helper.rkt)

  * Line 5, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.

Applied 6 fixes to [`typed-racket-lib/typed-racket/types/base-abbrev.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/base-abbrev.rkt)

  * Line 105, `define-syntax-syntax-rules-to-define-syntax-rule`: This `define-syntax` macro can be replaced with a simpler, equivalent `define-syntax-rule` macro.
  * Line 109, `define-syntax-syntax-rules-to-define-syntax-rule`: This `define-syntax` macro can be replaced with a simpler, equivalent `define-syntax-rule` macro.
  * Line 496, `define-syntax-syntax-rules-to-define-syntax-rule`: This `define-syntax` macro can be replaced with a simpler, equivalent `define-syntax-rule` macro.
  * Line 502, `define-syntax-syntax-rules-to-define-syntax-rule`: This `define-syntax` macro can be replaced with a simpler, equivalent `define-syntax-rule` macro.
  * Line 509, `define-syntax-syntax-rules-to-define-syntax-rule`: This `define-syntax` macro can be replaced with a simpler, equivalent `define-syntax-rule` macro.
  * Line 516, `define-syntax-syntax-rules-to-define-syntax-rule`: This `define-syntax` macro can be replaced with a simpler, equivalent `define-syntax-rule` macro.

Applied 3 fixes to [`typed-racket-test/external/tr-random-testing.rkt`](../blob/HEAD/typed-racket-test/external/tr-random-testing.rkt)

  * Line 5, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 10, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 337, `if-begin-to-cond`: Using `cond` instead of `if` here makes `begin` unnecessary

Applied 3 fixes to [`typed-racket-lib/typed-racket/types/signatures.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/signatures.rkt)

  * Line 6, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 52, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.
  * Line 59, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.

Applied 1 fix to [`typed-racket-lib/typed-racket/types/struct-table.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/struct-table.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.

Applied 3 fixes to [`typed-racket-lib/typed-racket/types/utils.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/utils.rkt)

  * Line 19, `define-lambda-to-define`: The `define` form supports a shorthand for defining functions.
  * Line 60, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.
  * Line 79, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.

Applied 4 fixes to [`typed-racket-lib/typed-racket/types/prop-ops.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/prop-ops.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 56, `single-clause-match-to-match-define`: This `match` expression can be simplified using `match-define`.
  * Line 111, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.
  * Line 382, `sort-with-keyed-comparator-to-sort-by-key`: This `sort` expression can be replaced with a simpler, equivalent expression.

Applied 1 fix to [`typed-racket-lib/typed-racket/types/union.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/union.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.

Applied 2 fixes to [`typed-racket-lib/typed-racket/types/generalize.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/generalize.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 48, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.

Applied 1 fix to [`typed-racket-test/external/historical-counterexamples.rkt`](../blob/HEAD/typed-racket-test/external/historical-counterexamples.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.

Applied 1 fix to [`typed-racket-lib/typed-racket/types/substitute.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/substitute.rkt)

  * Line 78, `if-let-to-cond`: `cond` with internal definitions is preferred over `if` with `let`, to reduce nesting

Applied 1 fix to [`typed-racket-lib/typed-racket/types/overlap.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/overlap.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.

Applied 3 fixes to [`typed-racket-lib/typed-racket/types/subtype.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/subtype.rkt)

  * Line 536, `apply-flattening`: The `apply` function accepts single arguments in addition to a trailing list argument.
  * Line 661, `if-else-false-to-and`: This `if` expression can be refactored to an equivalent expression using `and`.
  * Line 793, `single-clause-match-to-match-define`: This `match` expression can be simplified using `match-define`.

Applied 2 fixes to [`typed-racket-lib/typed/private/rewriter.rkt`](../blob/HEAD/typed-racket-lib/typed/private/rewriter.rkt)

  * Line 2, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 10, `syntax-disarm-migration`: The `syntax-disarm` function is a legacy function that does nothing.

Applied 2 fixes to [`typed-racket-lib/typed-racket/types/match-expanders.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/match-expanders.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 78, `define-simple-macro-to-define-syntax-parse-rule`: The `define-simple-macro` form has been renamed to `define-syntax-parse-rule`.

Applied 3 fixes to [`typed-racket-lib/typed-racket/types/resolve.rkt`](../blob/HEAD/typed-racket-lib/typed-racket/types/resolve.rkt)

  * Line 52, `if-else-false-to-and`: This `if` expression can be refactored to an equivalent expression using `and`.
  * Line 65, `inverted-when`: This negated `when` expression can be replaced by an `unless` expression.
  * Line 101, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.

## Summary

Fixed 50 issues in 19 files.

  * Fixed 14 occurrences of `tidy-require`
  * Fixed 7 occurrences of `single-clause-match-to-match-define`
  * Fixed 7 occurrences of `let-to-define`
  * Fixed 6 occurrences of `define-syntax-syntax-rules-to-define-syntax-rule`
  * Fixed 3 occurrences of `quasiquote-to-list`
  * Fixed 2 occurrences of `if-else-false-to-and`
  * Fixed 1 occurrence of `define-values-values-to-define`
  * Fixed 1 occurrence of `for/fold-result-keyword`
  * Fixed 1 occurrence of `apply-append-for-loop-to-for-loop`
  * Fixed 1 occurrence of `if-let-to-cond`
  * Fixed 1 occurrence of `apply-flattening`
  * Fixed 1 occurrence of `syntax-disarm-migration`
  * Fixed 1 occurrence of `define-simple-macro-to-define-syntax-parse-rule`
  * Fixed 1 occurrence of `inverted-when`
  * Fixed 1 occurrence of `if-begin-to-cond`
  * Fixed 1 occurrence of `define-lambda-to-define`
  * Fixed 1 occurrence of `sort-with-keyed-comparator-to-sort-by-key`

Author: resyntax-ci[bot]

typed-racket-lib/typed-racket/types/base-abbrev.rkt

@@ -102,15 +102,11 @@
   (foldr -pair b l))
 
 ;; Recursive types
-(define-syntax -v
-  (syntax-rules ()
-    [(_ x) (make-F 'x)]))
+(define-syntax-rule (-v x)
+  (make-F 'x))
 
-(define-syntax -mu
-  (syntax-rules ()
-    [(_ var ty)
-     (let ([var (-v var)])
-       (make-Mu 'var ty))]))
+(define-syntax-rule (-mu var ty)
+  (let ([var (-v var)]) (make-Mu 'var ty)))
 
 ;; Results
 (define/cond-contract (-result t [pset -tt-propset] [o -empty-obj])
@@ -493,31 +489,20 @@
 
 
 ;; Convenient syntax for polymorphic types
-(define-syntax -poly
-  (syntax-rules ()
-    [(_ (vars ...) ty)
-     (let ([vars (-v vars)] ...)
-       (make-Poly (list 'vars ...) ty))]))
-
-(define-syntax -polydots
-  (syntax-rules ()
-    [(_ (vars ... dotted) ty)
-     (let ([dotted (-v dotted)]
-           [vars (-v vars)] ...)
-       (make-PolyDots (list 'vars ... 'dotted) ty))]))
-
-(define-syntax -polyrow
-  (syntax-rules ()
-    [(_ (var) consts ty)
-     (let ([var (-v var)])
-       (make-PolyRow (list 'var) ty consts))]))
+(define-syntax-rule (-poly (vars ...) ty)
+  (let ([vars (-v vars)] ...) (make-Poly (list 'vars ...) ty)))
+
+(define-syntax-rule (-polydots (vars ... dotted) ty)
+  (let ([dotted (-v dotted)]
+        [vars (-v vars)] ...)
+    (make-PolyDots (list 'vars ... 'dotted) ty)))
+
+(define-syntax-rule (-polyrow (var) consts ty)
+  (let ([var (-v var)]) (make-PolyRow (list 'var) ty consts)))
 
 ;; abbreviation for existential types
-(define-syntax -some
-  (syntax-rules ()
-    [(_ (vars ...) ty)
-     (let ([vars (-v vars)] ...)
-       (make-Some (list 'vars ...) ty))]))
+(define-syntax-rule (-some (vars ...) ty)
+  (let ([vars (-v vars)] ...) (make-Some (list 'vars ...) ty)))
 
 ;; abbreviation for existential type results
 (define-syntax -some-res

typed-racket-lib/typed-racket/types/generalize.rkt

@@ -1,10 +1,12 @@
 #lang racket/base
 
-(require "../utils/utils.rkt"
+(require racket/match
          "../rep/type-rep.rkt"
-         "abbrev.rkt" "subtype.rkt" "substitute.rkt"
+         "../utils/utils.rkt"
+         "abbrev.rkt"
          "numeric-tower.rkt"
-         racket/match)
+         "substitute.rkt"
+         "subtype.rkt")
 
 (provide generalize)
 
@@ -45,15 +47,15 @@
         [(Pair: t1 (== -Null)) (-lst t1)]
         [(MPair: t1 (== -Null)) (-mlst t1)]
         [(or (Pair: t1 t2) (MPair: t1 t2))
-         (let ([t-new (loop t2)])
-           (define -lst-type
-             ((match t*
-                [(Pair: _ _) -lst]
-                [(MPair: _ _) -mlst])
-              t1))
-           (if (type-equiv? -lst-type t-new)
-               -lst-type
-               (exit t)))]
+         (define t-new (loop t2))
+         (define -lst-type
+           ((match t*
+              [(Pair: _ _) -lst]
+              [(MPair: _ _) -mlst])
+            t1))
+         (if (type-equiv? -lst-type t-new)
+             -lst-type
+             (exit t))]
         [(ListDots: t bound) (-lst (substitute Univ bound t))]
         [(? (lambda (t) (subtype t -Symbol))) -Symbol]
         [(== -True) -Boolean]

typed-racket-lib/typed-racket/types/match-expanders.rkt

@@ -1,16 +1,17 @@
 #lang racket/base
 
-(require "../utils/utils.rkt"
-         "../rep/type-rep.rkt"
-         "../rep/values-rep.rkt"
-         "../rep/rep-utils.rkt"
+(require (for-syntax racket/base
+                     syntax/parse)
          racket/match
-         syntax/parse/define
          racket/set
          racket/unsafe/undefined
-         "resolve.rkt"
+         syntax/parse/define
+         "../rep/rep-utils.rkt"
+         "../rep/type-rep.rkt"
+         "../rep/values-rep.rkt"
+         "../utils/utils.rkt"
          "base-abbrev.rkt"
-         (for-syntax racket/base syntax/parse))
+         "resolve.rkt")
 
 (provide Listof: List: MListof: AnyPoly: AnyPoly-names:
          HashTableTop:
@@ -75,7 +76,7 @@
          (app (λ (t) (Listof? t #t)) (? Type? elem-pat)))])))
 
 
-(define-simple-macro (make-Listof-pred listof-pred?:id pair-matcher:id)
+(define-syntax-parse-rule (make-Listof-pred listof-pred?:id pair-matcher:id)
   (define (listof-pred? t [simple? #f])
     (match t
       [(Mu-unsafe:

typed-racket-lib/typed-racket/types/overlap.rkt

@@ -1,16 +1,16 @@
 #lang racket/base
 
-(require "../utils/utils.rkt"
-         "../utils/prefab.rkt"
-         "../rep/type-rep.rkt"
+(require racket/match
+         (prefix-in c: (contract-req))
          "../rep/rep-utils.rkt"
          "../rep/type-mask.rkt"
-         (prefix-in c: (contract-req))
+         "../rep/type-rep.rkt"
+         "../utils/prefab.rkt"
+         "../utils/utils.rkt"
          "abbrev.rkt"
+         "resolve.rkt"
          "subtype.rkt"
-         "resolve.rkt" 
-         "utils.rkt"
-         racket/match)
+         "utils.rkt")
 
 
 (provide overlap?)

typed-racket-lib/typed-racket/types/printer.rkt

@@ -132,7 +132,7 @@
 (define name-ref->sexp
   (match-lambda
     [(? syntax? name-ref) (syntax-e name-ref)]
-    [(cons lvl arg) `(,lvl ,arg)]))
+    [(cons lvl arg) (list lvl arg)]))
 
 ;; prop->sexp : Prop -> S-expression
 ;; Print a Prop (see prop-rep.rkt) to the given port
@@ -149,20 +149,19 @@
      ;; instead of (<= x y) (<= y x) when we have both inequalities
      (define-values (leqs others) (partition LeqProp? ps))
      (define-values (eqs simple-leqs)
-       (for/fold ([eqs '()] [simple-leqs '()])
+       (for/fold ([eqs '()]
+                  [simple-leqs '()])
                  ([leq (in-list leqs)])
-         (match leq
-           [(LeqProp: lhs rhs)
-            (define flip (-leq rhs lhs))
-            (cond
-              [(not (member flip leqs))
-               (values eqs (cons leq simple-leqs))]
-              [(member flip eqs) (values eqs simple-leqs)]
-              [else (values (cons leq eqs) simple-leqs)])])))
+         (match-define (LeqProp: lhs rhs) leq)
+         (define flip (-leq rhs lhs))
+         (cond
+           [(not (member flip leqs)) (values eqs (cons leq simple-leqs))]
+           [(member flip eqs) (values eqs simple-leqs)]
+           [else (values (cons leq eqs) simple-leqs)])))
      (let ([simple-leqs (map prop->sexp simple-leqs)]
            [eqs (for/list ([leq (in-list eqs)])
-                  (match leq
-                    [(LeqProp: lhs rhs) `(= ,(object->sexp lhs) ,(object->sexp rhs))]))]
+                  (match-define (LeqProp: lhs rhs) leq)
+                  `(= ,(object->sexp lhs) ,(object->sexp rhs)))]
            [others (map prop->sexp others)])
        (match (append eqs simple-leqs others)
          [(list sexp) sexp]
@@ -317,37 +316,36 @@
          valid-names))
   ;; some types in the union may not be coverable by the candidates
   ;; (e.g. type variables, etc.)
-  (define-values (uncoverable coverable)
-    (values (apply set-subtract elems (map cdr candidates))
-            (set-intersect elems (apply set-union null (map cdr candidates)))))
+  (define uncoverable (apply set-subtract elems (map cdr candidates)))
+  (define coverable (set-intersect elems (apply set-union null (map cdr candidates))))
   ;; set cover, greedy algorithm, ~lg n approximation
   (let loop ([to-cover   coverable]
              [candidates candidates]
              [coverage   '()])
-    (cond [(null? to-cover) ; done
-           (define coverage-names (map car coverage))
-           ;; to allow :type to cue the user on unexpanded aliases
-           ;; only union types can flow here, and any of those could be expanded
-           (set-box! (current-print-unexpanded)
-                     (append coverage-names (unbox (current-print-unexpanded))))
-           ;; reverse here to retain the old ordering from when srfi/1 was
-           ;; used to process the list sets
-           (values coverage-names (reverse uncoverable))] ; we want the names
-          [else
-           ;; pick the candidate that covers the most uncovered types
-           (define (covers-how-many? c)
-             (length (set-intersect (cdr c) to-cover)))
-           (define-values (next _)
-             (for/fold ([next      (car candidates)]
-                        [max-cover (covers-how-many? (car candidates))])
-                 ([c (in-list candidates)])
-               (let ([how-many? (covers-how-many? c)])
-                 (if (> how-many? max-cover)
-                     (values c how-many?)
-                     (values next max-cover)))))
-           (loop (set-subtract to-cover (cdr next))
-                 (remove next candidates)
-                 (cons next coverage))])))
+    (cond
+      [(null? to-cover) ; done
+       (define coverage-names (map car coverage))
+       ;; to allow :type to cue the user on unexpanded aliases
+       ;; only union types can flow here, and any of those could be expanded
+       (set-box! (current-print-unexpanded)
+                 (append coverage-names (unbox (current-print-unexpanded))))
+       ;; reverse here to retain the old ordering from when srfi/1 was
+       ;; used to process the list sets
+       (values coverage-names (reverse uncoverable))] ; we want the names
+      [else
+       ;; pick the candidate that covers the most uncovered types
+       (define (covers-how-many? c)
+         (length (set-intersect (cdr c) to-cover)))
+       (define next
+         (for/fold ([next (car candidates)]
+                    [max-cover (covers-how-many? (car candidates))]
+                    #:result next)
+                   ([c (in-list candidates)])
+           (let ([how-many? (covers-how-many? c)])
+             (if (> how-many? max-cover)
+                 (values c how-many?)
+                 (values next max-cover)))))
+       (loop (set-subtract to-cover (cdr next)) (remove next candidates) (cons next coverage))])))
 
 ;; arr->sexp : arr -> s-expression
 ;; Convert an arr (see type-rep.rkt) to its printable form
@@ -365,11 +363,10 @@
       ;; as long as the resulting s-expressions are `display`ed
       ;; this is fine, though it may not pretty-print well.
       (for/list ([kw (in-list kws)])
-        (match kw
-          [(Keyword: k t req?)
-           (if req?
-               (format "~a ~a" k (type->sexp t))
-               (format "[~a ~a]" k (type->sexp t)))]))
+        (match-define (Keyword: k t req?) kw)
+        (if req?
+            (format "~a ~a" k (type->sexp t))
+            (format "[~a ~a]" k (type->sexp t))))
       (match rst
         [(Rest: (list rst-t)) `(,(type->sexp rst-t) *)]
         [(Rest: rst-ts) `(#:rest-star ,(map type->sexp rst-ts))]
@@ -461,8 +458,9 @@
         (define-values (pre mid) (split-at lst to-drop))
         (define-values (sub post) (split-at mid n))
         (list pre sub post)))
-    (apply append (for/list ([i (range (length lst) 0 -1)])
-                    (sublist-n i lst))))
+    (for*/list ([i (range (length lst) 0 -1)]
+                [v (in-list (sublist-n i lst))])
+      v))
   (let loop ([left-to-cover arrs])
     ;; try to match the largest sublists possible that correspond to
     ;; ->* types and then the remainder are formatted normally
@@ -478,16 +476,15 @@
 ;; case-lambda->sexp : Type -> S-expression
 ;; Convert a case-> type to an s-expression
 (define (case-lambda->sexp type)
-  (match type
-    [(Fun: arrows)
-     (match arrows
-       [(list) '(case->)]
-       [(list a) (arr->sexp a)]
-       [(and arrs (list a b ...))
-        (define cover (cover-case-lambda arrs))
-        (if (> (length cover) 1)
-            `(case-> ,@cover)
-            (car cover))])]))
+  (match-define (Fun: arrows) type)
+  (match arrows
+    [(list) '(case->)]
+    [(list a) (arr->sexp a)]
+    [(and arrs (list a b ...))
+     (define cover (cover-case-lambda arrs))
+     (if (> (length cover) 1)
+         `(case-> ,@cover)
+         (car cover))]))
 
 ;; class->sexp : Class [#:object? Boolean] -> S-expression
 ;; Convert a class or object type to an s-expression
@@ -512,11 +509,11 @@
          (cons 'field
                (for/list ([name+type (in-list fields)])
                  (match-define (list name type) name+type)
-                 `(,name ,(type->sexp type)))))))
+                 (list name (type->sexp type)))))))
   (define methods*
     (for/list ([name+type (in-list methods)])
       (match-define (list name type) name+type)
-      `(,name ,(type->sexp type))))
+      (list name (type->sexp type))))
   (define augments*
     (cond [(or object? (null? augments)) '()]
           [else (list (cons 'augment augments))]))