acteur Akka: Patterns.pipe pour un ou l'autre

Question

J'ai une méthode comme ceci:

def myFuture: Future[Either[MyLeft, MyRight]] = Future { 
. 
. 
. 
} 

Si je veux siffler le résultat, j'utilise:

Patterns.pipe(myFuture,ec).to(destinationActor) 

Mais je veux en cas de gauche , envoyer le résultat à un acteur et en cas de Droit envoyer le résultat à un autre acteur. pseudo code comme ceci:

MyPatterns.eitherPipe(myFuture,ec).to(leftConsumerActor,rightConsumerActor) 

Answer 1

Le code source d'Akka lui-même est un bon indice de ce qui doit être fait. Jetez un oeil à akka.pattern.PipeToSupport:

def pipeTo(recipient: ActorRef)(implicit sender: ActorRef = Actor.noSender): Future[T] = { 
    future andThen { 
    case Success(r) ⇒ recipient ! r 
    case Failure(f) ⇒ recipient ! Status.Failure(f) 
    } 
} 

On peut donc essentiellement réutiliser cette approche pour notre cas dispatching de Either:

val result: Future[Either[Int, Throwable]] = Future.successful(Left(5)) 
result andThen { 
    case Success(Left(value)) => leftActor ! value 
    case Success(Right(exception)) => rightActor ! exception 
    case Failure(exception) => println("Failure") 
} 

La réalisation DSL souhaitée:

Nous pouvons essayer d'atteindre votre DSL (soitPipe() et à (...)) comme ceci:

trait MyEitherPipeSupport extends PipeToSupport { 

    final class PipeableEitherFuture[L, R](val future: Future[Either[L, R]])(implicit executionContext: ExecutionContext) { 

     def to(leftRef: ActorRef, rightRef: ActorRef, exceptionRef: ActorRef) = future andThen { 
     case Success(Left(value)) ⇒ leftRef ! value 
     case Success(Right(exception)) ⇒ rightRef ! exception 
     case Failure(exception) ⇒ exceptionRef ! Status.Failure(exception) 
     } 
    } 

    implicit def eitherPipe[L, R](future: Future[Either[L, R]])(implicit executionContext: ExecutionContext): PipeableEitherFuture[L, R] = new PipeableEitherFuture(future) 

    } 

Maintenant, dans votre acteur vous mélangez juste MyEitherPipeSupport et vous pouvez écrire comme ceci:

val result: Future[Either[Int, Throwable]] = Future.successful(Left(5)) 
    eitherPipe(result).to(left, right, anotherOne) 

Answer 2

Si vous faites quelque chose comme ça?

myFuture onComplete { 
    case Success(s) => s match { 
     case Right(r) => rightConsumerActor ! r 
     case Left(l) => leftConsumerActor ! l 
    } 
    case Failure(f) => println("failure") 
}