scala notes: monoids and for-comprehensions working together

It has taken me awhile to understand monoids and their use. Once you get the hang of it, they make a lot of sense as a design pattern for structuring your code. Either, Option, Try are all monoids that can help structure your code and adapt existing code without changing the existing code or they help in structuring new code.

It also took a while to understand for-comprehensions as well. It turns out that switching monoids types in the middle of a for-comprehension is not impossible but difficult. Its best if each statement in the for-comprehension has the same monoid return type.

On gisthub: https://gist.github.com/aappddeevv/6530787 in case it does not display below correctly.

1:    
2:  // Define functions that return an Option  
3:  def f1(x: Int): Option[Int] = Some(x*30)  
4:  def f2(x: Int): Option[Int] = Some(x+3)  
5:  def f3(x: Int): Option[Int] = Some(x*2)  
6:    
7:  // Sequence the computation, it will be successful  
8:  var answer = for {  
9:   x <- f1(30)  
10:   y <- f2(x)  
11:   z <- f3(y)  
12:   } yield (x,y,z)  
13:     
14:  println("answer: " + answer)  
15:     
16:  // Sequence the computation, the filter will be used  
17:  answer = for {  
18:   x <- f1(30)  
19:   y <- f2(x) if(x>1000)  
20:   z <- f3(y)  
21:   } yield (x,y,z)  
22:     
23:  println("answer with filter: " + answer)  
24:     
25:  // Define functions that return Either  
26:  // Note that e2b returns Left as if it is an error.  
27:  def e1(x: Int): Either[String, Int] = Right(x*30)  
28:  def e2(x: Int): Either[String, Int] = Right(x+3)  
29:  def e2b(x: Int): Either[String, Int] = Left("error")  
30:  def e3(x: Int): Either[String, Int] = Right(x*2)  
31:    
32:  // Sequence the computations, knowing it will succeed  
33:  var eanswer = for {  
34:   x <- e1(30).right  
35:   y <- e2(x).right  
36:   z <- e3(y).right  
37:   } yield z  
38:     
39:  println("eanswer: " + eanswer)  
40:    
41:  // Sequence computations, knowing that it will have an error  
42:  eanswer = for {  
43:   x <- e1(30).right  
44:   y <- e2b(x).right  
45:   z <- e3(y).right  
46:   } yield z  
47:     
48:  println("eanswer (with Left()): " + eanswer)  
49:    
50:    
51:  /** Prints:  
52:  answer: Some((900,903,1806))  
53:  answer with filter: None  
54:  eanswer: Right(1806)  
55:  eanswer (with Left()): Left(error)  
56:  **/  
57:    
58:  // The following does not compile  
59:  // eanswer = for { ...  y <- e2b(x).left ... } ...  
60:  // Because e3, the function after e2b is called expects an int,   
61:  // but Left contains a String so when it is unwrapped to call  
62:  // e3 it is the wrong type. Scala compile time checks catch this!  
63:    
64:  // Either, Left and Right do not have a withFilter method  
65:  // so you cannot use if() clauses in for comprehensions directly  
66:  // when using Either. Option has a withFilter method.  
67:  println("Filter on <200: " + e2(33).right.filter[String](_<200))  
68:  println("Filter on >200: " + e2(33).right.filter[String](_ > 200))  
69:    
70:  /** Prints:  
71:  Filter on <200: Some(Right(36))  
72:  Filter on >200: None  
73:  **/  
74:    
75:  // Sequencing using just the Either monad and no filter  
76:  // criteria used on any of the map lines.   
77:  // Generally, when using a filter, check the scala  
78:  // docs for the monoid you are using (e.g. Option or  
79:  // Either) to understand what map, flatMap and withFilter  
80:  // do when applied to the monoid value. If withFilter  
81:  // is not present, then you may have difficulty using  
82:  // an if-condition on one of the "map" lines.  
83:  //  
84:  // Note that it does not make sense to have a withFilter  
85:  // on an Either. When using withFilter on an Option monoid,  
86:  // if the filter selects false (and hence returns a None),  
87:  // then a Some(yourValue) becomes a None. Both of which are  
88:  // well defined. But if you use either and the Right(yourValue)  
89:  // (or left depending on which 1/2 you use) is not selected,  
90:  // you need to return Left(someOtherYourValue) but someOtherYourValue  
91:  // is never defined automatically so there is no "automatic"  
92:  // other value to use. That's why you cannot apply a filter  
93:  // using the for-comprehension syntax.  
94:  //  
95:  // In the for-comprehension below, if a Left appears as a result  
96:  // of the function call, the for terminates immediately and returns   
97:  // the Left as the value.  
98:  var eanswer2 = for {  
99:   x <- e1(30).right  
100:   y <- e2(x).right  
101:   z <- e3(y).right  
102:   } yield z  
103:    
104:  println("eanswer with no filter: " + eanswer2)  
105:    
106:  /** Prints:  
107:  eanswer with no filter: Right(1806)  
108:  **/  
109: