Why is this syntax for multiple context receivers: ```context(Logging, Application) fun hello() { ...

# language-evolution

[David Bieregger]

Why is this syntax for multiple context receivers:

context(Logging, Application)
fun hello() {
  <http://logger.info|logger.info>("Hello " + applicationName)
}

Prefered over this:

fun (Logging, Application).hello() {
  <http://logger.info|logger.info>("Hello " + applicationName)
}

In my opinion the second one is more readable and makes intuitively more sense when you know how to do one context receiver just put braces around. I'm sure that considerations have been made here, but I can't imagine one real advatage of the first code example over the second one

[dmitriy.novozhilov]

Syntax you propose blocks potential introducing of tuples into the language

[dmitriy.novozhilov]

Also in your syntax extension receiver and context receivers are mixed, but they are two different entities which have different rules of call resolution

[David Bieregger]

Ah ok, makes sense. I haven't tested it yet, but can you mix context and extension receivers:

context(Application)
fun Logging.hello() {
  <http://logger.info|logger.info>("Hello " + applicationName)
}

[dmitriy.novozhilov]

Also your syntax is not suitable for context on classes, so there would be two different syntax (one for members, one for classes), which is inconsistent

[David Bieregger]

Makes sense, thank you

[Ben Woodworth]

Just re-phrasing what Dmitry said about them being different entities, since it took a bit for it to click with me when first reading the context receiver proposal. But basically the're different kinds of receivers

context(MyContext)
fun useMyContext() {}

This function can't be used like an extension receiver:

val myContext: MyContext

// Won't compile, since `myContext` is being used as an extension receiver, but a context was expected
myContext.useMyContext()

I'm pretty sure you can't even do this:

with (myContext) {
    this.useMyContext()
}

The main distinction is that a function can be called within multiple scopes/contexts, but, you can't really .call() a function on multiple variables at once. So having Logging and Application both as "extension" receivers doesn't make sense. (though it could in the future with tuples)

[elect]

I also dislike receivers on a different line
Personally, I'd like a contextalias similar to typealias