Automated Resyntax fixes (#1443)

* Fix 13 occurrences of `single-clause-match-to-match-define`

This `match` expression can be simplified using `match-define`.

* Fix 1 occurrence of `define-lambda-to-define`

The `define` form supports a shorthand for defining functions.

* Fix 8 occurrences of `let-to-define`

Internal definitions are recommended instead of `let` expressions, to reduce nesting.

* Fix 6 occurrences of `define-syntax-syntax-rules-to-define-syntax-rule`

This `define-syntax` macro can be replaced with a simpler, equivalent `define-syntax-rule` macro.

* Fix 4 occurrences of `if-else-false-to-and`

This `if` expression can be refactored to an equivalent expression using `and`.

* Fix 1 occurrence of `inverted-when`

This negated `when` expression can be replaced by an `unless` expression.

* Fix 2 occurrences of `zero-comparison-to-positive?`

This expression is equivalent to calling the `positive?` predicate.

* Fix 1 occurrence of `define-simple-macro-to-define-syntax-parse-rule`

The `define-simple-macro` form has been renamed to `define-syntax-parse-rule`.

* Fix 1 occurrence of `provide-deduplication`

Providing the same identifier multiple times is unnecessary.

* Fix 1 occurrence of `if-let-to-cond`

`cond` with internal definitions is preferred over `if` with `let`, to reduce nesting

* Fix 1 occurrence of `apply-flattening`

The `apply` function accepts single arguments in addition to a trailing list argument.

* Fix 2 occurrences of `define-values-values-to-define`

This use of `define-values` is unnecessary.

* Fix 3 occurrences of `sort-with-keyed-comparator-to-sort-by-key`

This `sort` expression can be replaced with a simpler, equivalent expression.

* Fix 1 occurrence of `map-to-for`

This `map` operation can be replaced with a `for/list` loop.

* Fix 3 occurrences of `quasiquote-to-list`

This quasiquotation is equialent to a simple `list` call.

* Fix 1 occurrence of `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.

* Fix 1 occurrence of `when-expression-in-for-loop-to-when-keyword`

Use the `#:when` keyword instead of `when` to reduce loop body indentation.

---------

Co-authored-by: resyntax-ci[bot] <181813515+resyntax-ci[bot]@users.noreply.github.com>

Author: resyntax-ci[bot]

typed-racket-lib/typed-racket/base-env/annotate-classes.rkt

@@ -169,7 +169,7 @@
            #:with ty #'t))
 (define-splicing-syntax-class optional-standalone-annotation
   (pattern (~optional a:standalone-annotation)
-           #:attr ty (if (attribute a) #'a.ty #f)))
+           #:attr ty (and (attribute a) #'a.ty)))
 
 (define-syntax-class type-variables
   #:attributes ((vars 1))
@@ -330,10 +330,8 @@
                  (define-values (all-mand-tys all-opt-tys)
                    (cond
                      [kw-property
-                      (define-values (mand-kw-set opt-kw-set)
-                        (values
-                         (list->set (lambda-kws-mand kw-property))
-                         (list->set (lambda-kws-opt kw-property))))
+                      (define mand-kw-set (list->set (lambda-kws-mand kw-property)))
+                      (define opt-kw-set (list->set (lambda-kws-opt kw-property)))
 
                       (define-values (mand-tys^ opt-kw^)
                         (partition (part-pred opt-kw-set)

typed-racket-lib/typed-racket/base-env/base-structs.rkt

@@ -11,7 +11,11 @@
 
 (require (for-template racket/base (prefix-in k: '#%kernel)))
 
-(provide initialize-structs -Date -Srcloc -Date -Arity-At-Least -Exn)
+(provide initialize-structs
+         -Date
+         -Srcloc
+         -Arity-At-Least
+         -Exn)
 
 (define-syntax define-hierarchy
   (syntax-rules (define-hierarchy)

typed-racket-lib/typed-racket/base-env/unit-prims.rkt

@@ -133,12 +133,8 @@
 ;; in the signature, this is needed to typecheck define-values/invoke-unit forms
 (define-for-syntax (imports/members sig-id)
   (define-values (_1 imp-mem _2 _3) (signature-members sig-id sig-id))
-  #`(#,sig-id #,@(map (lambda (id)
-                        (local-expand
-                         id
-                         (syntax-local-context)
-                         (kernel-form-identifier-list)))
-                      imp-mem)))
+  #`(#,sig-id #,@(for/list ([id (in-list imp-mem)])
+                   (local-expand id (syntax-local-context) (kernel-form-identifier-list)))))
 
 ;; Given a list of signature specs
 ;; Processes each signature spec to determine the variables exported

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")
 

typed-racket-lib/typed-racket/static-contracts/combinators/unit.rkt

@@ -16,10 +16,9 @@
         #: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)

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/classes.rkt

@@ -88,9 +88,9 @@
   (match-define (Row: inits fields methods augments _) row)
   ;; check a given clause type (e.g., init, field)
   (define (check-clauses row-dict absence-set)
-    (for ([(name _) (in-dict row-dict)])
-      (when (member name absence-set)
-        (fail name))))
+    (for ([(name _) (in-dict row-dict)]
+          #:when (member name absence-set))
+      (fail name)))
   (check-clauses inits init-absents)
   (check-clauses fields field-absents)
   (check-clauses methods method-absents)

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

@@ -45,15 +45,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/kw-types.rkt

@@ -31,8 +31,7 @@
   ;; the kw protocol puts the arguments in keyword-sorted order in the
   ;; function header, so we need to sort the types to match
   (define sorted-kws
-    (sort keywords (λ (kw1 kw2) (keyword<? (Keyword-kw kw1)
-                                           (Keyword-kw kw2)))))
+    (sort keywords keyword<? #:key Keyword-kw))
 
   (define pos-opt-arg-types
     (append (for/list ([t (in-list optional-arg-types)]
@@ -148,9 +147,7 @@
 (define (calculate-mandatory-args orig-arrows)
   ;; sorted order is important, our loops below rely on this order
   (define arity-sorted-arrows
-    (sort orig-arrows
-          (λ (a1 a2) (>= (Arrow-max-arity a1)
-                         (Arrow-max-arity a2)))))
+    (sort orig-arrows >= #:key Arrow-max-arity))
   (for/fold ([mand-arg-table '()])
             ([arrow (in-list arity-sorted-arrows)])
     (cond
@@ -172,36 +169,38 @@
     ;; set and set->list to retain determinism
     (remove-duplicates
      (for/list ([(arrow arrow-mand-arg-count) (in-assoc mand-arg-table)])
-       (match arrow
-         [(Arrow: dom rst kws rng rng-T+)
-          (define kws* (if actual-kws
-                           (handle-extra-or-missing-kws kws actual-kws)
-                           kws))
-          (define kw-opts-supplied (if actual-kws
-                                       (lambda-kws-opt-supplied actual-kws)
-                                       '()))
-          (define mand-arg-count (if actual-kws
-                                     (lambda-kws-pos-mand-count actual-kws)
-                                     arrow-mand-arg-count))
-          (define opt-arg-count (- (length dom) mand-arg-count))
-          (define extra-opt-arg-count
-            ;; In case `dom` has too many arguments that we try to treat
-            ;; as optional:
-            (if actual-kws
-                (max 0 (- opt-arg-count (length (lambda-kws-pos-opt-supplied? actual-kws))))
-                0))
-          (convert kws*
-                   kw-opts-supplied
-                   (take dom mand-arg-count)
-                   (drop dom mand-arg-count)
-                   (if actual-kws
-                       (append (lambda-kws-pos-opt-supplied? actual-kws)
-                               (make-list extra-opt-arg-count #f))
-                       (make-list opt-arg-count #f))
-                   rng
-                   rst
-                   split?
-                   rng-T+)]))))
+       (match-define (Arrow: dom rst kws rng rng-T+) arrow)
+       (define kws*
+         (if actual-kws
+             (handle-extra-or-missing-kws kws actual-kws)
+             kws))
+       (define kw-opts-supplied
+         (if actual-kws
+             (lambda-kws-opt-supplied actual-kws)
+             '()))
+       (define mand-arg-count
+         (if actual-kws
+             (lambda-kws-pos-mand-count actual-kws)
+             arrow-mand-arg-count))
+       (define opt-arg-count (- (length dom) mand-arg-count))
+       (define extra-opt-arg-count
+         ;; In case `dom` has too many arguments that we try to treat
+         ;; as optional:
+         (if actual-kws
+             (max 0 (- opt-arg-count (length (lambda-kws-pos-opt-supplied? actual-kws))))
+             0))
+       (convert kws*
+                kw-opts-supplied
+                (take dom mand-arg-count)
+                (drop dom mand-arg-count)
+                (if actual-kws
+                    (append (lambda-kws-pos-opt-supplied? actual-kws)
+                            (make-list extra-opt-arg-count #f))
+                    (make-list opt-arg-count #f))
+                rng
+                rst
+                split?
+                rng-T+))))
   (apply cl->* fns))
 
 ;; kw-convert : Type (Option LambdaKeywords) [Boolean] -> Type
@@ -269,7 +268,7 @@
                                  (take opt-types to-take))
                          (erase-props/Values rng)
                          #:kws actual-kws
-                         #:rest (if (= to-take opt-types-count) rest-type #f)
+                         #:rest (and (= to-take opt-types-count) rest-type)
                          #:T+ rng-T+)))]
              [else (int-err "unsupported arrs in keyword function type")])]
       [(Poly-names: names f) (make-Poly names (loop f))]

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

@@ -75,7 +75,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: