Automated Resyntax fixes

resyntax-ci[bot] · mflatt · commit 58a0267e4537 · 2024-11-20T16:25:03.000-07:00
This is an automated change generated by Resyntax.

#### Pass 1

Applied 9 fixes to [`scribble-text-lib/scribble/text/output.rkt`](../blob/HEAD/scribble-text-lib/scribble/text/output.rkt)

  * Line 2, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 50, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.
  * Line 76, `if-begin-to-cond`: Using `cond` instead of `if` here makes `begin` unnecessary
  * Line 89, `if-let-to-cond`: `cond` with internal definitions is preferred over `if` with `let`, to reduce nesting
  * Line 123, `if-begin-to-cond`: Using `cond` instead of `if` here makes `begin` unnecessary
  * Line 148, `if-begin-to-cond`: Using `cond` instead of `if` here makes `begin` unnecessary
  * Line 153, `if-begin-to-cond`: Using `cond` instead of `if` here makes `begin` unnecessary
  * Line 246, `if-let-to-cond`: `cond` with internal definitions is preferred over `if` with `let`, to reduce nesting
  * Line 295, `if-let-to-cond`: `cond` with internal definitions is preferred over `if` with `let`, to reduce nesting

Applied 4 fixes to [`scribble-text-lib/scribble/text/syntax-utils.rkt`](../blob/HEAD/scribble-text-lib/scribble/text/syntax-utils.rkt)

  * Line 3, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.
  * Line 123, `if-let-to-cond`: `cond` with internal definitions is preferred over `if` with `let`, to reduce nesting
  * Line 161, `always-throwing-if-to-when`: Using `when` and `unless` is simpler than a conditional with an always-throwing branch.
  * Line 185, `tidy-require`: Keep imports in `require` sorted and grouped by phase, with collections before files.

Applied 1 fix to [`scribble-text-lib/scribble/text/lang.rkt`](../blob/HEAD/scribble-text-lib/scribble/text/lang.rkt)

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

Applied 1 fix to [`scribble-text-lib/scribble/text/main.rkt`](../blob/HEAD/scribble-text-lib/scribble/text/main.rkt)

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

Applied 5 fixes to [`scribble-lib/scriblib/private/counter.rkt`](../blob/HEAD/scribble-lib/scriblib/private/counter.rkt)

  * Line 20, `quasiquote-to-list`: This quasiquotation is equialent to a simple `list` call.
  * Line 39, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.
  * Line 55, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.
  * Line 74, `map-to-for`: This `map` operation can be replaced with a `for/list` loop.
  * Line 87, `let-to-define`: Internal definitions are recommended instead of `let` expressions, to reduce nesting.

## Summary

Fixed 20 issues in 5 files.

  * Fixed 5 occurrences of `tidy-require`
  * Fixed 4 occurrences of `if-let-to-cond`
  * Fixed 4 occurrences of `let-to-define`
  * Fixed 4 occurrences of `if-begin-to-cond`
  * Fixed 1 occurrence of `quasiquote-to-list`
  * Fixed 1 occurrence of `always-throwing-if-to-when`
  * Fixed 1 occurrence of `map-to-for`
diff --git a/scribble-lib/scriblib/private/counter.rkt b/scribble-lib/scriblib/private/counter.rkt
@@ -17,7 +17,7 @@
 
 (define (tag->counter-tag counter tag . kind)
   (if (generated-tag? tag)
-      `(,(string->symbol (format "counter-~a" kind)) ,tag)
+      (list (string->symbol (format "counter-~a" kind)) tag)
       `(counter (,(counter-name counter) ,tag ,@kind))))
 
 (define (counter-target counter tag label
@@ -36,27 +36,28 @@
          (list
           (make-delayed-element
            (lambda (renderer part ri)
-             (let ([n (resolve-get part ri (tag->counter-tag counter tag "value"))])
-               (cons
-                (make-element label-style
-                              (let ([l (cons (make-element (default-figure-counter-style) (format "~a" n))
-                                             (decode-content (list label-suffix)))])
-                                (if label
-                                    (list* label 'nbsp l)
-                                    l)))
-                content)))
+             (define n (resolve-get part ri (tag->counter-tag counter tag "value")))
+             (cons (make-element label-style
+                                 (let ([l (cons (make-element (default-figure-counter-style)
+                                                              (format "~a" n))
+                                                (decode-content (list label-suffix)))])
+                                   (if label
+                                       (list* label 'nbsp l)
+                                       l)))
+                   content))
            (lambda () (if label
                           (list* label 'nbsp "N" content)
                           (cons "N" content)))
            (lambda () (if label
                           (list* label 'nbsp "N" content)
                           (cons "N" content)))))
          (lambda (ci)
-           (let ([n (if continue?
-                        (counter-n counter)
-                        (add1 (counter-n counter)))])
-             (set-counter-n! counter n)
-             (collect-put! ci (generate-tag (tag->counter-tag counter tag "value") ci) n)))))
+           (define n
+             (if continue?
+                 (counter-n counter)
+                 (add1 (counter-n counter))))
+           (set-counter-n! counter n)
+           (collect-put! ci (generate-tag (tag->counter-tag counter tag "value") ci) n))))
        (tag->counter-tag counter tag)))
     (if (counter-target-wrap counter)
         ((counter-target-wrap counter)
@@ -71,45 +72,36 @@
 (define (t-encode s)
   (apply
    string-append
-   (map (lambda (c)
-          (cond
-            [(and (or (char-alphabetic? c) (char-numeric? c))
-                  ((char->integer c) . < . 128))
-             (string c)]
-            [(char=? c #\space) "_"]
-            [else (format "x~x" (char->integer c))]))
-        (string->list (format "~s" s)))))
+   (for/list ([c (in-string (format "~s" s))])
+     (cond
+       [(and (or (char-alphabetic? c) (char-numeric? c)) ((char->integer c) . < . 128)) (string c)]
+       [(char=? c #\space) "_"]
+       [else (format "x~x" (char->integer c))]))))
 
 (define (counter-ref counter tag label
                      #:link-render-style [link-style #f])
   (make-delayed-element
    (lambda (renderer part ri)
-     (let ([n (resolve-get part ri (tag->counter-tag counter tag "value"))])
-       (let ([n (if (counter-ref-wrap counter)
-                    ((counter-ref-wrap counter)
-                     (format "~a" n)
-                     ;; Don't use this argument:
-                     (format "t:~a" (t-encode (list 'counter (list (counter-name counter) tag)))))
-                    (list (format "~a" n)))]
-             [link-number-only? (eq? (link-render-style-mode
-                                      (or link-style
-                                          (current-link-render-style)))
-                                     'number)])
-         (cond
-           [(and label link-number-only?)
-            (make-element #f
-                          (list label 'nbsp
-                                (make-link-element
-                                 #f
-                                 (list n)
-                                 (tag->counter-tag counter tag))))]
-           [else
-            (make-link-element
-             #f
-             (if label
-                 (list label 'nbsp n)
-                 n)
-             (tag->counter-tag counter tag))]))))
+     (define n (resolve-get part ri (tag->counter-tag counter tag "value")))
+     (let ([n (if (counter-ref-wrap counter)
+                  ((counter-ref-wrap counter)
+                   (format "~a" n)
+                   ;; Don't use this argument:
+                   (format "t:~a" (t-encode (list 'counter (list (counter-name counter) tag)))))
+                  (list (format "~a" n)))]
+           [link-number-only?
+            (eq? (link-render-style-mode (or link-style (current-link-render-style))) 'number)])
+       (cond
+         [(and label link-number-only?)
+          (make-element
+           #f
+           (list label 'nbsp (make-link-element #f (list n) (tag->counter-tag counter tag))))]
+         [else
+          (make-link-element #f
+                             (if label
+                                 (list label 'nbsp n)
+                                 n)
+                             (tag->counter-tag counter tag))])))
    (lambda () (if label
                   (list label 'nbsp "N")
                   (list "N")))
diff --git a/scribble-text-lib/scribble/text/lang.rkt b/scribble-text-lib/scribble/text/lang.rkt
@@ -1,7 +1,10 @@
 #lang racket/base
 
-(require "syntax-utils.rkt" "output.rkt"
-         racket/promise racket/list racket/string)
+(require racket/list
+         racket/promise
+         racket/string
+         "output.rkt"
+         "syntax-utils.rkt")
 
 (provide (except-out (all-from-out racket/base) #%module-begin)
          (all-from-out "output.rkt" racket/promise racket/list racket/string)
diff --git a/scribble-text-lib/scribble/text/main.rkt b/scribble-text-lib/scribble/text/main.rkt
@@ -1,7 +1,10 @@
 #lang racket/base
 
-(require "output.rkt" "syntax-utils.rkt"
-         racket/promise racket/list racket/string)
+(require racket/list
+         racket/promise
+         racket/string
+         "output.rkt"
+         "syntax-utils.rkt")
 
 (provide (all-from-out "output.rkt" racket/promise racket/list racket/string)
          begin/text include/text)
diff --git a/scribble-text-lib/scribble/text/output.rkt b/scribble-text-lib/scribble/text/output.rkt
@@ -1,6 +1,6 @@
 #lang racket/base
-(require racket/promise
-         racket/contract/base)
+(require racket/contract/base
+         racket/promise)
 
 (provide
  special?
@@ -47,7 +47,8 @@
   ;; the low-level string output function (can change with `with-writer')
   (define write write-string)
   ;; to get the output column
-  (define (getcol) (let-values ([(line col pos) (port-next-location p)]) col))
+  (define (getcol) (define-values (line col pos) (port-next-location p))
+                   col)
   ;; total size of the two prefixes
   (define (2pfx-length pfx1 pfx2)
     (if (and pfx1 pfx2)
@@ -73,56 +74,85 @@
     (define-syntax-rule (show pfx) ; optimize when not needed
       (unless (eq? pfx 0) (write (->str pfx) p)))
     (when (and pfx1 pfx2)
-      (if (eq? 0 col)
-        (begin (show pfx1) (show pfx2))
-        (let ([len1 (if (number? pfx1) pfx1 (string-length pfx1))])
-          (cond [(< col len1) (write (->str pfx1) p col) (show pfx2)]
-                [(= col len1) (show pfx2)]
-                [(eq? 0 pfx2)]
-                [else
-                 (let ([col (- col len1)]
-                       [len2 (if (number? pfx2) pfx2 (string-length pfx2))])
-                   (when (< col len2) (write (->str pfx2) p col)))])))))
+      (cond
+        [(eq? 0 col)
+         (show pfx1)
+         (show pfx2)]
+        [else
+         (define len1
+           (if (number? pfx1)
+               pfx1
+               (string-length pfx1)))
+         (cond
+           [(< col len1)
+            (write (->str pfx1) p col)
+            (show pfx2)]
+           [(= col len1) (show pfx2)]
+           [(eq? 0 pfx2)]
+           [else
+            (let ([col (- col len1)]
+                  [len2 (if (number? pfx2)
+                            pfx2
+                            (string-length pfx2))])
+              (when (< col len2)
+                (write (->str pfx2) p col)))])])))
   ;; the basic printing unit: strings
   (define (output-string x)
     (define pfx (mcar pfxs))
-    (if (not pfx) ; prefix disabled?
-      (write x p)
-      (let ([len (string-length x)]
-            [nls (regexp-match-positions* #rx"\n" x)])
-        (let loop ([start 0] [nls nls] [lpfx (mcdr pfxs)] [col (getcol)])
-          (cond [(pair? nls)
-                 (define nl (car nls))
-                 (if (regexp-match? #rx"^ *$" x start (car nl))
-                   (newline p) ; only spaces before the end of the line
-                   (begin (output-pfx col pfx lpfx)
-                          (write x p start (cdr nl))))
-                 (loop (cdr nl) (cdr nls) 0 0)]
-                ;; last substring from here (always set lpfx state when done)
-                [(start . = . len)
-                 (set-mcdr! pfxs lpfx)]
-                [(col . > . (2pfx-length pfx lpfx))
-                 (set-mcdr! pfxs lpfx)
-                 ;; the prefix was already shown, no accumulation needed
-                 (write x p start)]
-                [else
-                 (define m (regexp-match-positions #rx"^ +" x start))
-                 ;; accumulate spaces to lpfx, display if it's not all spaces
-                 (define lpfx* (if m (pfx+ lpfx (- (cdar m) (caar m))) lpfx))
-                 (set-mcdr! pfxs lpfx*)
-                 (unless (and m (= len (cdar m)))
-                   (output-pfx col pfx lpfx*)
-                   ;; the spaces were already added to lpfx
-                   (write x p (if m (cdar m) start)))])))))
+    (cond
+      ; prefix disabled?
+      [(not pfx) (write x p)]
+      [else
+       (define len (string-length x))
+       (define nls (regexp-match-positions* #rx"\n" x))
+       (let loop ([start 0]
+                  [nls nls]
+                  [lpfx (mcdr pfxs)]
+                  [col (getcol)])
+         (cond
+           [(pair? nls)
+            (define nl (car nls))
+            (if (regexp-match? #rx"^ *$" x start (car nl))
+                (newline p) ; only spaces before the end of the line
+                (begin
+                  (output-pfx col pfx lpfx)
+                  (write x p start (cdr nl))))
+            (loop (cdr nl) (cdr nls) 0 0)]
+           ;; last substring from here (always set lpfx state when done)
+           [(start . = . len) (set-mcdr! pfxs lpfx)]
+           [(col . > . (2pfx-length pfx lpfx))
+            (set-mcdr! pfxs lpfx)
+            ;; the prefix was already shown, no accumulation needed
+            (write x p start)]
+           [else
+            (define m (regexp-match-positions #rx"^ +" x start))
+            ;; accumulate spaces to lpfx, display if it's not all spaces
+            (define lpfx*
+              (if m
+                  (pfx+ lpfx (- (cdar m) (caar m)))
+                  lpfx))
+            (set-mcdr! pfxs lpfx*)
+            (unless (and m (= len (cdar m)))
+              (output-pfx col pfx lpfx*)
+              ;; the spaces were already added to lpfx
+              (write x
+                     p
+                     (if m
+                         (cdar m)
+                         start)))]))]))
   ;; blocks and splices
   (define (output-block c)
     (define pfx  (mcar pfxs))
     (define lpfx (mcdr pfxs))
     (define npfx (pfx+col (pfx+ pfx lpfx)))
     (set-mcar! pfxs npfx) (set-mcdr! pfxs 0)
-    (if (list? c)
-      (for ([c (in-list c)]) (loop c))
-      (begin (loop (car c)) (loop (cdr c))))
+    (cond
+      [(list? c)
+       (for ([c (in-list c)])
+         (loop c))]
+      [else
+       (loop (car c))
+       (loop (cdr c))])
     (set-mcar! pfxs pfx) (set-mcdr! pfxs lpfx))
   (define (output-splice c)
     (for-each loop c))
@@ -145,16 +175,18 @@
        (define c (special-contents x))
        (case (special-flag x)
          ;; preserve tailness & avoid `set!' for blocks/splices if possible
-         [(block) (if list=block?
-                    (output-block c)
-                    (begin (set! list=block? #t)
-                           (output-block c)
-                           (set! list=block? #f)))]
-         [(splice) (if list=block?
-                     (begin (set! list=block? #f)
-                            (output-splice c)
-                            (set! list=block? #t))
-                     (output-splice c))]
+         [(block) (cond
+                    [list=block? (output-block c)]
+                    [else
+                     (set! list=block? #t)
+                     (output-block c)
+                     (set! list=block? #f)])]
+         [(splice) (cond
+                     [list=block?
+                      (set! list=block? #f)
+                      (output-splice c)
+                      (set! list=block? #t)]
+                     [else (output-splice c)])]
          [(flush) ; useful before `disable-prefix'
           (output-pfx (getcol) (mcar pfxs) (mcdr pfxs))]
          [(disable-prefix) ; save the previous pfxs
@@ -243,11 +275,16 @@
   (let ([t (make-weak-hasheq)]
         [last '(#f #f)]) ; cache for the last port, to avoid a hash lookup
     (λ (p)
-      (if (eq? p (car last)) (cdr last)
-          (let ([s (or (hash-ref t p #f)
-                       (let ([s (mcons 0 0)]) (hash-set! t p s) s))])
-            (set! last (cons p s))
-            s)))))
+      (cond
+        [(eq? p (car last)) (cdr last)]
+        [else
+         (define s
+           (or (hash-ref t p #f)
+               (let ([s (mcons 0 0)])
+                 (hash-set! t p s)
+                 s)))
+         (set! last (cons p s))
+         s]))))
 
 ;; special constructs
 
@@ -292,12 +329,13 @@
 (define (add-newlines list #:sep [sep "\n"])
   (define r
     (let loop ([list list])
-      (if (null? list)
-        null
-        (let ([1st (car list)])
-          (if (or (not 1st) (void? 1st))
-            (loop (cdr list))
-            (list* sep 1st (loop (cdr list))))))))
+      (cond
+        [(null? list) null]
+        [else
+         (define 1st (car list))
+         (if (or (not 1st) (void? 1st))
+             (loop (cdr list))
+             (list* sep 1st (loop (cdr list))))])))
   (if (null? r) r (cdr r)))
 
 (provide split-lines)
diff --git a/scribble-text-lib/scribble/text/syntax-utils.rkt b/scribble-text-lib/scribble/text/syntax-utils.rkt
