A modern programming language that makes developers happier.

kotlinlang

How to create a generic function to execute a block of code after checking whether a lateinit property is initialized?
Something like
```fun KProperty0&lt;*&gt;.doIfInitialized(block: () -&gt; Unit) {
    // todo how to do this????
}```

You can't.

The code would be
```inline fun &lt;T&gt; KProperty0&lt;T&gt;.ifInitialized(block: (T) -&gt; Unit) {
    if (isInitialized) {
        block(get())
    }
}```
but the compiler doesn't allow calling `isInitialized` on a generic property, because the compiler doesn't allow calling `isInitialized` on a non-`lateinit` property:

```lateinit var a: String
var b: String = "foo"

println(::a.isInitialized)
println(::b.isInitialized) // compile error: This declaration can only be called on a reference to a lateinit property```
Since there is no way to know statically if `KProperty0` is a `lateinit` or not, the compiler cannot allow calling it on a given instance.

If you wanted to propagate the compiler check to the caller, you could in theory write
```inline fun &lt;T&gt; @receiver:AccessibleLateinitPropertyLiteral KProperty0&lt;T&gt;.ifInitialized(block: (T) -&gt; Unit) {
    if (isInitialized) {
        block(get())
    }
}```
but you can't, because `kotlin.internal.AccessibleLateinitPropertyLiteral` is not public.

However, the standard library could probably add this function if the maintainer wanted to.

You should create an issue with this proposal !

What's the use-case though? It's really not a big improvement...
```::a.ifInitialized {
    println(a)
}

if (a::isInitialized) {
    println(a)
}
```
Not everything needs syntax sugar

We have a lot of lateinit variables in the android view model. We need to destroy them once the scope is over. But since some of them are initialised conditionally, they are blowing up when we try to access the member functions of those lateinit vms. So wanted a clean nice extension function to do this check uniformly. Can you guys propose alternative solutions?

How is the extension function nicer than the `if`?

`variable.ifInitialised { }`
looks better to me than `if(::variable.isInitialised) {}`

It's not going to be `variable.ifInitialized` , as most it would be `::variable.ifInitialized`