Proposal: `where` blocks to allow adding local bin...

# language-proposals

[Felix Kranich]

Proposal: where blocks to allow adding local bindings to single-expression functions without creating a block (similar to Haskell's where)

fun greet(hourOfDay: Int, name: String) = println(greeting + name)
    where {
        val greeting = when {
            hourOfDay < 10 -> "Good morning, "
		    hourOfDay < 12 -> "Good day, "
		    hourOfDay < 17 -> "Good afternoon, "
  		    else -> "Good evening, "
        }
    }

[David Kubecka]

If you are after the single expression body you can do

when {
            hourOfDay < 10 -> "Good morning, "
		    hourOfDay < 12 -> "Good day, "
		    hourOfDay < 17 -> "Good afternoon, "
  		    else -> "Good evening, "
        }.let { println(it + name) }

[dmitriy.novozhilov]

What this feature can that regular block body can't?

[Felix Kranich]

It's mostly a stylistic choice. It allows you to put the "main" expression (the expression that gets returned) at the top, while putting any auxiliary logic in a separate block. The where block should only allow val bindings, encouraging creation of well-named intermediary values

[dmitriy.novozhilov]

This contradicts with readability principle "declarations should be put before usage", which is always true right now for local context

[Felix Kranich]

Hmm, there's some truth about that, I never thought about it that way. I was mainly looking for opinions here out of pure interest if there was a way to introduce a language feature into Kotlin that allows introducing bindings into a function while still keeping a terse, single expression syntax

[dmitriy.novozhilov]

New language features should solve some real use-cases and pain points in the first place

[dmitriy.novozhilov]

And in my personal opinion, expression bodies for functions were a mistake

[Klitos Kyriacou]

If it was like this:

fun greet(hourOfDay: Int, name: String) = println(greeting(hourOfDay) + name)

private fun greeting(hourOfDay: String) = when {
    hourOfDay < 10 -> "Good morning, "
    hourOfDay < 12 -> "Good day, "
    hourOfDay < 17 -> "Good afternoon, "
    else -> "Good evening, "
}

Would you prefer fun greeting to be declared before its use? Normal Kotlin practice is to define it after first use. So the readability principle of "declaration before use" is not universal.

Having said that, I quite like the use of where in Haskell - it does greatly improve readability in my opinion - but I don't think it quite fits into intuitive Kotlin syntax.

[Daniel Pitts]

And in my personal opinion, expression bodies for functions were a mistake

I'm curious what your reasoning is for this. I can certainly see how they can be abused, but when used correctly they can greatly simplify and clarify code.

[Javier]

@dmitriy.novozhilov why expression bodies were a mistake? A lot of functions do not have any variable in the body

[dmitriy.novozhilov]

Okay, maybe this statement was too harsh
I just dislike functions with expression bodies from stylish POV
But allowing to write a overridable function/property without explicit type is huge pain from the compiler perspective and source of quite hardly discoverable issues from user side

[Javier]

Ah, makes sense, in my case I always add the type. But I do this everywhere except when the linter says it is not necessary (constructor calls for example)

[Daniel Pitts]

Yep, that's more understandable. While it's probably too late to change it now, it would make sense if open/abstract functions always required explicit type. FWIW, I usually do that anyway for other reasons.

[Laxystem]

@dmitriy.novozhilov see explicit API mode
I agree, open functions and properties should always have explicit types.

[dmitriy.novozhilov]

I know about it, thanks