Scala 在函数体中使用泛型类型时，LabelledGenerid.Aux隐式不可用

我正在尝试这个方法，它很有效：

在val res=toClass[T].frommap.get中，我应该使用T而不是Foo，但它不会编译为缺少隐式

toClass[T].from是一个函数，用于从映射创建给定类型的case类

我怎样才能使这个隐式的，可能还有其他的.from依赖的东西可用呢

我尝试了def[T，H您可以将贴图转换为HList，然后将HList转换为T：

我试过了

---

def to[T，H写下你的ToCase。如果我理解正确，toClass[Foo]。frommap的类型是Foo。Where is。get in to class[Foo]。frommap.get from？你有没有。get in Foo？啊，可能不是Foo，而是Option[Foo]。是的。from返回一个选项[Foo].我在这方面又花了几个小时，但仍然没有进展，我肯定缺少一些基本的东西。如果在函数调用中定义了case类类型，则隐式将丢失。这很完美，谢谢。我的.from代码与您的代码类似，但缺少的是整个隐式包装器。我仍然不完全了解它的工作原理-意味着我对整个含蓄的事情理解不足，现在我将确保我完全理解它：@r3stle55祝你好运。如果你对答案感到满意，你可以接受它。 ` case class Foo(name: String)

class Morphic(map: Map[String, Any]) {

  def add(k: String, v: Any) = {
    new Morphic((map + (k -> v)))
  }

  def to[T](): T = {
    def toClass[A]: ToCase[A] = new ToCase[A] // This is class to convert from Map to case class
    val res = toClass[Foo].from(map).get // <-- problem is here - cannot use T
    res.asInstanceOf[T]
  }
}

object testApp extends App {
  var m = new Morphic(Map[String, Any]())
  var m1 = m.add("name", "john")
  println(m1.to[Foo])
}

import shapeless.{::, HList, HNil, LabelledGeneric, Witness}
import shapeless.labelled._

case class Foo(name: String)

trait MapToHList[L <: HList] {
  def apply(map: Map[String, Any]): Option[L]
}
object MapToHList {
  implicit object hNilMapToHList extends MapToHList[HNil] {
    override def apply(map: Map[String, Any]): Option[HNil] = Some(HNil)
  }

  implicit def hConsMapToHList[K <: Symbol, V, T <: HList](implicit
                                                           mapToHList: MapToHList[T],
                                                           witness: Witness.Aux[K]
                                                          ): MapToHList[FieldType[K, V] :: T] =
    new MapToHList[FieldType[K, V] :: T] {
      override def apply(map: Map[String, Any]): Option[FieldType[K, V] :: T] = {
        val str = witness.value.toString.tail
        for {
          v <- map.get(str)
          t <- mapToHList(map)
        } yield field[K](v.asInstanceOf[V]) :: t
      }
    }
}

trait ToCase[A] {
  def from(map: Map[String, Any]): Option[A]
}
object ToCase {
  implicit def mkToCase[A, L <: HList](implicit
                                       gen: LabelledGeneric.Aux[A, L],
                                       mapToHList: MapToHList[L]
                                      ): ToCase[A] =
    new ToCase[A] {
      override def from(map: Map[String, Any]): Option[A] = mapToHList(map).map(gen.from)
    }
}


class Morphic(map: Map[String, Any]) {

  def add(k: String, v: Any) = {
    new Morphic((map + (k -> v)))
  }

  def to[T](implicit toCase: ToCase[T]): T = toCase.from(map).get

}

object testApp extends App {
  var m = new Morphic(Map[String, Any]())
  var m1 = m.add("name", "john")
  println(m1.to[Foo]) // Foo(john)
}