scala - 任意函数 - 根据输入生成返回类型

Question

给定这个类:

class Step
case class Publish(p: String) extends Step
case class Receive(p: String) extends Step

class Data
case class Input(p: Int) extends Data
case class Output(p: Int) extends Data

type P = Publish
type R = Receive
type I = Input
type O = Output

我想要一个 method/trait/class这需要 Step* Publish 中的参数/Receive序列并返回一个采用 Data 的方法Input 序列中的参数/Output .

例如，对于:

val flow = Flow {"flow" =>
    (P("1"), R("2"), P("3"), R("4"), R("5"), P("6"), R("7"))
}

然后我应该可以调用电话了:

flow(I(1), O(2), I(3), O(4), O(5), I(6), O(7))

我最接近的是定义 Flow作为对象:

object Flow {
    def apply[T](f: String => T)(implicit val s: String): T => Unit = f(s) => ()
}

上面例子的签名为flow: (P, R, P, R, R, P, R) => Unit

如何映射 P -> I和 R -> O为了调用flow使用输入和输出，并确保在编译时进行类型检查？

在寻找解决方案时，我偶然发现了 shapeless 和 scalaz 作为我认为可能对我有帮助的框架，但我真的想不通。

---

在 this answer 之后, 我重写了 Flow进入:

object Flow {
    def apply[T <: HList, S <: HList](t: T)
        (implicit mapper : Mapper[IOFlow.type, T]): S => Unit = {
        val s = t.map(IOFlow)
        s => ()
    }
}

object IOFlow extends Poly1 {
    implicit val in = at[P]{ i => makeI(i) }
    implicit val out = at[R]{ r => makeO(r) }

    def makeI(p: P) = Input // so the return type is Input.type
    def makeO(p: R) = Output // and Output.type
}

object Main extends App {

    val initialList = HList(P("1"), R("2"), P("3"), R("4"), R("5"), P("6"), R("7"))
    val flow = Flow(initialList)
}

而且我收到一个关于 implicit mapper 的错误, 实际上是在 t.map(IOFLow) 收到的:

Error: could not find implicit value for parameter mapper: shapeless.ops.hlist.Mapper[com.tasegula.scala.shapeless.IOFlow.type,this.Repr]
val flow = Flow(hlist)
               ^

所以:

1. 如何提供隐式映射器？
2. 有没有办法改变Flow#apply apply(t: Step*) 的方法声明, 所以电话是 Flow(P("1"), R("2"), P("3"), R("4"), R("5"), P("6"), R("7")) ？

Answer 1

如何轻松做到这一点？我会看看 Shapeless它实际上可以通过定义一个 Poly 来做你想做的一切:

object IOFlow extends Poly1{
  implicit val in = at[P]{ i => makeI(i) }
  implicit val out = at[R]{ r => makeO(r) }

  def makeI(p: P): I
}

并且通过将调用转换为 HList，您将能够映射:

val input: I :: O :: I :: O :: I :: O = prprpr.map(IOFlow)