Is there a way to do this without using mutableList ``` fun

Question

Is there a way to do this without using mutableList ``` fun Example sequence vararg operations Example gt Example List lt Example gt val sequence = mutableListOf this operations forEach sequence add it sequence last return sequence toList ```

Shawn · Answer

hmm first thought is `foldWithNext`

Shawn · Answer

but that might not quite be what you want

Greg Stepniewski · Answer

I don t think so An example usage of this assuming Example is Int would be ``` 5 sequence plus 1 minus 2 times 2 5 6 4 8 ```

Greg Stepniewski · Answer

key here is that I need to provide a list of different operations and each operation builds on the result of the previous one

Shawn · Answer

you ll probably figure this out soon but I ll take a stab at it later if there isn t a solution posted

karelpeeters · Answer

Really ugly solution might give someone a better idea ``` fun lt T gt T chainOperations ops List lt T gt T gt List lt T gt var curr = this return listOf curr + ops map it curr also curr = it ```

Dominaezzz · Answer

Unfortunately yield twice but ``` sequence var curr = this for op in operation yield curr curr = op curr yield curr toList ```

Matias Reparaz · Answer

```fun Example sequence vararg operations Example gt Example List lt Example gt return operations fold listOf this acc cur gt acc + cur acc last ```

karelpeeters · Answer

Looks like this variant of `fold` is called `scan` in other languages

karelpeeters · Answer

< Matias Reparaz> The problem with folds like that is the terrible performance it s unfortunate disappointed

Greg Stepniewski · Answer

< Matias Reparaz> I don t think we can get cleaner than what you ve done This is perfect and I thank you slightly smiling face

Matias Reparaz · Answer

I have my doubts about the performance but if < Greg Stepniewski> is looking for a clear implementation I think that my solution can be a good one

Dominaezzz · Answer

`operations fold mutableListOf this acc cur gt acc += cur acc last ` might perform a bit better

karelpeeters · Answer

You need to actually return something from the lambda though

Dominaezzz · Answer

Although it s still side effecty

Dominaezzz · Answer

Ah I see

marstran · Answer

What about something like this ``` fun Example sequence vararg operations Example gt Example List lt Example gt if operations isEmpty return listOf this val mappedExample = operations first this val nextOperations = operations drop 1 val seq = mappedExample sequence nextOperations toTypedArray return listOf this + seq ``` It could probably be optimized to not create so many intermediate arrays and lists though It should also probably be made tail recursive

karelpeeters · Answer

Remove the vararg then you can skip the array and do `subList 1 ` instead of `drop 1 ` Still terrible performance of course upside down face

Dico · Answer

``` tailrec fun lt E gt E sequence ops List lt E gt E gt target MutableList lt E gt = arrayListOf ind Int = 0 List lt E gt target += this if ind gt = ops size return target return ops ind this sequence ops target ind+1 ```

Dico · Answer

Seems pretty optimal to me

Dico · Answer

You could replace ops with vararg array

Dico · Answer

If you want to do it better you can make the function private and delegate to it with the default parameters

karelpeeters · Answer

Also you can create an arraylist with the correct initial size

Dico · Answer

That s a good idea but we re reaching premature optimization territory

karelpeeters · Answer

Maybe but if it doesn t cost any effort slightly smiling face