Question

在下面的代码中，我试图创建一个列表的HList，但我在这段代码的最后一行面临编译时错误：

◾找不到参数tupler的隐含值： shapeless.ops.hlist.Tupler [shapeless.HList]◾没有足够的参数方法tupled :(隐式tupler： shapeless.ops.hlist.Tupler [shapeless.HList]）tupler.Out。不明值参数tupler。

object Problem extends App {

  def combinations[T](n: Int, ls: List[T]) = {

    import shapeless._
    import HList._

    def prepareHListR(t: Int, result: HList): HList = t match {
      case t if (t == 0) => result
      case _             => prepareHListR(t - 1, rotateLeft(t - 1, ls) :: result)
    }

    prepareHListR(n, HNil)

  }

  def rotateLeft[A](i: Int, xs: List[A]) = {
    val rot = if (i > 0) i else xs.length + i
    xs.drop(rot) ++ xs.take(rot)
  }

  println(combinations(3, List('a, 'b, 'c, 'd, 'e, 'f)))

}

输出：

列表（'a，'b，'c，'d，'e，'f）:: List（'b，'c，'d，'e，'f，'a）:: List（' c，'d，'e，'f，'a，'b）:: HNil

接下来我需要做的是创建这些列表的元组，如下所示：

（列表（'a，'b，'c，'d，'e，'f），列表（'b，'c，'d，'e，'f，'a），列表（'c ，'d，'e，'f，'a，'b））

我正在尝试：

combinations(3, List('a, 'b, 'c, 'd, 'e, 'f)).tupled

<小时/> 然而，这种方法在REPL上工作正常：

scala> import shapeless._
import shapeless._

scala> import HList._
import HList._

scala> val hlist = List(1, 2, 3) :: List(4, 5, 6) :: List(7, 8, 9) :: HNil
hlist: shapeless.::[List[Int],shapeless.::[List[Int],shapeless.::[List[Int],shapeless.HNil]]] = List(1, 2, 3) :: List(4, 5, 6) :: List(7, 8, 9) :: HNil

scala> val t  =hlist.tupled
t: (List[Int], List[Int], List[Int]) = (List(1, 2, 3),List(4, 5, 6),List(7, 8, 9))

<小时/> 对我而言，这似乎是类型参数的一个问题，但由于我对Scala和Shapeless的知识有限，我无法理解它。

非常感谢任何帮助！ TIA。

Answer 1

这里有几个相关的问题，但重要的是元组的大小取决于仅在运行时已知的值（这是一个问题）。 HList版本有效，但只是因为您丢弃了这些类型。您最终会得到一些静态输入为HList的内容，您几乎不能做任何事情（除了运行时的模式匹配），而且通常不是您想要的。

你可以编写一个这样的版本，它给你一个很好的，静态的元组类型的结果，但它的工作量更多一些，它会对你的n参数设置一个约束。首先，您需要一个自定义类型类：

import shapeless._, ops.tuple.{ Last, Prepend }

trait Rotated[N <: Nat, A] extends DepFn1[List[A]]

object Rotated {
  type Aux[N <: Nat, A, Out0] = Rotated[N, A] { type Out = Out0 }

  implicit def rotated0[A]: Aux[nat._1, A, Tuple1[List[A]]] =
    new Rotated[nat._1, A] {
      type Out = Tuple1[List[A]]

      def apply(l: List[A]): Tuple1[List[A]] = Tuple1(l)
    }

  implicit def rotatedN[N <: Nat, A, OutN, LA](implicit
    rotN: Aux[N, A, OutN],
    last: Last.Aux[OutN, LA],
    ev: LA <:< List[A],
    prep: Prepend[OutN, Tuple1[List[A]]]
  ): Aux[Succ[N], A, prep.Out] =
    new Rotated[Succ[N], A] {
      type Out = prep.Out

      def apply(l: List[A]): prep.Out = {
        val resultN = rotN(l)
        val lastList = ev(last(resultN))
        prep(resultN, Tuple1(lastList.drop(1) ++ lastList.take(1)))
      }
    }
}

有几种方法可以写出来。上面的版本是袖手旁观，但可能是合理的。

现在，您的combinations方法如下所示：

def combinations[T, O <: HList](n: Nat, ls: List[T])(implicit
  rotN: Rotated[n.N, T]
): rotN.Out = rotN(ls)

然后使用正是您所要求的：

scala> combinations(3, List('a, 'b, 'c, 'd, 'e, 'f))
res0: (List[Symbol], List[Symbol], List[Symbol]) = (List('a, 'b, 'c, 'd, 'e, 'f),List('b, 'c, 'd, 'e, 'f, 'a),List('c, 'd, 'e, 'f, 'a, 'b))

scala> combinations(2, List('a, 'b, 'c, 'd, 'e, 'f))
res1: (List[Symbol], List[Symbol]) = (List('a, 'b, 'c, 'd, 'e, 'f),List('b, 'c, 'd, 'e, 'f, 'a))

现在你要回到元组，代价是不能做这样的事情：

scala> val x = 4
x: Int = 4

scala> combinations(x, List('a, 'b, 'c, 'd, 'e, 'f))
<console>:20: error: Expression x does not evaluate to a non-negative Int literal
       combinations(x, List('a, 'b, 'c, 'd, 'e, 'f))
                    ^

但是如果你认为这是一个合理的约束 - 如果你想要一个在编译时可用的元组，你需要以编译时可用的方式指定那个大小。 / p>

找不到参数tupler的隐含值

1 个答案: