Today in an interview I was asked about scoped functions in Kotlin. I explained all of them very briefly and also explained the difference between each of them very clearly. But I got a counter question "What's the reason scope functions exists? I mean if we can do all of the things/ operation on an object without scope functions, then why use scope functions?" I told "It reduces boiler plate codes" Interviewer: "Any other reason apart from reducing boilerplate code". Now this is the part where I got confused and went speechless. And started wondering about the question. I always s*ck at "WHY" part of the questions in an interview 😅

Did the interviewer elaborate at all? Saying "it reduces boilerplate code" seems like a fair answer to me — a lot of Kotlin's standard library is helpful sugar around common problems.

I mean he accepted my answer but wanted more "reasons" of using scope functions

In addition to reducing boilerplate, extension can make code easier to read, in my opinion, and also reduce potential errors E.G. (this is bad code, but still kinda demonstrates)

val label1 = JLabel()
    val label2 = JLabel()
    label1.text = "label1"
    label1.icon = null
    label1.horizontalAlignment = SwingConstants.HORIZONTAL
    label2.text = "label2"
    label2.icon = null
    label2.horizontalAlignment = SwingConstants.HORIZONTAL

You're constantly repeating

label1

and

label2

, your modifications of the object aren't 'attached' to the initialization, etc

Scope functions are called scope functions because with them we can control the scope of symbols (their lifetime and accessibility).

someMap.forEach { (k, v) -> }

Here both

k

and

v

are only available within the scope of

forEach {}

, not before, not after. There are no questions regarding what value

k

or

v

has after the loop concludes. Compare this with the following (pseudo-code):

for (i = 0; i < x; ++i) {}
println(i)

In some languages this actually works because

i

leaks since it’s not scoped to only the loop.

@Fleshgrinder nice explanation, thanks

Maybe your interviewer didn't know the answer himself and also wanted to know why. 😛

@Dominaezzz that can also be the case 😂

Maybe he wanted you to mention the open closed principal of the SOLID design pattern? It makes code easily extendable (open) without needing to modify it (closed)? Just an idea. Personally my favourite reasons are readability, less boilerplate and context dependent code completion...

I tend to use them only when I can't be arsed to name variables.

it

is sometimes more readable that

superContextualLongVariableName

. Otherwise, overuse can make code trickier to read, especially with

?.

and

?:

.

The good old Java times when you had to remember that you needed the static

Arrays.asList()

method to create a list.