Add additional constructors for Try object

[tmccombs]

Try.apply currently returns a Failure if a NonFatal exception is thrown in the block.

However, that often isn't what is actually desired.

In fact, in #17737 it was discussed that NonFatal should be deprecated, perhaps in favor of just catching Exception instead (in particular, see #17737 (comment)).

It may also often be desirable to create a Try, but propagate Break exceptions, so that it can be used in a Boundary, for example in something like this:

boundary:
  val attempt = Try:
    if doSomething() then
      break()
  attempt.failure.foreach(logFailure)

Currently, this would loop forever, since the Try would catch the Break exception. It would be nice if there was an easy to use method on Try to create a Try that lets through Break exceptions, but catches other exceptions.

Something like:

def nonBreak[T](f: => T): Try[T] =
  try
    Success(f)
  catch
    case e: Exception if !e.isInstanceOf[Break[_]] => Failure(e)

Some other possible types of conditions that may be useful to have additional methods for:

def all[T](f: => T): Try[T] = try
  Success(f)
catch
  case e => Failure(e)

def nonError[T](f: => T): Try[T] = try
  Success(f)
catch
  case e if  !e.isInstanceOf[Error] => Failure(e)

Although I'm not sure how useful those would be.

Some other related ideas

It would probably be valuable to have a NonControl matcher or maybe NonBreak defined something like:

object NonBreak:
  def unapply(e: Throwable): Boolean = e.isInstanceOf[Exception] && !e.isInstanceOf[Break[_]]

I also wonder if it would be worth having a method on the Try trat like:

def rethrowIf(pred: Throwable => Boolean): Try[T] = this match
  case Failure(e) if pred(e) => throw e
  case _ => this

[som-snytt]

https://www.scala-lang.org/files/archive/api/current/scala/util/control/Exception$.html

scala> {
     | new Catch({ case _: RuntimeException => 42 }, rethrow = _.isInstanceOf[util.boundary.Break[?]])
     | }
val res4: scala.util.control.Exception.Catch[Int] = Catch()

scala> {
     | boundary:
     |   Try:
     |     for i <- 0 to 100 do
     |       if i > 50 then break(i)
     |     -1
     | }
val res5: scala.util.Try[Int] | Int = Failure(scala.util.boundary$Break)

scala> {
     | boundary:
     |   res4.withTry:
     |     for i <- 0 to 100 do
     |       if i > 50 then break(i)
     |     -1
     | }
val res6: scala.util.Try[Int] | Int = 51