Question

我正在开发一个API，它应该能够从对某些副产品类型进行操作的标准单态函数动态构建无形Poly1函数。

目标是公开一个接收函数的简单方法：

type FooCoproduct = Foo :+: Bar :+: CNil
def addF[E](f: E => E)(implicit ev: Inject[FooCoproduct, E]) = ???

并累积这些函数以构建涵盖副产品中所有类型的总Poly1函数。这里的证据ev是强制类型参数E是副产品中的一种类型。

在测试了几种方法，包括类型类的泛型推导之后，最有希望的方法让我在HList中积累了这些单态函数，并尝试通过Selector解决应用的问题。。通过示例可能更好地理解这一点：

object CoproductSample extends App {

  import shapeless.{ :+:, CNil, Coproduct, HList, HNil, Poly1 }
  import shapeless.ops.coproduct.Inject
  import shapeless.ops.hlist.Selector

  class Builder[A <: Coproduct] {

    def accum[B](f: B => B, hl: HList)(implicit ev: Inject[A, B]) = f :: hl

    class PolyBuilder[L <: HList](hl: L) extends Poly1 {
      implicit def run[T](implicit ev: Selector[L, T => T]) = 
        at[T](hl.select[T => T])
    }

  }

  type Cop = Int :+: String :+: CNil

  val builder = new Builder[Cop]

  val hl1 = builder.accum((i: Int) => i + 1, HNil)
  val hl2 = builder.accum((s: String) => s + "one", hl1)

  object pf extends builder.PolyBuilder(hl2)

  val rInt = Coproduct[Cop](10).fold(pf)
  val rStr = Coproduct[Cop]("ten").fold(pf)
}

此代码无法使用以下消息进行编译：

could not find implicit value for parameter folder:     
shapeless.ops.coproduct.Folder[CoproductSample.pf.type, CoproductSample.Cop]

我想我需要提供一个Selector[L, T => T]，其中L是累积HList的类型，但我无法想出这样做的方法。另一方面，我觉得必须有一个更简单的解决方案来解决我的问题。

任何帮助都将不胜感激。

更新

在做了一些研究之后，我想出了一个几乎可行的解决方案。不幸的是，我无法正确跟踪结果类型。

object CoproductSample {
  import shapeless.{ CNil, Coproduct, HList, HNil, Inl, Inr, Poly2, ::, :+: }

  // Accumulates ordinary functions from A => A in an HList
  def accum[A, L <: HList](f: A => A, hl: L): (A => A) :: L = f :: hl

  // A poly2 function that evaluates some monomorphic function present in
  // an HList for certain value that satifies the signature of this function
  object PolyEval extends Poly2 {
    implicit def hnilCase[A]: Case.Aux[A, HNil, Option[A]] =
      at[A, HNil]((a, l) => None)

    implicit def hheadCaseSuccess[A, T <: HList]: Case.Aux[A, (A => A) :: T, Option[A]] =
      at[A, (A => A) :: T]((a: A, l: (A => A) :: T) => Option(l.head(a)))

    implicit def hheadCaseFail[A, H, T <: HList](
        implicit tail: Case.Aux[A, T, Option[A]]
    ): Case.Aux[A, (H => H) :: T, Option[A]] =
      at[A, (H => H) :: T]((a: A, l: (H => H) :: T) => PolyEval(a, l.tail))
  }

  // A poly2 function that uses `PolyEval` for evaluating a value present in
  // a coproduct against an HList of monomorphic functions
  object PolyEvalCop extends Poly2 {
    implicit def cnilCase[A <: CNil, L <: HList]: Case.Aux[A, L, Option[A]] =
      at[A, L]((a, l) => sys.error("Impossible!"))

    implicit def cconsCase[H, T <: Coproduct, L <: HList](
        implicit head: PolyEval.Case.Aux[H, L, Option[H]],
        tail: Case[T, L]) // What is the return type here???)
    = at[H :+: T, L]((c, l) =>
        c match {
          case Inl(h) => PolyEval(h, l)
          case Inr(t) => PolyEvalCop(t, l)
      })
  }
}

控制台会话：

scala> import shapeless._, CoproductSample._
import shapeless._
import CoproductSample._

scala> case class Foo(i: Int); case class Bar(s: String)
defined class Foo
defined class Bar

scala> val f = (foo: Foo) => foo.copy(i = foo.i * 2)
f: Foo => Foo = <function1>

scala> val g = (bar: Bar) => bar.copy(s = bar.s + "_changed!")
g: Bar => Bar = <function1>

scala> val hl = accum(g, accum(f, HNil))
hl: shapeless.::[Bar => Bar,shapeless.::[Foo => Foo,shapeless.HNil.type]] = <function1> :: <function1> :: HNil

scala> type C = Foo :+: Bar :+: CNil
defined type alias C

scala> PolyEvalCop(Coproduct[C](Foo(10)), hl)
res1: Any = Some(Foo(20))

scala> PolyEvalCop(Coproduct[C](Bar("bar")), hl)
res2: Any = Some(Bar(bar_changed!))

未正确跟踪结果类型，并将其解析为Any。

Answer 1

从addF的签名看起来，您希望在Coproduct上进行映射，即修改其值并保留在副产品上，即def add[E](e:E):E，如果是是这样的情况：

@ {
  trait Add[E]{
    def add(e:E):E
  }
  object Add{
    def apply[E:Add]:Add[E] = implicitly[Add[E]]
    implicit object cnil extends Add[CNil] {
     def add(e:CNil) = throw new RuntimeException("Impossible")
    }
    implicit def coproduct[H, T <: Coproduct](
                 implicit
                 addH: Add[H],
                 addT:Add[T],
                 basis: ops.coproduct.Basis[H :+: T,T]
                 ):Add[H :+: T] = new Add[H :+: T]{
        def add(e: H :+: T) = e match {
           case Inl(h) => Coproduct[H :+: T](addH.add(h)) // to stay in the Coproduct
           case Inr(t) => addT.add(t).embed[H :+: T] // to stay in the coproduct
         }
      }
  }
  }
defined trait Add
defined object Add
@ implicit def addString = new Add[String] {
     def add(e:String) = e + "-ah"
  }
defined function addString
@ implicit def addInt = new Add[Int] {
     def add(e:Int) = e + 1
  }
defined function addInt
@ type C = Int :+: String :+: CNil
defined type C
@ val i = Coproduct[C](1)
i: C = 1
@ Add[C].add(i)
res24: C = 2 // notice that the return type is C
@ val s = Coproduct[C]("a")
s: C = a
@ Add[C].add(s)
res26: C = a-ah // notice that the return type is C

它显然适用于＆＃34;普通＆＃34;类型：

@ Add[Int].add(1)
res38: Int = 2

以上相当于map;但是如果你想要一个fold，即def add[E](e:E):Int，你只需修改这两行：

case Inl(h) => addH.add(h)
case Inr(t) => addT.add(t)

来自副产品的单态函数的多项函数

1 个答案: