Scala diverging implicit expansion

I want to write an anorm.ToStatement instance for generic enumeratum.values.ValueEnumEntry[ValueType]. But seems like ValueType is not inferred correctly.

My code:

import java.sql.PreparedStatement
import anorm._
import enumeratum.values._

sealed trait Test extends IntEnumEntry
object Test extends IntEnum[Test] {
  case object One extends Test {val value = 1}
  val values = findValues
}

implicit def valueEnumEntryToStatement[ValueType: ToStatement, A <: ValueEnumEntry[ValueType]]: ToStatement[A] =
  (s: PreparedStatement, index: Int, v: A) => implicitly[ToStatement[ValueType]].set(s, index, v.value)

val toStatement: ToStatement[Test] = implicitly[ToStatement[Test]] //NOT OK: diverging implicit expansion for type anorm.ToStatement[ValueType]

It fails on diverging implicit expansion for type anorm.ToStatement[ValueType].

But if I set Int type explicitly, it works.

//either
implicit def valueEnumEntryToStatement[A <: ValueEnumEntry[Int]]: ToStatement[A] =
  (s: PreparedStatement, index: Int, v: A) => implicitly[ToStatement[Int]].set(s, index, v.value)

val toStatement: ToStatement[Test] = implicitly[ToStatement[Test]] //OK
//or
def valueEnumEntryToStatement[ValueType: ToStatement, A <: ValueEnumEntry[ValueType]]: ToStatement[A] =
  (s: PreparedStatement, index: Int, v: A) => implicitly[ToStatement[ValueType]].set(s, index, v.value)
implicit def intEnumEntryToStatement[A <: IntEnumEntry]: ToStatement[A] = valueEnumEntryToStatement[Int, A]

val toStatement: ToStatement[Test] = implicitly[ToStatement[Test]]

Is there a way to make a general solution without explicitly setting a type?

The trouble is that ValueType is a type parameter in trait ValueEnumEntry and there is no type member ValueType there (so we can't use type Test#ValueType). Try defining a type class

  import java.sql.PreparedStatement
  import anorm._
  import enumeratum.values._

  sealed trait Test extends IntEnumEntry
  object Test extends IntEnum[Test] {
    case object One extends Test {val value = 1}
    val values = findValues
  }

  trait ValueEnumValueType[EntryType <: ValueEnumEntry[_]] {
    type ValueType
  }
  object ValueEnumValueType {
    type Aux[EntryType <: ValueEnumEntry[_], VT] = ValueEnumValueType[EntryType] { type ValueType = VT }
    implicit def byte[A <: ByteEnumEntry]    : Aux[A, Byte]   = null
    implicit def char[A <: CharEnumEntry]    : Aux[A, Char]   = null
    implicit def int[A <: IntEnumEntry]      : Aux[A, Int]    = null
    implicit def long[A <: LongEnumEntry]    : Aux[A, Long]   = null
    implicit def short[A <: ShortEnumEntry]  : Aux[A, Short]  = null
    implicit def string[A <: StringEnumEntry]: Aux[A, String] = null
  }

  implicit def valueEnumEntryToStatement[ValueType, A <: ValueEnumEntry[ValueType]](implicit
    enumValueType: ValueEnumValueType.Aux[A, ValueType],
    toStatement: ToStatement[ValueType]): ToStatement[A] =
    (s: PreparedStatement, index: Int, v: A) => toStatement.set(s, index, v.value)

  val toStatement: ToStatement[Test] = implicitly[ToStatement[Test]]