Long time swift user, just started using Kotlin and and loving it. The languages are so similar in syntax, it’s great. But I’m really missing Swift’s null-safe optional chaining: e.g.

if (val notOptional = someOptional) { … }

. Any plans for something similar in Kotlin? (Or does it exist and I've overlooked it?)

Check

let

,

run

,

also

,

apply

. Your example would be

someOptional?.let{nonOptional -> ... }

.

there are two ways to do this. My preferred way is:

if (someOptional != null) {
    // In here, it's automatically safe-unwrapped
}

The other is what @aimozg said

The

!=null

check does not work for `var`s, but you can capture the value with local

val varfield = varfield

that too

@aimozg Yes thank you!

let

is the closest to Swift’s

if let

, just a little less powerful. I think the Kotlin online reference manual should mention

let

in the null safety section.

Technically

let

is not special, it's the magic of smartcast

hence why I just use

if (someOptional != null)

😛

I always know just what's going on

Hmm, what about special highlighting, e. g. green or blue curly braces for inline functions?

@benleggiero keeping all under control is what programmer must do, but this does not mean avoiding any language features. simple smile

let

is a stdlib feature, and

!= null

is a language feature 😉

Inlining is a language feature. 😉

like anton said above

if (someOptional != null)

doesn’t unwrap, not exactly ideal

@benleggiero Maybe this example would explain what I was trying to get with at, and why

let

is superior to `if`:

var someOptional : String? = null

fun badFunc() {
        someOptional = null
}

fun optionalTest() {
       someOptional = "Foo"
        if(someOptional != null) {
                badFunc() //some idiot added this function  
                //prints "null". Idiot broke my code!
                println(someOptional)
        }


        someOptional = "Bar"
        someOptional.let { someOptional ->
                badFunc() //some idiot added this function  
                //prints "Bar". Idiot proof!
                println(someOptional)
        }
}

I see... yes that's a bad func 😛

@jbx I mused about

let

some time ago, with a final preference for not overusing its nullable form: http://beust.com/weblog/2016/01/14/a-close-look-at-kotlins-let/

@cedric I love using

let

in cases where I don't want to introduce a new

var

/

val

@jbx This is correct only if

if

expression containc single check. Converting this to

let

will not be so nice

if(someOptional != null && data != null)

@igor.wojda You could define your own function for that:

inline fun <A, B, T> letNotNull(arg1: A?, arg2: B?, block: (A, B) -> T): T? {
    if(arg1 != null && arg2 != null) {
        return block(arg1, arg2)
    }
    return null
}

Call like this:

letNotNull(a, b) { a, b ->
    println(a.length)
    println(b.length)
}

Note that in many cases you can use

?:

+ break/continue/return/throw for the same effect.

e.g.:

for (x in xs) {
    val y = foo(x) ?: continue
    val z = bar(x, y) ?: continue
    doStuff(x, y, z)
  }

Then, you can use

run

+

return@...

for an arbitrary preemptive exit, but yeah, that's not so readable.

Like:

run b@ {
            val x1 = foo(x ?: return@b)
            val y1 = bar(x1, y ?: return@b)
            doStuff(x1, y1)
        }

are there any plans to change the defaulted interface methods in kotlin to make it more compliant with java 8's defaulted method strategy?

@dmitry.petrov thats actually one of my favourite dark-horse features of kotlin. I know some formal type systems guys, and the "bottom" type that is

Nothing

has always been a big deal to them and I didnt really understood why until kotlin Doing kotlin things like

val something = nullablueValue ?: throw BlamException("fix your params!")

val result = whatevers.map {
  it.someExpression() ?: run { log("no good whatever: $it") return; }
}

is both nifty and convenient.

@dmitry.petrov Nice!

val y = foo(x) ?: continue

syntax was not obvious at all. I glossed over that detail in the reference manual. In my head I had imagined

?:

being defined as something like

fun <T?> ?:(optional: T?, defaultValue: T): T { ... }

because of the similarity to Swift’s

??

operator. But Swift does not evaluate the RHS as an expression.

@jbx that would also work in kotlin

inline infix fun <T> T?.elvis(default: () -> T) = if (this != null) this else default()

fun main(args: Array<String>) {
    val nullable: String? = null
    val nonNullable = nullable elvis { throw Exception() }
}