Zip with a constant value

A simple tip for zipping a List (or other collection) with a single value.

1. scala> Stream.continually("h") zip List(1,2,3,4)
2. res2: scala.collection.immutable.Stream[(java.lang.String, Int)] = Stream((h,1), ?)
4. scala> res2 mkString ","
5. res3: String = (h,1),(h,2),(h,3),(h,4)
7. scala> List(1,2,3,4) zip Stream.continually("h")
8. res4: List[(Int, java.lang.String)] = List((1,h), (2,h), (3,h), (4,h))

Streams 2: Stream construction

This post just adds to the information about streams in the previous post Introducing Streams. In this topic the methods in the Stream object are looked at a little closer:
(standard warning. Examples were done in Scala 2.8 so some examples may need to be modified for Scala 2.7)

1. scala> import Stream._
2. import Stream._
4. // the empty stream.  good for terminating a stream
5. scala> empty        
6. res0: scala.collection.immutable.Stream[Nothing] = Stream()
8. // one way to declare a stream. 
9. scala> 1 #:: 2 #:: empty foreach (println _)
10. 1
11. 2
12.  // the other main way to create a stream
13. scala> cons(1, cons(2, empty)) foreach println
14. 1
15. 2
17. /*
18. Neither of the previous methods of stream creation are particularily useful because they are explicit and therefore they may as well be Lists or some other collection.  There is very little benefit in those cases.  However when the cons of a stream (tail) is defined as a function then things get a bit more interesting
19. */
20. scala> def i(x:Int,y:Int):Stream[Int] = (x*y) #:: i(x+1,y*2)
21. i: (x: Int,y: Int)Stream[Int]
23. scala> i(2,3) take 3 foreach println
24. 6
25. 18
26. 48
28. // now lets visit a few more methods in the Stream object
31. // create an infinite stream starting at 10
32. scala> from (10) take 3 foreach println     
33. 10
34. 11
35. 12
37. // an infinite stream starting at 10 an increasing by 3
38. scala> from (10,3) take 3 foreach println
39. 10
40. 13
41. 16
43. // converting an interator to a stream
44. scala> (1 until 4).iterator.toStream foreach println
45. 1
46. 2
47. 3
49. // creating an Iterable to a stream
50. scala> (1 until 4).toStream foreach println         
51. 1
52. 2
53. 3
55. // a stream that always returns 7
56. // the following is a pretty convoluted way to compute 7*49 :-P
57. scala> continually(7) take 49 reduceLeft {_ + _}
58. res10: Int = 343
60. // create a stream of 6 streams
61. scala> fill(6)(1 to 2 toStream) foreach println
62. Stream(1, ?)
63. Stream(1, ?)
64. Stream(1, ?)
65. Stream(1, ?)
66. Stream(1, ?)
67. Stream(1, ?)
69. /*
70. create the same stream as the last example but flatten it out so instead of being a stream of 6 streams it is a stream of 12 elements. Each element in each of the streams are visited in order
71. */
72. scala> fill(6)(1 to 2 toStream).flatten take 6 foreach println
73. 1
74. 2
75. 1
76. 2
77. 1
78. 2
80. /*
81. equivalent to:
82. (1 until 20 by 3).toStream foreach println
83. */
84. scala> range(1, 20, 3) foreach println
85. 1
86. 4
87. 7
88. 10
89. 13
90. 16
91. 19
93. /*
94. equivalent to
95. (1 until 3).toStream foreach println
96. */
97. scala> range(1,3) foreach println          
98. 1
99. 2
101. /*
102. iterate is fun! 
103. signature is iterator(start)(elem)
104. basically starting at 3 execute the function on the previous value in the stream.
106. This is an infinite stream
107. */
108. scala> iterate(3){i => i-10} take 5 foreach println _               
109. 3
110. -7
111. -17
112. -27
113. -37
115. /*
116. Another example
117. */
118. scala> iterate(3){i => i*2} take 5 foreach println _ 
119. 3
120. 6
121. 12
122. 24
123. 48
125. /*
126. A final example
127. */
128. scala> iterate(3){i => i} take 5 foreach println _  
129. 3
130. 3
131. 3
132. 3
133. 3
135. /*
136. The real final,final example.  This example uses the optional length parameter.   So the stream is restricted to 5 elements
137. */
138. scala> iterate(3,5){i => i} foreach println       
139. 3
140. 3
141. 3
142. 3
143. 3

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.