From 976ff84532729983a30a0ec26b148cf5e92a294f Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Mon, 14 Aug 2017 22:05:25 +0200
Subject: [PATCH 01/15] Parse + emit code for for/else and break-with-value

This commit enables a combination of two language features that dovetail
nicely together (as remarked by @StefanKarpinski in [1]): for/else and
break-with-value, which together allow something like:

    name = for person in people
        if person.id == id
            break person.name
        end
    else
        generate_name()
    end

The parsing patch is pretty straightforward. As for the code lowering
part, I opted to make a second version of `'break-block`, called
`'break-block-with-value`, which passes a target variable for the return
value onto the `break-labels` stack. That's where the `'break` operation
finds it.

An alternative approach would be something more similar to the existing
`replace-return` function: Instead of having an intermediate node
representing `'break-block-with-value`,we could traverse the expression
tree and replace `break-with-value` by an assignment followed by a
break.

I have no opinion either way; the current commit seemed like the obvious
implementation to me, but that was before I saw `replace-return`'s prior
art.

This patch still has a few places marked `TODO`, where scoping issues
for the `else` block need to be resolved. I'll tackle that after
awaiting feedback.

[1] https://github.com/JuliaLang/julia/issues/22891
---
 src/jlfrontend.scm   |  4 +++-
 src/julia-parser.scm | 31 ++++++++++++++++++------
 src/julia-syntax.scm | 57 +++++++++++++++++++++++++++++++++++---------
 3 files changed, 73 insertions(+), 19 deletions(-)

diff --git a/src/jlfrontend.scm b/src/jlfrontend.scm
index a556310a881d0..94f9aa96ee3cb 100644
--- a/src/jlfrontend.scm
+++ b/src/jlfrontend.scm
@@ -43,7 +43,9 @@
                                       tab)))
                 ((lambda)       tab)
                 ((local)        tab)
-                ((break-block)  (find-possible-globals- (caddr e) tab))
+                ((break-block)             (find-possible-globals- (caddr e) tab))
+                ;; TODO: elsebody in (cadddr e)
+                ((break-block-with-value)  (find-possible-globals- (caddr e) tab))
                 ((module toplevel) '())
                 (else
                  (for-each (lambda (x) (find-possible-globals- x tab))
diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index b7ca3a19577c6..a7d05548fdc57 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -1286,11 +1286,22 @@
                          (expect-end s word)))
        ((for)
         (let* ((ranges (parse-comma-separated-iters s))
-               (body   (parse-block s)))
-          (expect-end s word)
-          `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
-                ,body)))
-
+               (body   (parse-block s))
+               (nxt    (take-token s)))
+          (case nxt
+            ((end)
+              `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
+                    ,body))
+            ((else)
+              (let* ((elsebody (parse-block s)))
+                (expect-end s word)
+                `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
+                      ,body
+                      ,elsebody)))
+            (otherwise
+              (error (string "\"" word "\" at "
+                             current-filename ":" input-port-line
+                             " expected \"end\", got \"" nxt "\""))))))
        ((if elseif)
         (if (newline? (peek-token s))
             (error (string "missing condition in \"if\" at " current-filename
@@ -1481,14 +1492,20 @@
                             (if (or (eqv? t #\newline) (closing-token? t))
                                 (list 'return '(null))
                                 (list 'return (parse-eq s)))))
-       ((break continue)
+       ((continue)
         (let ((t (peek-token s)))
           (if (or (eof-object? t)
                   (and (eq? t 'end) (not end-symbol))
                   (memv t '(#\newline #\; #\) :)))
               (list word)
               (error (string "unexpected \"" t "\" after " word)))))
-
+       ((break)
+        (let ((t (peek-token s)))
+          (if (or (eof-object? t)
+                  (and (eq? t 'end) (not end-symbol))
+                  (memv t '(#\newline #\; #\) :)))
+              (list word '(null))
+              (list word (parse-eq s)))))
        ((module baremodule)
         (let* ((name (parse-unary-prefix s))
                (loc  (line-number-node s))
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 172478f3550fc..075e5f8a68fa6 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -1669,7 +1669,7 @@
                             (if ,g ,g
                                 ,(loop (cdr tail)))))))))))
 
-(define (expand-for while lhs X body)
+(define (expand-for while lhs X elsebody body)
   ;; (for (= lhs X) body)
   (let ((coll  (make-ssavalue))
         (state (gensy)))
@@ -1685,7 +1685,8 @@
                    #;,@(map (lambda (v) `(local ,v)) (lhs-vars lhs))
                    ,(lower-tuple-assignment (list lhs state)
                                             `(call (top next) ,coll ,state))
-                   ,body))))))))
+                   ,body))
+                 ,elsebody))))))
 
 ;; convert an operator parsed as (op a b) to (call op a b)
 (define (syntactic-op-to-call e)
@@ -2224,10 +2225,13 @@
    'while
    (lambda (e)
      `(scope-block
-       (break-block loop-exit
+       (break-block-with-value loop-exit
                     (_while ,(expand-forms (cadr e))
                             (break-block loop-cont
-                                         ,(expand-forms (caddr e)))))))
+                                         ,(expand-forms (caddr e))))
+                    ,(if (length> e 3)
+                       (expand-forms (cadddr e))
+                       '(null)))))
 
    'inner-while
    (lambda (e)
@@ -2238,9 +2242,9 @@
 
    'break
    (lambda (e)
-     (if (pair? (cdr e))
+     (if (symbol? (cadr e))
          e
-         '(break loop-exit)))
+         `(break loop-exit ,(cadr e))))
 
    'continue (lambda (e) '(break loop-cont))
 
@@ -2253,6 +2257,9 @@
        (expand-for (if first 'while 'inner-while)
                    (cadr (car ranges))
                    (caddr (car ranges))
+                   (if (and (length> e 3) first)
+                     (cadddr e) ;; elsebody
+                     '(null))
                    (if (null? (cdr ranges))
                        (caddr e)  ;; body
                        (nest (cdr ranges) #f)))))
@@ -2524,6 +2531,8 @@
         ((or (not (pair? e)) (quoted? e)) tab)
         ((memq (car e) '(lambda scope-block module toplevel)) tab)
         ((eq? (car e) 'break-block) (unbound-vars (caddr e) bound tab))
+        ((eq? (car e) 'break-block-with-value) (unbound-vars (caddr e) bound tab))
+        ;; TODO: elsebody in (cadddr e)
         ((eq? (car e) 'with-static-parameters) (unbound-vars (cadr e) bound tab))
         (else (for-each (lambda (x) (unbound-vars x bound tab))
                             (cdr e))
@@ -2620,8 +2629,12 @@
         ((eq? (car e) 'module)
          (error "module expression not at top level"))
         ((eq? (car e) 'break-block)
-         `(break-block ,(cadr e) ;; ignore type symbol of break-block expression
+         `(,(car e) ,(cadr e) ;; ignore type symbol of break-block expression
                        ,(resolve-scopes- (caddr e) env outerglobals implicitglobals lam renames #f))) ;; body of break-block expression
+        ((eq? (car e) 'break-block-with-value)
+         `(,(car e) ,(cadr e) ;; ignore type symbol of break-block expression
+                       ,(resolve-scopes- (caddr e) env outerglobals implicitglobals lam renames #f) ;; body of break-block expression
+                       ,(resolve-scopes- (cadddr e) env outerglobals implicitglobals lam renames #f))) ;; elsebody of break-block-with-value expression
         ((eq? (car e) 'with-static-parameters)
          `(with-static-parameters ;; ignore list of sparams in break-block expression
             ,(resolve-scopes- (cadr e) env outerglobals implicitglobals lam renames #f)
@@ -2646,6 +2659,8 @@
         ((symbol? e) (put! tab e #t))
         ((and (pair? e) (eq? (car e) 'outerref)) (put! tab (cadr e) #t))
         ((and (pair? e) (eq? (car e) 'break-block)) (free-vars- (caddr e) tab))
+        ;; TODO: elsebody in (cadddr e)
+        ((and (pair? e) (eq? (car e) 'break-block-with-value)) (free-vars- (caddr e) tab))
         ((and (pair? e) (eq? (car e) 'with-static-parameters)) (free-vars- (cadr e) tab))
         ((or (atom? e) (quoted? e)) tab)
         ((eq? (car e) 'lambda)
@@ -3553,14 +3568,34 @@ f(x) = yt(x)
                                 value #f)
                        (mark-label endl)))
              (if value (compile '(null) break-labels value tail)))
+            ((break-block-with-value)
+             (let ((endl (make-label))
+                   (valvar (if (or value tail) (new-mutable-var) #f)))
+               (compile (caddr e)
+                        (cons (list (cadr e) endl handler-level valvar)
+                              break-labels)
+                        value #f)
+               (if (length> e 3)
+                 (let ((elseval (compile (cadddr e) break-labels valvar #f)))
+                   (if valvar (emit `(= ,valvar ,elseval))))
+                 (let ((elseval (compile '(null) break-labels valvar #f)))
+                   (if (and valvar elseval) (emit `(= ,valvar ,elseval)))))
+               (mark-label endl)
+               (if tail (emit-return valvar) valvar)))
             ((break)
              (let ((labl (assq (cadr e) break-labels)))
                (if (not labl)
                    (error "break or continue outside loop")
-                   (begin
-                     (if (> handler-level (caddr labl))
-                         (emit `(leave ,(- handler-level (caddr labl)))))
-                     (emit `(goto ,(cadr labl)))))))
+                   (let ((endl (cadr labl))
+                         (hlevel (caddr labl))
+                         (valtarget (if (length> labl 3) (cadddr labl) #f))
+                         (valexpr (if (length> e 2) (caddr e) '(null))))
+                     (let ((res (compile valexpr break-labels valtarget #f)))
+                       (if valtarget
+                         (emit `(= ,valtarget ,res))))
+                     (if (> handler-level hlevel)
+                         (emit `(leave ,(- handler-level hlevel))))
+                     (emit `(goto ,endl))))))
             ((label symboliclabel)
              (if (eq? (car e) 'symboliclabel)
                  (if (has? label-level (cadr e))

From d8b2553ce82f3ace5da79ca2683b4e42126c1616 Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Mon, 14 Aug 2017 22:07:33 +0200
Subject: [PATCH 02/15] Implement findnext() in terms of for/else and
 break-with-value

Because a new language feature should probably be used in
the standard library, to encourage cargo-culting.
---
 base/array.jl | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index 300512537ad8d..dcd3e5ded1fb4 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -1251,10 +1251,11 @@ julia> findnext(A,3)
 function findnext(A, start::Integer)
     for i = start:length(A)
         if A[i] != 0
-            return i
+            break i
         end
+    else
+        0
     end
-    return 0
 end
 
 """
@@ -1301,10 +1302,11 @@ julia> findnext(A,4,3)
 function findnext(A, v, start::Integer)
     for i = start:length(A)
         if A[i] == v
-            return i
+            break i
         end
+    else
+        0
     end
-    return 0
 end
 """
     findfirst(A, v)
@@ -1350,10 +1352,11 @@ julia> findnext(isodd, A, 2)
 function findnext(testf::Function, A, start::Integer)
     for i = start:length(A)
         if testf(A[i])
-            return i
+            break i
         end
+    else
+        0
     end
-    return 0
 end
 
 """
@@ -1399,9 +1402,10 @@ julia> findprev(A,1)
 """
 function findprev(A, start::Integer)
     for i = start:-1:1
-        A[i] != 0 && return i
+        A[i] != 0 && break i
+    else
+        0
     end
-    return 0
 end
 
 """

From 8a8d4cc450fea8d0c43dddf170b16f66ef3d9dfe Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Tue, 15 Aug 2017 22:37:02 +0200
Subject: [PATCH 03/15] Fix break-with-value in case the value expression is a
 symbol

Before 976ff845327299, a parsed `break` expression `'(break)` was being
augmented to `'(break <label>)` by the function `expand-forms`. Since
the latter is supposed to be idempotent [1], it used to check

    (pair? e)

before deciding on replacing it. In 976ff8453272 however, the parsed
break can have a value expression, so `(pair? e)` can be true for that
reason as well. Thinking I was being smart, I replaced the check by

    (symbol? (cadr e))

not realizing that a lone symbol can be a valid expression too!

This commit fixes that by *always* compiling the break expression to a
*triple*

    '(break <expression> <label>)

where <expression> may be `'(null)`. This should have no big
implications for the code being generated, because `'(null)` generates
no code when, in the function `compile`, `(and value tail)` is false,
which is likely the typical case.

[1] At least, that's what I'm guessing is the reason.
---
 src/julia-syntax.scm | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 075e5f8a68fa6..074e980faaeab 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -1244,7 +1244,7 @@
         ((eq? (car e) 'return)
          `(block ,@(if ret `((= ,ret true)) '())
                  (= ,retval ,(cadr e))
-                 (break ,bb)))
+                 (break (null) ,bb)))
         (else (map (lambda (x) (replace-return x bb ret retval)) e))))
 
 (define (expand-try e)
@@ -2242,11 +2242,12 @@
 
    'break
    (lambda (e)
-     (if (symbol? (cadr e))
-         e
-         `(break loop-exit ,(cadr e))))
+     (case (length e)
+       ((3) e)
+       ((2) `(break ,(cadr e) loop-exit))
+       ((1) `(break (null) loop-exit))))
 
-   'continue (lambda (e) '(break loop-cont))
+   'continue (lambda (e) `(break (null) loop-cont))
 
    'for
    (lambda (e)
@@ -3583,13 +3584,13 @@ f(x) = yt(x)
                (mark-label endl)
                (if tail (emit-return valvar) valvar)))
             ((break)
-             (let ((labl (assq (cadr e) break-labels)))
+             (let ((labl (assq (caddr e) break-labels)))
                (if (not labl)
                    (error "break or continue outside loop")
                    (let ((endl (cadr labl))
                          (hlevel (caddr labl))
                          (valtarget (if (length> labl 3) (cadddr labl) #f))
-                         (valexpr (if (length> e 2) (caddr e) '(null))))
+                         (valexpr (cadr e)))
                      (let ((res (compile valexpr break-labels valtarget #f)))
                        (if valtarget
                          (emit `(= ,valtarget ,res))))

From 3abd4d9a8daae939f5493f72545e46a10722912e Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Wed, 16 Aug 2017 00:08:06 +0200
Subject: [PATCH 04/15] Simplify break-with-value implementation: don't
 distinguish break-block and break-block-with-value

Instead, we give every `break-block` an `else`-block, potentially equal
to `'(null)`. This gives us one less atom to worry about.

This commit also makes a small modification to `compile`, which now
passes the value of `tail` for a `break` onto the `break-labels` stack.
That means a `break` can be compiled to a `return` if the `break-block`
is in the last position of a function.
---
 src/jlfrontend.scm   |  3 +--
 src/julia-syntax.scm | 58 ++++++++++++++++++--------------------------
 2 files changed, 25 insertions(+), 36 deletions(-)

diff --git a/src/jlfrontend.scm b/src/jlfrontend.scm
index 94f9aa96ee3cb..7fda27a3658a1 100644
--- a/src/jlfrontend.scm
+++ b/src/jlfrontend.scm
@@ -43,9 +43,8 @@
                                       tab)))
                 ((lambda)       tab)
                 ((local)        tab)
-                ((break-block)             (find-possible-globals- (caddr e) tab))
                 ;; TODO: elsebody in (cadddr e)
-                ((break-block-with-value)  (find-possible-globals- (caddr e) tab))
+                ((break-block)             (find-possible-globals- (caddr e) tab))
                 ((module toplevel) '())
                 (else
                  (for-each (lambda (x) (find-possible-globals- x tab))
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 074e980faaeab..1efbcfd98ca8d 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -1288,7 +1288,8 @@
                                 `(try ,tryb ,var ,catchb)
                                 tryb))
                         false
-                        (= ,err true)))
+                        (= ,err true))
+                   (null))
                   (= ,finally-exception (the_exception))
                   ,finalb
                   (if ,err (foreigncall 'jl_rethrow_other (core Void) (call (core svec) Any)
@@ -2225,10 +2226,11 @@
    'while
    (lambda (e)
      `(scope-block
-       (break-block-with-value loop-exit
+       (break-block loop-exit
                     (_while ,(expand-forms (cadr e))
                             (break-block loop-cont
-                                         ,(expand-forms (caddr e))))
+                                         ,(expand-forms (caddr e))
+                                         (null)))
                     ,(if (length> e 3)
                        (expand-forms (cadddr e))
                        '(null)))))
@@ -2238,7 +2240,8 @@
      `(scope-block
        (_while ,(expand-forms (cadr e))
                (break-block loop-cont
-                            ,(expand-forms (caddr e))))))
+                            ,(expand-forms (caddr e))
+                            (null)))))
 
    'break
    (lambda (e)
@@ -2531,8 +2534,8 @@
         ((symbol? e) (if (not (memq e bound)) (put! tab e #t)) tab)
         ((or (not (pair? e)) (quoted? e)) tab)
         ((memq (car e) '(lambda scope-block module toplevel)) tab)
+        ;; TODO: elseblock
         ((eq? (car e) 'break-block) (unbound-vars (caddr e) bound tab))
-        ((eq? (car e) 'break-block-with-value) (unbound-vars (caddr e) bound tab))
         ;; TODO: elsebody in (cadddr e)
         ((eq? (car e) 'with-static-parameters) (unbound-vars (cadr e) bound tab))
         (else (for-each (lambda (x) (unbound-vars x bound tab))
@@ -2630,12 +2633,9 @@
         ((eq? (car e) 'module)
          (error "module expression not at top level"))
         ((eq? (car e) 'break-block)
-         `(,(car e) ,(cadr e) ;; ignore type symbol of break-block expression
-                       ,(resolve-scopes- (caddr e) env outerglobals implicitglobals lam renames #f))) ;; body of break-block expression
-        ((eq? (car e) 'break-block-with-value)
-         `(,(car e) ,(cadr e) ;; ignore type symbol of break-block expression
+         `(break-block ,(cadr e) ;; ignore type symbol of break-block expression
                        ,(resolve-scopes- (caddr e) env outerglobals implicitglobals lam renames #f) ;; body of break-block expression
-                       ,(resolve-scopes- (cadddr e) env outerglobals implicitglobals lam renames #f))) ;; elsebody of break-block-with-value expression
+                       ,(resolve-scopes- (cadddr e) env outerglobals implicitglobals lam renames #f))) ;; elsebody of break-block expression
         ((eq? (car e) 'with-static-parameters)
          `(with-static-parameters ;; ignore list of sparams in break-block expression
             ,(resolve-scopes- (cadr e) env outerglobals implicitglobals lam renames #f)
@@ -2659,9 +2659,8 @@
   (cond ((or (eq? e 'true) (eq? e 'false) (eq? e UNUSED)) tab)
         ((symbol? e) (put! tab e #t))
         ((and (pair? e) (eq? (car e) 'outerref)) (put! tab (cadr e) #t))
-        ((and (pair? e) (eq? (car e) 'break-block)) (free-vars- (caddr e) tab))
         ;; TODO: elsebody in (cadddr e)
-        ((and (pair? e) (eq? (car e) 'break-block-with-value)) (free-vars- (caddr e) tab))
+        ((and (pair? e) (eq? (car e) 'break-block)) (free-vars- (caddr e) tab))
         ((and (pair? e) (eq? (car e) 'with-static-parameters)) (free-vars- (cadr e) tab))
         ((or (atom? e) (quoted? e)) tab)
         ((eq? (car e) 'lambda)
@@ -3562,27 +3561,16 @@ f(x) = yt(x)
                (emit `(goto ,topl))
                (mark-label endl)))
             ((break-block)
-             (let ((endl (make-label)))
-               (begin0 (compile (caddr e)
-                                (cons (list (cadr e) endl handler-level)
-                                      break-labels)
-                                value #f)
-                       (mark-label endl)))
-             (if value (compile '(null) break-labels value tail)))
-            ((break-block-with-value)
              (let ((endl (make-label))
                    (valvar (if (or value tail) (new-mutable-var) #f)))
                (compile (caddr e)
-                        (cons (list (cadr e) endl handler-level valvar)
+                        (cons (list (cadr e) endl handler-level valvar tail)
                               break-labels)
-                        value #f)
-               (if (length> e 3)
-                 (let ((elseval (compile (cadddr e) break-labels valvar #f)))
-                   (if valvar (emit `(= ,valvar ,elseval))))
-                 (let ((elseval (compile '(null) break-labels valvar #f)))
-                   (if (and valvar elseval) (emit `(= ,valvar ,elseval)))))
+                        #f #f)
+               (let ((elseval (compile (cadddr e) break-labels value tail)))
+                 (if (and value (not tail)) (emit `(= ,valvar ,elseval))))
                (mark-label endl)
-               (if tail (emit-return valvar) valvar)))
+               valvar))
             ((break)
              (let ((labl (assq (caddr e) break-labels)))
                (if (not labl)
@@ -3590,13 +3578,15 @@ f(x) = yt(x)
                    (let ((endl (cadr labl))
                          (hlevel (caddr labl))
                          (valtarget (if (length> labl 3) (cadddr labl) #f))
+                         (blocktail (if (length> labl 3) (cadddr (cdr labl)) #f))
                          (valexpr (cadr e)))
-                     (let ((res (compile valexpr break-labels valtarget #f)))
-                       (if valtarget
-                         (emit `(= ,valtarget ,res))))
-                     (if (> handler-level hlevel)
-                         (emit `(leave ,(- handler-level hlevel))))
-                     (emit `(goto ,endl))))))
+                     (let ((res (compile valexpr break-labels valtarget blocktail)))
+                       (if (not blocktail)
+                         (begin
+                           (if valtarget (emit `(= ,valtarget ,res)))
+                           (if (> handler-level hlevel)
+                             (emit `(leave ,(- handler-level hlevel))))
+                           (emit `(goto ,endl)))))))))
             ((label symboliclabel)
              (if (eq? (car e) 'symboliclabel)
                  (if (has? label-level (cadr e))

From ed6ff287226b2a88be21d45034dc52af1d45f536 Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Wed, 16 Aug 2017 19:44:42 +0200
Subject: [PATCH 05/15] Document for/else and break-with-value

---
 doc/src/manual/control-flow.md | 53 +++++++++++++++++++++++++++++++++-
 1 file changed, 52 insertions(+), 1 deletion(-)

diff --git a/doc/src/manual/control-flow.md b/doc/src/manual/control-flow.md
index 4d751a836aceb..82b6c783a2b88 100644
--- a/doc/src/manual/control-flow.md
+++ b/doc/src/manual/control-flow.md
@@ -524,7 +524,58 @@ julia> for i = 1:2, j = 3:4
 (2, 4)
 ```
 
-A `break` statement inside such a loop exits the entire nest of loops, not just the inner one.
+A `break` statement inside such a loop exits the entire nest of loops, not just
+the inner one.
+
+Every statement in julia is an expression, and a `for` loop is no exception.
+Its value is `nothing`:
+```jldoctest
+julia> nothing === (for i=1:10 end)
+true
+```
+However, in some cases it is convenient to return a value from a loop. For
+example, if we search a record in an unordered list, we'll want to `break` out
+of it as soon as we found it. For this, the `break` statement allows passing a
+value:
+
+```jldoctest using-records-variable
+julia> records = [(10,"Alice"), (12, "Bob"), (5, "Carol")];
+julia> name = for (id, n) in records
+           if id == 12
+               # break the loop, returning the current value of n
+               break n
+           end
+       end;
+julia> name
+"Bob"
+```
+If we want to specify a default value in case the iteration ends without ever
+hitting a `break` statement, we can add an `else` block:
+```jldoctest using-records-variable
+julia> name = for (id, n) in records
+           if id == 16
+               # break the loop, returning the current value of n
+               break n
+           end
+       else
+           "<name not found>"
+       end;
+julia> name
+"<name not found>"
+```
+
+Similar semantics work in a `while` loop:
+```jldoctest
+julia> f(p) = while true
+           q = nextfloat(p)
+           if q > pi
+               break p
+           end
+           p = q
+       end
+julia> f(3.1415926)
+3.141592653589793
+```
 
 ## Exception Handling
 

From 24c64f448965526e16226f1fb9f5ddaaea43626e Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Wed, 16 Aug 2017 20:04:42 +0200
Subject: [PATCH 06/15] Fix error message from incomplete for loop

The following issue:

    Test Failed
      Expression: Base.incomplete_tag(parse(str, raise=false)) == tag
       Evaluated: none == block

was due to returning a different error message string in case of parsing
the incomplete string "for i=1;". This commit fixes it by delegating
error handling to `expect-end`.
---
 src/julia-parser.scm | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index a7d05548fdc57..8bc896e7a9db7 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -1287,21 +1287,23 @@
        ((for)
         (let* ((ranges (parse-comma-separated-iters s))
                (body   (parse-block s))
-               (nxt    (take-token s)))
+               (nxt    (peek-token s)))
           (case nxt
             ((end)
-              `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
-                    ,body))
+             (begin
+               (take-token s) ;; consume nxt
+               `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
+                     ,body)))
             ((else)
-              (let* ((elsebody (parse-block s)))
-                (expect-end s word)
-                `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
-                      ,body
-                      ,elsebody)))
-            (otherwise
-              (error (string "\"" word "\" at "
-                             current-filename ":" input-port-line
-                             " expected \"end\", got \"" nxt "\""))))))
+              (begin
+                (take-token s) ;; consume nxt
+                (let* ((elsebody (parse-block s)))
+                  (expect-end s word)
+                  `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
+                        ,body
+                        ,elsebody))))
+            (else
+              (expect-end s word))))) ;; which will throw the correct error
        ((if elseif)
         (if (newline? (peek-token s))
             (error (string "missing condition in \"if\" at " current-filename

From f15be305473befb2f9035fb364d2d4d10e680156 Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Wed, 16 Aug 2017 20:17:13 +0200
Subject: [PATCH 07/15] Avoid allocating a value variable when break-block is
 in tail position

This was triggered by

    Error in testset inference:
    Test Failed
      Expression: all(isleaftype, (ast12474[1])[1].slottypes)

which had, as a root cause, the unused new-mutable-var being of type
Any.

Now, that isn't really what this doctest is trying to avoid, but I'm
guessing it's worthwhile avoiding an unneeded mutable var nonetheless.
---
 src/julia-syntax.scm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 1efbcfd98ca8d..605684f91bc9b 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -3562,7 +3562,7 @@ f(x) = yt(x)
                (mark-label endl)))
             ((break-block)
              (let ((endl (make-label))
-                   (valvar (if (or value tail) (new-mutable-var) #f)))
+                   (valvar (if (and value (not tail)) (new-mutable-var) #f)))
                (compile (caddr e)
                         (cons (list (cadr e) endl handler-level valvar tail)
                               break-labels)

From a67bc9fbf99af4aa17a8771ec765ca0202e8f9ce Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Wed, 16 Aug 2017 20:53:59 +0200
Subject: [PATCH 08/15] Remove unnecessary if relating to break-labels contents

This is an artifact from when I wasn't sure whether anything else would
write to the break-labels stack apart from the code point that I had
updated. I'm now confident that doesn't happen, so no need for special
cases.
---
 src/julia-syntax.scm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 605684f91bc9b..98673a87b6925 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -3577,8 +3577,8 @@ f(x) = yt(x)
                    (error "break or continue outside loop")
                    (let ((endl (cadr labl))
                          (hlevel (caddr labl))
-                         (valtarget (if (length> labl 3) (cadddr labl) #f))
-                         (blocktail (if (length> labl 3) (cadddr (cdr labl)) #f))
+                         (valtarget (cadddr labl))
+                         (blocktail (cadddr (cdr labl)))
                          (valexpr (cadr e)))
                      (let ((res (compile valexpr break-labels valtarget blocktail)))
                        (if (not blocktail)

From e0697d16533085abc5400fe70e8a56962ba998d0 Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Thu, 17 Aug 2017 23:02:58 +0200
Subject: [PATCH 09/15] break-with-value: add elsebody to a few recursive
 expression traversals

I postponed this mostly because the names of the methods sounded scary
and I thought I'd need to think about it; turns out it's just a tree
traversal.
---
 src/jlfrontend.scm   |  6 ++++--
 src/julia-syntax.scm | 13 ++++++++-----
 2 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/src/jlfrontend.scm b/src/jlfrontend.scm
index 7fda27a3658a1..cb3d57864a8b0 100644
--- a/src/jlfrontend.scm
+++ b/src/jlfrontend.scm
@@ -43,8 +43,10 @@
                                       tab)))
                 ((lambda)       tab)
                 ((local)        tab)
-                ;; TODO: elsebody in (cadddr e)
-                ((break-block)             (find-possible-globals- (caddr e) tab))
+                ((break-block)
+                  (begin
+                    (find-possible-globals- (caddr e) tab)
+                    (find-possible-globals- (cadddr e) tab)))
                 ((module toplevel) '())
                 (else
                  (for-each (lambda (x) (find-possible-globals- x tab))
diff --git a/src/julia-syntax.scm b/src/julia-syntax.scm
index 98673a87b6925..13150a09b85b0 100644
--- a/src/julia-syntax.scm
+++ b/src/julia-syntax.scm
@@ -2534,9 +2534,10 @@
         ((symbol? e) (if (not (memq e bound)) (put! tab e #t)) tab)
         ((or (not (pair? e)) (quoted? e)) tab)
         ((memq (car e) '(lambda scope-block module toplevel)) tab)
-        ;; TODO: elseblock
-        ((eq? (car e) 'break-block) (unbound-vars (caddr e) bound tab))
-        ;; TODO: elsebody in (cadddr e)
+        ((eq? (car e) 'break-block)
+         (begin
+           (unbound-vars (caddr e) bound tab)
+           (unbound-vars (cadddr e) bound tab)))
         ((eq? (car e) 'with-static-parameters) (unbound-vars (cadr e) bound tab))
         (else (for-each (lambda (x) (unbound-vars x bound tab))
                             (cdr e))
@@ -2659,8 +2660,10 @@
   (cond ((or (eq? e 'true) (eq? e 'false) (eq? e UNUSED)) tab)
         ((symbol? e) (put! tab e #t))
         ((and (pair? e) (eq? (car e) 'outerref)) (put! tab (cadr e) #t))
-        ;; TODO: elsebody in (cadddr e)
-        ((and (pair? e) (eq? (car e) 'break-block)) (free-vars- (caddr e) tab))
+        ((and (pair? e) (eq? (car e) 'break-block))
+          (begin
+            (free-vars- (caddr e) tab)
+            (free-vars- (cadddr e) tab)))
         ((and (pair? e) (eq? (car e) 'with-static-parameters)) (free-vars- (cadr e) tab))
         ((or (atom? e) (quoted? e)) tab)
         ((eq? (car e) 'lambda)

From aa4822277bab4dcd51d5790b9d09f9be9336889b Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Sat, 19 Aug 2017 17:45:33 +0200
Subject: [PATCH 10/15] break-with-value: also parse 'else'-block for while
 loops

---
 src/julia-parser.scm | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index 8bc896e7a9db7..a0eedaa13db9a 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -1282,8 +1282,23 @@
             (if (eq? word 'quote)
                 (list 'quote blk)
                 blk))))
-       ((while)  (begin0 (list 'while (parse-cond s) (parse-block s))
-                         (expect-end s word)))
+       ((while)
+        (let* ((cnd  (parse-cond s))
+               (body (parse-block s))
+               (nxt  (peek-token s)))
+          (case nxt
+            ((end)
+             (begin
+               (take-token s) ;; consume nxt
+               (list 'while cnd body)))
+            ((else)
+             (begin
+               (take-token s) ;; consume nxt
+               (let* ((elsebody (parse-block s)))
+                 (expect-end s word)
+                 (list 'while cnd body elsebody))))
+            (else
+             (expect-end s word))))) ;; which will throw the correct error
        ((for)
         (let* ((ranges (parse-comma-separated-iters s))
                (body   (parse-block s))

From 29d98abe5265919c45be6b17cfc52439801aea19 Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Sat, 19 Aug 2017 17:46:07 +0200
Subject: [PATCH 11/15] More consistent indentation in julia-parser.scm

(Use `git blame -w` to see the most recent functional changes to this code.)
---
 src/julia-parser.scm | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index a0eedaa13db9a..7654de57ed504 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -1310,15 +1310,15 @@
                `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
                      ,body)))
             ((else)
-              (begin
-                (take-token s) ;; consume nxt
-                (let* ((elsebody (parse-block s)))
-                  (expect-end s word)
-                  `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
-                        ,body
-                        ,elsebody))))
+             (begin
+               (take-token s) ;; consume nxt
+               (let* ((elsebody (parse-block s)))
+                 (expect-end s word)
+                 `(for ,(if (length= ranges 1) (car ranges) (cons 'block ranges))
+                       ,body
+                       ,elsebody))))
             (else
-              (expect-end s word))))) ;; which will throw the correct error
+             (expect-end s word))))) ;; which will throw the correct error
        ((if elseif)
         (if (newline? (peek-token s))
             (error (string "missing condition in \"if\" at " current-filename

From b801f490c65081cd4d4ce6221b49f194175d22ad Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Sat, 19 Aug 2017 18:28:51 +0200
Subject: [PATCH 12/15] break-with-value: don't emit 'nothing' as the break
 value from the parser level

Since 8a8d4cc450fea8d0c43, julia-syntax.scm can deal with length 1
'break' expression nodes. So there is no need for this. In addition,
this ensures that :(break) prints as :(break), not as

    :($(Expr(:break, nothing)))

This was caught by a testcase in test/show.jl
---
 src/julia-parser.scm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/julia-parser.scm b/src/julia-parser.scm
index 7654de57ed504..c289953f35f67 100644
--- a/src/julia-parser.scm
+++ b/src/julia-parser.scm
@@ -1521,7 +1521,7 @@
           (if (or (eof-object? t)
                   (and (eq? t 'end) (not end-symbol))
                   (memv t '(#\newline #\; #\) :)))
-              (list word '(null))
+              (list word)
               (list word (parse-eq s)))))
        ((module baremodule)
         (let* ((name (parse-unary-prefix s))

From bad3c358f51a0eb2747b45cff97601e938515e52 Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Tue, 30 Jan 2018 21:16:00 +0100
Subject: [PATCH 13/15] Revert "Implement findnext() in terms of for/else and
 break-with-value"

This was only used for testing the for/else construct; it's not actually
more readable. As discussed in #23260, `intersect()` is a nicer show
case. Moreover, this prevents a merge conflict with `master`, which has
diverged significantly by now.

This reverts commit d8b2553ce82f3ace5da79ca2683b4e42126c1616.
---
 base/array.jl | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/base/array.jl b/base/array.jl
index dcd3e5ded1fb4..300512537ad8d 100644
--- a/base/array.jl
+++ b/base/array.jl
@@ -1251,11 +1251,10 @@ julia> findnext(A,3)
 function findnext(A, start::Integer)
     for i = start:length(A)
         if A[i] != 0
-            break i
+            return i
         end
-    else
-        0
     end
+    return 0
 end
 
 """
@@ -1302,11 +1301,10 @@ julia> findnext(A,4,3)
 function findnext(A, v, start::Integer)
     for i = start:length(A)
         if A[i] == v
-            break i
+            return i
         end
-    else
-        0
     end
+    return 0
 end
 """
     findfirst(A, v)
@@ -1352,11 +1350,10 @@ julia> findnext(isodd, A, 2)
 function findnext(testf::Function, A, start::Integer)
     for i = start:length(A)
         if testf(A[i])
-            break i
+            return i
         end
-    else
-        0
     end
+    return 0
 end
 
 """
@@ -1402,10 +1399,9 @@ julia> findprev(A,1)
 """
 function findprev(A, start::Integer)
     for i = start:-1:1
-        A[i] != 0 && break i
-    else
-        0
+        A[i] != 0 && return i
     end
+    return 0
 end
 
 """

From 98d5dd7da970d44d9c073810ebd5c769858ee68d Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Thu, 1 Feb 2018 00:39:56 +0100
Subject: [PATCH 14/15] Test execution order of break-with-value inside a
 try/finally block

---
 test/core.jl | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/test/core.jl b/test/core.jl
index c2995bda5639c..63d3379039464 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -979,6 +979,40 @@ let a = []
     @test length(a) == 1
 end
 
+function test23260()
+    res = []
+    function value(val)
+        push!(res, "value")
+        val
+    end
+    # loop returning a value through `break`
+    val = for i=1:10
+        push!(res, "loop$i")
+        try
+            i == 2 && break value(42)
+        finally
+            push!(res, "finally")
+        end
+    end
+    push!(res, val)
+
+    # same, but now in tail position
+    for i=1:10
+        push!(res, "loop$i")
+        try
+            i == 2 && break value(res)
+        finally
+            push!(res, "finally")
+        end
+    end
+end
+@test test23260() == [
+    # first for loop
+    "loop1", "finally", "loop2", "value", "finally", 42,
+    # second for loop (in tail position)
+    "loop1", "finally", "loop2", "value", "finally",
+]
+
 # chained and multiple assignment behavior (issue #2913)
 let
     local x, a, b, c, d, e

From e0a42c636d61a8c95eaff1f6140f6880da86912d Mon Sep 17 00:00:00 2001
From: Timo Kluck <tkluck@infty.nl>
Date: Sat, 16 Jun 2018 14:10:12 +0200
Subject: [PATCH 15/15] break-with-value doctest fixes (whitespace, trivial
 output)

---
 doc/src/manual/control-flow.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/src/manual/control-flow.md b/doc/src/manual/control-flow.md
index 1c0ffcfe60cdb..94ea7e490e466 100644
--- a/doc/src/manual/control-flow.md
+++ b/doc/src/manual/control-flow.md
@@ -560,12 +560,14 @@ value:
 
 ```jldoctest using-records-variable
 julia> records = [(10,"Alice"), (12, "Bob"), (5, "Carol")];
+
 julia> name = for (id, n) in records
            if id == 12
                # break the loop, returning the current value of n
                break n
            end
        end;
+
 julia> name
 "Bob"
 ```
@@ -580,6 +582,7 @@ julia> name = for (id, n) in records
        else
            "<name not found>"
        end;
+
 julia> name
 "<name not found>"
 ```
@@ -593,6 +596,8 @@ julia> f(p) = while true
            end
            p = q
        end
+f (generic function with 1 method)
+
 julia> f(3.1415926)
 3.141592653589793
 ```