Emulating C#’s default keyword in Scala, and putting it on steroids

This is my first programming blog post, please be gentle in your criticism. 🙂

Emulating C#’s default keyword in Scala

In generic classes and methods, one issue that arises is how to assign a default value to a type parameter A when you do not know in advance whether A is a reference type, a numeric type, or something else. To handle such a situation, C# provides a keyword default, which returns null for reference types, and zero for numeric types. For structs, which are CLR’s value types, default returns an object with all members initialized to their respective default values using the same mechanism.

The following example shows the default keyword in action:

1
using System;
2
using System.Diagnostics;
3

4
class Example {
5
  static void Main(string[] args) {
6
    Debug.Assert(default(Int32) == 0);
7
    Debug.Assert(default(Boolean) == false);
8
    Debug.Assert(default(String) == null);
9
  }
10
}

Scala has a similar feature to get a default value for the given type parameter. Just declare a variable at the class level, annotate it with a type, and put an underscore after the assignment operator. The variable will then be assigned the appropriate default according to its type. (Note: All Scala snippets in this post were typed into the REPL.)

1
scala> class Test[A] {
2
     |   var a: A = _
3
     | }
4
defined class Test
5

6
scala> new Test[Int].a
7
res3: Int = 0
8

9
scala> new Test[Boolean].a
10
res4: Boolean = false
11

12
scala> new Test[String].a
13
res5: String = null

However, for reasons I do not know, this feature is only available for class fields. It doesn’t work for local variables.

1
scala> def default[A] = {
2
     |   var a: A = _
3
     |   a
4
     | }
5
<console>:8: error: local variables must be initialized
6
         var a: A = _
7
             ^

This can be worked around easily:

1
scala> def default[A] = {
2
     |   class Test {
3
     |     var a: A = _
4
     |   }
5
     |   (new Test).a
6
     | }
7
default: [A]=> A
8

9
scala> default[Int]
10
res6: Int = 0
11

12
scala> default[Boolean]
13
res7: Boolean = false
14

15
scala> default[String]
16
res8: String = null

Thus we have successfully emulated the behavior of C#’s default keyword in Scala (except for the structs case, which do not exist on JVM anyway).

Putting it on steroids

Now what do I mean by putting default on steroids? Think about how we could improve the behavior of the defaulting mechanism we built above. Wouldn’t it make more sense for a string to default to an empty string, i.e. ""? Wouldn’t it make more sense for an Option[_] variable to default to None? Similarly, your custom classes could have more appropriate defaults than null. For example, 0.0 + 0.0j would be a suitable default for a Complex object. In the remaining part of this post, we are going to see how Scala’s typeclasses let us build such a default on steroids.

Here is the required machinery for this little utility:

1
scala> :paste
2
// Entering paste mode (ctrl-D to finish)
3

4
trait Default[A] {
5
  def value: A
6
}
7

8
trait LowPriorityImplicitsForDefault { this: Default.type =>
9
  implicit def forAnyRef[A](implicit ev: Null <:< A) = Default withValue (null : A)
10
}
11

12
object Default extends LowPriorityImplicitsForDefault {
13
  def withValue[A](a: A) = new Default[A] {
14
    def value = a
15
  }
16

17
  implicit val forBoolean = Default withValue false
18
  implicit val forChar = Default withValue ' '
19
  implicit def forNumeric[A](implicit n: Numeric[A]) = Default withValue n.zero
20
  implicit val forString = Default withValue ""
21
  implicit def forOption[A] = Default withValue (None : Option[A])
22
}
23

24
// Exiting paste mode, now interpreting.
25

26
defined trait Default
27
defined trait LowPriorityImplicitsForDefault
28
defined module Default

The trait Default is a typeclass, which is invariant on A for obvious reasons. Its companion object Default contains implicits and implicit suppliers for a few common types. The method forAnyRef is put in a separate trait LowPriorityImplicitsForDefault so that it has a lower precedence than other more specific implicit supplier methods such as forNumeric (we do this to hack around Scala’s implicit lookup rules. Don’t bother if you do not understand this, as it’s beyond the point of this post).

Now all we need to do is define a no-arg method default that picks an appropriate Default implicit from the scope and returns its value.

1
scala> def default[A : Default] = implicitly[Default[A]].value
2
default: [A](implicit evidence$1: Default[A])A

And we are done! 🙂

Here is our new default, in action:

1
scala> default[Int]
2
res0: Int = 0
3

4
scala> default[String]
5
res1: String = ""
6

7
scala> default[Boolean]
8
res2: Boolean = false
9

10
scala> default[Option[Int]]
11
res3: Option[Int] = None

Say, later on at some point we define a class Complex. How do you supply a Default implicit for it? Easy. Put it in Complex’s companion.

1
scala> :paste
2
// Entering paste mode (ctrl-D to finish)
3

4
case class Complex(real: Double, imaginary: Double)
5

6
object Complex {
7
  implicit val default = Default withValue Complex(0.0, 0.0)
8
}
9

10
// Exiting paste mode, now interpreting.
11

12
defined class Complex
13
defined module Complex
14

15
scala> default[Complex]
16
res6: Complex = Complex(0.0,0.0)

Cool, isn’t it? 🙂

What happens when there’s no implicit defined for a certain type? Well, in such a case, the method forAnyRef acts as a fallback method, and default returns null.

1
scala> case class Point(x: Double, y: Double)
2
defined class Point
3

4
scala> default[Point]
5
res8: Point = null

This example shows how Scala’s typeclasses can be immensely useful in cases requiring post hoc polymorphism.

That’s it. Suggestions and criticism are welcome.