Hi there! Are there any functional fun to iterate over a list and apply an operation to the current ...

# announcements

[AdalPari]

Hi there!
Are there any functional fun to iterate over a list and apply an operation to the current element with the previous one?
It would be like a fold, but instead of accumulating the result, just applying it to each element.
E.g:
(1..9).fold("a", { last, current -> last + current })
This just returns a123456789 but I actually need to create the following list: { "a1", "a12", "a123", "a1234", .. }
I would be more like a map but knowing previous element:
(1..9).map { "$previousElement$it" }

[streetsofboston]

Not sure if this fun exists on a List, but have you tried scan? (this fun exists on Rx)

[AdalPari]

Not really, will check!

[Kroppeb]

This is a scan, which doesn't exist in the stdlib sadly

[Hampus Londögård]

You can use windowed.

(1..9).windowed(size=2).map { items -> "${items.first()}${items.last()}" }

It defaults to partialWindows=false. Not really what you asked for though, but it does the job 🙂

[Kroppeb]

I don't see how you could use it.

[Hampus Londögård]

Nvm, I got it wrong. Thought it was just the previous one

[Kroppeb]

var previous = "a"
(1..9).map {current -> 
    previous += current
    previous
})

[Hampus Londögård]

This works

(1..9).fold(listOf<String>()) { acc, current -> acc + ((acc.lastOrNull() ?: "") + current) }

[streetsofboston]

^^^ @Kroppeb That’ll work for ordered and indexed collections, but you are using a side-effect by updating an external `var`….

[Kroppeb]

This is the scan implementation I have in my utils for AoC. It doesn't return the start value. If you want the start value to also be returned you can change line 3 to val ret = mutableListOf(start)

Untitled

[streetsofboston]

Here’s another version of scan , which can handle large collections and scans the in- and out-put values one at a time, avoiding the allocation of possibly large collections until the end.

fun <T, R> Sequence<T>.scan(start: R, oper: (R, T) -> R): Sequence<R> = sequence {
    var next = start
    for (value in iterator()) {
        next = oper(next, value).also { yield(it) }
    }
}

fun <T, R> Iterable<T>.scan(start: R, oper: (R, T) -> R): Iterable<R> =
    this.asSequence().scan(start, oper).asIterable()

It uses a Sequence to do so.

[AdalPari]

Lot of answers! thanks!