使用 shapeless 从案例类中提取数据，对其进行修改并重新创建案例类

Question

我有一个包含一些案例类的程序。其中一个可能是 Person，它依赖于其他一些类，包括一个称为 StemmedString 的类，这在这里很重要：

case class Person(name: String, skills: List[Skill], hobbbies: List[StemmedString]
case class Skill(score: Int, title: StemmedString)
case class StemmedString(original: String, stemmed: String)

现在我希望能够将这个人翻译成另一种语言。为此，我想从 Person -> List[String] 开始。这是需要翻译的单个字符串的列表。然后我想从 List[String] -> Person 返回。

我希望能够定义所有应该翻译的事物的 TYPES，而无需事先知道 Person 的格式，这样就可以在由相同 TYPES 组成的多个案例类上推广，被翻译。

假设我们翻译的是所有 StemmedString 的。

我可以通过 LabelledGeneric 和 flatMap 创建两个 HList，一个是要翻译的值，另一个是不翻译的值：

trait LowPriorityUnTranslatable extends Poly1 {
  implicit def default[T] = at[T](_ :: HNil)
}

object unTranslatable extends LowPriorityUnTranslatable {
  implicit def caseStemmedString[K, T] = at[FieldType[K, StemmedString]](x => HNil)
  implicit def caseSkill[K, T] = at[FieldType[K, Skill](x => HNil)
}


trait LowPriorityTranslatable extends Poly1 {
  implicit def default[T] = at[T](HNil)
}

object Translatable extends LowPriorityTranslatable {
  implicit def caseStemmedString[K, T] = at[FieldType[K, StemmedString]](_ :: HNil)
  implicit def caseSkill[K, T] = at[FieldType[K, Skill](_ :: HNil)
}

这感觉有点冗长，但效果很好。我现在有两个 HList，它们可以很容易地连接起来并使用 align 返回到原始案例类：

val person = Person("...")
val gen = LabelledGeneric[Person] 
val personList = gen.to(person)
val toTranslate = personList flatMap isTranslatable
val notTranslated = personList flatMap unTranslatable    
gen.from((toTranslate ++ notTranslated) align personList)

这很酷，现在我需要做的就是在中间添加一个翻译步骤。当然，从 isTranslatable -> List[String] 很容易，但是我无法完全弄清楚如何以可以再次返回的方式执行此操作。我开始尝试学习 shapeless，因为它似乎是适合这种情况的工具，但我不太了解如何充分使用它。在我的脑海中，如果我can solve this question，那么我会没事的，但可能有一种更简单的方法可以使用 shapeless 来解决这个问题。任何见解将不胜感激！

Answer 1

如果您不介意使用可变数据结构（在本例中为Iterator），您可以使用everything/everywhere 来获得简单的解决方案。

首先，我们使用everything 查询提取待翻译的字符串；在此示例中，我们将提取 StemmedString 对象的原始值。使用 Append 函数连接单例列表。

trait TranslatableLP extends Poly1 {
  implicit def default[T] = at[T](_ => Nil: List[String])
}

object Translatable extends TranslatableLP {
  implicit def caseStemmedString = at[StemmedString](s => List(s.original))
}

object Append extends Poly2 {
  implicit val caseString = at[List[String], List[String]](_ ++ _)
}

val strings = everything(Translatable)(Append)(person)

现在我们翻译字符串：

def translate(s: String): String = ???

val translatedStrings = strings.map(translate)

最后我们可以使用 everywhere 翻译的字符串映射 StemmedString 对象：

object Update extends Poly1 {
  def iterator = translatedStrings.iterator
  implicit def caseStemmedString = at[StemmedString](_.copy(original = iterator.next))
}

val translated = everywhere(Update)(person)

当我有时间时，我会尝试提出一个更简洁的解决方案，只使用不可变的数据结构。