A modern programming language that makes developers happier.

kotlinlang

Is is possible to require a context receiver for a lambda? Those do not work:

```context(String)
val foo = {
    println(toString())
}```
```val foo = context(String) {
    println(toString())
}```

Would this work?
```context(String)
val foo get() = {
    println(toString())
	}```

Otherwise it's not really clear what you're trying to achieve

It's declared in the type:
```val foo: context(String) () -&gt; Unit = {
    println(toString())
}```

Sorry <@U02KG3K1WTG>, I did not explain enough, I want to accept a lambda with a context receiver as a parameter of my function. Thanks to <@UFGCACPE0> I now understand how to do this.

So I've tried this:

```val print: context(String) () -&gt; Unit = {
    println(toString())
}```
It works well but I cannot call it with a context receiver:

```with("hello") {
    print()
    //   ^ Error: No value passed for parameter 'p1' 
}```
I must pass the context as a parameter:

```print("hello")```
Is this the only way?

I'm not sure. Maybe it's a bug of the current implementation? It is just a prototype, after all.

It seems similar to the behavior of regular receivers, where lambdas can accept them as regular parameters instead.

&gt; It seems similar to the behavior of regular receivers, where lambdas can accept them as regular parameters instead.
Oh I did not know that actually!

But in the case of regular receivers, it's optional: you can pass it either as receiver or as a parameter

&gt; It is just a prototype, after all.
Yeah, I'm okay with this and I'm not expecting much. I'm just taking a look at context receivers to explain to people why we can't use them right now :sweat_smile:

But I do not want to say stupid things, so I try and learn :stuck_out_tongue:

That's the best approach! Have fun learning :slightly_smiling_face:

Calling contextual lambdas like that is a current limitation of the prototype. One easy way to get over it is to do:
```context(A) operator fun &lt;A, R&gt; (context(A) () -&gt; R).invoke(): R = this(this@A)```