Another example, using explicit message types:

sealed class Message
data class Ask(val question: Question, val response: CompletableDeferred<Response>)

suspend fun usage() {
  val response = CompletableDeferred<Response>()
  
  actor.send(Ask(Question(), response)) // ask
  val result = response.await() // wait
  
  // use the result
}

I personally think there is a

actWithResult { }

pattern missing there... but on one discussion with @[removed] it might not be so difficult to implement. I think the use case is running using a regular

act { }

and getting results in another context using

actWithResult { }

, or simply having a background context to call

actWithResult { }

, the actor would insure that any requests will be handled synchronously...

That way we avoid the extra param passing... @Jonathan?

And the thing is in both cases, it would still be an ask & wait which is what I want to avoid.

(I can do it, but it quickly becomes complicated without the ask&wait)

So it ends up not being a pipeline anymore...

Sometimes you need to get back data back from an actor. But you should not wait. You should give your channel to that actor and let it send of that channel, so that you can process responses asynchronousy.

Maybe actor is simply not the good abstraction for composition then.

(By actor composition I meant creating a (composed) actor, which decompose and delegate its work to other (component) actors)

If you don’t need that, you don’t need actor. You use plain suspending functions