5

我有以下斯卡拉问题：

编写一个函数来获取 HLists 的列表

List(23 :: “a” :: 1.0d :: HNil, 24 :: “b” :: 2.0d :: HNil)    # this is list of hlists

并返回 HList of Lists

List[Int](23, 24) :: List[String](“a”, “b") :: List[Double](1.0d, 2.0d) :: HNil # this is hlist of lists

这有点像通用的 unzipN。任意HList是否有可能？

谢谢你。

4

2 回答 2

6

有很多方法可以解决这个问题，定义一个自定义类型类（如 Nikita 的回答）是一个非常好的方法。不过，我个人认为以下方法更清晰一些。首先让我们将任何由幺半群组成的异构列表变成一个幺半群：

import shapeless._
import scalaz._, Scalaz._

implicit object hnilMonoid extends Monoid[HNil] {
  val zero = HNil
  def append(f1: HNil, f2: => HNil) = HNil
}

implicit def hconsMonoid[H: Monoid, T <: HList: Monoid] = new Monoid[H :: T] {
  val zero = Monoid[H].zero :: Monoid[T].zero
  def append(f1: H :: T, f2: => H :: T) =
    (f1.head |+| f2.head) :: (f1.tail |+| f2.tail)
}

我正在使用Scalaz的Monoid，尽管您可以很容易地编写自己的 —— 它只是一个类型类，它见证了一个类型具有一个带有标识元素的类似加法的操作。对于此示例而言，至关重要的是（任何​​事物的）列表是串联下的幺半群，其中空列表作为标识元素。

接下来是一个简单的多态函数，它将你给它的任何东西包装在一个列表中：

object singleton extends Poly1 { implicit def anything[A] = at[A](List(_)) }

然后我们将它们捆绑在一起：

def unzipN[L <: HList, Out <: HList](hlists: List[L])(implicit
  mapper: ops.hlist.Mapper.Aux[singleton.type, L, Out],
  monoid: Monoid[Out]
): Out = hlists.map(_ map singleton).suml

现在我们可以定义我们的示例：

val myList = List(23 :: "a" :: 1.0d :: HNil, 24 :: "b" :: 2.0d :: HNil)

我们完成了：

scala> println(unzipN(myList))
List(23, 24) :: List(a, b) :: List(1.0, 2.0) :: HNil

使用这种方法，大多数机器都非常通用，并且很容易直观地了解每个步骤的作用。考虑以下简化示例：

val simple = List(1 :: "a" :: HNil, 2 :: "b" :: HNil)

现在simple.map(_ map singleton)只是以下内容：

List(List(1) :: List("a") :: HNil, List(2) :: List("b") :: HNil)

但是我们知道如何“添加”类型的东西List[Int] :: List[String] :: HNil，这要归功于我们在顶部的幺半群机器。所以我们可以使用 Scalaz's 获取列表的总和suml，我们就完成了。

这都是使用 Shapeless 2.0，但在 1.2 中看起来非常相似。

于 2014-01-29T22:46:17.603 回答
3

要解决这个问题，您需要一个自定义类型类：

import shapeless._

trait Unzipper[ -input ]{
  type Output
  def unzip( input: input ): Output
}
object Unzipper {
  implicit def headTail
    [ head, tail <: HList ]
    ( implicit tailUnzipper: Unzipper[ List[ tail ] ]{ type Output <: HList } )
    =
    new Unzipper[ List[ head :: tail ] ]{
      type Output = List[ head ] :: tailUnzipper.Output
      def unzip( list: List[ head :: tail ] ) = 
        list.map(_.head) :: tailUnzipper.unzip(list.map(_.tail))
    }
  implicit val nil =
    new Unzipper[ List[ HNil ] ]{
      type Output = HNil
      def unzip( list: List[ HNil ] ) = HNil
    }
}

val list = List(23 :: "a" :: 1.0d :: HNil, 24 :: "b" :: 2.0d :: HNil)
println( implicitly[Unzipper[list.type]].unzip(list) )

输出：

List(23, 24) :: List(a, b) :: List(1.0, 2.0) :: HNil
于 2014-01-29T21:55:02.270 回答