implicit resolution error for Aux pattern with parametrized type #10528
Description
Description
The error shows itself when implicit resolution tried to find Aux pattern for a type that has parameter. The same case without Aux pattern or without type parameter compiles fine. I expect that more complicated example should also compile, but it fails.
Code
Error reproduction
The error could be reproduced with the following code:
trait Holder[A] trait NilHolder[A] extends Holder[A] trait Solve[A, H <: Holder[A]] { type Output <: Holder[A] } type SolveAux[A, H <: Holder[A], O <: Holder[A]] = Solve[A, H] {type Output = O} implicit def nilSolve[A] = new Solve[A, NilHolder[A]] { override type Output = NilHolder[A] } trait WrapSolve[A, H <: Holder[A]] { type Output <: Holder[A] } implicit def wrapAux[A, H <: Holder[A], O <: Holder[A]](implicit one : SolveAux[A, H, O]) = new WrapSolve[A, H] { override type Output = O } val wrapped = implicitly[WrapSolve[String, NilHolder[String]]] Error message
OutsideImplicitTree.scala:30: error: could not find implicit value for parameter e: Parametrized.WrapSolve[String,Parametrized.NilHolder[String]] val wrapped = implicitly[WrapSolve[String, NilHolder[String]]] ^ one error found I tried to -Xlog-implicits and it showed quite useful info. nilSolve was successfully adopted as implicit argument, but typechecker suddenly failed to recognized its type:
OutsideImplicitTree.scala:30: nilSolve is not a valid implicit value for Parametrized.SolveAux[String,Parametrized.NilHolder[String],O] because: type parameters weren't correctly instantiated outside of the implicit tree: inferred type arguments [this.Output] do not conform to method wrapAux's type parameter bounds [O <: Parametrized.Holder[A]] val wrapped = implicitly[WrapSolve[String, NilHolder[String]]] ^ Workaround
If you chose to abandon Aux pattern compiler recognizes types immediately:
implicit def wrapNoAux[A, H <: Holder[A]](implicit one : Solve[A, H]) = new WrapSolve[A, H] { override type Output = one.Output } When workaround does not work
This workaround works but is not universally applicable. For example, what If I need to perform some transformation twice?
trait TwoTimes[A, H <: Holder[A]] { type Output <: Holder[A] } implicit def twoTimes[A, H <: Holder[A], O <: Holder[A]](implicit one : SolveAux[A, H, O], two : Solve[A, O] ) = new TwoTimes[A, H] { override type Output = two.Output } Comparing to simple type
If the Holder type is not parametrized the entire thing works flawlessly:
trait Holder trait NilHolder extends Holder trait Solve[A, H <: Holder] { type Output <: Holder } type SolveAux[A, H <: Holder, O <: Holder] = Solve[A, H] {type Output = O} implicit def nilSolve[A] = new Solve[A, NilHolder] { override type Output = NilHolder } trait WrapSolve[A, H <: Holder] { type Output <: Holder } implicit def wrapAux[A, H <: Holder, O <: Holder](implicit one : SolveAux[A, H, O]) = new WrapSolve[A, H] { override type Output = O } val wrapped = implicitly[WrapSolve[String, NilHolder]]