Scala类型：如何限制子类的泛型类型？

Question

我有一个特点：

trait OAuthService { 
    def sendWithAuthorizationQueryParams[A](request: OAuthRequest)(implicit unmarshaller: Unmarshaller[ResponseEntity, A]): Future[A] = { 
    val httpRequest = request.toHttpRequestWithAuthorizationQueryParams 

    sendAndReceive(httpRequest, request.signature) 
    } 

    def sendWithAuthorizationHeader[A](request: OAuthRequest)(implicit unmarshaller: Unmarshaller[ResponseEntity, A]): Future[A] = { 
    val httpRequest = request.toHttpRequestWithAuthorizationHeader 

    sendAndReceive(httpRequest, request.signature) 
    } 

    protected def sendAndReceive[A](httpRequest: HttpRequest, id: String)(implicit unmarshaller: Unmarshaller[ResponseEntity, A]): Future[A] 
} 

我创建一个子类：

class StreamingOAuthService()(implicit val actorPlumbing: ActorPlumbing) extends OAuthService { 
    private val log = LoggerFactory.getLogger(getClass()) 

    override protected def sendAndReceive[A](httpRequest: HttpRequest, id: String)(implicit unmarshaller: Unmarshaller[ResponseEntity, A]) = { 
    log.debug(s"Http request: {}.", httpRequest) 

    import actorPlumbing._ 

    val host = httpRequest.uri.authority.host.address() 

    val connectionFlow: Flow[HttpRequest, HttpResponse, Future[OutgoingConnection]] = Http().outgoingConnectionTls(host) 

    Source.single(httpRequest) 
     .via(connectionFlow) 
     .runWith(Sink.head) 
    } 
} 

在StreamingOAuthService，我想冻结泛型类型为ResponseEntity。换句话说，我想指定StreamingOAuthService方法支持的唯一类型是ResponseEntity。如图所示，StreamingOAuthService.sendAndReceive不会编译，因为返回类型是Future[ResponseEntity]，而不是由性状指定的Future[A]。

Answer 1

我假设你的意思是你想要类型规格A被锁定在ResponseEntity的子类中。如果是的话，你可以尝试将抽象类型成员的特征和子类：

trait OAuthService { 

    type A 

    def sendWithAuthorizationQueryParams(request: OAuthRequest)(implicit unmarshaller: Unmarshaller[ResponseEntity, A]): Future[A] = { 
    ... 
    } 

    ... 
} 

class StreamingOAuthService()(implicit val actorPlumbing: ActorPlumbing) extends OAuthService { 
    private val log = LoggerFactory.getLogger(getClass()) 

    type A = ResponseEntity 

    override protected def sendAndReceive(httpRequest: HttpRequest, id: String)(implicit unmarshaller: Unmarshaller[ResponseEntity, ResponseEntity]) = { 
    ... 
    } 

    ... 
} 

注意，这个假设A需要是同一类型的一个实例中的所有方法，甚至在基本特质。

如果这不是意图，上述想法可以扩展为定义每种方法的类型（尽管显然这可能会很快得到解决）。

这里有一个（简单的）例子给你的想法：

trait Base { 

    type A 
    type B 
    ... 

    def fun1(input: String): A 

    def fun2(input: Int): B 

    ... 
} 

class Sub extends Base { 

    type A = Double 
    type B = Double 
    ... 

    def fun1(input: String): A = { 
    input.toDouble 
    } 

    def fun2(input: Int): B = { 
    input.toDouble 
    } 

    ... 
} 

Answer 2

可以参数化用[A]和摆脱参数化的特质每个方法的整体特点：

trait OAuthService [A]{ 
    def sendWithAuthorizationQueryParams(request: OAuthRequest)(implicit unmarshaller: Unmarshaller[ResponseEntity, A]): Future[A] = ... 
    ... 
} 

而且然后限制StreamingOAuthService使用ResponseEntity：

class StreamingOAuthService()(implicit val actorPlumbing: ActorPlumbing) extends OAuthService[ResponseEntity] { 
... 
} 

Answer 3

我想了解一下我的伯爵ier回答，甚至在多类型的形式，它仍然不是很满意，因为你需要定义所有类型A，B，等等基类的任何实例要使用，并且该子类只能接受每种方法的这些类型。

类型运营商（广义类型约束）看起来像他们提供一个更好的选择：

trait Base { 

    type T 

    def fun1[A](input: String)(implicit tp: A <:< T): A 

    def fun2[A](input: Int)(implicit tp: A <:< T): A 
} 

class RestrictedSub extends Base { 

    override type T = Double 

    def fun1[A](input: String)(implicit tp: A <:< T): A = { 
    ... 
    } 

    def fun2[A](input: Int)(implicit tp: A <:< T): A = { 
    ... 
    } 
} 

对于方法的任何呼叫，编译器可以提供一个适当的隐式<:<[A,T]（通常写入A <:< T，类似于一个二进制运算符）当且仅当A是T的子类型，因此在编译时应禁止任何不适当的调用。

对于无限制的子类（的良好候选中该性状的同伴对象工厂方法），类型T可以设置为Any或AnyRef适当。

我也注意到，虽然，我没有使用此建立自己的特质与隐性Unmarshaller S和Future返回类型，这可能复杂化的妥善解决办法一个完全充实版本尝试。