Scala将动态切换添加到未来的地图中

Question

In my application there is some boilerplate I'm trying to reduce when the API calls appropriate service methods.

Here is an abstract example:

override def foo(in: FooRequest): Future[FooResponse] =
   commandService
     .doFoo(in)
     .map {
       case Success(_) => FooResponse()
       case Failure(e) => failureHandler(Status.INTERNAL, e)
     }
     .recover { case e: Throwable => failureHandler(Status.INTERNAL, e) }



override def bar(in: BarRequest): Future[BarResponse] =
   commandService
     .doBar(in)
     .map {
       case Success(_) => BarResponse()
       case Failure(e) => failureHandler(Status.INTERNAL, e)
     }
     .recover { case e: Throwable => failureHandler(Status.INTERNAL, e) }

20times

So as you can see there is some opportunity to apply DRY principals here.

I could create a function that accepts a the service method as a function and then perform the boilerplate actions, but I don't know how to work in a case statement into the future map.

private def executeCommand[A, B, C](
   command: A, 
   f: A => Future[Try[B]], 
   onSuccess: Try[B] => C): Future[C] =
f(command)
  .map(onSuccess)
  .recover { case e: Throwable => failureHandler(Status.INTERNAL, e) }

But this would require me to call the method like this:

def foo(in: FooRequest) =
   executeCommand(
     in,
     commandService.doFoo, { x: Try[FooSuccess] =>
        x match {
            case Success(_) => FooResponse(in.requestId)
            case Failure(e) => failureHandler(Status.INTERNAL, e)
       }
     }

The Failure case would be repeated for each method. I would like to add that to the executeCommand method if possible. Also, this approach seems like it doesn't remove much boilerplate, but I feel like another approach might.

UPDATE WITH SOLUTION EXAMPLE

Thanks to all for your help. In the end I was able to find a pretty good solution using awagen's answer.

def foo(in: FooRequest) = 
   commandService.doFoo(in).handleResults((pass: FooSuccess) => FooResponse(pass.requestId))

//20 times

implicit private class FooBarServiceHandler[A](future: Future[Try[A]]) {
   import scala.language.higherKinds

   def handleResults[B](func: A => B): Future[B] =
      future.map(onSuccess(func)).recover { case e: Throwable => failureHandler(Status.INTERNAL, e) }

   private def onSuccess[B, C](func: B => C): Try[B] => C = {
      case Success(resp) => func(resp)
      case Failure(e)    => failureHandler(Status.INTERNAL, e)
}

}

Answer 1

How about you do it like this:

def onSuccess[B,C](func: B => C): Try[B] => C = {
  {
            case Success(resp) => func.apply(resp)
            case Failure(e) => failureHandler(Status.INTERNAL, e)
 }
}

and pass the function resp => FooResponse(in.requestId) or for other use cases use the actual Success result within the function to generate the respective response. This way ud avoid repeating the match and just have different interpretation of the result in success case and different types (excuse me, the code is to be seen as kinda pseudocode :) )

Answer 2

A better way to solve this is to use partial function and currying

def executeCommand[A, B, C](f: A => Future[Try[B]])
                         (handleFailure: PartialFunction[Try[B], C])
                         (handleSuccess: PartialFunction[Try[B], C])
                         (command: A)
                         (implicit executionContext: ExecutionContext): Future[C] = {
     val handleResult = handleSuccess.orElse(handleFailure)
     f(command).collect(handleResult)
}.recover{
case ex: Throwable => failureHandler(Status.INTERNAL, e)
}


val failureHandlerPf = {
    case Failure(e) => failureHandler(Status.INTERNAL, e)
}
val successHandlerFooPf = {
    x: FooResponse => x
}
val func1 = executeCommand(failureHandlerPf)

val fooPf = func1(successHandlerFooPf)
override def foo = fooPf(in)

val successHandlerBarPf = {
    case x: BarResponse => x
}
val barPf = func1(successHandlerBarPf)
override def bar = barPf(in)