Can I map multiple value? `flowNode.nextNodes.addAll(target.outgoing.toList().map { it.target }`, I ...

# getting-started

[fstn]

Can I map multiple value? flowNode.nextNodes.addAll(target.outgoing.toList().map { it.target }, I would like to return it.target and it.description can I write flowNode.nextNodes.addAll(target.outgoing.toList().map { it.target,it.description }?

[karelpeeters]

Please surround your code with `.

[karelpeeters]

You may be looking for flatMap.

[fstn]

mmm, I thought that flatMap is used to map multiple values for example multiple targets, but I would return target and description

[karelpeeters]

What do you want the result to be? A list of pairs? A map? A list that contains both the `target`s and `description`s?

[fstn]

a list of pairs

[fstn]

(target,description)

[karelpeeters]

In that case use .map { it.target to it.description }.

[fstn]

thank you, so when I want to associate value inside a pair, I can use the infix function to

[karelpeeters]

It's technically just a normal infix function, but yes.

[fstn]

😉 It’s my first day using Kotlin, sorry

[karelpeeters]

No problem!

[fstn]

what do you thing about writing that kind of stuff : val outgoingResult = target.outgoing.toList().map { it.target to it.extensionElements?.elementsQuery?.filterByType(CamundaInputOutput::class.java) }.map({ (it,flow) ->parseNode(it) to flow })

[fstn]

it’s seems to be hard to understand for someone else

[fstn]

what kind of coding style should I use? all on one line? or maybe split into variables

[karelpeeters]

I'd put the parseNode in the original map, there's no reason for it to be separated.

[karelpeeters]

The code itself looks fine to me, just format it correctly. I'd go with one of these:

[karelpeeters]

outgoingResult = target.outgoing.toList().map {
    parseNode(it.target) to it.extensionElements?.elementsQuery?.filterByType(CamundaInputOutput::class.java)
}

outgoingResult = target.outgoing.toList().map {
    Pair(
            parseNode(it.target),
            it.extensionElements?.elementsQuery?.filterByType(CamundaInputOutput::class.java)
    )
}

[fstn]

yes 🙂 it’s better now

[fstn]

I need to find my style 🙂

[fstn]

I use this `it.extensionElements?.elementsQuery?.filterByType(CamundaInputOutput::class.java)?.list()?.map { it.camundaInputParameters?.map { it.textContent } }?.first()`multiple times, what is the best way to mutualise this part of code?

[fstn]

create a function?

[fstn]

or there is something better?

[karelpeeters]

x?.let{ ... } can help eliminate a bunch of those ?'s in that code.

[karelpeeters]

You can also just inline maps, .map{ f(it) }.map { g(x) } is the same as .map(g(f(it)).

[karelpeeters]

If you still want to create a function for it there are extension functions: https://kotlinlang.org/docs/reference/extensions.html

[fstn]

ok, for the let I can use only one let to replace all ?

[fstn]

I need to put it at the end?

[karelpeeters]

Sure as long as the ?'s in your code all come from one of the first things being null.

[fstn]

thank you

[fstn]

.map { it.camundaInputParameters?.map { it.textContent } } no seems to be similar to `.map { it.camundaInputParameters}?.map { it.textContent } ``

[fstn]

I don’t understand why

[fstn]

It should be the same no?

[fstn]

I have no compilation issue by adding a first between both `map { it.camundaInputParameters}?.first()?.map { it->it.textContent } ``

[karelpeeters]

They are mostly the same, yes.

[karelpeeters]

There may be some null-related differences but that just depends on where you place the ?'s.