CODEWITHSUNDEEP
scalascala-collections
John Smith
John Smith

Reputation: 3197

Strange results when using Scala collections

I have some tests with results that I can't quite explain.

The first test does a filter, map and reduce on a list containing 4 elements:

{
    val counter = new AtomicInteger(0)
    val l = List(1, 2, 3, 4)
    val filtered = l.filter{ i =>
        counter.incrementAndGet()
        true
    }
    val mapped = filtered.map{ i =>
        counter.incrementAndGet()
        i*2
    }
    val reduced = mapped.reduce{ (a, b) =>
        counter.incrementAndGet()
        a+b
    }
    println("counted " + counter.get + " and result is " + reduced)
    assert(20 == reduced)
    assert(11 == counter.get)
}

The counter is incremented 11 times as I expected: once for each element during filtering, once for each element during mapping and three times to add up the 4 elements.

Using wildcards the result changes:

{
    val counter = new AtomicInteger(0)
    val l = List(1, 2, 3, 4)
    val filtered = l.filter{
        counter.incrementAndGet()
        _ > 0
    }
    val mapped = filtered.map{
        counter.incrementAndGet()
        _*2
    }
    val reduced = mapped.reduce{ (a, b) =>
        counter.incrementAndGet()
        a+b
    }
    println("counted " + counter.get + " and result is " + reduced)
    assert(20 == reduced)
    assert(5 == counter.get)
}

I can't work out how to use wildcards in the reduce (code doesnt compile), but now, the counter is only incremented 5 times!!

So, question #1: Why do wildcards change the number of times the counter is called and how does that even work?

Then my second, related question. My understanding of views was that they would lazily execute the functions passed to the monadic methods, but the following code doesn't show that.

{
    val counter = new AtomicInteger(0)
    val l = Seq(1, 2, 3, 4).view
    val filtered = l.filter{
        counter.incrementAndGet()
        _ > 0
    }
println("after filter: " + counter.get)
    val mapped = filtered.map{
        counter.incrementAndGet()
        _*2
    }
println("after map: " + counter.get)
    val reduced = mapped.reduce{ (a, b) =>
        counter.incrementAndGet()
        a+b
    }
println("after reduce: " + counter.get)
    println("counted " + counter.get + " and result is " + reduced)
    assert(20 == reduced)
    assert(5 == counter.get)
}

The output is:

after filter: 1
after map: 2
after reduce: 5
counted 5 and result is 20

Question #2: How come the functions are being executed immediately?

I'm using Scala 2.10

Upvotes: 1

Views: 151

Answers (1)

Rex Kerr
Rex Kerr

Reputation: 167921

You're probably thinking that

filter {
  println
  _ > 0
}

means

filter{ i =>
  println
  i > 0
}

but Scala has other ideas. The reason is that

{ println; _ > 0 }

is a statement that first prints something, and then returns the > 0 function. So it interprets what you're doing as a funny way to specify the function, equivalent to:

val p = { println; (i: Int) => i > 0 }
filter(p)

which in turn is equivalent to

println
val temp = (i: Int) => i > 0   // Temporary name, forget we did this!
val p = temp
filter(p)

which as you can imagine doesn't quite work out the way you want--you only print (or in your case do the increment) once at the beginning. Both your problems stem from this.

Make sure if you're using underscores to mean "fill in the parameter" that you only have a single expression! If you're using multiple statements, it's best to stick to explicitly named parameters.

Upvotes: 11

Related Questions