31

I have a method like this:

def aMethod(param: String = "asdf") = {
    ...
}

If the method is called as follows, then param is given the default value "asdf":

aMethod() ...

But what I would like, is that if the method is called with null, then the default value would also be applied:

aMethod(null)  //inside the method, I can use `param` and it has the value "asdf".

Whats the best way to do this in Scala? I can think of pattern matching or a simple if statement.

John Smith
  • 3,037
  • 5
  • 29
  • 31

3 Answers3

57

Pattern matching

def aMethod(param: String = null) {
    val paramOrDefault = param match {
        case null => "asdf"
        case s => s
    }
}

Option (implicitly)

def aMethod(param: String = null) {
    val paramOrDefault = Option(param).getOrElse("asdf")
}

Option (explicitly)

def aMethod(param: Option[String] = None) {
    val paramOrDefault = param getOrElse "asdf"
}

The last approach is actually the most idiomatic and readable once you get use to it.

Tomasz Nurkiewicz
  • 334,321
  • 69
  • 703
  • 674
  • 1
    Is there a way to implicitly convert to an Option? Sure I could write my own def, but is there one in the API already? – John Smith Mar 15 '12 at 20:32
  • 4
    @JohnSmith: you mean something like: `implicit def obj2Option[T](t: T) = Option(t)`? I think this is a bit too fragile/dangerous to be part of standard implicit conversions, I don't know of any such. – Tomasz Nurkiewicz Mar 15 '12 at 20:38
  • @TomaszNurkiewicz please see my answer, as this solution, at a closer examination, will have negative impact on Scala dev tools and will have the potential to break the code whenever inheritance is involved. – Vlad Gudim Mar 15 '12 at 23:17
  • this answer doesn't seem to address characteristics mentioned in @VladGudim 's solution e.g.: `* The method definition clearly indicates the parameter's default value.; * usage in traits, etc.` ; please clarify if it does. Are there any advantages of your method over @VladGudim 's – Neil Feb 26 '16 at 23:05
6
def aMethod(param: String = null) = { 
  val p = 
    if(param == null)
      "asdf"
     else
       param

  println(p) 
}

But the question must be asked: why allow null? Would Option be possible in your case? For this you could do:

def aMethod(param: Option[String]) = { 
  val p = param.getOrElse("asdf")    
  println(p)
}

This makes it clear that your method expects the possibility of a "null" argument.

dhg
  • 52,383
  • 8
  • 123
  • 144
6

If the method has just one or two default parameters that can be set to null consider this pattern:

// please note that you must specify function return type
def aMethod (x:String = "asdf"):String = if (x==null) aMethod() else {
    // aMethod body ...
    x 
}

There are some benefits:

  • The method definition clearly indicates the parameter's default value.
  • The correct default value can be picked by Scala tools, including ScalaDoc.
  • There is no need to define an additional value to substitute for the original parameter within the method body - less room for mistakes, easier to reason.
  • The pattern is fairly concise.

Furthermore, consider the following scenario:

trait ATrait {
  def aMethod (x:String = "trait's default value for x"):String
}

class AClass extends ATrait {
    ....
}

Clearly, here we need to extend the trait, whilst preserving the original default value. Any of the patterns that involve initially setting the parameter to null followed by a check and actual default value will break the contract established by the trait:

class AClass extends ATrait {
  // wrong, breaks the expected contract
  def aMethod(x: String = null):String = {
      val xVal = if (x == null) "asdf" else x 
      ...
  }
}

Indeed in this scenario the only way to preserve the original value from ATrait will be:

class AClass extends ATrait {
  override def aMethod (x:String):String = if (x==null) aMethod() else {
    ... // x contains default value defined within ATrait
  }
}

However, in the scenario when there are more than one or two default parameters that can be set to null the pattern starts getting rather messy:

// two parameters
def aMethod (x:String = "Hello",y:String = "World"):String = 
  if (x==null) aMethod(y=y) else
  if (y==null) aMethod(x=x) else {
    // aMethod body ...
    x + " " + y
}

// three parameters
def aMethod (x:String = "Hello",y:String = " ",z:String = "World"):String = 
  if (x==null) aMethod(y=y,z=z) else
  if (y==null) aMethod(x=x,z=z) else 
  if (z==null) aMethod(x=x,y=y) else {
    // aMethod body ...
    x + y + z
}

Still when overriding an existing contract this might be the only way to honour the original default values.

Vlad Gudim
  • 23,397
  • 16
  • 69
  • 92
  • I really like your approach (and justification); I wish could give it more points; since I think it should be the answer. Thanks. – Neil Feb 26 '16 at 23:02