What is the best code to create

List<DataA>

and

List<DataB>

starting from a

List<Source>

?

data class Source {
	val label
	val valueA
	val valueB
}

data class DataA {
	val label
	val valueA
}

data class DataB {
	val label
	val valueB
}

honestly unless the list is giant, just map over List<Source> twice

@nanodeath I was thinking there was a way to create both from the same loop

I mean, maybe yes, but it's going to be a mess

ok

It’s still linear O(n) so don’t worry.

you can probably do

.asSequence().flatMap { sequenceOf(DataA, DataB) }.partitionBy { it is DataA }

kind of a thing, but ew

maybe I could just loop the list with a simple for loop?

imperative might be the way to go here

yes, I was thinking that 😉

some people get a bit hung up on doing a functional style for everything, but at least in Kotlin that's not always viable. so long as it's self-contained in a nice little method, should be just fine.

yes, you are right

The functional style here is a bit tricky and may not work so great in Kotlin, I'm not sure

It depends… the most important is to copy elements to array with pre-allocated capacity. The rest is case of style. But I assume

map

pre-allocates array to be faster that’s why it’s probably better because developers usually forget about it when doing it with

for

loop.

https://pl.kotl.in/qoEJoW3qM doing it functionally seems fine to me in this case

no shit, this unzip method is awesome

it looks good 🙂 but yes, it would just work in this particular case

hey, you can't go changing the requirements now 🙂

You could argue an

unzip()

for

Triple

ought to exist in the stdlib also (or its easy enough to make yourself). I wonder what the generic version ought to look like.

The generic version would be transposing a list of lists

my first instinct was folding over the list to a pair of mutable lists; but yeah just making two mutable lists beforehand, looping over the sources and just putting them in, and then returning the lists out of a function is probably the best to begin with.

@ephemient nice, I didn't realize Kotlin had unzip

Kotlin has specialized kotlin.jvm.functions.Function0..Function22 clases (why 22? I dunno, but Scala's specialized Function and Tuple classes also go up to 22)

I don't understand how a language with destructuring can eliminate tuples because "it's better to name things in a data structure" with a straight face

dunno, I agree with it. Pairs are just super convenient, and Triples are...kinda awkward? it's nice to have named fields, anyway. (I'm also not a big fan of destructuring.)

names are nice, but being able to perform operations like zip, unzip, cartesian product on larger tuples would also be nice

@nanodeath so you would write:

for (x in zip(firstList, secondList)) {
    // x.first, x.second
}

?

you got me, destructuring is great for iterating over pairs and entries 🙂 I avoid writing

.first

and

.second

and

.key

and

.value

whenever I can

yeah, if you write a generic function like

zip

though you don't really have anything intelligent to call the entries though

ehh this is mostly good as a highlight of performance pitfalls of functional programs tbh

And using mutableList and add?

Yeah that would work