Scala中嵌套列表的深度反转

trait Reverser[C] {
  def reverse(xs: C): C
}

implicit def rev[A](implicit ev: Reverser[A] = null) = new Reverser[List[A]] {
  def reverse(xs: List[A]) =
    Option(ev).map(r => xs map r.reverse).getOrElse(xs).reverse
}

def deepReverse[A](xs: A)(implicit ev: Reverser[A]): A = ev.reverse(xs)

我们的rev方法中的隐含参数ev证明A本身是可逆的,如果ev是null,这意味着它不是.如果我们有这样的证据表明A是可逆的,我们用它来扭转我们的List [A]的元素(这是地图正在做的),然后我们反转列表本身.如果我们没有这个证据(getOrElse的情况),我们可以反转列表.

我们可以像这样简洁地(但可能更有效地)写入rev：

implicit def rev[A](implicit ev: Reverser[A] = null) = if (ev == null) {
  new Reverser[List[A]] {
    def reverse(xs: List[A]) = xs.reverse
  }
} else {
  new Reverser[List[A]] {
   def reverse(xs: List[A]) = (xs map ev.reverse).reverse
  }
}

要测试这两个版本之一,我们可以写下列内容：

scala> deepReverse(List.tabulate(3)(identity))
res0: List[Int] = List(2,1,0)

scala> deepReverse(List.tabulate(2,3) { case (a,b) => a + b })
res1: List[List[Int]] = List(List(3,2,1),List(2,0))

scala> deepReverse(List.tabulate(2,3,4,5,6) {
     |   case (a,b,c,d,e) => a + b + c + d + e
     | }).head.head.head.head
res2: List[Int] = List(15,14,13,12,11,10)

如预期

我应该补充说,以下是一个更常见的成语,就是在这样的情况下得到这个意思：

trait ReverserLow {
  implicit def listReverser[A] = new Reverser[List[A]] {
    def reverse(xs: List[A]) = xs.reverse
  }
}

object ReverserHigh extends ReverserLow {
  implicit def nestedListReverser[A](implicit ev: Reverser[A]) =
    new Reverser[List[A]] {
      def reverse(xs: List[A]) = xs.map(ev.reverse).reverse
    }
}

import ReverserHigh._

如果我们刚刚在同一级别写了listReverser和nestedListReverser,当我们尝试反转列表列表时,我们会收到以下错误：

scala> deepReverse(List.tabulate(2,3)(_ + _))
<console>:12: error: ambiguous implicit values:
 both method listReverser...
 and method nestedListReverser...
 match expected type Reverser[List[List[Int]]]
              deepReverse(List.tabulate(2,3)(_ + _))

优先考虑两者的标准方法是将较低优先级隐含在一个特征(WhateverLow)中,另一个在扩展该特征的对象(WhateverHigh)中.在这样一个相当简单的情况下,尽管如此,在上面的rev方法中使用默认参数技巧更为简洁(更清晰).但是,您更有可能在其他人的代码中看到其他版本.