hi there, small question: having 2 lists such as

[1, 2, 3]

and

[4, 5, 6, 7]

is there an existing function that intercalates both so the result is

[1, 4, 2, 5, 3, 6, 7]

?

la.zip(lb) { a, b -> listOf(a, b) }.flatten()

almost works, in that it only keeps the length of the shortest list

Check if this suits you:

@Test
    fun asas1() {
        val l1 = listOf(1, 2, 3)
        val l2 = listOf(4, 5, 6, 7)
        val expected = listOf(1, 4, 2, 5, 3, 6, 7)

        val result =
                l1.zip(l2).flatMap { listOf(it.first, it.second) } +
                        l1.drop(l2.size) + l2.drop(l1.size)

        assertEquals(expected, result)
    }

    @Test
    fun asas2() {
        val l1 = listOf(4, 5, 6, 7)
        val l2 = listOf(1, 2, 3)
        val expected = listOf(4, 1, 5, 2, 6, 3, 7)

        val result =
                l1.zip(l2).flatMap { listOf(it.first, it.second) } +
                        l1.drop(l2.size) + l2.drop(l1.size)

        assertEquals(expected, result)
    }

Most of those solutions are very inefficient, hopefully we’re not talking about huge lists here

Ok, I see, thanks @wbertan! I think I'll keep with my function for now

@aballano Note, that your function returns

[1, 4, 2, 5, 3, 6]

instead of

[1, 4, 2, 5, 3, 6, 7]

for your example.

I would use something more like this (untested)

fun <T> Iterable<T>.alternateWith(other: Iterable<T>): Iterable<T> =
    Iterable {
        object : Iterator<T> {

            private val a = this@alternateWith.iterator()
            private val b = other.iterator()
            private var switch = false

            override fun hasNext(): Boolean =
                a.hasNext() || b.hasNext()

            override fun next(): T {
                switch = !switch
                return if (switch) next(b, a) else next(a, b)
            }

            private fun next(first: Iterator<T>, second: Iterator<T>): T =
                if (first.hasNext()) first.next() else second.next()

        }
    }