Nullability and type inference


#1

This is something I wanted to ask for a long time. Now it struck my mind again. Type inference works well for non-null vars, e.g.

val str1 = "foo"

But for optional nulls type inference seems not to work:

val str2? = "bar" // compiler error val str2 = "bar"? // compiler error

Think I tried out all positions where you can put the ?. Seems like I have to declare the type explicitly for things to compile if the var may be null:

val str: String? = "baz" // compiles fine

While this is not really dramatic, it still feels a bit like a nuisance. Am I doing something wrong or could it be done in the compiler? Just curious ...

Regards, Oliver

P.S.: Thanks for M9. Kotlin is now in a state that you can really develop with it :slight_smile:


#2

I think you might have got the wrong impression about what "a?.b" is. It is not "call 'b' on 'a?' ", but rather "safe-call 'b' on 'a' ". I.e. '?.' is one operator name "safe call", not two, dot and questionmark. (Just for the record, it's the same for '?:').

val str2? = "bar" // compiler error val str2 = "bar"? // compiler error

So this sytax is not Kotlin :) You can't append question marks to expressions, nor variable declarations. I can think of a possible meaning for the first line, but can't see how to sensibly define semnatics for the secons, so that it is compatible with '?.' semantics.


#3

Hello,

what I mean is this: Instead of “val str: String = “baz”” I can say “val str = “baz””. In the same way, in the case of “val str: String? = “baz”” I would like to leave the type information away as well (that str, which may also be null as in "val str: String? = “baz”, is a String). So this is why I came up with “val str? = “baz””. I’m aware of the elvis operator, but there is no method invocation being done here. It is about being able to say “val str: String? = “baz”” without having to declare the type, which here is String.

The point of the question was to ask whether there is a way of saying “val str: String? = “baz”” without having to declare a type String as in this example and let the compiler do the type inference work. I think this would be really nice. I don’t see why type inference should not be at the developers disposal when declaring a variable that may be null.

So this sytax is not Kotlin :slight_smile: You can’t append question marks to expressions, nor variable declarations.

The point was to communicate that I had tried out all kinds of combinations to no avail. Maybe I’m just getting it wrong. I don’t know … :wink:


#4

Ha! Got an idea and it works:

fun <T> T.orNull() : T? {   val t: T? = this   return t }

fun main(args: Array<String>) {
  var str = “”.orNull()
  str?.toUpperCase()
  str.toUpperCase() // does not compile as desired

  var num = 123.orNull()
  var otherNum = num;
  otherNum = otherNum?.inc()
  otherNum = null
  otherNum.inc()  // does not compile as desired
}


I used val in my first post instead of var. Think that’s why it could not be understood. Mea culpa. Anyway extension methods in Kotlin are really amazing :-). Well, I still prefer <var str? = “”>. But who cares. Maybe something like orNull() should be in the base library?


#5

This is a good solution indeed. Feel free to file an issue for standard library


#6

Okay, here it is:

KT-6052

#7

Thanks