Where causes code to be called twice

[Deijin27]

Take the code

class Foo {
  num { _num }
  construct new(num) {
    _num = num
    System.print("Creating foo")
  }
}

var bar = [1, 2].map{|x| Foo.new(x) }.where{|x| x.num > 0}.toList

If run, it prints "Creating foo" 4 times. Intuitively I expect it to call only 2 times, and I tested the same thing using C# linq and it is called 2 times.

Is this possible to fix with how WhereSequence works?
At the very least it's something to look out for in case your construction is resource intensive.

[ruby0x1]

Interesting! Sequences are evaluated lazily, which seems to be involved.
If you resolve the map sequence first via toList it prints twice only, since the where is only on the list

var bar = [1, 2].map{|x| Foo.new(x) }.toList.where{|x| x.num > 0}.toList

[mhermier]

This is to be expected, since the filtering done by where involve accessing the value, in addition of the acces for flattening to list. Effectively it doubles the access to the value, resulting in the effect you see. You can either do an intermediate flattening as proposed (or any other form of memoization), or if possible rearrange the order of map so that they happens last in the chain.

[pedro-w]

I thought this was surprising too - as mhermier says it is because of the way WhereSequence calls iteratorValue on its 'upstream' sequence (at least) once to find a value that satisfies the filter and once to actually get the value (see below). Specifically iteratorValue calls back though the chain every time, in this case calling the map function on the way to the source list [1,2]

If you have two where clauses then it prints 'Creating foo' six times

var bar = [1, 2].
 map{|x| Foo.new(x) }.
 where{|x| x.num > 0}.
 where{|x| x.num < 10}.
 toList

An option would be to have WhereSequence's iterator memoise the last result but assuming you don't want to change the code, would it be possible to make this a bit clearer in the iterator protocol docs?
Thanks!

wren/src/vm/wren_core.wren

Lines 168 to 182 in c2a75f1

	class WhereSequence is Sequence {
	construct new(sequence, fn) {
	_sequence = sequence
	_fn = fn
	}
	iterate(iterator) {
	while (iterator = _sequence.iterate(iterator)) {
	if (_fn.call(_sequence.iteratorValue(iterator))) break
	}
	return iterator
	}
	iteratorValue(iterator) { _sequence.iteratorValue(iterator) }
	}