Automated Resyntax fixes

This is an automated change generated by Resyntax.

#### Pass 1

Applied 2 fixes to [`scribble-test/tests/scribble/eval.rkt`](../blob/HEAD/scribble-test/tests/scribble/eval.rkt)

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

Applied 2 fixes to [`scribble-test/tests/scribble/html.rkt`](../blob/HEAD/scribble-test/tests/scribble/html.rkt)

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

Applied 1 fix to [`scribble-test/tests/scribble/decode.rkt`](../blob/HEAD/scribble-test/tests/scribble/decode.rkt)

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

Applied 1 fix to [`scribble-test/tests/scribble/exe.rkt`](../blob/HEAD/scribble-test/tests/scribble/exe.rkt)

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

Applied 3 fixes to [`scribble-test/tests/scribble/reader.rkt`](../blob/HEAD/scribble-test/tests/scribble/reader.rkt)

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

Applied 1 fix to [`scribble-test/tests/scribble/render.rkt`](../blob/HEAD/scribble-test/tests/scribble/render.rkt)

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

Applied 3 fixes to [`scribble-test/tests/scribble/docs.rkt`](../blob/HEAD/scribble-test/tests/scribble/docs.rkt)

  * Line 5, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 20, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.
  * Line 68, `when-expression-in-for-loop-to-when-keyword`: Use the `#:when` keyword instead of `when` to reduce loop body indentation.

Applied 2 fixes to [`scribble-test/tests/scribble/text-lang.rkt`](../blob/HEAD/scribble-test/tests/scribble/text-lang.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 61, `when-expression-in-for-loop-to-when-keyword`: Use the `#:when` keyword instead of `when` to reduce loop body indentation.

Applied 1 fix to [`scribble-test/tests/scribble/text-collect.rkt`](../blob/HEAD/scribble-test/tests/scribble/text-collect.rkt)

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

Applied 1 fix to [`scribble-test/tests/scribble/xref.rkt`](../blob/HEAD/scribble-test/tests/scribble/xref.rkt)

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

## Summary

Fixed 17 issues in 10 files.

  * Fixed 10 occurrences of `tidy-require`
  * Fixed 4 occurrences of `let-to-define`
  * Fixed 2 occurrences of `when-expression-in-for-loop-to-when-keyword`
  * Fixed 1 occurrence of `single-clause-match-to-match-define`

Author: resyntax-ci[bot]

scribble-test/tests/scribble/decode.rkt

@@ -1,8 +1,8 @@
 #lang racket/base
-(require scribble/decode
-         scribble/core
+(require racket/contract/base
          rackunit
-         racket/contract/base)
+         scribble/core
+         scribble/decode)
 
 (check-true (pre-content? "x"))
 (check-true (pre-content? null))

scribble-test/tests/scribble/docs.rkt

@@ -2,31 +2,32 @@
 
 ;; Use text renderer to check some Scribble functionality
 
-(require scribble/base-render
+(require racket/class
+         racket/file
+         racket/runtime-path
+         scribble/base-render
+         tests/eli-tester
          (prefix-in text: scribble/text-render)
          (prefix-in html: scribble/html-render)
          (prefix-in latex: scribble/latex-render)
-         (prefix-in markdown: scribble/markdown-render)
-         racket/file 
-         racket/class
-         racket/runtime-path
-         tests/eli-tester)
+         (prefix-in markdown: scribble/markdown-render))
 
 (define-runtime-path source-dir "docs")
 (define work-dir (build-path (find-system-path 'temp-dir)
                              "scribble-docs-tests"))
 
 (define (build-doc render% src-file dest-file)
-  (let* ([renderer (new render% [dest-dir work-dir])]
-         [docs     (list (if (module-declared? `(submod ,src-file doc) #t)
-                             (dynamic-require `(submod ,src-file doc) 'doc)
-                             (dynamic-require src-file 'doc)))]
-         [fns      (list (build-path work-dir dest-file))]
-         [fp       (send renderer traverse docs fns)]
-         [info     (send renderer collect  docs fns fp)]
-         [r-info   (send renderer resolve  docs fns info)])
-    (send renderer render docs fns r-info)
-    (send renderer get-undefined r-info)))
+  (define renderer (new render% [dest-dir work-dir]))
+  (define docs
+    (list (if (module-declared? `(submod ,src-file doc) #t)
+              (dynamic-require `(submod ,src-file doc) 'doc)
+              (dynamic-require src-file 'doc))))
+  (define fns (list (build-path work-dir dest-file)))
+  (define fp (send renderer traverse docs fns))
+  (define info (send renderer collect docs fns fp))
+  (define r-info (send renderer resolve docs fns info))
+  (send renderer render docs fns r-info)
+  (send renderer get-undefined r-info))
 
 (define (build-text-doc src-file dest-file)
   (build-doc (text:render-mixin render%) src-file dest-file))
@@ -65,11 +66,9 @@
           (define (contents file)
             (regexp-replace #rx"\n+$" (file->string file) ""))
           (define undefineds (build-text-doc src-file "gen.txt"))
-          (for ([u (in-list undefineds)])
-            (when (eq? 'tech (car u))
-              (test #:failure-message
-                    (format "undefined tech: ~e" u)
-                    #f)))
+          (for ([u (in-list undefineds)]
+                #:when (eq? 'tech (car u)))
+            (test #:failure-message (format "undefined tech: ~e" u) #f))
           (test #:failure-message
                 (format
                  "mismatch for: \"~a\", expected text in: \"~a\", got:\n~a"

scribble-test/tests/scribble/eval.rkt

@@ -1,5 +1,8 @@
 #lang racket/base
-(require scribble/eval scribble/core rackunit racket/match)
+(require racket/match
+         rackunit
+         scribble/core
+         scribble/eval)
 
 (check-not-exn (λ () (make-base-eval)))
 (check-not-exn (λ () (make-base-eval #:pretty-print? #t #:lang 'racket/base)))
@@ -24,7 +27,8 @@
 (check-not-exn (λ () ((make-eval-factory '() #:pretty-print? #t #:lang 'lazy))))
 
 (define (get-result-blocks nf)
-  (match (nested-flow-blocks nf) [(list (table _ (list _ res))) res]))
+  (match-define (list (table _ (list _ res))) (nested-flow-blocks nf))
+  res)
 
 (define filter-datum '(define (filter p? lst) 
                         (if (null? lst) 

scribble-test/tests/scribble/exe.rkt

@@ -1,6 +1,6 @@
 #lang racket/base
-(require racket/file
-         compiler/embed
+(require compiler/embed
+         racket/file
          racket/system)
 
 ;; Check that `scribble/manual` can be embedded in an executable

scribble-test/tests/scribble/html.rkt

@@ -5,17 +5,18 @@
 ;;  match a master list of HTML tags (defined in this file)
 ;; Also check that `scribble/html/html` is disjoint from `racket/base`
 
-(require rackunit racket/set)
+(require racket/set
+         rackunit)
 
 (define (phase0-provides m) ; Symbol -> [Setof Symbol]
   (parameterize ([current-namespace (make-base-namespace)])
     (dynamic-require m #f)
-    (let-values ([(e1* e2*) (module->exports m)])
-      (for*/seteq ([export* (in-list (list e1* e2*))]
-                   [tag+exp (in-list export*)]
-                   #:when (or (not (car tag+exp)) (zero? (car tag+exp)))
-                   [exp (in-list (cdr tag+exp))])
-        (car exp)))))
+    (define-values (e1* e2*) (module->exports m))
+    (for*/seteq ([export* (in-list (list e1* e2*))]
+                 [tag+exp (in-list export*)]
+                 #:when (or (not (car tag+exp)) (zero? (car tag+exp)))
+                 [exp (in-list (cdr tag+exp))])
+      (car exp))))
 
 (define (expected-disjoint m1 m2)
   (format "'~a' and '~a' should provide disjoint sets of identifiers" m1 m2))

scribble-test/tests/scribble/reader.rkt

@@ -1,6 +1,8 @@
 #lang racket/base
 
-(require tests/eli-tester (prefix-in scr: scribble/reader) racket/list)
+(require racket/list
+         tests/eli-tester
+         (prefix-in scr: scribble/reader))
 
 (define the-tests #<<END-OF-TESTS
 
@@ -825,8 +827,10 @@ END-OF-TESTS
   (if whole?
     (reader i)
     (let loop ()
-      (let ([x (reader i)])
-        (if (eof-object? x) '() (cons x (loop)))))))
+      (define x (reader i))
+      (if (eof-object? x)
+          '()
+          (cons x (loop))))))
 
 (define read/BS (scr:make-at-reader #:command-char #\\ #:syntax? #f))
 (define read-syntax/BS (scr:make-at-reader #:command-char #\\ #:syntax? #t))
@@ -940,19 +944,17 @@ END-OF-TESTS
            [ts (regexp-split #px"(?m:^)-+(?:$|\r?\n)" ts)])
       (parameterize ([port-count-lines-enabled #t])
         (for ([t ts] #:unless (regexp-match? #px"^\\s*$" t))
-          (let ([m (or (regexp-match #px"^(.*)\n\\s*(-\\S+->)\\s*\n(.*)$"
-                                     t)
-                       (regexp-match #px"^(.*\\S)\\s+(-\\S+->)\\s+(\\S.*)$"
-                                     t))])
-            (if (not (and m (= 4 (length m))))
+          (define m
+            (or (regexp-match #px"^(.*)\n\\s*(-\\S+->)\\s*\n(.*)$" t)
+                (regexp-match #px"^(.*\\S)\\s+(-\\S+->)\\s+(\\S.*)$" t)))
+          (if (not (and m (= 4 (length m))))
               (error 'bad-test "~a" t)
-              (let-values ([(x y)
-                            ((string->tester (caddr m)) (cadr m) (cadddr m))])
-                (test #:failure-message
-                      (format "bad result in\n    ~a\n  results:\n    ~s != ~s"
-                              (regexp-replace* #rx"\n" t "\n    ")
-                              x y)
-                      (matching? x y))))))))
+              (let-values ([(x y) ((string->tester (caddr m)) (cadr m) (cadddr m))])
+                (test #:failure-message (format "bad result in\n    ~a\n  results:\n    ~s != ~s"
+                                                (regexp-replace* #rx"\n" t "\n    ")
+                                                x
+                                                y)
+                      (matching? x y)))))))
 
     ;; Check static versus dynamic readtable for command (dynamic when "c" in the
     ;; name) and datum (dynamic when "d" in the name) parts:

scribble-test/tests/scribble/render.rkt

@@ -1,8 +1,8 @@
 #lang racket/base
-(require scribble/render
-         scribble/text-render
+(require racket/file
          scribble/core
-         racket/file
+         scribble/render
+         scribble/text-render
          tests/eli-tester)
 
 (provide render-tests)

scribble-test/tests/scribble/text-collect.rkt

@@ -1,6 +1,7 @@
 #lang racket/base
 
-(require tests/eli-tester scribble/text/syntax-utils)
+(require scribble/text/syntax-utils
+         tests/eli-tester)
 
 (provide begin/collect-tests)
 (module+ main (begin/collect-tests))

scribble-test/tests/scribble/text-lang.rkt

@@ -1,6 +1,9 @@
 #lang racket/base
 
-(require tests/eli-tester racket/runtime-path racket/port racket/sandbox
+(require racket/port
+         racket/runtime-path
+         racket/sandbox
+         tests/eli-tester
          (prefix-in doc: (lib "scribblings/scribble/text.scrbl")))
 
 (provide text-lang-tests)
@@ -58,8 +61,9 @@
       (t (if len-to-read (read-string len-to-read i) (port->string i))
          => expected)
       (t (begin (kill-thread thd) (cond [exn => raise] [else #t])))
-      (for ([m more])
-        (when (file-exists? (car m)) (delete-file (car m))))))
+      (for ([m more]
+            #:when (file-exists? (car m)))
+        (delete-file (car m)))))
   (call-with-trusted-sandbox-configuration
     (lambda ()
       (for ([t (in-list (doc:tests))])

scribble-test/tests/scribble/xref.rkt

@@ -1,6 +1,6 @@
 #lang racket/base
-(require scribble/xref
-         racket/fasl
+(require racket/fasl
+         scribble/xref
          setup/dirs
          tests/eli-tester)