zipWith (mapping over multiple Seq) in Scala
A lazy list isn't a copy of a list - it's more like a single object. In the case of a lazy zip implementation, each time it is asked for the next item, it grabs an item from each of the two input lists and creates a tuple from them, and you then break the tuple apart with the pattern-matching in your lambda.
So there's never a need to create a complete copy of the whole input list(s) before starting to operate on them. It boils down to a very similar allocation pattern to any application running on the JVM - lots of very short-lived but small allocations, which the JVM is optimised to deal with.
Update: to be clear, you need to be using Streams (lazy lists) not Lists. Scala's streams have a zip that works the lazy way, and so you shouldn't be converting things into lists.
Ideally your algorithm should be capable of working on two infinite streams without blowing up (assuming it doesn't do any folding
, of course, but just reads and generates streams).
In Scala 2.8:
val baz = (foo, bar).zipped map (_ + _)
And it works for more than two operands in the same way. I.e. you could then follow this up with:
(foo, bar, baz).zipped map (_ * _ * _)
Well, that, the lack of zip, is a deficiency in Scala's 2.7 Seq. Scala 2.8 has a well-thought collection design, to replace the ad-hoc way the collections present in 2.7 came to be (note that they weren't all created at once, with an unified design).
Now, when you want to avoid creating temporary collection, you should use "projection" on Scala 2.7, or "view" on Scala 2.8. This will give you a collection type for which certain instructions, particularly map, flatMap and filter, are non-strict. On Scala 2.7, the projection of a List is a Stream. On Scala 2.8, there is a SequenceView of a Sequence, but there is a zipWith right there in the Sequence, you wouldn't even need it.
Having said that, as mentioned, JVM is optimized to handle temporary object allocations, and, when running in server mode, the run-time optimization can do wonders. So, do not optimize prematurely. Test the code in the conditions it will be run -- and if you haven't planned to run it in server mode, then rethink that if the code is expected to be long-running, and optmize when/where/if necessary.
EDIT
What is actually going to be available on Scala 2.8 is this:
(foo,bar).zipped.map(_+_)
The function you want is called zipWith
, but it isn't a part of the standard library. It will be in 2.8 (UPDATE: Apparently not, see comments).
foo zipWith((f: Double, b : Double) => f+b) bar
See this Trac ticket.