PHP RFC: Conditional Return, Break, and Continue Statements


Most generally, this is a syntactical change that (IMO, of course) allows for a terser and more expressive way to achieve conditional returns (along with breaks and continues).

This proposal is a syntatical addition that allows `break`, `continue` and `return` to be conditionally qualified. Two variations are possible (depending on which, if either are desirable to have.)

Option #1 with optional return value at end of statement:

    function divide($dividend, $divisor = null) {
        return if ($divisor === null || $divisor === 0);
        // or
        return if ($divisor === null || $divisor === 0): 0;
        return $dividend / $divisor;

Option #2 with optional return after return keyword:

    function divide($dividend, $divisor = null) {
        return if ($divisor === null || $divisor === 0);
        // or
        return 0 if ($divisor === null || $divisor === 0);
        return $dividend / $divisor;

Considering Zeev's quote:

Consider only features which have significant traction to a large chunk of our userbase, and not something that could be useful in some

I believe a significant number of developers would start to write conditional return (breaks and continues) as a natural tendency, and without thinking twice, if it were available... And I also believe that there would be, for a large population of developers and immediate benefit in reading code and reviewing code when adopting these kinds of conditional statements for php code that is written in the most popular coding standards that exist today.


The general concept comes from the idea of a guard clause. (Also sometimes called “short circuiting”, or even simply “returning early”.)

In short [I perceive], a benefit of using guard clauses is to avoid deeply nested conditionals and to avoid increasing cognitive complexity in a function or method. Utilizing this technique in code results in code that is more easily code reviewable and easier to determine possible code paths that exists from the top to the bottom of a function or method.

Over the past few years, I've seen a growing number of blog posts, conference talks, and even tooling (for example code complexity scoring), that suggest writing guard clauses is a good practice to utilize. I've also seen it more prevalent in code, and even attempts at achieving this with Exceptions (in an HTTP context) in a framework like Laravel. See abort_if/throw_if in Laravel.

It is also worth mentioning that Ruby has similar features (called a modifier), and I believe they are heavily utilized.. see here.

(While the text of this applies most arguments to `return`, at current the same arguments apply for break and continue, and are included in this proposal.)

Variation #1

My personal favorite is this variation (in it's full statement form):

return if ($condition): $returnValue;


  1. `return if` acts as a compound keyword, put another way since `if` must follow `return`, their proximity acts just like a new singular keyword would. It would effectively be a singular visual cue (much like, for example `return_if` if it were proposed).
  2. In the most common coding standards, `return if` will be aligned to the left most side of a line of code, making it easier for (humans) to scan for and quickly identify.
  3. (Building on the #2 Pro...) It keeps the precedence of information about the statement in a prioritized order. Put another way, since the first 2 lexical tokens are constant, and a meaning for the full statement can be derived from those, the following information (the actual condition and the actual optional return value - which I argue have less precedence) can be found later in the statement.
  4. The optional return value syntax mimics that of the function/method return type hint syntax, as in at the end of a method signature in the `: <return>` format.


  1. Does not read like an “English-like” statement: “Return X if Y”

Variation #2

I am also fond of this variation which is commonly asked for (to be fair I like it to a slightly lesser degree than #1):

return $returnValue if ($condition);


  1. Reads well “Return subject if condition”
  2. Follows a similar pattern as found in other languages, like Ruby


  1. Large optional return values will create more space between the `return` and `if` keywords, potentially making it harder for (humans) to scan for the conditional qualifier.

A visual argument between the two variations

(Click to view full)

Backward Incompatible Changes

No BC issues: there are no new keywords, nor does not impact any existing code.

This syntactical change is reusing existing keywords.

Proposed PHP Version(s)


RFC Impact

To Opcache

Unknown, under discussion.

Proposed Voting Choices

Include these so readers know where you are heading and can discuss the proposed voting options.

Patches, Tests, Implementation


rfc/conditional_break_continue_return.txt · Last modified: 2022/04/17 18:38 by ilutov