zipWithIndex

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