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)

Introducing Streams

Streams are a special type of Iterable/Traversable whose elements are not evaluated until they are requested. Streams are normally constructed as functions.

A Scala List basically consists of the head element and the rest of the list. A Scala Stream is the head of the stream and a function that can construct the rest of the Stream. It is a bit more than this because each element is evaluated only once and stored in memory for future evaluations. That should be more clear after some examples.

As usual I created these examples with the Scala 2.8 REPL but I think most if not all should work in 2.7.

1. scala> import Stream.cons          
2. import Stream.cons
3. /*
4. Because streams are very functional in nature it is recommended that methods from the Stream object are used for creation
6. This is a real boring example of creating a Stream.  Anything this simple should be a list.
8. The important part is that cons take the value at the point and a function to return the rest of the
9. stream NOT another stream.  
10. */
11. scala> val stream1 = cons(0,cons(1,Stream.empty))
12. stream1: Stream.Cons[Int] = Stream(0, ?)
14. scala> stream1 foreach {print _}                 
15. 01
17. /*
18. This illustrates the similarity in design between Stream and list, again the difference is the entire list is created in a stream the second argument of cons is not evaluated until it is requested
19. */
20. scala> new ::(0, new ::(1,List.empty))
21. res35: scala.collection.immutable.::[Int] = List(0, 1)
24. /*
25. To drive home the point of the similarities.  Here is an alternative declaration of a
26. stream most similar to declaring a list
27. */
28. scala> val stream2 = 0 #:: 1 #:: Stream.empty    
29. stream2: scala.collection.immutable.Stream[Int] = Stream(0, ?)
31. scala> stream2 foreach {print _}
32. 01
34. scala> 0 :: 1 :: Nil
35. res36: List[Int] = List(0, 1)
37. /*
38. A little more interesting now.  The accessing the second element will run the function.  Notice it is not evaluated until request
39. */
40. scala> val stream3 = cons (0, {    
41.      | println("getting second element")
42.      | cons(1,Stream.empty)
43.      | })
44. stream3: Stream.Cons[Int] = Stream(0, ?)
46. scala> stream3(0)
47. res56: Int = 0
49. // function is evaluated
50. scala> stream3(1)
51. getting second element
52. res57: Int = 1
54. /* 
55. Function is only evaluated once.  
57. Important! This means that all elements in a Stream are loaded into a memory so
58. it can cause a OutOfMemoryError if the stream is large
59. */
60. scala> stream3(1)
61. res58: Int = 1
63. scala> stream3(1)
64. res59: Int = 1
66. /*
67. This creates an infinate stream then forces resolution of all elements
68. */
69. scala> Stream.from(100).force            
70. java.lang.OutOfMemoryError: Java heap space
72. // Alternative demonstration of laziness
73. scala> val stream4 = 0 #:: {println("hi"); 1} #:: Stream.empty
74. stream4: scala.collection.immutable.Stream[Int] = Stream(0, ?)
76. scala> stream4(1)
77. hi
78. res2: Int = 1

A very common way to construct a Stream is to define a recursive method. Each recursive call constructs a new element in the stream. The method may or may not have a guard condition that terminates the stream.

1. // construct a stream of random elements
2. scala> def make : Stream[Int] = Stream.cons(util.Random.nextInt(10), make)
3. make: Stream[Int]
5. scala> val infinate = make                                                
6. infinate: Stream[Int] = Stream(3, ?)
8. scala> infinate(5)                                  
9. res10: Int = 6
11. scala> infinate(0)
12. res11: Int = 3
14. // Once evaluated each element does not change
15. scala> infinate(5)
16. res13: Int = 6
18. // this function makes a stream that does terminate
19. scala> def make(i:Int) : Stream[String] = {                  
20.      | if(i==0) Stream.empty                                 
21.      | else Stream.cons(i + 5 toString, make(i-1))           
22.      | }
23. make: (i: Int)Stream[String]
25. scala> val finite = make(5)                       
26. finite: Stream[String] = Stream(10, ?)
28. scala> finite foreach print _                     
29. 109876
31. // One last demonstration of making a stream object
32. scala> Stream.cons("10", make(2))
33. res18: Stream.Cons[String] = Stream(10, ?)
35. /*
36. This method is dangerous as it forces the entire stream to be evaluated
37. */
38. scala> res18.size
39. res19: Int = 3

This is only an introduction. I hope to add a few more topics that focus on Streams because they can be very powerful but are also more challenging to recognize where they should be used instead of a standard collection.

Using objects as functions

A fun but easily overlooked fact is that many classes inherit from a Function class and therefore can be used where "normal" functions can be used.

1. scala> List(1,2) map (Map(1->"one",2->"two"))
2. res0: List[java.lang.String] = List(one, two)
4. scala> List(3,3,2) map (List('a', 'b', 'c','d'))
5. res2: List[Char] = List(d, d, c)

Basic Collection Operations

In this example I show some common operations that can be performed on all collections. The examples use list but any Iterable can be used.

1. scala> val list = List(1,2,3,4)
2. list: List[Int] = List(1, 2, 3, 4)
4. scala> list.mkString(",")
5. res0: String = 1,2,3,4
7. scala> list.mkString("(",",",")")
8. res1: String = (1,2,3,4)
10. scala> list.reduceLeft ( (next,cumulative) => cumulative + next )
11. res2: Int = 10
13. scala> for( e <- list ) println ( e ) 
14. 1 2 3 4  
16. scala> for( e <- list ) {      
17.      | println ( e )      
18.      | } 
19. 1 2 3 4  
21. scala> for( e <- list ) yield e+1 
22. res5: List[Int] = List(2, 3, 4, 5)  
24. scala> for ( e <- list; if( e % 2 == 0 ) ) yield e 
25. res6: List[Int] = List(2, 4)