折叠未知类型的 HList

Question

我有一种复杂的类型层次结构，但要分解它有两个基本特征：Convertable 和 Conversion[A <: Convertable, B <: Convertable，例如有一个 Conversion 可以将 Mealy 自动机转换为 Moore 自动机。每个 Conversion[A,B] 都有一个 convert(automaton: A) : B 方法。

现在我想介绍一下smart Conversions的概念，它基本上就是一个普通Conversions的List，会一个接一个的执行。因此，我引入了一个 AutoConversion 特征，扩展了一个具有 val path : HList 参数的 Conversion 来表示转换链，并且应该实现 convert 方法，以便 AutoConversions 只需要提供要进行的实际转化的列表。我想你可以在 path 上用 fold 来实现这个，所以这是我的第一次尝试：

package de.uni_luebeck.isp.conversions

import shapeless._
import shapeless.ops.hlist.LeftFolder

trait AutoConversion[A <: Convertable, B <: Convertable] extends Conversion[A, B] {
  val path: HList

  object combiner extends Poly {
      implicit def doSmth[C <: Convertable, D <: Convertable] = 
         use((conv : Conversion[C, D] , automaton : C) => conv.convert(automaton))

}

  override def convert(startAutomaton: A): B = {
    path.foldLeft(startAutomaton)(combiner)
  }
}

这行不通，因为找不到隐式文件夹，所以我猜我必须在某处为编译器提供更多类型信息，但不知道在哪里

Answer 1

关于需要更多类型信息，您是对的，一般来说，如果您有一个 HList 作为静态类型的值，您可能需要改变您的方法。如果您只知道 HList 是一个 HList （除了在其前面加上值），那么您基本上无法用 HList 做任何事情，而且您通常只会将 HList 写成一个类型约束。

在您的情况下，您所描述的是一种类型对齐的序列。在您继续使用此方法之前，我建议您确定您确实需要这样做。关于函数（以及像你的 Conversion 这样的函数类型）的好处之一是它们可以组合：你有一个 A => B 和一个 B => C 然后你将它们组合成一个 A => C 并且可以永远忘记 B。你会得到一个漂亮干净的黑盒子，这通常正是你想要的。

不过，在某些情况下，能够以可以反映管道各个部分的方式组合类似函数的东西可能很有用。我假设这是其中一种情况，但你应该自己确认一下。如果不是，那么你很幸运，因为接下来的内容有点乱。

我假设这些类型：

trait Convertable

trait Conversion[A <: Convertable, B <: Convertable] {
  def convert(a: A): B
}

我们可以定义一个类型 class 来见证一个特定的 HList 由一个或多个转换组成，其类型排列如下：

import shapeless._

trait TypeAligned[L <: HList] extends DepFn1[L] {
  type I <: Convertable
  type O <: Convertable
  type Out = Conversion[I, O]
}

L 包含有关管道的所有类型信息，I 和 O 是其端点的类型。

接下来我们需要这个类型的实例class（注意这必须和上面的特征一起定义才能使两者相伴）：

object TypeAligned {
  type Aux[L <: HList, A <: Convertable, B <: Convertable] = TypeAligned[L] {
    type I = A
    type O = B
  }

  implicit def firstTypeAligned[
    A <: Convertable,
    B <: Convertable
  ]: TypeAligned.Aux[Conversion[A, B] :: HNil, A, B] =
    new TypeAligned[Conversion[A, B] :: HNil] {
      type I = A
      type O = B
      def apply(l: Conversion[A, B] :: HNil): Conversion[A, B] = l.head
    }

  implicit def composedTypeAligned[
    A <: Convertable,
    B <: Convertable,
    C <: Convertable,
    T <: HList
  ](implicit
    tta: TypeAligned.Aux[T, B, C]
  ): TypeAligned.Aux[Conversion[A, B] :: T, A, C] =
    new TypeAligned[Conversion[A, B] :: T] {
      type I = A
      type O = C
      def apply(l: Conversion[A, B] :: T): Conversion[A, C] =
        new Conversion[A, C] {
          def convert(a: A): C = tta(l.tail).convert(l.head.convert(a))
        }
    }
}

现在您可以编写一个 AutoConversion 版本来跟踪有关管道的所有类型信息：

class AutoConversion[L <: HList, A <: Convertable, B <: Convertable](
  path: L
)(implicit ta: TypeAligned.Aux[L, A, B]) extends Conversion[A, B] {
  def convert(a: A): B = ta(path).convert(a)
}

你可以这样使用它：

case class AutoA(i: Int) extends Convertable
case class AutoB(s: String) extends Convertable
case class AutoC(c: Char) extends Convertable

val ab: Conversion[AutoA, AutoB] = new Conversion[AutoA, AutoB] {
  def convert(a: AutoA): AutoB = AutoB(a.i.toString)
}

val bc: Conversion[AutoB, AutoC] = new Conversion[AutoB, AutoC] {
  def convert(b: AutoB): AutoC = AutoC(b.s.lift(3).getOrElse('-'))
}

val conv = new AutoConversion(ab :: bc :: HNil)

并且 conv 将具有预期的静态类型（并实现 Conversion[AutoA, AutoC]）。

折叠未知类型的 HList

Fold over HList with unknown Types

scala

shapeless