Add named-let-loop-to-for/first-in-naturals rule (#621)

Author: jackfirth

default-recommendations/named-let-loopification-test.rkt

@@ -33,6 +33,36 @@ no-change-test: "named let loop over counter not refactorable when loop function
 ------------------------------------------------------------
 
 
+test: "named let loop can be refactored to for/first with in-naturals"
+------------------------------------------------------------
+(define (f c g)
+  (let loop ([i 0])
+    (cond
+      [(c i)
+       (loop (+ i 1))]
+      [else
+       (g i)])))
+============================================================
+(define (f c g)
+  (for/first ([i (in-naturals 0)]
+              #:unless (c i))
+    (g i)))
+------------------------------------------------------------
+
+
+no-change-test: "named let loop not refactorable to for/first with in-naturals when loop referenced"
+------------------------------------------------------------
+(define (f c g)
+  (let loop ([i 0])
+    (cond
+      [(c i)
+       (loop (+ i 1))]
+      [else
+       (displayln loop)
+       (g i)])))
+------------------------------------------------------------
+
+
 test: "named let loop with conditional return over vector can be replaced by for/first"
 ------------------------------------------------------------
 (define vec (vector 0 1 2 3 4 5))
@@ -68,8 +98,7 @@ test: "named let loop over list can be replaced by for/list"
      (displayln (car xs))
      (cons (* (car xs) 10)
            (loop (cdr xs)))]))
-------------------------------------------------------------
-------------------------------------------------------------
+============================================================
 (require racket/list)
 (let loop ([xs (list 1 2 3)])
   (cond
@@ -78,8 +107,7 @@ test: "named let loop over list can be replaced by for/list"
      (displayln (first xs))
      (cons (* (first xs) 10)
            (loop (rest xs)))]))
-------------------------------------------------------------
-------------------------------------------------------------
+============================================================
 (require racket/list)
 (for/list ([x (in-list (list 1 2 3))])
   (displayln x)
@@ -97,8 +125,7 @@ test: "named let loop can be replaced with for/and when equivalent"
       [(and (big? (first xs)) (not (red? (car xs))))
        (loop (rest xs))]
       [else #false])))
-------------------------------------------------------------
-------------------------------------------------------------
+============================================================
 (require racket/list)
 (define (f xs big? red?)
   (for/and ([x (in-list xs)])
@@ -115,8 +142,7 @@ test: "named let loop can be replaced with for/or when equivalent"
       [(empty? xs) #false]
       [(and (big? (first xs)) (not (red? (car xs)))) #true]
       [else (loop (rest xs))])))
-------------------------------------------------------------
-------------------------------------------------------------
+============================================================
 (require racket/list)
 (define (f xs big? red?)
   (for/or ([x (in-list xs)])
@@ -125,14 +151,14 @@ test: "named let loop can be replaced with for/or when equivalent"
 
 
 test: "read-until-eof loop refactorable to for loop with in-port"
---------------------
+------------------------------------------------------------
 (define (print-reads)
   (let loop ([v (read)])
     (unless (eof-object? v)
       (displayln v)
       (loop (read)))))
-====================
+============================================================
 (define (print-reads)
   (for ([v (in-port)])
     (displayln v)))
---------------------
+------------------------------------------------------------

default-recommendations/named-let-loopification.rkt

@@ -131,20 +131,42 @@
     modified-element-condition))
 
 
+(define-refactoring-rule named-let-loop-to-for/first-in-naturals
+  #:description
+  "This named `let` expression can be replaced by a simpler, equivalent `for/first` loop."
+  #:literals (let cond else + add1)
+
+  (let loop:id ([i:id start:expr])
+    (cond
+      [condition:expr
+       (loop2:id (~or (+ i2:id 1) (add1 i2:id)))]
+      [else
+       body:expr ...+]))
+  #:when (free-identifier=? (attribute loop) (attribute loop2))
+  #:when (free-identifier=? (attribute i) (attribute i2))
+  #:when (not (syntax-find-first #'(condition body ...)
+                id:id #:when (free-identifier=? (attribute id) (attribute loop))))
+
+  (for/first ([i (in-naturals start)]
+              #:unless condition)
+    body ...))
+
+
 (define-refactoring-rule named-let-loop-to-for/first-in-vector
-  #:description "This loop can be replaced by a simpler, equivalent `for/first` loop."
+  #:description
+  "This named `let` expression can be replaced by a simpler, equivalent `for/first` loop."
   #:literals (let add1 + vector-length vector-ref if and <)
   (let loop1:id ([i1:id 0])
     (and (< i2:id (vector-length vec1:id))
          (let ([x:id (vector-ref vec2:id i3:id)])
            (if condition:expr
                true-branch:expr
                (loop2:id (~or (add1 i4:id) (+ i4:id 1) (+ 1 i4:id)))))))
-  #:when (and (log-resyntax-rule-condition (free-identifier=? #'loop1 #'loop2))
-              (log-resyntax-rule-condition (free-identifier=? #'i1 #'i2))
-              (log-resyntax-rule-condition (free-identifier=? #'i1 #'i3))
-              (log-resyntax-rule-condition (free-identifier=? #'i1 #'i4))
-              (log-resyntax-rule-condition (free-identifier=? #'vec1 #'vec2)))
+  #:when (free-identifier=? #'loop1 #'loop2)
+  #:when (free-identifier=? #'i1 #'i2)
+  #:when (free-identifier=? #'i1 #'i3)
+  #:when (free-identifier=? #'i1 #'i4)
+  #:when (free-identifier=? #'vec1 #'vec2)
   (for/first ([x (in-vector vec1)] #:when condition)
     true-branch))
 
@@ -166,6 +188,7 @@
 (define-refactoring-suite named-let-loopification
   #:rules (named-let-loop-to-for-in-range
            named-let-loop-to-for/and
+           named-let-loop-to-for/first-in-naturals
            named-let-loop-to-for/first-in-vector
            named-let-loop-to-for/list
            named-let-loop-to-for/or