Kotlin extension functions with null checks Kotlin defines extension functions like also but they are not null checked. That's fine because you might not need the check. In case you do though, do you see any issue with the solution below?

inline fun &lt;T&gt; T?.ifNotNull(block: (T) -&gt; Unit): T? {
    return this?.also {
        block(it)
    }
}

inline fun &lt;T&gt; T?.otherwise(block: () -&gt; Unit) {
    this?: run {
        block()
    }
}

fun main(args: Array&lt;String&gt;) {
    "it".ifNotNull {
        println("You can use $it")
    }.otherwise {
        // will not happen
    }

    null.ifNotNull {
        // will not happen
    }.otherwise {
        println("You don't see it")
    }

}
OK, I'll give my answer. One problem I had trying this approach is that there are too many combinations: there are cases when you want to use also cases when you want to use let etc. 
It looks like having the operators and the extension functions independently defined gives you the advantage of a kind of strategy pattern when you can combine different strategies to have an exponential number of configuration without having to define an exponential number of functions.

So you have 

Operators:

 1. `?.`
 2. `?:`


Extension functions

a) `also`
b) `let`
c) `run`
d) etc


then you can combine operator 1. with extension fun b) or operator 2. with extension fun c) etc

If you try to define extension funs with null checks then you need to define one function for each combination: it's even difficult just to find names for the functions 

So I will keep the otherwise helper fun but I will not use if ifNotNull