创建一个采用任何2D序列并将其转换为Scala中的数组[Array [_]]的

隐含的免费答案：

def ss2aa[A,B[_],C[_]](c: C[B[A]])(
  implicit b2seq: B[A] => Seq[A],c2seq: C[B[A]] => Seq[B[A]],ma: ClassManifest[A]
) = c2seq(c).map(b => b2seq(b).toArray).toArray

效率更高,隐含：

implicit def seq2array[A: ClassManifest](sa: Seq[A]) = sa.toArray
def ss2aa[A,C[_]](c: C[B[A]])(
  implicit b2arr: B[A] => Array[A],c2arr: C[B[A]] => Array[B[A]],ma: ClassManifest[A]
) = c2arr(c).map(b2arr)

更老,更笨拙,但可能更有效的答案：

为了正常工作,这显然需要一个相当重要的解决方案.一种方法是使用Either编码Array和Seq的类型联合：

implicit def ss2leftleft[A](ssa: Seq[Seq[A]]) = Left(Left(ssa))
implicit def sa2leftright[A](saa: Seq[Array[A]]) = Left(Right(saa))
implicit def as2rightleft[A](asa: Array[Seq[A]]) = Right(Left(asa))
implicit def aa2rightright[A](aaa: Array[Array[A]]) = Right(Right(aaa))
def ss2aa[A: Manifest](
  x: Either[Either[Seq[Seq[A]],Seq[Array[A]]],Either[Array[Seq[A]],Array[Array[A]]]]
) = x match {
  case Left(Left(y)) => y.map(_.toArray).toArray
  case Left(Right(y)) => y.toArray
  case Right(Left(y)) => y.map(_.toArray)
  case Right(Right(y)) => y
}

如果你觉得这样,你当然可以定义你自己的超类和子类包装器做同样的事情.可能比使用Either更安全.

另一个选择是使用Miles Sabin’s type union operator.通过清单工作有点难看;这是一个实际上安全的版本,但编译器不知道它,因此需要进行强制转换：

object Example {
  // Type union system from Miles Sabin (with non-Unicode names)
  type Not[A] = A => Nothing
  type Union[A,B] = Not[Not[A] with Not[B]]
  type Id[A] = Not[Not[A]]

  def ss2aa[A,C[_]](b: C[B[A]])(
    implicit ev: (Id[B[A]] <:< Union[Seq[A],Array[A]]),ev2: (Id[C[B[_]]] <:< Union[Seq[B[_]],Array[B[_]]]),ma: ClassManifest[A],mssa: ClassManifest[Seq[Seq[A]]],msaa: ClassManifest[Seq[Array[A]]],masa: ClassManifest[Array[Seq[A]]],mf: ClassManifest[C[B[A]]]
  ) = {
    if (mf <:< mssa) b.asInstanceOf[Seq[Seq[A]]].map(_.toArray).toArray
    else if (mf <:< masa) b.asInstanceOf[Array[Seq[A]]].map(_.toArray)
    else if (mf <:< msaa) b.asInstanceOf[Seq[Array[A]]].toArray
    else b.asInstanceOf[Array[Array[A]]]
  }
}

总的来说,我会说第一个解决方案有点清洁.