A modern programming language that makes developers happier.

kotlinlang

How to flatten a list that deep layer is not same:

ex1:
```val deepList = listOf(
    listOf(
        listOf(-1, 0),
        listOf(1)
    ),
    listOf(2, 3),
    listOf(4, 5, 6)
)
println(deepList.flatten()) // [-1, 0, 1, 2, 3, 4, 5, 6]```
ex2:
```val deepList = listOf(
    -1,
    listOf(listOf(listOf(0))),
    listOf(2, 3),
    listOf(4, 5, 6)
)
println(deepList.flatten()) // [-1, 0, 1, 2, 3, 4, 5, 6]```

Flatten the list recursively:
```fun main() {
    val deepList = listOf(
        listOf(
            listOf(-1, 0),
            listOf(1)
        ),
        listOf(2, 3),
        listOf(4, 5, 6)
    )

    println(deepList.deepFlatten())
}

fun Iterable&lt;*&gt;.deepFlatten(): Iterable&lt;*&gt; = flatMap {
    when (it) {
        is Iterable&lt;*&gt; -&gt; it.deepFlatten()
        else -&gt; listOf(it)
    }
}```
(Quickly cobbled together, not necessarily the best approch. YMMV)

It's a bit subtle though, because anything that happens to implement `Iterable` will silently get flattened. It also loses the type argument. I'd recommend not having heterogeneous lists like that if that can be avoided.

For example, maps and sets are also `Iterable`, but I doubt you would want `listOf(mapOf("foo" to 42)).deepFlatten()` to give you `listOf(Pair("foo", 42))`.

Regarding type, the list already is `List&lt;Any&gt;`, so there is no type to begin with.
Regarding the use of `Iterable`, it depends on one's needs. You are right, however. To be safe, one might want seperate functions for list and set flattening.

However, `Map` does not implement `Iterable` :face_with_raised_eyebrow:
```val deepList = listOf(mapOf("foo" to 42)).deepFlatten()
println(deepList.deepFlatten())
// [{foo=42}]```

That was just meant as an example though. My point is that `Iterable` is implemented by a lot of things.

Its a fair point! I just thought "broader = better!" without giving much thought to the consequences.