Playing with streams
wwagner4
// What basic function exist to create a Stream
{
val s = Stream.from(-1)
println("(1)" + take10(s))
}
{
val s = Stream.from(100, -3)
println("(2)" + take10(s))
}
{
val s = Stream.continually("A")
println("(3)" + take10(s))
}
{
val s = "B" #:: Stream.continually("A")
println("(4)" + take10(s))
}
// Add a separator except for the first item using the [false, true, true, true, ...] stream s1
{
val s1 = false #:: Stream.continually(true)
val s2 = List("A", "B", "C")
val s3 = s2 zip s1
val l = (s3 map { case (v, b) => if (b) List("|", v) else List(v) }).flatten mkString ("(", "", ")")
println("(5a)" + l)
}
// The [false, true, true, true, ...] stream s1 can be reused in different threads at the same time. It is immutable
{
val s1 = false #:: Stream.continually(true)
scala.actors.Actor.actor {
val s2 = 1 to 5
val s3 = s2 zip s1
val l = (s3 map { case (v, b) => if (b) List("|", v) else List(v) }).flatten mkString ("(", "", ")")
println("(5b)" + l)
}
scala.actors.Actor.actor {
val s2 = List("A", "B", "C")
val s3 = s2 zip s1
val l = (s3 map { case (v, b) => if (b) List("|", v) else List(v) }).flatten mkString ("(", "", ")")
println("(5c)" + l)
}
scala.actors.Actor.actor {
val s2 = 1 to 200
val s3 = s2 zip s1
val l = (s3 map {case (v, true) => List("|", v) case (v, _) => List(v) }).flatten mkString ("(", "", ")")
println("(5d)" + l)
}
scala.actors.Actor.actor {
val s2 = 1 to 200
val s3 = s2 zip s1
val l = (s3 map {case (v, true) => List("|", v) case (v, _) => List(v)}).flatten mkString ("(", "", ")")
println("(5e)" + l)
}
}
{
// How can that be written in one line ?
val s1: Stream[Option[String]] = Stream.continually(Some("A"))
val s = None #:: s1
println("(6)" + take10(s))
}
// Iterate is for me the most interesting method of creating streams
{
val s = Stream.iterate(2) { n => n + 3 }
println("(7)" + take10(s))
}
{
val s = Stream.iterate(List.fill(4)(100)) { n => n map (_ + 1) }
println("(8)" + take10(s))
}
{
val s = Stream.iterate(List.fill(4)(-4)) { n => n map (_ + 1) }.flatten
println("(9)" + take10(s))
}
{
val s = Stream.continually(0 until 4)
println("(10)" + take10(s))
}
{
val s = Stream.continually(0 until 4).flatten
println("(11)" + take10(s))
}
// Coordinates for an n columns array produced with two streams s1, s2
{
val n = 3
val s1 = Stream.continually(0 until n).flatten
val s2 = Stream.iterate(List.fill(n)(0)) { n => n map (_ + 1) }.flatten
val s = s1 zip s2
println("(12a)" + take30(s1))
println("(12b)" + take30(s2))
println("(12c)" + take30(s))
println("(12d)" + s(10))
println("(12e)" + s(1000000))
// Much faster than the one before
println("(12f)" + s(999999))
}
def take10[A](s: Iterable[A]) = s.take(10).toList
def take30[A](s: Iterable[A]) = s.take(30).toList
}
Alexander Daniel
> {
> val s1: Stream[Option[String]] = Stream.continually(Some("A"))
> val s = None #:: s1
> println("(6)" + take10(s))
> }
val s = Stream.cons(None, Stream.continually(Some("A")))
O.k. But why does the version with #:: not work? Let's look at the compiler message:
scala> val s = None #:: Stream.continually(Some("A"))
<console>:7: error: type mismatch;
found : None.type (with underlying type object None)
required: Some[java.lang.String]
val s = None #:: Stream.continually(Some("A"))
^
Hmmmm. The compiler wants a object of type Some[String] and does not accept None. Following code is fine for the compiler:
scala> val s = Some("B") #:: Stream.continually(Some("A"))
s: scala.collection.immutable.Stream[Some[java.lang.String]] = Stream(Some(B), ?)
scala> val s = None #:: Stream.continually(None)
s: scala.collection.immutable.Stream[None.type] = Stream(None, ?)
What is going on? If a method is used in operator notation and the method name ends in a colon, the method is invoked on the right operand, i.e. in we have
scala> val s = Stream.continually(Some("A")).#::(None)
<console>:7: error: type mismatch;
found : None.type (with underlying type object None)
required: Some[java.lang.String]
val s = Stream.continually(Some("A")).#::(None)
^
Of course it gives the same compiler message as before. So where is #:: defined?
It is defined in ConsWrapper in Stream.scala with an implicit conversion:
/** A wrapper class that adds `#::` for cons and `#:::` for concat as operations
* to streams.
*/
class ConsWrapper[A](tl: => Stream[A]) {
def #::(hd: A): Stream[A] = cons(hd, tl)
def #:::(prefix: Stream[A]): Stream[A] = prefix append tl
}
/** A wrapper method that adds `#::` for cons and `#::: for concat as operations
* to streams.
*/
implicit def consWrapper[A](stream: => Stream[A]): ConsWrapper[A] =
new ConsWrapper[A](stream)
I.e. we have
scala> val s = new scala.collection.immutable.Stream.ConsWrapper(Stream.continually(Some("A"))).#::(None)
<console>:7: error: type mismatch;
found : None.type (with underlying type object None)
required: Some[java.lang.String]
val s = new scala.collection.immutable.Stream.ConsWrapper(Stream.continually(Some("A"))).#::(None)
^
and are getting the same compiler message again. ConsWrapper is very strict about the types. They have to match. But we can specify the type when creating ConsWrapper:
scala> val s = new scala.collection.immutable.Stream.ConsWrapper[Option[String]](Stream.continually(Some("A"))).#::(None)
s: scala.collection.immutable.Stream[Option[String]] = Stream(None, ?)
:-) That works. Unwinding again using the implicit conversion and specifying the type parameter:
scala> val s = Stream.continually[Option[String]](Some("A")).#::(None)
s: scala.collection.immutable.Stream[Option[String]] = Stream(None, ?)
:-) Now to operator notation:
scala> val s = None #:: Stream.continually[Option[String]](Some("A"))
s: scala.collection.immutable.Stream[Option[String]] = Stream(None, ?)
:-) Now we have an alternative one line notation but it looks more complicated than the first solution Stream.cons(None, Stream.continually(Some("A")))
So what is the signature of Stream.cons?
/** An alternative way of building and matching Streams using Stream.cons(hd, tl).
*/
object cons {
/** A stream consisting of a given first element and remaining elements
* @param hd The first element of the result stream
* @param tl The remaining elements of the result stream
*/
def apply[A](hd: A, tl: => Stream[A]) = new Cons(hd, tl)
/** Maps a stream to its head and tail */
def unapply[A](xs: Stream[A]): Option[(A, Stream[A])] = #::.unapply(xs)
}
Because we now have one method call with two parameters the compiler can figure out the supertype Option of None and Some and it works.
But why does it work for lists:
scala> val l = None :: List(Some("A"))
l: List[Option[java.lang.String]] = List(None, Some(A))
That I will explore another time.
Alex