Drop Nonlocal Return

[odersky]

Nonlocal returns can have surprising behavior due to the way they interact with try. It turns out that with implicit function types one can delegate non-local returns to a library at basically the same efficiency as what is implemented now.

The idea is to express a non-local return like this:

returning {  ....    throwReturn(x)  .... }

The name throwReturn is chosen so that it is made clear that the return is non-local and involves throwing an exception. The exception is caught at the Returning point where the
transmitted result is returned.

Here's an implementation of this functionality:

package scala.util.control

object NonLocalReturns {

  class ReturnThrowable[T] extends ControlThrowable {
    private var myResult: T = _
    def throwReturn(result: T): Nothing = {
      myResult = result
      throw this
    }
    def result: T = myResult
  }

  def throwReturn[T](result: T)(implicit returner: ReturnThrowable[T]): Nothing =
    returner.throwReturn(result)

  def returning[T](op: implicit ReturnThrowable[T] => T): T = {
    val returner = new ReturnThrowable[T]
    try op(returner)
    catch {
      case ex: ReturnThrowable[_] =>
       if (ex `eq` returner) ex.result.asInstanceOf[T] else throw ex
    }
  }

Here's a test case:

def has(xs: List[Int], elem: Int) =
    returning {
      for (x <- xs)
        if (x == elem) throwReturn(true)
      false
    }

Advantages: a simpler language spec and less surprises for the users
Disadvantages: a bit more verbose (which might be a good thing, after all!)

[Daenyth]

I like this because it makes things less confusing for users coming from other languages who might footgun themselves with return out of habit

[smarter]

+1000 for this!

@olafurpg Do you know if scalameta can distinguish between local and non-local returns? That would be required to make a rewrite rule for this.

[olafurpg]

@smarter can you provide examples diffs (before/after) of how the rewrite should work? Including cases for both local and non-local returns.

[smarter]

For local returns there's nothing to do, here's an example with a non-local return:
before:

object Test {
  def test(xs: List[Int]): Int = {
    xs foreach { x =>
      if (x > 2)
        return x
    }
    0
  }
}

after:

import scala.util.control.Returning
import Returning.throwReturn

object Test {
  def test(xs: List[Int]): Int = Returning {
    xs foreach { x =>
      if (x > 2)
        throwReturn(x)
    }
    0
  }
}

If we want to be backward compatible with Scala 2 we'll have to be more verbose and write Returning { implicit returner => instead.

[odersky]

I renamed things a bit so that it is now

returning { ... }

No need to capitalize.

[odersky]

I believe all our library is still compiled first with scalac, rigtht? In this case we have to wait until bootstrap before we can implement this.

[olafurpg]

Thanks for the example @smarter are returns local only when they're inside the body of a HOF or can they appear elsewhere?

The rewrite seems doable, but it would be good to have a list of input/output test cases to explore more corner cases.

[smarter]

are returns local only when they're inside the body of a HOF or can they appear elsewhere?

I guess you mean non-local, not local. Returns are also non-local in the rhs of lazy vals, that's about it I think.

[olafurpg]

Yes, I meant non-local. Sounds good!