Either

The Scala Either class is similar in function as Option but it represents a choice. For example a method can return Either an Int or an Exception. Usage example:

1. // If string can be converted to an Int then return Right[Int] otherwise
2. // return a Left[String] with the error message
3. // by convention the error state will always be the Left
4. scala> def toInt(string:String):Either[String,Int] = {
5.      | try { Right(string.toInt) }
6.      | catch { case e => Left("Error: "+e.getMessage) }
7.      | }
8. toInt: (string: String)Either[String,Int]
10. scala> toInt("1")
11. res0: Either[String,Int] = Right(1)
13. scala> toInt("booger")
14. res1: Either[String,Int] = Left(Error: For input string: "booger")

By convention if one return value is a error state and the other the expected state then Right will contain the expected state and Left will contain the error state.

1. scala> def toInt(string:String):Either[String,Int] = {
2.      | try { Right(string.toInt) }
3.      | catch { case e => Left("Error: "+e.getMessage) }
4.      | }
5. toInt: (string: String)Either[String,Int]
7. scala> toInt("1")
8. res0: Either[String,Int] = Right(1)
10. scala> toInt("booger")
11. res1: Either[String,Int] = Left(Error: For input string: "booger")
13. // you can test if the value is a left or right value quite easily
14. scala> res0.isLeft
15. res2: Boolean = false
17. scala> res1.isRight
18. res3: Boolean = false
20. scala> res0.isRight
21. res4: Boolean = true
23. scala> res1.isLeft 
24. res5: Boolean = true
26. // or matching can be used
27. scala> res0 match {                                   
28.      | case Left(l) => println("it is a left")        
29.      | case Right(r) => println("it is a right")      
30.      | }
31. it is a right
33. scala> res1 match {                             
34.      | case Left(l) => println("it is a left")  
35.      | case Right(r) => println("it is a right")
36.      | }
37. it is a left
40. // Perhaps cleaner than matching even is being able to pass 
41. // functions to the fold method:
42. // define one function for each side of the either
44. // first the function to handle the left side case
45. scala> def leftFunc(errMsg:String) = println("there has been an error")             
46. leftFunc: (errMsg: String)Unit
48. // next the function the handle the right side case
49. scala> def rightFunc(i:Int) = println(i+" was calculated")              
50. rightFunc: (i: Int)Unit
52. // then you can pass the two functions to the fold method
53. // and the correct one will be invoked
54. scala> res0 fold (leftFunc _, rightFunc _)
55. 1 was calculated
57. scala> res1 fold (leftFunc _, rightFunc _)
58. there has been an error