Question

我正在使用一个库，该类的类具有非常复杂的泛型类型。我需要编写一个方法，该方法接受带有类库的val的泛型类型的参数，并且我希望避免在方法签名中写出类型。我想我可以创建一个隐式类，它可以在方法签名中使用val添加一个类型，类似于：

// This comes from a library and can't be changed
case class LibraryClass[A](a: A)

//----------------------------------

object MyCode {
  val thing = LibraryClass(3)

  implicit class LibraryClassWithType[A](lc: LibraryClass[A]) {
    type TheType = A
  }

  def doStuff(something: thing.TheType): Unit = {
    println(something)
  }
}

这不编译（TheType不是LibraryClass的成员）。但如果我自己将它包装在课堂上，那就可以了。

  val thingWithType = LibraryClassWithType(thing)
  def doStuff(something: thingWithType.TheType): Unit = {
    println(something)
  }

我有什么遗漏可以使这项工作，或者这种隐式转换是无效的Scala？

Answer 1

你可以这样做（我想）你想做的事情：

implicit val thing = LibraryClass(3)
def doStuff[A](something: A)(implicit lc: LibraryClass[A])

我不明白为什么这需要如此复杂。为什么不坚持使用你的第二种方法，没有暗示，哪种方法有效，或者为什么不这样做 def doStuff[A](something: A)开头？

Answer 2

我还没有能够用implicits做这种事情，但是我必须做类似的事情，我只是实例化了这些类型的持有者：

case class LibraryClass[A](a: A)

object MyCode {
  val thing = LibraryClass(3)

  class HigherTypeHolder[A,F[A]](a: F[A]) {
    type AT = A
  }
  val th = new HigherTypeHolder(thing)

  def doStuff(something: th.AT): Unit = {
    println(something)
  }
}

隐式转换以使通用类型可用

2 个答案: