projection + map + find is cheating...

Hi,

The following code prints

1
2
3

I expected

1
2

Is this a bug?


  case class F(i:Int) extends (()=> Int)
  {
    override def apply() = {
      println(i)
      i
    }
  }
 
  def main(args: Array[String]) = {
    val l = F(1) :: F(2) :: F(3) :: F(4) :: Nil
    val m = l.projection.map(_().toString).find(_ == "2")
    ()
  }

BR,
John

John Nilsson schrieb:
> val m = l.projection.map(_().toString).find(_ == "2")

My goolge-fu is failing me right now, but I seem to recall a similar
discussion where the answer was that several non-strict constructs in
scala always evaluate the element after the current, so they know
whether they have a next element or not.
Anyway, the semantics of projections in the presence of side effects
(like your println) is underspecified:
http://lampsvn.epfl.ch/trac/scala/ticket/1081

I also found this, which is interesting, too, but for a slightly
different problem:
http://www.nabble.com/Re%3A-Re%3A-Two-questions-about-"yield"-p17298441.html

- Florian.

On Sun, Jan 4, 2009 at 5:55 AM, John Nilsson wrote:
> Hi,
>
> The following code prints
>
> 1
> 2
> 3
>
> I expected
>
> 1
> 2
>
> Is this a bug?
>
>
It's currently the expected behavior: the projection of a List is
defined to be a Stream, and Streams always evaluate their head
elements. This is likely to change in 2.8.0, though (I mean, that
List's projection is a Stream).

Cheers

It's currently the expected behavior: the projection of a List is
defined to be a Stream, and Streams always evaluate their head
elements. This is likely to change in 2.8.0, though (I mean, that
List's projection is a Stream).

Just to be clear, the problem is that find evaluates the next element, not
with the projection itself.

If you used "val m = l.projection.map(_().toString).tail.head" instead, the
result would be the one you expected.