From 766b5adfd16d8b793e3c2b17553eca2a6ade63e5 Mon Sep 17 00:00:00 2001
From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com>
Date: Sun, 20 Jul 2025 00:12:39 +0000
Subject: [PATCH 1/9] Fix 1 occurrence of `if-begin-to-cond`

Using `cond` instead of `if` here makes `begin` unnecessary
---
 drracket/browser/private/btree.rkt | 147 ++++++++++++++---------------
 1 file changed, 73 insertions(+), 74 deletions(-)

diff --git a/drracket/browser/private/btree.rkt b/drracket/browser/private/btree.rkt
index 564fd484a..e3843e8e8 100644
--- a/drracket/browser/private/btree.rkt
+++ b/drracket/browser/private/btree.rkt
@@ -67,80 +67,79 @@
 
 (define (insert before? n btree pos data)
   (define new (node pos data #f #f #f 'black))
-  (if (not (btree-root btree))
-      (set-btree-root! btree new)
-  
-      (begin
-  
-        (set-node-color! new 'red)
-  
-        ; Insert into tree
-        (if before?
-  
-            (if (not (node-left n))
-                (begin
-                  (set-node-left! n new)
-                  (set-node-parent! new n))
-  
-                (let loop ([node (node-left n)])
-                  (if (node-right node)
-                      (loop (node-right node))
-                      (begin
-                        (set-node-right! node new)
-                        (set-node-parent! new node)))))
-  
-            (if (not (node-right n))
-                (begin
-                  (set-node-right! n new)
-                  (set-node-parent! new n))
-  
-                (let loop ([node (node-right n)])
-                  (if (node-left node)
-                      (loop (node-left node))
-                      (begin
-                        (set-node-left! node new)
-                        (set-node-parent! new node))))))
-  
-        ; Make value in new node relative to right-hand parents
-        (let loop ([node new])
-          (let ([p (node-parent node)])
-            (when p
-              (when (eq? node (node-right p))
-                (adjust-offsets p new))
-              (loop p))))
-  
-        ; Balance tree
-        (let loop ([node new])
-          (let ([p (node-parent node)])
-            (when (and (not (eq? node (btree-root btree))) (eq? 'red (node-color p)))
-              (let* ([recolor-k (lambda (y)
-                                  (set-node-color! p 'black)
-                                  (set-node-color! y 'black)
-                                  (let ([pp (node-parent p)])
-                                    (set-node-color! pp 'red)
-                                    (loop pp)))]
-                     [rotate-k (lambda (rotate node)
-                                 (let ([p (node-parent node)])
-                                   (set-node-color! p 'black)
-                                   (let ([pp (node-parent p)])
-                                     (set-node-color! pp 'red)
-                                     (rotate pp btree)
-                                     (loop pp))))]
-                     [k (lambda (node-y long-rotate always-rotate)
-                          (let ([y (node-y (node-parent p))])
-                            (if (and y (eq? 'red (node-color y)))
-                                (recolor-k y)
-                                (let ([k (lambda (node) (rotate-k always-rotate node))])
-                                  (if (eq? node (node-y p))
-                                      (begin
-                                        (long-rotate p btree)
-                                        (k p))
-                                      (k node))))))])
-                (if (eq? p (node-left (node-parent p)))
-                    (k node-right rotate-left rotate-right)
-                    (k node-left rotate-right rotate-left))))))
-  
-        (set-node-color! (btree-root btree) 'black))))
+  (cond
+    [(not (btree-root btree)) (set-btree-root! btree new)]
+  
+    [else
+     (set-node-color! new 'red)
+  
+     ; Insert into tree
+     (if before?
+  
+         (if (not (node-left n))
+             (begin
+               (set-node-left! n new)
+               (set-node-parent! new n))
+  
+             (let loop ([node (node-left n)])
+               (if (node-right node)
+                   (loop (node-right node))
+                   (begin
+                     (set-node-right! node new)
+                     (set-node-parent! new node)))))
+  
+         (if (not (node-right n))
+             (begin
+               (set-node-right! n new)
+               (set-node-parent! new n))
+  
+             (let loop ([node (node-right n)])
+               (if (node-left node)
+                   (loop (node-left node))
+                   (begin
+                     (set-node-left! node new)
+                     (set-node-parent! new node))))))
+  
+     ; Make value in new node relative to right-hand parents
+     (let loop ([node new])
+       (let ([p (node-parent node)])
+         (when p
+           (when (eq? node (node-right p))
+             (adjust-offsets p new))
+           (loop p))))
+  
+     ; Balance tree
+     (let loop ([node new])
+       (let ([p (node-parent node)])
+         (when (and (not (eq? node (btree-root btree))) (eq? 'red (node-color p)))
+           (let* ([recolor-k (lambda (y)
+                               (set-node-color! p 'black)
+                               (set-node-color! y 'black)
+                               (let ([pp (node-parent p)])
+                                 (set-node-color! pp 'red)
+                                 (loop pp)))]
+                  [rotate-k (lambda (rotate node)
+                              (let ([p (node-parent node)])
+                                (set-node-color! p 'black)
+                                (let ([pp (node-parent p)])
+                                  (set-node-color! pp 'red)
+                                  (rotate pp btree)
+                                  (loop pp))))]
+                  [k (lambda (node-y long-rotate always-rotate)
+                       (let ([y (node-y (node-parent p))])
+                         (if (and y (eq? 'red (node-color y)))
+                             (recolor-k y)
+                             (let ([k (lambda (node) (rotate-k always-rotate node))])
+                               (if (eq? node (node-y p))
+                                   (begin
+                                     (long-rotate p btree)
+                                     (k p))
+                                   (k node))))))])
+             (if (eq? p (node-left (node-parent p)))
+                 (k node-right rotate-left rotate-right)
+                 (k node-left rotate-right rotate-left))))))
+  
+     (set-node-color! (btree-root btree) 'black)]))
 
 (define (find-following-node btree pos)
   (define root (btree-root btree))

From 24f81572474afe2667fd2b2c30920fe65a6b6184 Mon Sep 17 00:00:00 2001
From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com>
Date: Sun, 20 Jul 2025 00:12:39 +0000
Subject: [PATCH 2/9] Fix 1 occurrence of `if-let-to-cond`

`cond` with internal definitions is preferred over `if` with `let`, to reduce nesting
---
 drracket/browser/private/btree.rkt | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/drracket/browser/private/btree.rkt b/drracket/browser/private/btree.rkt
index e3843e8e8..e28ceaae6 100644
--- a/drracket/browser/private/btree.rkt
+++ b/drracket/browser/private/btree.rkt
@@ -147,13 +147,14 @@
              [so-far root]
              [so-far-pos (and root (node-pos root))]
              [v 0])
-    (if (not n)
-        (values so-far so-far-pos)
-        (let ([npos (+ (node-pos n) v)])
-          (cond
-            [(<= pos npos) (loop (node-left n) n npos v)]
-            [(or (not so-far-pos) (> npos so-far-pos)) (loop (node-right n) n npos npos)]
-            [else (loop (node-right n) so-far so-far-pos npos)])))))
+    (cond
+      [(not n) (values so-far so-far-pos)]
+      [else
+       (define npos (+ (node-pos n) v))
+       (cond
+         [(<= pos npos) (loop (node-left n) n npos v)]
+         [(or (not so-far-pos) (> npos so-far-pos)) (loop (node-right n) n npos npos)]
+         [else (loop (node-right n) so-far so-far-pos npos)])])))
 
 (define (create-btree)
   (btree #f))

From 533a60ad97da59a4e12d277dee5c06d20d6df4bf Mon Sep 17 00:00:00 2001
From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com>
Date: Sun, 20 Jul 2025 00:12:39 +0000
Subject: [PATCH 3/9] Fix 1 occurrence of
 `hash-ref-with-constant-lambda-to-hash-ref-without-lambda`

The lambda can be removed from the failure result in this `hash-ref` expression.
---
 drracket/browser/private/entity-names.rkt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drracket/browser/private/entity-names.rkt b/drracket/browser/private/entity-names.rkt
index 0095cff99..9809e7099 100644
--- a/drracket/browser/private/entity-names.rkt
+++ b/drracket/browser/private/entity-names.rkt
@@ -256,6 +256,6 @@
           (euro . 8364)))
 
 (define (entity-name->integer s)
-  (hash-ref table s (lambda () #f)))
+  (hash-ref table s #f))
 
 

From 926773f2b2bf276f4be2634d9a4e9f9c41dc80b3 Mon Sep 17 00:00:00 2001
From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com>
Date: Sun, 20 Jul 2025 00:12:39 +0000
Subject: [PATCH 4/9] Fix 11 occurrences of `let-to-define`

Internal definitions are recommended instead of `let` expressions, to reduce nesting.
---
 drracket/browser/private/bullet.rkt |  19 ++--
 drracket/browser/private/html.rkt   | 165 +++++++++++++---------------
 2 files changed, 85 insertions(+), 99 deletions(-)

diff --git a/drracket/browser/private/bullet.rkt b/drracket/browser/private/bullet.rkt
index 3ec528198..19db107e4 100644
--- a/drracket/browser/private/bullet.rkt
+++ b/drracket/browser/private/bullet.rkt
@@ -51,16 +51,15 @@
                           [(0) (values (lambda (x y w h) (send dc draw-ellipse x y w h)) #t)]
                           [(1) (values (lambda (x y w h) (send dc draw-ellipse x y w h)) #f)]
                           [else (values (lambda (x y w h) (send dc draw-rectangle x y w h)) #f)])])
-            (let ([b (send dc get-brush)])
-              (send dc set-brush
-                    (if solid?
-                        (send the-brush-list
-                              find-or-create-brush
-                              (send (send dc get-pen) get-color)
-                              'solid)
-                        transparent-brush))
-              (draw x y bsize bsize)
-              (send dc set-brush b)))))]
+            (define b (send dc get-brush))
+            (send dc set-brush
+                  (if solid?
+                      (send the-brush-list find-or-create-brush
+                            (send (send dc get-pen) get-color)
+                            'solid)
+                      transparent-brush))
+            (draw x y bsize bsize)
+            (send dc set-brush b))))]
     [define/override copy
       (lambda ()
         (make-object bullet-snip% depth))]
diff --git a/drracket/browser/private/html.rkt b/drracket/browser/private/html.rkt
index 3514dd669..d07c73c25 100644
--- a/drracket/browser/private/html.rkt
+++ b/drracket/browser/private/html.rkt
@@ -118,19 +118,17 @@
       (super on-event dc x y editor-x editor-y evt))
     
     (define/override (adjust-cursor dc x y editor-x editor-y evt)
-      (let ([snipx (- (send evt get-x) x)]
-            [snipy (- (send evt get-y) y)])
-        (if (find-rect snipx snipy)
-            finger-cursor
-            #f)))
+      (define snipx (- (send evt get-x) x))
+      (define snipy (- (send evt get-y) y))
+      (if (find-rect snipx snipy) finger-cursor #f))
 
     ;; warning: buggy. This doesn't actually copy the bitmap
     ;; over because there's no get-bitmap method for image-snip%
     ;; at the time of this writing.
     (define/override (copy)
-      (let ([cp (new image-map-snip% (html-text html-text))])
-        (send cp set-key key)
-        (send cp set-rects rects)))
+      (define cp (new image-map-snip% (html-text html-text)))
+      (send cp set-key key)
+      (send cp set-rects rects))
     
     (super-make-object)
     
@@ -143,9 +141,9 @@
 ;;
 
 (define (make-racket-color-delta col)
-  (let ([d (make-object style-delta%)])
-    (send d set-delta-foreground col)
-    d))
+  (define d (make-object style-delta%))
+  (send d set-delta-foreground col)
+  d)
 
 (define racket-code-delta (make-racket-color-delta "brown"))
 (define racket-code-delta/keyword
@@ -163,17 +161,17 @@
 (define current-style-class (make-parameter null))
 
 (define (lookup-class-delta class)
-  (let ([class-path (cons class (current-style-class))])
-    (cond
-     [(sub-path? class-path '("racket")) racket-code-delta]
-     [(sub-path? class-path '("keyword" "racket")) racket-code-delta/keyword]
-     [(sub-path? class-path '("variable" "racket")) racket-code-delta/variable]
-     [(sub-path? class-path '("global" "racket")) racket-code-delta/global]
-     [(or (sub-path? class-path '("selfeval" "racket"))
-          (sub-path? class-path '("racketresponse"))) racket-code-delta/selfeval]
-     [(sub-path? class-path '("comment" "racket")) racket-code-delta/comment]
-     [(sub-path? class-path '("navigation")) navigation-delta]
-     [else #f])))
+  (define class-path (cons class (current-style-class)))
+  (cond
+    [(sub-path? class-path '("racket")) racket-code-delta]
+    [(sub-path? class-path '("keyword" "racket")) racket-code-delta/keyword]
+    [(sub-path? class-path '("variable" "racket")) racket-code-delta/variable]
+    [(sub-path? class-path '("global" "racket")) racket-code-delta/global]
+    [(or (sub-path? class-path '("selfeval" "racket")) (sub-path? class-path '("racketresponse")))
+     racket-code-delta/selfeval]
+    [(sub-path? class-path '("comment" "racket")) racket-code-delta/comment]
+    [(sub-path? class-path '("navigation")) navigation-delta]
+    [else #f]))
 
 (define (sub-path? a b)
   (cond
@@ -241,34 +239,34 @@
 
 ;; cache-bitmap : string -> (is-a?/c bitmap%)
 (define (cache-bitmap url)
-  (let ([url-string (url->string url)])
-    (let loop ([n 0])
-      (cond
-       [(= n NUM-CACHED)
-        ;; Look for item to uncache
-        (vector-set! cached-use 0 (max 0 (sub1 (vector-ref cached-use 0))))
-        (let ([m (let loop ([n 1][m (vector-ref cached-use 0)])
-                   (if (= n NUM-CACHED)
-                       m
-                       (begin
-                         (vector-set! cached-use n (max 0 (sub1 (vector-ref cached-use n))))
-                         (loop (add1 n) (min m (vector-ref cached-use n))))))])
-          (let loop ([n 0])
-            (if (= (vector-ref cached-use n) m)
-                (let ([bitmap (get-bitmap-from-url url)])
-                  (cond
+  (define url-string (url->string url))
+  (let loop ([n 0])
+    (cond
+      [(= n NUM-CACHED)
+       ;; Look for item to uncache
+       (vector-set! cached-use 0 (max 0 (sub1 (vector-ref cached-use 0))))
+       (let ([m (let loop ([n 1]
+                           [m (vector-ref cached-use 0)])
+                  (if (= n NUM-CACHED)
+                      m
+                      (begin
+                        (vector-set! cached-use n (max 0 (sub1 (vector-ref cached-use n))))
+                        (loop (add1 n) (min m (vector-ref cached-use n))))))])
+         (let loop ([n 0])
+           (if (= (vector-ref cached-use n) m)
+               (let ([bitmap (get-bitmap-from-url url)])
+                 (cond
                    [bitmap
                     (vector-set! cached n bitmap)
                     (vector-set! cached-name n url-string)
                     (vector-set! cached-use n 5)
                     bitmap]
                    [else #f]))
-                (loop (add1 n)))))]
-       [(equal? url-string (vector-ref cached-name n))
-        (vector-set! cached-use n (min 10 (add1 (vector-ref cached-use n))))
-        (vector-ref cached n)]
-       [else
-        (loop (add1 n))]))))
+               (loop (add1 n)))))]
+      [(equal? url-string (vector-ref cached-name n))
+       (vector-set! cached-use n (min 10 (add1 (vector-ref cached-use n))))
+       (vector-ref cached n)]
+      [else (loop (add1 n))])))
 
 (define (update-image-maps image-map-snips image-maps)
   (for-each
@@ -305,28 +303,25 @@
 ;; matches the above, it is interprted propoerly;
 ;; otherwise silently nothing happens.
 (define (add-area image-map-snip sexp)
-  (let ([shape #f]
-        [coords #f]
-        [href #f])
-    (let loop ([sexp sexp])
-      (cond
-       [(pair? sexp)
-        (let ([fst (car sexp)])
-          (when (and (pair? fst)
-                     (symbol? (car fst))
-                     (pair? (cdr fst))
-                     (string? (cadr fst)))
-            (case (car fst)
-              [(shape) (set! shape (cadr fst))]
-              [(coords) (set! coords (cadr fst))]
-              [(href) (set! href (cadr fst))]
-              [else (void)]))
-          (loop (cdr sexp)))]
-       [else (void)]))
-    (when (and shape coords href)
-      (let ([p-coords (parse-coords coords)])
-        (when p-coords
-          (send image-map-snip add-area shape p-coords href))))))
+  (define shape #f)
+  (define coords #f)
+  (define href #f)
+  (let loop ([sexp sexp])
+    (cond
+      [(pair? sexp)
+       (let ([fst (car sexp)])
+         (when (and (pair? fst) (symbol? (car fst)) (pair? (cdr fst)) (string? (cadr fst)))
+           (case (car fst)
+             [(shape) (set! shape (cadr fst))]
+             [(coords) (set! coords (cadr fst))]
+             [(href) (set! href (cadr fst))]
+             [else (void)]))
+         (loop (cdr sexp)))]
+      [else (void)]))
+  (when (and shape coords href)
+    (let ([p-coords (parse-coords coords)])
+      (when p-coords
+        (send image-map-snip add-area shape p-coords href)))))
 
 ;; parse-coords : string -> (listof number)
 ;; separates out a bunch of comma separated numbers in a string
@@ -337,10 +332,9 @@
      [(regexp-match #rx"^[ \t\n]*([0-9]+)[ \t\n]*,(.*)$" str)
       =>
       (lambda (m)
-        (let ([num (cadr m)]
-              [rst (caddr m)])
-          (cons (string->number num)
-                (loop rst))))]
+        (define num (cadr m))
+        (define rst (caddr m))
+        (cons (string->number num) (loop rst)))]
      [(regexp-match #rx"^[ \t\n]*([0-9]+)[ \t\n]*" str)
       =>
       (lambda (m)
@@ -348,31 +342,24 @@
      [else null])))
 
 (define (make-get-field str)
-  (let ([s (apply
-            string-append
-            (map
-             (lambda (c)
-               (format "[~a~a]"
-                       (char-upcase c)
-                       (char-downcase c)))
-             (string->list str)))]
-        [spc (string #\space #\tab #\newline #\return #\vtab)])
-    (let ([re:plain (regexp (format "(^|[~a])~a[~a]*=[~a]*([^~a]*)" spc s spc spc spc))]
-          [re:quote (regexp (format "(^|[~a])~a[~a]*=[~a]*\"([^\"]*)\"" spc s spc spc))])
-      (lambda (args)
-        (let ([m (or (regexp-match re:quote args)
-                     (regexp-match re:plain args))])
-          (and m (caddr m)))))))
+  (define s
+    (apply string-append
+           (map (lambda (c) (format "[~a~a]" (char-upcase c) (char-downcase c))) (string->list str))))
+  (define spc (string #\space #\tab #\newline #\return #\vtab))
+  (define re:plain (regexp (format "(^|[~a])~a[~a]*=[~a]*([^~a]*)" spc s spc spc spc)))
+  (define re:quote (regexp (format "(^|[~a])~a[~a]*=[~a]*\"([^\"]*)\"" spc s spc spc)))
+  (lambda (args)
+    (let ([m (or (regexp-match re:quote args) (regexp-match re:plain args))]) (and m (caddr m)))))
 
 (define (get-field e name)
-  (let ([a (assq name (cadr e))])
-    (and a (cadr a))))
+  (define a (assq name (cadr e)))
+  (and a (cadr a)))
 
 (define get-racket-arg
   (let ([get-rkt (make-get-field "racket")])
     (lambda (str)
-      (let ([v (get-rkt str)])
-        (and v (filter-racket v))))))
+      (define v (get-rkt str))
+      (and v (filter-racket v)))))
 
 (define filter-racket 
   (lambda (v)

From d3f73f3ce7f54e865327b6f73205462caa371c15 Mon Sep 17 00:00:00 2001
From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com>
Date: Sun, 20 Jul 2025 00:12:39 +0000
Subject: [PATCH 5/9] Fix 2 occurrences of `define-lambda-to-define`

The `define` form supports a shorthand for defining functions.
---
 drracket/browser/private/html.rkt | 22 ++++++++++------------
 1 file changed, 10 insertions(+), 12 deletions(-)

diff --git a/drracket/browser/private/html.rkt b/drracket/browser/private/html.rkt
index d07c73c25..a67375fc5 100644
--- a/drracket/browser/private/html.rkt
+++ b/drracket/browser/private/html.rkt
@@ -191,15 +191,14 @@
 (define re:hexcolor 
   (regexp "^#([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])([0-9a-fA-F][0-9a-fA-F])$"))
 
-(define color-string->color
-  (lambda (str)
-    (let ([m (regexp-match re:hexcolor str)])
-      (if m
-          (make-object color%
-                       (string->number (cadr m) 16)
-                       (string->number (caddr m) 16)
-                       (string->number (cadddr m) 16))
-          (send the-color-database find-color str)))))
+(define (color-string->color str)
+  (let ([m (regexp-match re:hexcolor str)])
+    (if m
+        (make-object color%
+                     (string->number (cadr m) 16)
+                     (string->number (caddr m) 16)
+                     (string->number (cadddr m) 16))
+        (send the-color-database find-color str))))
 
 (define html-eval-ok (make-parameter #t))
 (define html-img-ok (make-parameter #t))
@@ -361,9 +360,8 @@
       (define v (get-rkt str))
       (and v (filter-racket v)))))
 
-(define filter-racket 
-  (lambda (v)
-    (regexp-replace* "[|]" v "\"")))
+(define (filter-racket v)
+  (regexp-replace* "[|]" v "\""))
 
 (define face-list #f)
 

From 622f4b2b2788a515c74d5cfb7e1ff6855e8508ce Mon Sep 17 00:00:00 2001
From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com>
Date: Sun, 20 Jul 2025 00:12:39 +0000
Subject: [PATCH 6/9] Fix 1 occurrence of `if-else-false-to-and`

This `if` expression can be refactored to an equivalent expression using `and`.
---
 drracket/browser/private/html.rkt | 53 +++++++++++++------------------
 1 file changed, 22 insertions(+), 31 deletions(-)

diff --git a/drracket/browser/private/html.rkt b/drracket/browser/private/html.rkt
index a67375fc5..21cbdbf01 100644
--- a/drracket/browser/private/html.rkt
+++ b/drracket/browser/private/html.rkt
@@ -204,37 +204,28 @@
 (define html-img-ok (make-parameter #t))
 
 (define (get-bitmap-from-url url)
-  (if (html-img-ok)
-      (let ([tmp-filename (make-temporary-file "rktguiimg~a")])
-        (load-status #t "image" url)
-        (call-with-output-file* tmp-filename
-                                (lambda (op)
-                                  (with-handlers ([exn:fail? 
-                                                   (lambda (x)
-                                                     (printf "exn.9 ~s\n" (and (exn? x)
-                                                                               (exn-message x)))
-                                                     (void))])
-                                    (call/input-url 
-                                     url
-                                     get-pure-port
-                                     (lambda (ip)
-                                       (copy-port ip op)))))
-                                #:exists 'truncate)
-        (pop-status)
-        (let ([bitmap (make-object bitmap% tmp-filename)])
-          (with-handlers ([exn:fail?
-                           (lambda (x)
-                             (message-box "Warning"
-                                          (format "Could not delete file ~s\n\n~a"
-                                                  tmp-filename
-                                                  (if (exn? x)
-                                                      (exn-message x)
-                                                      x))))])
-            (delete-file tmp-filename))
-          (if (send bitmap ok?)
-              bitmap
-              #f)))
-      #f))
+  (and (html-img-ok)
+       (let ([tmp-filename (make-temporary-file "rktguiimg~a")])
+         (load-status #t "image" url)
+         (call-with-output-file*
+          tmp-filename
+          (lambda (op)
+            (with-handlers ([exn:fail? (lambda (x)
+                                         (printf "exn.9 ~s\n" (and (exn? x) (exn-message x)))
+                                         (void))])
+              (call/input-url url get-pure-port (lambda (ip) (copy-port ip op)))))
+          #:exists 'truncate)
+         (pop-status)
+         (let ([bitmap (make-object bitmap% tmp-filename)])
+           (with-handlers ([exn:fail? (lambda (x)
+                                        (message-box "Warning"
+                                                     (format "Could not delete file ~s\n\n~a"
+                                                             tmp-filename
+                                                             (if (exn? x)
+                                                                 (exn-message x)
+                                                                 x))))])
+             (delete-file tmp-filename))
+           (if (send bitmap ok?) bitmap #f)))))
 
 ;; cache-bitmap : string -> (is-a?/c bitmap%)
 (define (cache-bitmap url)

From af91ded2222b246b1a88717a18ce8d16a79becee Mon Sep 17 00:00:00 2001
From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com>
Date: Sun, 20 Jul 2025 00:12:39 +0000
Subject: [PATCH 7/9] Fix 1 occurrence of `for-each-to-for`

This `for-each` operation can be replaced with a `for` loop.
---
 drracket/browser/private/html.rkt | 26 +++++++++++---------------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/drracket/browser/private/html.rkt b/drracket/browser/private/html.rkt
index 21cbdbf01..10947c4a4 100644
--- a/drracket/browser/private/html.rkt
+++ b/drracket/browser/private/html.rkt
@@ -259,21 +259,17 @@
       [else (loop (add1 n))])))
 
 (define (update-image-maps image-map-snips image-maps)
-  (for-each
-   (lambda (image-map-snip)
-     (let ([image-map-key (send image-map-snip get-key)])
-       (let loop ([image-maps image-maps])
-         (cond
-          [(null? image-maps) (void)]
-          [else
-           (let* ([image-map (car image-maps)]
-                  [name (get-field image-map 'name)])
-             (if (and name 
-                      (equal? (format "#~a" name)
-                              (send image-map-snip get-key)))
-                 (find/add-areas image-map-snip image-map)
-                 (loop (cdr image-maps))))]))))
-   image-map-snips))
+  (for ([image-map-snip (in-list image-map-snips)])
+    (send image-map-snip get-key)
+    (let loop ([image-maps image-maps])
+      (cond
+        [(null? image-maps) (void)]
+        [else
+         (let* ([image-map (car image-maps)]
+                [name (get-field image-map 'name)])
+           (if (and name (equal? (format "#~a" name) (send image-map-snip get-key)))
+               (find/add-areas image-map-snip image-map)
+               (loop (cdr image-maps))))]))))
 
 (define (find/add-areas image-map-snip image-map)
   (let loop ([sexp image-map])

From 9cba69df380f5fb3e555b7b5bab92edfdfddc94b Mon Sep 17 00:00:00 2001
From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com>
Date: Sun, 20 Jul 2025 00:12:39 +0000
Subject: [PATCH 8/9] Fix 1 occurrence of `send-chain-to-send+`

This method chain made of nested `send` expressions can be written more clearly as a `send+` expression.
---
 drracket/browser/private/bullet.rkt | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/drracket/browser/private/bullet.rkt b/drracket/browser/private/bullet.rkt
index 19db107e4..65b587544 100644
--- a/drracket/browser/private/bullet.rkt
+++ b/drracket/browser/private/bullet.rkt
@@ -11,8 +11,7 @@
 
 (define bullet-size 
   (make-parameter
-   (let ([s (send (send (send (make-object text%) get-style-list) basic-style)
-                  get-size)])
+   (let ([s (send+ (make-object text%) (get-style-list) (basic-style) (get-size))])
      (max 7 (quotient s 2)))))
 
 (define (get-bullet-width)

From 4bc7f98743cd6907991547a8a8c4c763c457d3b5 Mon Sep 17 00:00:00 2001
From: "resyntax-ci[bot]" <181813515+resyntax-ci[bot]@users.noreply.github.com>
Date: Sun, 20 Jul 2025 00:12:39 +0000
Subject: [PATCH 9/9] Fix 1 occurrence of `nested-if-to-cond`

This `if`-`else` chain can be converted to a `cond` expression.
---
 drracket/browser/private/bullet.rkt | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/drracket/browser/private/bullet.rkt b/drracket/browser/private/bullet.rkt
index 65b587544..554bdaa9d 100644
--- a/drracket/browser/private/bullet.rkt
+++ b/drracket/browser/private/bullet.rkt
@@ -67,11 +67,10 @@
         (send stream put depth))]
     [define/override get-text
       (lambda (offset num flattened?)
-        (if (< num 1)
-            ""
-            (if flattened?
-                "* "
-                "*")))]
+        (cond
+          [(< num 1) ""]
+          [flattened? "* "]
+          [else "*"]))]
     (super-new)
     (set-snipclass bullet-snip-class)
     (set-count 1)))