A quick note. ScalaDays Rocks! Wish you were here :)

This topic just demonstrates a cute little trick that can occasionally be quite useful:

1. scala> List(1,2,3) ++ Some(4)
2. res0: List[Int] = List(1, 2, 3, 4)
4. scala> List(1,2,3) ++ None   
5. res1: List[Int] = List(1, 2, 3)

Options are implicitly converted to Iterables, so Options can be appended to collections.

1. scala> val x : Iterable[Int] = None       
2. x: Iterable[Int] = List()
4. scala> val x : Iterable[Int] = Some(4)
5. x: Iterable[Int] = List(4)

Chaining Options with orElse

A simple but handy use for Option is to select the first valid option from a selection of possible choices. Sound vague? Well it is because it can be used in many different situations. The one presented here is: the program needs a directory that can be set by the user either as a system variable, and environment variable or the default value. The java code is a nightmare of if (xxx == null) statements. The Scala code is beautiful.

1. scala> val propsTemplates = Option(System getProperty "MVN_CREATOR_TEMPLATES")
2. propsTemplates: Option[java.lang.String] = None
4. scala> val envTemplates = Option(System getenv "MVN_CREATOR_TEMPLATES")
5. envTemplates: Option[java.lang.String] = None
7. scala> val defaultHome = Some(System getProperty "user.home")
8. defaultHome: Some[java.lang.String] = Some(/Users/jeichar)
10. /* 
11. chain the different options together in order of priority and get the value
13. I am taking a small liberty here because I am assuming that user.home is always available
14. */
16. scala> propsTemplates.orElse(envTemplates).orElse(defaultHome).get
17. res0: java.lang.String = /Users/jeichar
19. // alternative form:
20. scala> propsTemplates orElse envTemplates orElse defaultHome get
21. res1: java.lang.String = /Users/jeichar

More on Null to Option Conversion

I have seen requests for a simpler way of dealing with nulls than Option(x) so here are a couple ideas:

Note: This only works with Scala 2.8+

1. // create an alias from Option.apply to ?
2. scala> import Option.{apply => ?} 
3. import Option.{apply=>$qmark}
5. scala> ?(null)
6. res0: Option[Null] = None
8. scala> ?(3)
9. res1: Option[Int] = Some(3)
11. scala> ?(3).getOrElse(10)
12. res2: Int = 3
14. scala> ?(null).getOrElse(10)
15. res3: Any = 10
17. // create an implicit conversion to Option
18. scala> implicit def toOption[T](x:T) : Option[T] = Option(x)
19. toOption: [T](x: T)Option[T]
21. scala> 3 getOrElse (10)
22. res4: Int = 3
24. scala> val i:String = null
25. i: String = null
27. scala> i getOrElse "hi"
28. res6: String = hi

Options

Scala is forced to have a "null" value because it interoperates with Java. However unlike Java APIs the recommended way to hand cases where there may or may not be a value (IE a return value) is to return an Option object. Compare the Scala and Java idioms for handling a possible null (or None) return value:

Note: The Option class have been updated in Scala 2.8 so I am going to use some of the scala 2.8 methods. Most of the examples will work with Scala 2.7 but not all; the principal is the same for 2.7 and 2.8.

Java:

1. /**
2.  * Returns the annotation with the given name or null if there is no annotation
3.  * on the objects class with the given name.
4.  */
5. public static < A extends java.lang.annotation.Annotation> Annotation annotation(Object obj, Class< A> annotationCls) {
6.   return obj.getClass().getAnnotation(annotationCls)
7. }

Scala:

1. import java.lang.annotation.Annotation
2. /**
3.  * Returns the annotation with the given name.
4.  */
5. def annotation[A <: Annotation](obj:Object, annotationCls:Class[A]) : Option[Annotation] = {
6.    Option (obj.getClass.getAnnotation (annotationCls))
7. }

In the Scala version it is obvious the use of the API (and the compiler) that there are two types of legal return types. Some or None and the compiler will force you to deal with this fact. Where in Java it is very easy to forget to check for null.

Also not that it is very easy to Wrap a null in an Option using the Option objects apply method. If the parameter is a null then None is return otherwise Some is returned.

The other important aspect is how to deal with the Option object and obtain the data from the object if it is present. This is both simple and non-simple. There are a large number of possible useage patterns that can be applied to it.

Examples:

1. scala> import java.lang.annotation.Annotation
2. import java.lang.annotation.Annotation
4. kscala> def annotation[A <: Annotation](obj:Object, annotationCls:Class[A]) : Option[Annotation] = { 
5.      |    Option (obj.getClass.getAnnotation (annotationCls))                                      
6.      | }
7. annotation: [A <: java.lang.annotation.Annotation](obj: java.lang.Object,annotationCls: Class[A])Option[java.lang.annotation.Annotation]
9. // strings do not have the Documented annotation so None is returned
10. scala> annotation("x", classOf[java.lang.annotation.Documented])                                   
11. res0: Option[java.lang.annotation.Annotation] = None
13. // None is not defined
14. scala> res0.isDefined
15. res1: Boolean = false
17. // None IS empty 
18. scala> res0.isEmpty
19. res26: Boolean = true
21. // We need a some example so LineNumberInputStream has Deprecated annotation
22. // we will use that in order to 
23. scala> val in = new LineNumberInputStream(new ByteArrayInputStream("hello".getBytes))
24. in: java.io.LineNumberInputStream = java.io.LineNumberInputStream@8ca9a2d
26. scala> annotation(in, classOf[Deprecated])                                           
27. res2: Option[java.lang.annotation.Annotation] = Some(@java.lang.Deprecated())
29. // Some(...) is always defined even if it contains null
30. scala> res2.isDefined
31. res3: Boolean = true
33. scala> val nullSome = Some(null)
34. nullSome: Some[Null] = Some(null)
36. scala> nullSome.isDefined
37. res28: Boolean = true
39. // Some is never empty
40. scala> res2.isEmpty
41. res4: Boolean = false
43. // You can also test particular values as follows
44. scala> if(res0 == None) println("its ok to use")
45. its ok to use
47. scala> if (res2.map {a => "found"} == Some("found")) println ("it is deprecated dont use!")
48. it is deprecated dont use!
50. scala> res0 match {                                                       
51.      | case None => println("its ok to use")                              
52.      | case Some(x:Deprecated) => println ("it is deprecated dont use!") 
53.      | }
54. its ok to use
56. scala> res2 match {                                                      
57.      | case None => println("its ok to use")                             
58.      | case Some(x:Deprecated) => println ("it is deprecated dont use!")
59.      | }
60. it is deprecated dont use!
62. scala> if(Some("hi") == Some("hi")) println("a match")    
63. a match
65. scala> if(Some("hi") == Some("ho")) println("a match")
68. // After you have tested you can use get to obtain the value
69. // but becareful, you will get an exception if you forget to test.
70. scala> res0.get
71. java.util.NoSuchElementException: None.get
72.                           at scala.None$.get(Option.scala:169)
73.                           at scala.None$.get(Option.scala:167)
74.                           at .< init>(< console>:12)
75.                           at .< clinit>(< console>)
76.                           [snip]
78. scala> res2.get
79. res10: java.lang.annotation.Annotation = @java.lang.Deprecated()
81. // a potentially better way of optaining the value is to provide a default if 
82. // the value does not exists
83. scala> res2.getOrElse(classOf[java.lang.annotation.Documented])
84. res13: java.lang.Object = @java.lang.Deprecated()
86. scala> res0.getOrElse(classOf[java.lang.annotation.Documented])
87. res14: java.lang.Object = interface java.lang.annotation.Documented
89. // A Option is a "monad" (dont worry too much about the term if 
90. // you dont know it) a very (VERY) simplified meaning of that is that 
91. // option behaves a bit like a collection of size 1 or 0
92. // you can use similar methods on an Option as a collection.  
93. // So exists tests each element in the Option to see if it matches 
94. // the function passed in as the parameter
96. // res2 has an object that is an instanceOf Annotation 
97. scala> res2.exists {_.isInstanceOf[Annotation]}  
98. res7: Boolean = true
100. // None always returns false to exists
101. scala> res0.exists {_.isInstanceOf[Annotation]}
102. res8: Boolean = false
104. scala> res2.exists {_.toString == "hi"}
105. res29: Boolean = false
107. // Similarly you can use the filter method that is present in all collections
108. scala> res2.filter {_.toString == "hi"}    
109. res30: Option[java.lang.annotation.Annotation] = None
111. scala> res2.filter {_.isInstanceOf[Annotation]}
112. res32: Option[java.lang.annotation.Annotation] = Some(@java.lang.Deprecated())
114. // apart from just filtering you can convert the type contained 
115. // in the Option by using map to map from one type of Option to
116. // another type of Option in this examples we map from 
117. // Option[Annotation] to Option[String]
118. scala> res0.map {_.toString}.getOrElse("does not exist")                        
119. res15: java.lang.String = does not exist
121. scala> res2.map {_.toString}.getOrElse("does not exist")
122. res16: java.lang.String = @java.lang.Deprecated()
124. // Another very handy and safe way to access the value is to use foreach
125. // this will call the function with the parameter from the Option if
126. // the Option is Some but a noop will occur if the Option is None.
127. scala> res2.foreach { println _ }
128. @java.lang.Deprecated()
130. scala> res0.foreach { println _ }
132. // orElse is simply a method to ensure that the Option is a Some
133. scala> res0.orElse(Some(classOf[java.lang.annotation.Documented]))
134. res22: Option[java.lang.Object] = Some(interface java.lang.annotation.Documented)
136. scala> res2.orElse(Some(classOf[java.lang.annotation.Documented]))
137. res23: Option[java.lang.Object] = Some(@java.lang.Deprecated())