How do I create a cartesian product of 2 channels where each channel is a tuple of (meta,value)?

[idot]

I need to create the cartesian product of 2 channels where each channel has the nf-core structure of a tuple(meta,value).
Without the tuple it works, but the tuple gives me an error. It looks like the entries are flattened by combine.

ERROR ~ Invalid method invocation `doCall` with arguments: [[:], 1, [:], A] (java.util.LinkedList) on _closure3 type

//def t(v){ tuple([:],v) } //it does not work with the tuple
def t(v){ v }
ch_a = Channel.fromList([t(1),t(2),t(3)])
ch_b = Channel.fromList([t("A"),t("B"),t("C")])


ch_a.combine(ch_b)
    .multiMap{ :x b ->
      a: a
      b: b
    }
    .set{ comb }

[bentsherman]

Yes, combine flattens the pairwise combinations. You can use cross if you don't want them to be flattened. This is a long-standing point of confusion about combine vs cross, but I have a PR that clarifies this point in the docs.

I'm not sure what's going on with your multiMap syntax, but I assume you were trying to do a, b -> as the closure arguments.

[idot]

Dear Ben,

thank you very much for the answer, but combine has two functions:

1. create cartesian product of 2 channels (and the output gets flattened)
2. create cartesian product of 2 channels for each common key (with by, only if the channel produces tuples, otherwise no output)

cross only does the second one with the ability to define a function for creating the mapping ( identical extractor for both channels )

I need an operator that creates the cartesian product of two channels that each produces tuples, ignoring any possible common "keys" and the result should preserve the input structure.

def t(m,v){ tuple([m:m],v) }
ch_a = Channel.fromList([t("x",1),t("y",2),t("z",3)])
ch_b = Channel.fromList([t("x","A"),t("B","B"),t("C","C")])


ch_a.cross(ch_b)
        .set{ comb }

comb.view()

Result cross

[[[m:x], 1], [[m:x], A]]

Result combine

[[m:x], 1, [m:x], A]
[[m:x], 1, [m:B], B]
[[m:y], 2, [m:x], A]
[[m:y], 2, [m:B], B]
[[m:x], 1, [m:C], C]
[[m:y], 2, [m:C], C]
[[m:z], 3, [m:x], A]
[[m:z], 3, [m:B], B]
[[m:z], 3, [m:C], C]

Desired result combine

[[[m:x], 1], [[m:x], A]]
[[[m:x], 1], [[m:B], B]]
[[[m:y], 2], [[m:x], A]]
[[[m:y], 2], [[m:B], B]]
[[[m:x], 1], [[m:C], C]]
[[[m:y], 2], [[m:C], C]]
[[[m:z], 3], [[m:x], A]]
[[[m:z], 3], [[m:B], B]]
[[[m:z], 3], [[m:C], C]]

[bentsherman]

You're right, cross can't do a simple cross product without matching, which seems odd since it's literally named cross 😅

While we could change cross to do a simple cross product when by is not given, Paolo probably won't accept it because it could break existing pipelines. Maybe we can do it if you explicitly say by: null ?

Anyway, for now I recommend you use combine and then map to un-flatten the combos:

ch_a.combine(ch_b)
    .map { a, b, c, d -> [ [a, b], [c, d] ] }