In a third-party library there is a series of request classes, all of which derive from some common base class, which is generic and takes response class as a parameter:

abstract class AbstractRequest[ResponseType] {

  …

  def execute(): ResponseType

}



class UserList {…}

class UserListRequest extends AbstractRequest[UserList] {…}



class Avatar {…}

class AvatarRequest extends AbstractRequest[Avatar] {…}



…

I want to write some generic method that takes a request instance, executes it several times in some special ways and delegates processing of the responses to a function supplied in arguments:

def specialMultiExecute(request: Req)(responseHandler: Resp => Unit): Unit = …

— to be called like:

val myRequest: UserListRequest = …

specialMultiExecute(myRequest){ userList => … }

The problem is that I need to somehow specify Req and Resp types in the specialMultiExecute declaration. I tried the obvious approach:

def specialMultiExecute[Req <: AbstractRequest[Resp], Resp](request: Req)(responseHandler: Resp => Unit): Unit = …

— but Scala compiler fails to deduct generic argument types (an explicit specification like specialMultiExecute[UserListRequest, UserList](myRequest){ userList => … } is required).

In C++ in such case I could write a template function with a single template parameter Req, while making Resp to be determined as result type of the method Req::execute:

template<typename Req>

void specialMultiExecute(

    Req request,

    std::function<void (decltype(std::declval<Req>().execute()))> responseHandler

) {…}

//i.e. we use `decltype(std::declval<Req>().execute())` instead of Resp

Is there way to write something similar is Scala?

I mean something like (in Scala-like pseudocode):

def specialMultiExecute[Req <: AbstractRequest](request: Req)(responseHandler: ResultTypeOf(Req#execute) => Unit): Unit = …

It is a limitation of the type inference mechanism.
The simplest way to solve it is to use an implicit evidence that Req is a subtype of AbstractRequest[ResponseType].

Here is an example.

import scala.language.implicitConversions

import scala.reflect.runtime.universe.TypeTag



abstract class AbstractRequest[ResponseType] {

  def execute(): ResponseType

}



final case class User(id: Int, name: String)

final case class House(id: Int, price: Int)



class UserListRequest extends AbstractRequest[List[User]] {

  override def execute(): List[User] = List(User(id = 3, name = "Sasha"))

  override def toString: String = "UserListRequest"

}



final class RequestWrapper[Req, Resp](val request: Req) extends AnyVal {

  type ResponseType = Resp

}



implicit def request2wrapper[Req, Resp](request: Req)(implicit ev: Req <:< AbstractRequest[Resp]): RequestWrapper[Req, Resp] =

  new RequestWrapper(request)



def specialMultiExecute[Req, Resp](wrapper: RequestWrapper[Req, Resp])

                                  (responseHandler: wrapper.ResponseType => Unit)

                                  (implicit ev: Req <:< AbstractRequest[Resp], TTReq: TypeTag[Req], TTResp: TypeTag[Resp]): Unit = {

  val request: Req = wrapper.request

  val executionResult: Resp = request.execute()

  responseHandler(executionResult)

  println(TTReq)

  println(TTResp)

  println(request)

}



specialMultiExecute(new UserListRequest())(println)

// List(User(3,Sasha))

// TypeTag[UserListRequest]

// TypeTag[List[User]]

// UserListRequest

Reference for <:<.
Reference for "Dependent types".

Edit

Te above code example was modified to allow identification of the concrete Request and Response types being used.