If I have a

List<List<T>>

, is there a way to flatten it while adding items at the boundaries between the lists?

You don't want items at the end?

The idea is if I have something like this

val list = listOf(
        listOf("a", "b", "c"),
        listOf("d", "e", "f")
)

and I call this imaginary function, say the joining element is "|", I want it to return

listOf("a", "b", "c", "|", "d", "e", "f")

Terrible performance:

list.reduce { acc, list -> acc + "|" + list }

Would a reduction suffice here?

val list = listOf(
            listOf("a", "b", "c"),
            listOf("d", "e", "f")
    )

    println(list.reduce { a, b -> a + "|" + b })

Ah, yeah that works. Thanks

I wouldn't do it though, just write a quick extension function on the side somewhere.

Do reductions like that incur a performance cost that would be noticable?

Yeah, this creates 2 temporary lists per join that happens.

The only other solution that I could think of is worse

Sure, for small inputs like this performance is pretty much irrelevant.