Scala 隐式上限类型？

Question

I have a first trait like this:

trait FirstTrait[U] {
  val myVal: U
}

And another one as follows:

trait SecondTrait[T <: firstTrait[U],U]

For the implementation I am doing:

case class FirstImpl(myVal: MyType) extends FirstTrait[MyType]

object SecondImpl extends SecondTrait[FirstImpl,MyType]

Is there a better way to do the same thing, I would like to simplify my implementation of the second trait like this if possible:

object SecondImpl extends SecondTrait[FirstImpl]

EDIT

I am using after both type in a function:

  def func[T <: FirstTrait[U],U](myVal: T): U

When I use existential type, I have to explicit types or I get an "inferred type arguments [FirstImpl,Nothing] do not conform to method func" error.

So this is how I have to implement the function:

val myVal : MyType = MyType()
func[FirstImpl,MyType](FirstImpl(myVal))

Can anything simplify?

Answer 1

You can try existential type

trait FirstTrait[U] {
  type _U = U
  val myVal: U
}

trait SecondTrait[T <: FirstTrait[_]]

case class FirstImpl(myVal: MyType) extends FirstTrait[MyType]

object SecondImpl extends SecondTrait[FirstImpl]

def func[T <: FirstTrait[_]](myVal: T): myVal._U = ???

func(FirstImpl(myVal)): MyType

or

trait FirstTrait {
  type U
  val myVal: U
}

trait SecondTrait[T <: FirstTrait]

case class FirstImpl(myVal: MyType) extends FirstTrait { type U = MyType }

object SecondImpl extends SecondTrait[FirstImpl]

def func[T <: FirstTrait](myVal: T): myVal.U = ???

func(FirstImpl(myVal)): MyType

or

def func[T, U](myVal: T)(implicit ev: T <:< FirstTrait[U]): U = ???

Answer 2

 def func[T <: FirstTrait[U],U](myVal: T): U

The problem is that the type of myVal doesn't mention U , so the compiler is failing to infer it simultaneously with T . If it inferred T first, it could get U from it, but it doesn't currently work this way.

However, T is actually useless here and it can be rewritten as

def func[U](myVal: FirstTrait[U]): U    

You can already pass any subtype of FirstTrait[U] here and lose the source of the type inference problem.

If this is a simplified signature, a trick which can work is mentioning U in the parameter type even if it should be redundant:

def func[T <: FirstTrait[U], U](myVal: T with FirstTrait[U]): U