Use map function to transform two seqs into one. Scala

Question

in clojure we have a map function where you can provide a function and two collections

(map + [1 2 ] [4 5 ]) ;;=> (5 7 )

is there something similar in Scala?

I tried with for comprehension but then i got 4 combinations.

If there is a way with for comprehension, would be even better because i have to do some filtering in the future/

Answer 1

You can use .zip first to combine the two collections into one, then map:

seq1.zip(seq2).map { case (x, y) => x + y }

I don't think it's possible with a for-comprehension. You can do filtering with a call to .filter or .filterNot as well.

Answer 2

@JoeK gives you the specific answer.

I'll provide two more general answers for you. Clojure, and many other dynamic languages, will often abstract over arity (the standard library's map and apply functions are great examples of this). In the absence of dependent types, this is difficult to do in statically typed languages. The general pattern you'll see instead is repeated applications of a function as many times as needed. In this case if you needed to do

(map + [1 2 3] [4 5 6] [7 8 9])

You would need to do

xs.zip(ys).zip(zs).map{ case (x, (y, z)) => x + y + z }

Generally this extra boilerplate is not terrible. Where abstraction over arity becomes more sorely missed is when you want to abstract over arbitrary tuples or arbitrary case classes. That's when Shapeless, a Scala library that gives you a limited form of dependent types, comes into play.

I would not break out Shapeless for something like this though.

The second general point is that you cannot zip lists in the manner you're asking for with for comprehensions (well not in general... because you can compare everything for equality in Scala you kind of sort of can with a final filter pass but that fails for anything where builtin equality doesn't give you what you want). The general principle behind this is a bit more subtle. It turns out that there's a hierarchy of power of these collection functions. You start out with map. If you add zip and List.apply you jump to the next level. If you replace zip with flatten you get another level. With flatten you can recover a version of zip, but not the other way around.

The default Scala flatMap and flatten (note that a for comprehension is ultimately a series of flatMap calls) for collections does give rise to a form of zip, i.e. something with the same type signature, but it turns out to be the Cartesian product as you've noticed.

There is a version of flatten that does give rise to the standard zip, but it only makes sense if all your collections are the same length. It involves taking the diagonal of the square matrix that results from a collection of collections.

This is usually not as useful for finite collections because Scala's type system is not powerful enough to express the constant length constraint and you can get some strange behavior if you don't ensure consistent length.

On the other hand this is the version of flatten and flatMap that is actually useful for infinite streams (where the equivalent of List.apply is an infinite constant stream) whereas the "normal" version of flatten would fail to get past processing the first stream.

Side note: You can of course always use your zipped list later in a for comprehension (where you might do some filtering). You just can't implement the zipping itself in a for comprehension.

Answer 3

Not really adding anything new here, but maybe this will help:

def mapCollections[A,B,C](as: Seq[A], bs: Seq[B])(f: (A,B) => C): Seq[C] = 
  as zip bs map f.tupled

mapCollections(List(1, 2), List(4, 5))(_ + _) // = List(5, 7)