获取Seq [_]的HList并生成具有值

时间:2018-04-21 14:38:42

标签: scala shapeless

我是Shapless的新手。

我正在尝试编写一个函数,该函数将采用HList不同类型的序列,将其转换为包含原始Seq[HList]元素的笛卡尔积的HList ,并迭代生成的序列

例如:

val input = Seq(true, false) :: Seq(1,2,3)::Seq("foo", "bar") :: HNil

cartesianProduct: Seq[Boolean :: Int :: String :: HNil] = Seq(
  true :: 1 :: foo :: HNil, 
  true :: 1 :: bar :: HNil, 
  true :: 2 :: foo :: HNil, 
  true :: 2 :: bar :: HNil, 
  true :: 3 :: foo :: HNil, 
  true :: 3 :: bar :: HNil, 
  false :: 1 :: foo :: HNil, 
  false :: 1 :: bar :: HNil, 
  false :: 2 :: foo :: HNil, 
  false :: 2 :: bar :: HNil, 
  false :: 3 :: foo :: HNil, 
  false :: 3 :: bar :: HNil)

我能够使用以下代码在Intellij Scala工作表中实现此目的:

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


object combine extends Poly {
  implicit def `case`[T <: HList, S] = use((acc : Seq[T], curr : Seq[S]) => {
    for {
      el <- curr
      v <- acc
    } yield el :: v
  })
}

val input = Seq(true, false) :: Seq(1,2,3)::Seq("foo", "bar") :: HNil

val combinations = input.foldLeft(Seq[HNil](HNil))(combine) 

combinations.foreach(println)

我认为这里的一切都有效,因为编译器已知完整类型的input

但是,当我尝试将整个操作包装在一个函数中时,input的完整类型会丢失,我无法在foldLeft的结果上调用foreach:

def cartesian[T <: HList](input: T)
         (implicit folder: LeftFolder[T, Seq[HNil], combine.type]) = {
  input.foldLeft(Seq[HNil](HNil))(combine)
    .foreach(println)
}

编译器抱怨:

  value foreach is not a member of folder.Out
    input.foldLeft(Seq[HNil](HNil))(combine).foreach(println)
                                            ^

我想有一些隐含的证据可以请求断言input HList Seq[_]的正确形状,从而让编译器找出结果的类型foldLeft,但我无法弄清楚它可能是什么......

希望有人可以帮我解决这个问题。 感谢。

更新 这个问题的最终目标是,给定HList Seq[_]来派生一个函数(可能在一个案例类中),它将接受一个与输入HList和参数类型具有相同arg arity的函数。以相同的顺序匹配'Seq'元素类型。例如,对于上面的输入,函数将是f: (Boolean, Int, String) => R 因此,我可以使用f迭代输入的笛卡尔积。 最终代码如下所示:

import shapeless._
import shapeless.ops.function.FnToProduct
import shapeless.ops.hlist.LeftFolder
import shapeless.syntax.std.function.fnHListOps


object combine extends Poly {
  implicit def `case`[EL <: HList, S] = use((acc : Seq[EL], curr : Seq[S]) => {
    for {
      el <- curr
      v <- acc
    } yield el :: v
  })
}

case class Cartesian[R <: HList, F, FR](combinations: Seq[R])
                                 (implicit ftp: FnToProduct.Aux[F, R => Unit]) {
  def foreach(f: F) =  combinations.foreach(f.toProduct)
}


def cartesian[T <: HList, R <: HList, F, FR](variants: T)(implicit
                             folder: LeftFolder.Aux[T, Seq[HNil], combine.type, _ <: Seq[R]],
                             fnToProd: FnToProduct.Aux[F, R => Unit]
                            ) = {
  val combinations: Seq[R] = variants.foldLeft(Seq[HNil](HNil))(combine)
  Cartesian(combinations)
}

val variants = Seq(true, false) :: Seq("foo", "bar") :: Seq(1, 2, 3) :: HNil

cartesian(variants).foreach((a, b, c) => println(s"$a, $b, $c")) 

请注意,函数参数abc的类型已被正确推断,并且为BooleanString和{{1} }。 目前,传递到Int的函数的结果类型必须是固定的(在上面的代码中是foreach)。它不能从传入的函数中推断出来。

1 个答案:

答案 0 :(得分:0)

问题不在于编译器对输入一无所知,而在于它对输出一无所知。

def cartesian内,编译器已知的是foldLeft之后你会得到一些类型folder.Out(这取决于一个无形的实例)。

为了确保结果类型,您可以将LeftFolder.Aux与一个额外的类型参数一起使用,例如

def cartesian[T <: HList](input: T)
         (implicit folder: LeftFolder.Aux[T, Seq[HNil], combine.type, _ <: Seq[Any]]) = {
  input.foldLeft(Seq[HNil](HNil))(combine)
    .foreach(println)
}

现在编译器会知道结果是Seq[Any]的某个子类型,因此可以在其上调用foreach

当然,这只是里面的问题 def。在呼叫站点,输出类型将根据输入进行解析,因此您可以在没有Aux的情况下执行此操作:

def cartesian2[T <: HList](input: T)
         (implicit folder: LeftFolder[T, Seq[HNil], combine.type]) = {
  input.foldLeft(Seq[HNil](HNil))(combine)
}

cartesian2(input).foreach(println)

可运行代码:https://scalafiddle.io/sf/n409yNW/2