Wrapping with

let

hides the uninitialized variable being null. Is there an explanation regarding this? Seems Kotlin (1.6.21) is not null-safe in this situation.

class SomeClass { // extremely minified code

  val foo = let { bar } // compile error (almost broke production but my unit test captured it)
  // val foo = bar // compile error (safe!)
    
  val bar = true
}

you can easily write

class SomeClass {
  val foo = bar()
  val bar = true
  private fun bar() = bar

and see an uninitialized variable there as well

Thanks! I was sure something so basic would have an existing discussion thread already, so I was mainly looking for such. Thanks 🙂

In the above examples from both Allan and ephemient,

SomeClass().foo

is initialized to

false

. I thought this discussion is saying it's uninitialized.

On the JVM, uninitialized values have a default "zero" value when declared. For primitive numbers, that will be

0

, for `boolean`s it will be

false

, and for references it will be

null

. Essentially, when you declare a value on the JVM, it has memory allocated for it and all the bits are set to

0

, which is interpreted as I mentioned above. (That implementation detail will eventually be important when Project Valhalla ever happens.)

Ah good point! My example was bad. The original code has a

List<T>

type which is null if uninitialized.