A modern programming language that makes developers happier.

kotlinlang

I'm guessing this is something that has been discussed before, so I'm asking if anyone has a YouTrack for it somewhere.
Does Kotlin have any plans to make something that looks like this possible?
```val myNumberList: List&lt;Int&gt; = listOf(1, 2, 3, listOf(4,5)).flatten()```

what would the type of that flatten method look like?

yeah...the first list is type `List&lt;Any&gt;`, which is hard to do much with

for reference, the existing flatten method has type `fun &lt;T&gt; Iterable&lt;Iterable&lt;T&gt;&gt;.flatten(): List&lt;T&gt;`

Why not just do `val myNumberList: List&lt;Int&gt; = listOf(1, 2, 3) + listOf(4,5)`?

But I’m pretty sure Kotlin would have to support union types in order for something like that to be possible without unsafe/unchecked typecasting

`listOf(1, 2, 3, listOf(4,5))` is `List&lt;Any&gt;` , so you've already lost type safety.  Not ideal and probably not a candidate for std lib.  Here is a horribly unsafe version that I would never use:
```    @Suppress("UNCHECKED_CAST")
    @OptIn(ExperimentalStdlibApi::class)
    fun &lt;OUT&gt; Iterable&lt;Any?&gt;.reallyFlatten(): List&lt;OUT&gt; = buildList {
        this@reallyFlatten.filterNotNull().forEach {
            when (it) {
                is Iterable&lt;*&gt; -&gt; addAll(it.reallyFlatten())
                else -&gt; add(it as OUT)
            }
        }
    }```
Called as `listOf(1, 2, 3, listOf(4,5)).reallyFlatten&lt;Int&gt;()`.

equally unsafe, just shorter:
```fun &lt;T&gt; Iterable&lt;Any?&gt;.reallyFlatten(): List&lt;T&gt; = this.flatMap { it as? Iterable&lt;T&gt; ?: listOf(it as T) }```

heck, you could even go so far as
```fun &lt;T&gt; Iterable&lt;Any?&gt;.reallyReallyFlatten(): List&lt;T&gt; = this.flatMap { (it as? Iterable&lt;Any?&gt;)?.reallyReallyFlatten() ?: listOf(it as T) }```

but yes, no type safety at all and not suitable for stdlib

the closest to ever doing something like this in real life I've come is flattening out jsons for certain purposes

but, as mentioned, you would have nested data structures using sealed classes

Wait, does `as?` return `null` if the type cannot be cast?  I thought it was a nullable cast i.e. cast if not null.

<https://kotlinlang.org/docs/reference/typecasts.html#safe-nullable-cast-operator> TIL

<@U345RGQ49> no, `as? T` and `as T?` have different behavior