is there are nicer way of writting the following: ...

# announcements

[robstoll]

is there are nicer way of writting the following:

val list = mutableListOf()
var parent = map[current]
while(parent != null){
  list.add(parent)
  parent = map[parent]
}

I have the feeling there is a functional equivalent but I cannot come up with what it is

[Andreas Sinz]

recursion comes to my mind

[robstoll]

japp but I figured there is a function for this. Seems like a standard problem

[robstoll]

that was my first guess but I don't see how I can fold

[Andreas Sinz]

i've removed it, because there is nothing to fold over

[Andreas Sinz]

so your best bet is recursion

[robstoll]

hm...

[Andreas Sinz]

if you do it right, you can make it as fast as the while-loop way: https://kotlinlang.org/docs/reference/functions.html#tail-recursive-functions

[robstoll]

I am not a functional purist 🙂 in the end tailrecursion is optimised to the while above so I can write the while from the beginning

[robstoll]

I'll search a bit and will come back if I found a solution

[dsavvinov]

Looks like generateSequence would fit nicely here:

fun main(args: Array<String>) {
    val initial = 0
    val map: Map<Int, Int?> = mapOf(
            0 to 2,
            2 to 1,
            1 to 3,
            3 to null
    )
    generateSequence(initial) { map[it] }.toList()
}

Code above prints [0, 2, 1, 3]

[robstoll]

the thing is, it does not need to be the first key

[robstoll]

I am not familiar with generateSequence, how would I need to adopt it?

[diesieben07]

generateSequence returns a sequence by repeatedly applying the function until it returns null

[robstoll]

ah.. damit, did not see initial 😄

[robstoll]

unfortunate that it is much slower than the while loop 😞

[dsavvinov]

Why do you think so? Essentially, it creates intermediate object (GeneratorSequence), then takes iterator from it (which will just delegate to passed function along with some simple conditional checks) and uses it to iterate over sequence in a usual way.

Overhead shouldn't be very significant, unless you absolutely need every bit of a performance -- in such case yes, you will have to sacrifice code conciseness and readability for performance (which is extremely rare case, tbh)

[robstoll]

I just made a quick benchmark 😉 nothing serious though

[robstoll]

but still, quite a difference, following a sample:

generateSequence1522.179
flatMap: 1412.807
while: 10.216
while: 2.104
generateSequence:356.357
flatMap: 345.54
flatMap: 336.826
while: 3.005
generateSequence:338.329

[robstoll]

the numbers are System.nanoTime()/1000f

[robstoll]

I think the numbers are significant enough that I can neglect my ragged setup