Agfdhyk

I have a list of strings which I would like to process, so lets say

val List<String?> = listOf("Q", NULL, "W", "E", NULL, "E", "E", "R", "R", "T") [sic]

I want to process this so that I can apply a predicate where there are two matching strings in adjacent positions and return a list of non nullable strings.

The method signature of the extension would then be

fun <T : Any> List<T?>.processList(action: (T) -> T): List<T>

lets say my predicate this time is to add "gotcha" to the first string in a duplicate and remove the second so in this case I would end up with

ListOf("Q", "W", "Egotcha", "E", "Rgotcha", "T")

I can do this in an old school way with a while loop very easily

a messy version being along these lines

val nL : ArrayList<T> = ArrayList<T>()

var indexThis : Int = 0

while ( indexThis < intermediate.size-1 ) {

    if (intermediate[indexThis] != intermediate[indexThis + 1]) {

        nL.add(intermediate[indexThis]!!)

        indexThis += 1 }

    else {

        nL.add(processList(intermediate[indexThis]!!))

        indexThis += 2 }

}

This is a long way from being the finished article but but was my attempt at getting the process clear in my head...

but I'm struggling to get started doing it in a more functional way

so I can see that I might want to do start with

 this.filter {a -> a != null}

but then I can't see where I would go as a next step ? Then only method I can think of is forEachIndexed but my attempts at this this seem very convoluted I'm sure I've seen examples of people comparing items in a List in a map ?

and my last train of thought was going along the lines of

.map{b -> b?.run{b ...  processList (b)}}

but this seems very wrong

Can anyone point me in the right direction ?

Here is the first pass at this, which is a bit harder functionally because some state must be maintained as you accumulate the result.

fun <T> List<T?>.processList(action: (T) -> T): List<T> where T: Comparable<T> {

    data class Accumulator(val resultList: MutableList<T> = mutableListOf(), var previousWasDupe: Boolean = false)



    return this.asSequence()

               .filterNotNull()

               .windowed(2, partialWindows = true).fold(Accumulator()) { accum, value ->

        if (accum.previousWasDupe) {

            // skip this one that was already consumed in the dupe

            accum.previousWasDupe = false

        } else if (value.size < 2 || value[0] != value[1]) {

            accum.resultList.add(value[0])

            accum.previousWasDupe = false  //  already is false, you could delete this line, here for clarity

        } else {

            accum.resultList.add(action(value[0]))

            accum.previousWasDupe = true

        }

        accum

    }.resultList



}

for your test case:

val items = listOf("Q", null, "W", "E", null, "E", "E", "R", "R", "T")

println(items.processList { it + "gotcha" })



// prints "[Q, W, Egotcha, E, Rgotcha, T]"

You could use am immutable accumulator as well (I don't like it being mutable but it will perform better), but there is no point in taking that hit given the state is internal to the function. Whether this performs better as a sequence (as written) or with copies depends on the size of the lists and is hard to say without performance testing.

Notice that I also made sure the items <T> were Comparable so that we can be sure that == is doing what we expect, otherwise you really don't know you are receiving things that this function would even work upon.

For fun, the immutable version:

fun <T> List<T?>.processListImmutable(action: (T) -> T): List<T> where T: Comparable<T> {

    data class Accumulator(val resultList: List<T> = emptyList(), val previousWasDupe: Boolean = false)



    return this.asSequence()

        .filterNotNull()

        .windowed(2, partialWindows = true).fold(Accumulator()) { accum, value ->

            if (accum.previousWasDupe) {

                Accumulator(accum.resultList, false) // could also be: accum.copy(previousWasDupe = false)

            } else if (value.size < 2 || value[0] != value[1]) {

                Accumulator(accum.resultList + value[0], false)

            } else {

                Accumulator(accum.resultList + action(value[0]), true)

            }

        }.resultList

}

An edge case to check with solutions is the input:

val items = listOf("Q", null, "W", "E", null, 

                   "E", "E", "R", "R", "T", 

                   "Z", "Z", "Zgotcha")  // <--- this is the trap

which should return:

[Q, W, Egotcha, E, Rgotcha, T, Zgotcha, Zgotcha]

and not:

[Q, W, Egotcha, E, Rgotcha, T, Zgotchagotcha]

Try next code:

fun List<String?>.processList(action: (String) -> String): List<String> {

    var remove = false

    val dest = arrayListOf<String>()

    return filterNotNullTo(dest).mapIndexedNotNull { index, s ->

        if (remove) {

            remove = false

            null

        } else {

            if (index + 1 <= dest.lastIndex && s == dest[index + 1]) {

                remove = true

                action()

            } else {

                s

            }

        }

    }

}



val l = listOf("Q", null, "W", "E", null, "E", "E", "R", "R", "T")

val result = l.processList {"${it}gotcha"}