A modern programming language that makes developers happier.

kotlinlang

you're out of luck then, for most programmers it does :slightly_smiling_face:

can you than give some examples when continue the chain with null make sens?

you can solve this with `a?.b.toString().length ?: null.toString()`

There's nothing to solve, that's just how toString works.

You could define your own functions on nullable types as well.

So, no use cases, just mine invented :disappointed:
This feature was not designed well

I think a better example will be `a?.b.c.d`
`a?.b` can be non-null, but how can you be sure `b.c` is also non-null?
Think using a general case will make more sense.

besides `toString()` here's something from code I've seen in production (dumbed down for brevity)
```
fun prepareNextActionCommand(input: ParamsObject): Command {
    fun null.toCommand() = DefaultActionCommand()
    return input.action.toCommand().apply { /* stuff */ }
}```

<@U0CP8EBRV> 
you can solve this by adding `?: null.toCommand()`

nope, I can't, because you're proposing to break chain on `null`, so if your version is accepted, `null.toCommand()` will not execute `toCommand()` and will instead return `null`

`?:` doesn't mean if left is null execute right?

then if left will be reduced to null the `null.toCommand()` will be executed, as needed

I don't see how `null.toString()` won't be executed and `null.toCommand()` will :smile:

they both will be executed if they are at right at `?:`

oh, so not only you're proposing hidden chain-break, you're also saying that this chain-break should not occur in expression if it is to the right of `?:`
Too much non-obvious behaviour in my opinion.

it is not hidden, you know it will break at first null
it always break at first null and reduce to null
so `a?.b.toString()` will be reduced to `null` and we will have
`null ?: null.toString()`

`?:` operator changing how method chaining works does not make sense to me personally