Flattening a Set of pairs of sets to one pair of sets

Question

I have a for-comprehension with a generator from a Set[MyType] This MyType has a lazy val variable called factsPair which returns a pair of sets: (Set[MyFact], Set[MyFact]).

I wish to loop through all of them and unify the facts into one flattened pair (Set[MyFact], Set[MyFact]) as follows, however I am getting No implicit view available ... and not enough arguments for flatten: implicit (asTraversable ... errors. (I am a bit new to Scala so still trying to get used to the errors).

lazy val allFacts  =
(for {
  mytype <- mytypeList
} yield mytype.factsPair).flatten

What do I need to specify to flatten for this to work?

score 3 · Answer 1 · answered Nov 15 '13 at 16:29

Scala flatten works on same types. You have a Seq[(Set[MyFact], Set[MyFact])], which can't be flattened.

I would recommend learning the foldLeft function, because it's very general and quite easy to use as soon as you get the hang of it:

lazy val allFacts = myTypeList.foldLeft((Set[MyFact](), Set[MyFact]())) {
  case (accumulator, next) =>
    val pairs1 = accumulator._1 ++ next.factsPair._1
    val pairs2 = accumulator._2 ++ next.factsPair._2
    (pairs1, pairs2)
}

The first parameter takes the initial element it will append the other elements to. We start with an empty Tuple[Set[MyFact], Set[MyFact]] initialized like this: (Set[MyFact](), Set[MyFact]()).

Next we have to specify the function that takes the accumulator and appends the next element to it and returns with the new accumulator that has the next element in it. Because of all the tuples, it doesn't look nice, but works.

Thanks. Your answer was a little bit more lengthy, but still good for me to understand what's going on. — jbx, Nov 15 '13 at 16:52
@jbx It's not just lengthy, but it does the job in one pass, rather than multiple ones. That's usually the advantage of `foldLeft` is that you can write as much magic into the body as you would like :) — Akos Krivachy, Nov 15 '13 at 16:57

Daniel C. Sobral · Accepted Answer · 2013-11-18T23:48:44.097

1

You won't be able to use flatten for this, because flatten on a collection returns a collection, and a tuple is not a collection.

You can, of course, just split, flatten, and join again:

val pairs = for {
  mytype <- mytypeList
} yield mytype.factsPair
val (first, second) = pairs.unzip
val allFacts = (first.flatten, second.flatten)

edited Nov 18 '13 at 23:48

answered Nov 15 '13 at 16:29

Daniel C. Sobral

295,120
86
501
681

1

or: `val (first, second) = pairs.unzip`? – dhg Nov 15 '13 at 16:31
@dhg so I can actually just change the `flatten` to `unzip` in my solution? I already have a Set of pairs coming through the for-comprehension, so if I am understanding correctly unzip will combine them into one pair of sets? – jbx Nov 15 '13 at 16:43
@dhg I had forgetten about `unzip`. Thanks for the tip! – Daniel C. Sobral Nov 18 '13 at 23:50

score 0 · Answer 3 · answered Nov 15 '13 at 16:25

0

A tuple isn't traverable, so you can't flatten over it. You need to return something that can be iterated over, like a List, for example:

List((1,2), (3,4)).flatten          // bad
List(List(1,2), List(3,4)).flatten  // good

answered Nov 15 '13 at 16:25

dhg

52,383
8
123
144

Thanks. I have `Set((Set(1,2),Set(3,4)), (Set(5,6),Set(7,8)))` and the result I want is `(Set(1,2,5,6), Set(3,4,7,8))`. I guess all the nesting was confusing me. – jbx Nov 15 '13 at 16:51

score 0 · Answer 4 · answered Nov 15 '13 at 21:12

I'd like to offer a more algebraic view. What you have here can be nicely solved using monoids. For each monoid there is a zero element and an operation to combine two elements into one.

In this case, sets for a monoid: the zero element is an empty set and the operation is a union. And if we have two monoids, their Cartesian product is also a monoid, where the operations are defined pairwise (see examples on Wikipedia).

Scalaz defines monoids for sets as well as tuples, so we don't need to do anything there. We'll just need a helper function that combines multiple monoid elements into one, which is implemented easily using folding:

def msum[A](ps: Iterable[A])(implicit m: Monoid[A]): A =
  ps.foldLeft(m.zero)(m.append(_, _))

(perhaps there already is such a function in Scala, I didn't find it). Using msum we can easily define

def pairs(ps: Iterable[MyType]): (Set[MyFact], Set[MyFact]) =
  msum(ps.map(_.factsPair))

using Scalaz's implicit monoids for tuples and sets.

Flattening a Set of pairs of sets to one pair of sets

4 Answers4