How to re-write this code idiomatically in Scala?

Question

Suppose I have a function f: Int => String which may throw exceptions. I would like to write a function tryF(f: Int => String, arg: Int, defaultOpt: Option[String]), which works as follows:

Invoke f(arg) and return the result if it has thrown no exception
if the invocation has failed with an exception and defaultOpt.isDefined then return defaultOpt.get
Otherwise throw the exception

I am writing it as follows:

def tryF(f: Int => String, arg: Int, defaultOpt: Option[String]) = {
  val r = scala.util.Try(f(arg))
  r.toOption orElse defaultOpt getOrElse r.get
}

Does it make sense ? Would you rewrite it ?

vptheron · Accepted Answer · 2014-07-17 13:55:13Z

5

Your solution is fine even though I personally don't find it very readable. I would do something like that:

def tryF[A](f: =>A, defaultOpt: Option[A]): A = (Try(f), defaultOpt) match {
  case (Success(result), _)          => result
  case (Failure(_), Some(defValue))  => defValue
  case (Failure(t), None)            => throw t
}

Note that it is unnecessarily verbose (I could have used wildcard in some of the cases) but I think your use case deserves some self documenting code. It is easy to understand what triggers each case.

answered Jul 17, 2014 at 13:55

vptheron

7,4761 gold badge29 silver badges35 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Michael Over a year ago

Thanks. The pattern matching was the alternative. It looks verbose but probably more readable (for most people at least).

Ashalynd · Accepted Answer · 2014-07-17 14:26:06Z

2

A verbose, but easy-to-understand way...

import scala.util.{Try,Success,Falure}

def tryF(f: Int => String, arg: Int, defaultOpt: Option[String]) = {
 Try(f(arg)) match {
      case Success(r) => r
      case Failure(ex) => defaultOpt match {
           case Some(content) => content
           case None => throw ex
      } 
 }

Slightly more compact way:

import scala.util.{Try,Success,Falure}

def tryF(f: Int => String, arg: Int, defaultOpt: Option[String]) = 
 Try(f(arg)) match {
      case Success(r) => r
      case Failure(ex) => defaultOpt getOrElse {throw ex}
 }

edited Jul 17, 2014 at 14:26

answered Jul 17, 2014 at 14:05

Ashalynd

12.6k2 gold badges36 silver badges38 bronze badges

4 Comments

Michael Over a year ago

I would use defaultOpt getOrElse {throw ex} instead of the nested pattern matching.

Ashalynd Over a year ago

agreed, but outer pattern matching is still needed to get ex

Michael Over a year ago

I like the 2nd solution. Thank you.

Jim Collins Over a year ago

I don't think using Try is appropriate in this instance and you would be better using try/catch as answered by Dan Getz. I would use the Try as the return type indicating success or failure.

Dan Getz · Accepted Answer · 2014-07-17 16:34:53Z

2

No need for Try in your case; try/catch is enough:

def tryF(f: Int => String, arg: Int, defaultOpt: Option[String]) = {
  try {
    f(arg)
  } catch {
    case e: Exception => defaultOpt getOrElse { throw e }
  }
}

If you want to use Try, I'd suggest taking advantage of recover:

def tryF(f: Int => String, arg: Int, defaultOpt: Option[String]) = {
  Try {
    f(arg)
  }.recover({
    case _ if defaultOpt.isDefined => defaultOpt.get
  }).get
}

However, if this is your actual function, I'd consider rewriting the argument types to be generic, rather than rewriting the implementation, as long as the implementation already works:

def tryF[A, B](f: A => B, arg: A, defaultOpt: Option[B]): B = /* ... */

edited Jul 17, 2014 at 16:34

answered Jul 17, 2014 at 14:53

Dan Getz

9,2327 gold badges38 silver badges75 bronze badges

2 Comments

The Archetypal Paul Over a year ago

(This is not snark, at least, not intentionally) Try { f(arg) }.recover(Function.unlift(Function.const(defaultOpt))).get - is that really readable (as in "you can clearly see what it is doing - i.e. conditionally throwing the exception?

Dan Getz Over a year ago

You're right, that was pretty unreadable. Got rid of the Function._ stuff.

wedens · Accepted Answer · 2014-07-17 14:00:19Z

1

def tryF(f: Int => String, arg: Int, defaultOpt: Option[String]) = {
  val r = scala.util.Try(f(arg))
  (r, defaultOpt) match {
    case (Success(result), _) => result
    case (Failure(_), Some(opt)) => opt
    case (Failure(ex), None) => throw ex
}

answered Jul 17, 2014 at 14:00

wedens

1,84015 silver badges18 bronze badges

Comments

Shyamendra Solanki · Accepted Answer · 2014-07-17 14:05:10Z

1

def tryF(f: Int => String, arg: Int, defaultOpt: Option[String]) = {

    val r = scala.util.Try(f(arg))

    if (r.isSuccess) r.get else defaultOpt.getOrElse(r.get)

    // reads like -> if r is success, get from r, else get from default, else get from r
}

edited Jul 17, 2014 at 14:05

answered Jul 17, 2014 at 13:44

Shyamendra Solanki

8,8512 gold badges33 silver badges25 bronze badges

1 Comment

Michael Over a year ago

If defaultOpt is None I need to throw the original exception.

Collectives™ on Stack Overflow

How to re-write this code idiomatically in Scala?

5 Answers 5

1 Comment

4 Comments

2 Comments

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

1 Comment

4 Comments

2 Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related