A modern programming language that makes developers happier.

kotlinlang

Hi! What could this error be?
```Unresolved reference. None of the following candidates is applicable because of receiver type mismatch:
public open operator fun &lt;A&gt; (EagerEffect&lt;BaseError, TypeVariable(A)&gt; /* = Raise&lt;BaseError&gt;.() → TypeVariable(A) */).invoke(): TypeVariable(A) defined in arrow.core.raise.Raise
public open suspend operator fun &lt;A&gt; (suspend Raise&lt;BaseError&gt;.() → TypeVariable(A)).invoke(): TypeVariable(A) defined in arrow.core.raise.Raise```

The function is this:
```fun interface RecordConnectionAndGetAccountUseCase {
    suspend operator fun Raise&lt;DomainError&gt;.invoke(state: State): Account
}```

And I'm trying to call this from an either block...

Oh... I had to write this
```with(recordConnection) { invoke(state) }```
:face_with_spiral_eyes:

Kinda defeats the purpose of the invoke operator there... another reason to wait for context receivers... meanwhile I guess I should be using `either { }` everywhere instead...?

Why are you using `fun interface` there? :thinking_face:
Having two receivers is indeed very annoying, and in case of a method the functions already have a receiver.

Depending on you code usage etc that can be less, or more of a problem. Using `Either` doesn't have this issue ye.

&gt; Why are you using `fun interface` there
Before I introduced Arrow, it was easier to test interactions between use cases like that :smile:... just make a lambda as a Fake...

I'd suppose you're proposing to just make that into a top-level function, which would avoid the receiver problem... but then injecting Fakes wouldn't be possible.

I guess there isn't any way to have the best of both worlds... avoiding the extra `either`s while not being able to use context receivers to call them in a sane way :cry:.