2

I was trying to play around a bit with higher-kinds and type bounds when I bumped into this problem. My use case is that I want to be able to parameterize GenericAction instances with any subtype of Request, or the Request type itself. The Action trait extends the GenericAction trait with a default type of Request (in this case only anonymous instances of Request will be spawned). 

trait Request[+A]

trait GenericAction[A, R[_] <: Request[_]]

trait Action[A] extends GenericAction[A, Request]

trait ActionBuilderBase[R[_] <: Request[_], G[_] <: GenericAction[_,R]]

ActionBuilderBase has utility methods that are shared with the sub-traits ActionBuilder and ActionBuilder2. ActionBuilder generates default Action[A] and Request[A] instances. 

trait ActionBuilder extends ActionBuilderBase[Request,Action]

So far so good, but when I try to create another trait that extends ActionBuilderBase with a subtype of R and GenericAction (in this case anonymous instances of GenericAction would be created), it fails to compile. I guess the reason is that in the case of the first ActionBuilder, the request type has already been "filled in" (since Action[A] already has a request type == Request) , unlike the example below. What would I need to "fill in" in order for this example to work? 

//Fails with "GenericAction takes two type parameters, expected: one" - what should the type annotation for GenericAction look like?
trait ActionBuilder2[R[_] <: Request[_]] extends ActionBuilderBase[R,GenericAction]
Blake Pettersson
  • 8,927
  • 3
  • 27
  • 36

1 Answers1

7

It would be nice in this situation to be able to write something like this:

trait ActionBuilder2[R[_] <: Request[_]] extends
  ActionBuilderBase[R, GenericAction[_, R]]

To indicate that you want to partially apply GenericAction. Unfortunately that's not valid Scala syntax (although Erik Osheim has a compiler plugin that lets you write something very similar).

You can use the "type lambda trick", however:

trait ActionBuilder2[R[_] <: Request[_]] extends
  ActionBuilderBase[R, ({ type L[A] = GenericAction[A, R] })#L]

See this answer for a detailed explanation of how it works.

Community
  • 1
  • 1
Travis Brown
  • 138,631
  • 12
  • 375
  • 680
  • @BlakePettersson: Yeah, there's a reason people refer to it as the "type lambda _trick_"—it's an ugly way to implement something that really ought to be supported by the language more directly. – Travis Brown Oct 21 '12 at 18:28