I want this for

TN

without writing that code manually

Unfortunately not, no.

@karelpeeters I read https://kotlinlang.org/docs/reference/delegated-properties.html#local-delegated-properties-since-11. But I didn't understand when we can use it? What's benefits of local delegation (lazy)

One use case is the example they show that uses the short-circuiting of

&&

.

Forgive me. I can't understand again. Do anyone can explain when we can use local delegation?

fun example(computeFoo: () -> Foo) {
    val memoizedFoo by lazy(computeFoo)
    if (someCondition && memoizedFoo.isValid()){
        memoizedFoo.doSomething()
    }
}

Let's say

computeFoo

is a slow function, and we want to avoid calling it whenever possible. In the above code, if

someCondition == false

the

&&

will "short-circuit", meaning it won't even bother to evaluate the right side since

false && x

is guaranteed to be

false

. That means that the code behind

lazy

doesn't call

computeFoo

at all. If on the other hand

someCondition == true

,

memoizedFoo.isValid()

will be evaluated,

lazy

will call

computeFoo

and the result will be available in

memoizedFoo

.

Well. What's different between this and "lazy" evaluation? val foo : Int by lazy { 10 }

I don't really get your question, it is lazy evaluation.

Is there any different between these:? val foo : Int by lazy { 10 } & val foo by lazy{ computeFoo() }

(surround code with `)

I think you mean

lazy(computeFoo)

.

There's not really a difference, in the first case you're using a function that returns a constant value (

10

) and you're specifying the type explicitly.

lazy(computeFoo)

is the same as

lazy{computeFoo()}

btw, Idea wil even suggest changing it.

So, why Hadi Harriri teaches the first one (of my example) in "lazy evaluation" lecture, and second one in "Delegation" lecture?

Well lazy evaluation is for local variables, delegation is for fields. I think the only difference is the behind-the-scenes implemetation.

Haven't seen the lectures though.

Thanks a lot for spend your time. You helped a lot. But my brain is lazy. May I have to ask from Hadi Harriri himself. Thanks again

He's on slack too: @hhariri

It is one of the more difficult parts of Kotlin, good luck!

Thanks. you too.

can a getter return a different type than what the underlying field has? e.g. I have a field of type

Double?

but I want to expose it as

Double

because I know it can't be null

Separate the field and getter:

val _num: Double? = 3d
val num get() = _num!!

oh I see, I almost got it, just didn't realize the field needs a different name

Hi, so I was working on a project of mine and wanted to do something similar to "when(variable/*: Short*/) { 1 -> doSomething()}" but it things the "1" is an Int. Is there a way without casting to tell Kotlin it's a Short?

@Mike Lynch uploaded a file: Untitled

Well declare

x: Short

somewhere?

Yeah, it's passed in via a method parameter

This is the full snippet. So it's already declared as a Short. I can cast the "1" as a Short in the when statement, but since this is an operation that will happen often, I would prefer to avoid that if possible.

That or I can set each value it tests to a variable but that it's rather verbose

Ah I see. Maybe do

when(x.toInt()) { ... }

?