Daily scala

A common desire is to have access to the index of an element when using collection methods like foreach, filter, foldLeft/Right, etc... Fortunately there is a simple way.

List('a','b','c','d').zipWithIndex.

But wait!

Does that not trigger an extra iteration through the collection?. Indeed it does and that is where Views help.

List('a','b','c','d').view.zipWithIndex

When using a view the collection is only traversed when required so there is no performance loss.

Here are some examples of zipWithIndex:

1. scala> val list = List('a','b','c','d')
2. list: List[Char] = List(a, b, c, d)
3. /*
4. I like to use functions constructed with case statements
5. in order to clearly label the index.  The alternative is 
6. to use x._2 for the index and x._1 for the value
7. */
8. scala> list.view.zipWithIndex foreach {case (value,index) => println(value,index)}
9. (a,0)
10. (b,1)
11. (c,2)
12. (d,3)
13. // alternative syntax without case statement
14. scala> list.view.zipWithIndex foreach {e => println(e._1,e._2)}
15. (a,0)
16. (b,1)
17. (c,2)
18. (d,3)
19. /*
20. Fold left and right functions have 2 parameters (accumulator, nextValue) 
21. using a case statement allows you to expand that but watch the brackets!
22. */
23. scala> (list.view.zipWithIndex foldLeft 0) {case (acc,(value,index)) => acc + value.toInt + index} 
24. res14: Int = 400
25. // alternative syntax without case statement
26. scala> (list.view.zipWithIndex foldLeft 0) {(acc,e) => acc + e._1.toInt + e._2} 
27. res23: Int = 400
28. /*
29. alternative foldLeft operator.  The thing I like about this
30. syntax is that it has the initial accumulator value on the left 
31. in the same position as the accumulator parameter in the function.
33. The other thing I like about it is that visually you can see that it starts with
34. "" and the folds left
35. */
36. scala> ("" /: list.view.zipWithIndex) {                          
37.      | case (acc, (value, index)) if index % 2 == 0 => acc + value
38.      | case (acc, _) => acc                                       
39.      | }
40. res15: java.lang.String = ac
41. /*
42. This example filters based on the index then uses map to remove the index
43. force simply forces the view to be processed.  (I love these collections!)
44. */
45. scala> list.view.zipWithIndex.filter { _._2 % 2 == 0 }.map { _._1}.force
46. res29: Seq[Char] = List(a, c)

I picked up this tip from one of Daniel Spiewak's tweets. He tweeted a pro tip that uses flatMap to create a filtered list:

1. list flatMap {
2.   case st: String => Some(st)
3.   case _ => None
4. }

At a glance one might wonder why not simply use list.filter{_.isInstanceOf[String]}. The difference is that the flatMap will return a List[String].

However Scala 2.8 offers the collect method for doing a similar thing.

1. def strings(list: List[Any]) = list flatMap {
2.   case st: String => Some(st)
3.   case _ => None
4. }
5. // returned list is a List[String]
6. scala> strings("hi" :: 1 :: "world" :: 4 :: Nil)
7. res11: List[String] = List(hi, world)
8. // returned list is a List[Any] (not as useful)
9. scala> "hi" :: 1 :: "world" :: 4 :: Nil filter {_.isInstanceOf[String]}
10. res12: List[Any] = List(hi, world)
11. // collect returns List[String]
12. scala> "hi" :: 1 :: "world" :: 4 :: Nil collect {case s:String => s}           
13. res13: List[String] = List(hi, world)

This topic is a simple tip for a cleaner syntax for guards. Guards/filters are statements in for-comprehensions and case statements that guard or filter matches. Often you will see them as follows:

1. scala> for (i <- 1 to 10; if (i % 2 == 1)) yield i
2. res0: scala.collection.immutable.IndexedSeq[Int] = IndexedSeq(1, 3, 5, 7, 9)
3. scala> util.Random.nextInt(10) match {
4.      | case i if(i>5) => println("hi")
5.      | case _ => println("low")
6.      | }
7. low

However you have the option to apply a little sugar to the statements cleaning them up a little:

1. scala> for (i <- 1 to 10; if i % 2 == 1) yield i  
2. res2: scala.collection.immutable.IndexedSeq[Int] = IndexedSeq(1, 3, 5, 7, 9)
3. scala> util.Random.nextInt(10) match {          
4.      | case i if i>5 => println("hi")           
5.      | case _ => println("low")                 
6.      | }
7. hi

As you can see the brackets are optional. That is because in both cases the brackets are not required for the parser to determine the start and end of the guard statements. They are added so that the "normal" syntax used in the typical if statements will compile.

1. scala> 10 match { case i if i == 1 || i == 10 => "obviously this is a match"} 
2. res4: java.lang.String = obviously this is a match
3. /*
4. In case statements you can split the if almost any way you want because it is very clearly bound by the if and the => that is required for all case statements with a guard
5. */
6. scala> 10 match { case i if i == 1 ||                                        
7.      | i == 10 => "obviously this is a match"}
8. res5: java.lang.String = obviously this is a match
9. scala> 10 match {        
10.      | case i
11.      | if
12.      | i == 1
13.      | ||
14.      | i == 10 
15.      | => "matched"
16.      | }
17. res6: java.lang.String = matched
18. /*
19. For-comprehensions are not as flexible since it is harder for the compiler to determine where the guard ends. So try to keep it on one line or otherwise make it a function.  That is probably good advice for case statements as well.
20. */
21. scala> for { 
22.      | x <- 1 to 10
23.      | if
24.      | x > 10
25.      | || x == 2 } yield x
26. < console>:5: error: '<-' expected but integer literal found.
27.        || x == 2 } yield x
28.                ^
29. < console>:5: error: illegal start of simple expression
30.        || x == 2 } yield x
31.                  ^
32. scala> for {              
33.      | x <- 1 to 10       
34.      | if x == 1 || x == 10 } yield x
35. res7: scala.collection.immutable.IndexedSeq[Int] = IndexedSeq(1, 10)