How can I write a function have a polymorphic return type based on the type argument of its type parameter?

Question

I have some code like this:

sealed trait Foo[A] {
  def value: A
}
case class StringFoo(value: String) extends Foo[String]
case class IntFoo(value: Int) extends Foo[Int]

I'd like to have a function which can use the A type given a subtype's type parameter.

// Hypothetical invocation
val i: Int = dostuff[IntFoo](param)
val s: String = dostuff[StringFoo](param)

I can't figure out how to declare dostuff in a way that works. The closest thing I can figure out is

def dostuff[B <: Foo[A]](p: Param): A

But that doesn't work because A is undefined in that position. I can do something like

def dostuff[A, B <: Foo[A]](p: Param): A

But then I have to invoke it like dostuff[String, StringFoo](param) which is pretty ugly.

It seems like the compiler should have all the information it needs to move A across to the return type, how can I make this work, either in standard scala or with a library. I'm on scala 2.10 currently if that impacts the answer. I'm open to a 2.11-only solution if it's possible there but impossible in 2.10

Answer 1

Another option is to use type members:

sealed trait Foo {
  type Value
  def value: Value
}

case class StringFoo(value: String) extends Foo { type Value = String }
case class IntFoo(value: Int) extends Foo { type Value = Int }

def dostuff[B <: Foo](p: Any): B#Value = ???

// Hypothetical invocation
val i: Int = dostuff[IntFoo](param)
val s: String = dostuff[StringFoo](param)

Note that both solutions mainly work around the syntactic restriction in Scala, that you cannot fix one type parameter of a list and have the compiler infer the other.