Scala 找不到参数元组的隐式值

在下面的代码中，我试图创建一个列表列表，但在代码的最后一行我遇到了编译时错误，如下所示：

◾找不到参数元组的隐式值： shapless.ops.hlist.Tupler[shapless.hlist]◾没有足够的论据支持 方法元组：（隐式元组： shapless.ops.hlist.Tupler[shapless.hlist]）Tupler.Out。未指明 值参数元组

输出：

列表（'a，'b，'c，'d，'e，'f）：：列表（'b，'c，'d，'e，'e，'f，'a）：：列表（'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和Shapess方面的知识有限

---

非常感谢您的帮助！TIA。

这里有几个相关的问题，但重要的一点是元组的大小取决于只有在运行时才知道的值（这是一个问题）。

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)))
      }
    }
}

然后，用法正是您要求的：

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))

现在，您将返回元组，代价是无法执行以下操作：

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

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))
                    ^

scala>val x=4
x:Int=4
scala>组合（x，列表（'a，'b，'c，'d，'e，'f））
：20:错误：表达式x的计算结果不是非负整数文字
组合（x，列表（'a，'b，'c，'d，'e，'f））
^

---

但是，如果您想让元组的大小在编译时可用，那么这是一个合理的约束，您需要以编译时可用的方式指定该大小。

对，您可能缺少一个类型参数（以及一条隐式证据）。如果您能提供一个完整的示例（包含导入和所有定义），诊断起来会更容易。@TravisBrown谢谢您的回复。我已经用工作代码和进一步的解释更新了帖子。

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))
                    ^