将scala代码推广到函数中

Question

所以我最近不小心写了一个关于Scala问题的Haskell答案。 对Haskell比较熟悉，解决方案很容易对我来说：

myMaxBy :: (a -> a -> Ordering) -> [a] -> [a]
myMaxBy _ [] = undefined
myMaxBy f (x:xs) = foldr step [x] xs
  where step y acc@(z:_) = case f y z of
          GT -> [y]
          EQ -> y:acc
          LT -> acc

然后有人提醒我这是一个Scala问题。 我开始将我的代码转换为Scala，经过多次努力后我决定：

(List(xs.head) /: xs.tail) { (acc, y) =>
  y compare acc.head match {
    1  => List(y)
    0  => y :: acc
    -1 => acc
  }
}

但我不能为我的生活让Scala类型系统屈服于我的意愿并将其概括为一个函数，其中xs和compare是输入（理想情况下，首先是比较器的咖喱输入）。 虽然这肯定是由于我对Scala的一般不熟悉，但我也略微责怪Scala的复杂（虽然非常强大）类型系统。 你可以做一些手握，并指导我如何把它变成一个通用函数，类型签名类似于Haskell等价？ （阅读： 如同一般 。）如果它比myMaxBy(myCompare)(someList)更复杂，请同时演示用法。

Answer 1

您错过了模式匹配中的case关键字，这非常重要！

您只需要集合参数类型就可以使用compare方法。 Scala中有两个用于比较事物的系统：扩展Ordered或使用Ordering 。 两者之间存在隐含的转换，因此您选择的内容并不重要; 第一个可能更容易理解。

首先，使用Ordered ：

  def myMaxBy[A <% Ordered[A]](xs: List[A]) = {
    (List(xs.head) /: xs.tail) { (acc, y) =>
      y compare acc.head match {
        case 1  => List(y)
        case 0  => y :: acc
        case -1 => acc
      }
    }  
  }

这里我们给泛型类型A一个使用<% 绑定的视图 ，这意味着“可以看作是”。 这比使用上限更一般<:和对于未本身类有用Ordered ，但有隐式转换为Ordered类，例如Int到RichInt 。

或者，如果您希望能够灵活地更改排序条件，则可以这样写：

  def myMaxBy[A](xs: List[A])(implicit ord: Ordering[A]) = {
    (List(xs.head) /: xs.tail) { (acc, y) =>
      ord.compare(y, acc.head) match {
        case 1  => List(y)
        case 0  => y :: acc
        case -1 => acc
      }
    }
  }

在调用时，如果范围中存在隐式Ordering[A] ，则可以保留第二个参数。 第二种方式还有一个优点，即您可以在任意类上定义Ordering ，无论它们是否已经支持它。

您可以使用例如myMaxBy(List(1,2,3,4,3,4))来调用它们。 在第二种情况下，如果你想要反向排序： myMaxBy(List(1,2,3,4,3,4))(Ordering.Int.reverse) 。

您可能在此上下文中看到的另一件事是上下文边界 。 例如[A: Ordering] 。 这意味着与[A](implicit ord: Ordering[A]) ，这更简洁，除了你没有得到Ordering的句柄，所以必须implicitly地召唤它。 所以在这里最好如上所述明确说明。

Answer 2

您需要将A类型扩展为Ordered或更好，限制它以便可以使用Ordering类型。 第一个看起来像：

def sort[A <: Ordered[A]](xs: List[A]) =
  (List(xs.head) /: xs.tail) { (acc, y) => y compare acc.head match { … } }

正如Luigi指出的更好的是使用视图绑定<％而不是子类型绑定<：因为它允许对Ordered视图进行隐式转换的类型。

def sort[A <% Ordered[A]](xs: List[A]) =
  (List(xs.head) /: xs.tail) { (acc, y) => y compare acc.head match { … } }

但更好的是使用Ordering类型：

def sort[A](xs: List[A])(implicit ord: Ordering[A]) =
  (List(xs.head) /: xs.tail) { (acc, y) => ord compare (y, acc.head) match { … } }

您也可以使用上下文绑定：

def sort[A: Ordering](xs: List[A]) = {
  val ord = implicitly[Ordering[A]]
  (List(xs.head) /: xs.tail) { (acc, y) => ord compare (y, acc.head) match { … } }
}

虽然这在语法上稍微清晰一点，但它不允许你传递一个明确的备用排序（比如说例如字符串的字符串排序）。