Index: for.ss
===================================================================
--- for.ss	(revision 15593)
+++ for.ss	(working copy)
@@ -23,7 +23,7 @@
              for/hasheq for*/hasheq
 
              for/fold/derived for*/fold/derived
-             
+
              (rename *in-range in-range)
              (rename *in-naturals in-naturals)
              (rename *in-list in-list)
@@ -722,14 +722,15 @@
     (syntax-case stx ()
       ;; Done case (no more clauses, and no generated clauses to emit):
       [(_ [orig-stx nested? emit? ()] ([fold-var fold-init] ...) ()
-          expr1 expr ...)
-       #`(let ([fold-var fold-init] ...) (let () expr1 expr ...))]
+          body1 body ...)
+       #`(let ([fold-var fold-init] ...) (let () body1 body ...))]
       ;; Switch-to-emit case (no more clauses to generate):
       [(_ [orig-stx nested? #f binds] ([fold-var fold-init] ...) () . body)
        #`(for/foldX/derived [orig-stx nested? #t binds]
                             ([fold-var fold-init] ...) () . body)]
       ;; Emit case:
-      [(_ [orig-stx nested? #t binds] ([fold-var fold-init] ...) rest expr1 . body)
+      [(_ [orig-stx nested? #t binds]
+          ([fold-var fold-init] ...) rest body1 . body)
        (with-syntax ([(([outer-binding ...]
                         outer-check
                         [loop-binding ...]
@@ -737,21 +738,29 @@
                         [inner-binding ...]
                         pre-guard
                         post-guard
-                        [loop-arg ...]) ...) (reverse (syntax->list #'binds))])
+                        [loop-arg ...]) ...)
+                      (reverse (syntax->list #'binds))]
+                     [(return body)
+                      (syntax-case #'(body1 . body) ()
+                        [(#:return expr . body) (list #'expr #'body)]
+                        [_ (list #'(values* fold-var ...) #'(body1 . body))])])
          #'(let-values (outer-binding ... ...)
              outer-check ...
              (let for-loop ([fold-var fold-init] ...
                             loop-binding ... ...)
                (if (and pos-guard ...)
-                   (let-values (inner-binding ... ...)
-                     (if (and pre-guard ...)
-                         (let-values ([(fold-var ...)
-                                       (for/foldX/derived [orig-stx nested? #f ()] ([fold-var fold-var] ...) rest expr1 . body)])
-                           (if (and post-guard ...)
-                               (for-loop fold-var ... loop-arg ... ...)
-                               (values* fold-var ...)))
-                         (values* fold-var ...)))
-                   (values* fold-var ...)))))]
+                 (let-values (inner-binding ... ...)
+                   (if (and pre-guard ...)
+                     (let-values ([(fold-var ...)
+                                   (for/foldX/derived
+                                    [orig-stx nested? #f ()]
+                                    ([fold-var fold-var] ...)
+                                    rest . body)])
+                       (if (and post-guard ...)
+                         (for-loop fold-var ... loop-arg ... ...)
+                         return))
+                     return))
+                 return))))]
       ;; Bad body cases:
       [(_ [orig-stx . _] fold-bind ())
        (raise-syntax-error
@@ -760,12 +769,17 @@
        (raise-syntax-error
         #f "bad syntax (illegal use of `.') after sequence bindings" #'orig-stx)]
       ;; Guard case, no pending emits:
-      [(_ [orig-stx nested? #f ()] ([fold-var fold-init] ...) (#:when expr . rest) . body)
-       #'(let ([fold-var fold-init] ...)
-           (if expr
-             (for/foldX/derived [orig-stx nested? #f ()]
-                                ([fold-var fold-var] ...) rest . body)
-             (values* fold-var ...)))]
+      [(_ [orig-stx nested? #f ()]
+          ([fold-var fold-init] ...) (#:when expr . rest) . body)
+       (with-syntax ([(return body)
+                      (syntax-case #'body ()
+                        [(#:return expr . body) (list #'expr #'body)]
+                        [_ (list #'(values* fold-var ...) #'body)])])
+         #'(let ([fold-var fold-init] ...)
+             (if expr
+               (for/foldX/derived [orig-stx nested? #f ()]
+                                  ([fold-var fold-var] ...) rest . body)
+               return)))]
       ;; Guard case, pending emits need to be flushed first
       [(frm [orig-stx nested? #f binds] ([fold-var fold-init] ...)
             (#:when expr . rest) . body)
@@ -777,7 +791,8 @@
        #'(for/foldX/derived [orig-stx nested? #f binds] fold-bind
                             ([(id) rhs] . rest) . body)]
       ;; If we get here in single-value mode, then it's a bad clause:
-      [(_ [orig-stx #f #f nested? #f binds] fold-bind (clause . rest) . body)
+      [(_ [orig-stx #f #f nested? #f binds] fold-bind
+          (clause . rest) . body)
        (raise-syntax-error
         #f "bad sequence binding clause" #'orig-stx #'clause)]
       ;; Expand one multi-value clause, and push it into the results to emit: