Scala - Optional Arguments without requiring user to input Some(...)

Question

I am designing a program. I am new to Scala but it seems optional arguments are handled using the following:

def f1(my_string: Option[String] = None) = {

// Maybe do some pattern matching here to extract the value

}

However, for an end user this is pretty ugly as they will need to call this function like:

f1(Some("foo")

Is there a technique or pattern to turn this into:

f1("foo"))

and still work with an optional argument?i.e f1() also works?

The reason I ask is I have obviously used Scala libraries where adding an explicit Some(..) has not been necessary, but in their source code they have defined functions as above. I would personally use a default argument but wandering why this is a design pattern.

I'm puzzled by the asymmetric parentheses in the two uses of f1 — typo? (I know nothing of Scala, so it may be obvious to an aficionado.) — Jonathan Leffler
– Jonathan Leffler, Commented Jul 25, 2022 at 14:16

Alexey Romanov · Accepted Answer · 2020-06-12 22:55:25Z

An option is to create a helper class only for such arguments to avoid the anyToOption implicit conversion in the linked thread:

class OptArg[A](val asOption: Option[A])

object OptArg {
  def NoArg[A] = new OptArg[A](None)
  implicit def fromValue[A](x: A): OptArg[A] = new OptArg(Some(x))
  // optional
  implicit def toOption[A](arg: OptArg[A]) = arg.asOption
}

// use
def f1(my_string: OptArg[String] = NoArg) = {
  // can use my_string as if it was Option,
  // or call my_string.asOption explicitly
}

In simple cases of course overloading will be more suitable, but not if you have many optional arguments.

The drawback is relying on implicit conversions, but I think this one is pretty benign and unlikely to trigger accidentally.

OTOH I think it's quite rare in practice that an argument is optional but "no argument" doesn't correspond to some default value of that type, so I'd look if it can be defined as

def f1(my_string: String = something)

to avoid the whole problem.

jwvh · Accepted Answer · 2020-06-12 19:31:31Z

2

Instead of Option you could overload the method.

f1() :ReturnType = {...}

f1(arg:String) :ReturnType = {...}

answered Jun 12, 2020 at 19:31

jwvh

51.3k7 gold badges42 silver badges70 bronze badges

2 Comments

finite_diffidence Over a year ago

Thanks @jwvh, just as a matter of interest, if I was working with a class instead, would the idiomatic way still be overloading the constructor?

jwvh Over a year ago

In that case you probably want to use an auxiliary constructor. They have some restrictions but can be useful.

Mario Galic · Accepted Answer · 2020-06-12 20:01:40Z

2

Syntactic cost of Option in calls such as

f1(Some("foo"))

is trivial as compared to the value of minimised risk of null pointer exceptions in a large codebase. Hoare, a Turing Awardee, appologised

I call it my billion-dollar mistake. It was the invention of the null reference in 1965.

answered Jun 12, 2020 at 20:01

Mario Galic

48.6k6 gold badges64 silver badges111 bronze badges

1 Comment

Alexey Romanov Over a year ago

But why compare it to that risk?

Collectives™ on Stack Overflow

Scala - Optional Arguments without requiring user to input Some(...)

3 Answers 3

Comments

2 Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

2 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related