kotlin-null-safety

I saw the following comment in a S.O. post, and I'm intrigued: why don't you use if for null checks? a?.let{} ?: run{} is only appropriate in rare cases, otherwise it is not idiomatic – voddan May 15 '16 at 7:29 best way to null check in kotlin? Why is that construct "only appropriate in rare cases"? The lead engineer for Kotlin says, run allows you to use multiple statements on the right side of an elvis operator https://stackoverflow.com/a/51241983/6656019 although I admit that's not actually endorsing it as idiomatic. Both of these posts seem to be from very well respected S.O. Kotlin

This question already has an answer here: Why do unsafe .run() call works fine on a null value in Kotlin? 3 answers Given the code fun main(args: Array<String>) { val someText: String? = null println(someText.toString()) } When run, output is null Two questions appear: is that possible to implement custom null-safe method with fallback to some default code (like, I think, toString does) why no exception is thrown? From the docs : fun Any?.toString(): String Returns a string representation of the object. Can be called with a null receiver, in which case it returns the string "null". You can

I have the following code fragment: val foo: String? = null foo.run { println("foo") } I have here a nullable variable foo that is actually set to null followed by a nonsafe .run() call. When I run the code snippet, I get foo printed out despite the fact that the run method is called on a null . Why is that? Why no NullPointerException ? Why does compiler allow a nonsafe call on an optional value? If I pass println(foo) , I get a nice juicy null in the console so I think it's safe to assume that foo is actually null . I believe, there are two things that both might be of some surprise: the

Is there a way in kotlin to prevent function call if all (or some) arguments are null? For example Having function: fun test(a: Int, b: Int) { /* function body here */ } I would like to prevent null checks in case when arguments are null . For example, for arguments: val a: Int? = null val b: Int? = null I would like to replace: a?.let { b?.let { test(a, b) } } with: test(a, b) I imagine that function definition syntax could look something like this: fun test(@PreventNullCall a: Int, @PreventNullCall b: Int) And that would be equivalent to: fun test(a: Int?, b: Int?) { if(a == null) { return }

How can I test if a KType variable holds a value of a nullable kotlin type, (e.G. Int?)? I have var type: KType variable coming from a KProperty<*>.returnType and I need to detect if it is equal to certain kotlin types (Int, Long, etc). This works with: when (type) { Int::class.defaultType -> ... Long::class.defaultType -> ... else -> ... } but this only works for non-nullable types, so the first branch does not match to Int? However I was yet unable to figure out how I could detect is type is Int? other then to obvious but not so nice type.toString().equals("kotlin.Int?") As you can see from

Should I use double = , or triple = ? if(a === null) { //do something } or if(a == null) { //do something } Similarly for 'not equals': if(a !== null) { //do something } or if(a != null) { //do something } Both approaches generate the same bytecode so you can choose whatever you prefer. A structural equality a == b is translated to a?.equals(b) ?: (b === null) Therefore when comparing to null , the structural equality a == null is translated to a referential equality a === null . According to the docs , there is no point in optimizing your code, so you can use a == null and a != null Note that