Fix rule to only fuse for* loops and single-clause for loops

- Renamed fuse-map-with-for-rule to fuse-map-with-for*-rule that matches only for* loops (any number of clauses)
- Updated fuse-map-with-for-single-clause-rule to match only single-clause for loops (not for*)
- Added test for single-clause for* loop fusion
- Added no-change test for multi-clause for loop (cannot be fused due to parallel iteration)

Co-authored-by: jackfirth <8175575+jackfirth@users.noreply.github.com>

Author: Copilot

default-recommendations/loops/fuse-map-with-for-test.rkt

@@ -24,6 +24,20 @@ test: "map producing list for for* loop can be fused"
 --------------------
 
 
+test: "map producing list for single-clause for* loop can be fused"
+--------------------
+(define (f xs g)
+  (define ys (map (λ (x) (g x)) xs))
+  (for* ([y (in-list ys)])
+    (displayln y)))
+====================
+(define (f xs g)
+  (for* ([x (in-list xs)]
+         [y (in-list (g x))])
+    (displayln y)))
+--------------------
+
+
 test: "map producing list for for loop can be fused"
 --------------------
 (define (f xs g)
@@ -38,6 +52,16 @@ test: "map producing list for for loop can be fused"
 --------------------
 
 
+no-change-test: "multi-clause for loop cannot be fused"
+--------------------
+(define (f xs zs)
+  (define ys (map (λ (x) (+ x 1)) xs))
+  (for ([y (in-list ys)]
+        [z (in-list zs)])
+    (displayln (list y z))))
+--------------------
+
+
 no-change-test: "map with short lambda but ys used elsewhere not refactorable"
 --------------------
 (define (f xs g h)

default-recommendations/loops/fuse-map-with-for.rkt

@@ -53,16 +53,16 @@
     #:attr single-body #'only-form))
 
 
-(define-definition-context-refactoring-rule fuse-map-with-for-rule
+(define-definition-context-refactoring-rule fuse-map-with-for*-rule
   #:description
-  "A `map` expression producing a list for a `for` loop can be fused with the loop."
+  "A `map` expression producing a list for a `for*` loop can be fused with the loop."
   #:analyzers (list identifier-usage-analyzer)
-  #:literals (define map in-list for for*)
+  #:literals (define map in-list for*)
   (~seq body-before ...
         (define ys:id (map function:fuseable-map-lambda list-expr:expr))
-        ((~or for-id:for for-id:for*)
+        (for*-id:for*
          (~and original-clauses
-               ([y-var:id (in-list ys-usage:id)] remaining-clause ...+))
+               ([y-var:id (in-list ys-usage:id)] remaining-clause ...))
          for-body ...)
         body-after ...)
 
@@ -72,22 +72,22 @@
 
   ;; Generate the refactored code - fuse as nested clauses
   (body-before ...
-   (for-id ([function.x (in-list list-expr)]
-            [y-var (in-list function.single-body)]
-            remaining-clause ...)
-           for-body ...)
+   (for*-id ([function.x (in-list list-expr)]
+             [y-var (in-list function.single-body)]
+             remaining-clause ...)
+            for-body ...)
    body-after ...))
 
 
-;; Rule for when there are no remaining clauses - use internal definition
+;; Rule for when there are single-clause for loops (not for*) - use internal definition
 (define-definition-context-refactoring-rule fuse-map-with-for-single-clause-rule
   #:description
-  "A `map` expression producing a list for a `for` loop can be fused with the loop."
+  "A `map` expression producing a list for a single-clause `for` loop can be fused with the loop."
   #:analyzers (list identifier-usage-analyzer)
-  #:literals (define map in-list for for*)
+  #:literals (define map in-list for)
   (~seq body-before ...
         (define ys:id (map function:fuseable-map-lambda list-expr:expr))
-        ((~or for-id:for for-id:for*)
+        (for-id:for
          (~and original-clauses
                ([y-var:id (in-list ys-usage:id)]))
          for-body ...)
@@ -107,5 +107,5 @@
 
 
 (define-refactoring-suite fuse-map-with-for
-  #:rules (fuse-map-with-for-rule
+  #:rules (fuse-map-with-for*-rule
            fuse-map-with-for-single-clause-rule))