小编Yan*_*san的帖子

我需要一个maxBy，在相等的情况下返回所有最大值。

这是签名和第一个实现：

def maxBy[A, B](as: Seq[A])(f: A => B)(implicit cmp: Ordering[B]) : Seq[A] = 
  as.groupBy(f).toList.maxBy(_._1)._2

范例：

maxBy(Seq(("a", "a1"),("a", "a2"),("b", "b1"),("b", "b2")))(_._1)
res6: Seq[(String, String)] = List(("b", "b1"), ("b", "b2"))

更新为@thearchetypepaul评论

  def maxBy[A, B](l: Seq[A])(f: A => B)(implicit cmp: Ordering[B]) : Seq[A] = {
    l.foldLeft(Seq.empty[A])((b, a) =>
      b.headOption match {
        case None => Seq(a)
        case Some(v) => cmp.compare(f(a), f(v)) match {
          case -1 => b
          case 0 => b.+:(a)
          case 1 => Seq(a)
        }
      }
    )
  }

有没有更好的办法 ？

给定一种方法

def f(a: String, b: String) = ???

我想得到两个部分应用的函数(第一个参数和第二个参数).

我写了以下代码:

def fst = f _ curried "a"
def snd = (s: String) => (f _ curried)(s)("b")

有没有更好的办法 ？

[更新] snd可写得更短 def snd = (f _ curried)((_: String))("b")

我们是否应该始终使用override特质来先解决钻石继承问题？

让我们看一个例子来解释这一点:

trait S { def get : String }
trait A extends S { override def get = "A" }
trait B extends S { override def get = "B" }
class C extends A with B

没有override,以下不编译.

这是我的实际解决方案

  private def transpose[E, A](readers : Seq[Reader[E, A]]) : Reader[E, Seq[A]] =
    Reader { e: E => readers.map { r => r(e) } }

scalaz是否有更简单的解决方案(可能使用现有的组合器)？

即使它真的很简单，例如对于 LocalDate ：

  implicit val ord : Ordering[java.time.LocalDate] = new Ordering[java.time.LocalDate] {
    override def compare(x: LocalDate, y: LocalDate): Int = x.compareTo(y)
  }

有没有办法将 a 转换Comparable<A>为Ordering[A].

我尝试导入import scala.math.Ordering._但出现此错误

diverging implicit expansion for type Ordering[java.time.LocalDate]
[error] starting with method comparatorToOrdering in trait LowPriorityOrderingImplicits

我需要一种方法从集合中统一选择一个随机值.

这是我目前的impl.

implicit class TraversableOnceOps[A, Repr](val elements: TraversableOnce[A]) extends AnyVal {
  def pickRandomly : A = elements.toSeq(Random.nextInt(elements.size))
}

但是这段代码实例化了一个新的集合,因此在内存方面并不理想.

有什么方法可以改善？

[更新]使其工作Iterator

  implicit class TraversableOnceOps[A, Repr](val elements: TraversableOnce[A]) extends AnyVal {
    def pickRandomly : A = {
      val seq = elements.toSeq
      seq(Random.nextInt(seq.size))
    }
  }

我想知道组合spark udf是否存在性能损失.一般来说,我更喜欢编写做一件事的小功能......

给出一个DataFramedf ,这是一个简单的例子:

def inc = udf( (i: Double) => i + 1)
def double = udf( (i: Double) => i * 2)
df.withColumn("r", double(inc($"c")))

与

def incAndDouble = udf( (i: Double) => (i + 1) * 2)
df.withColumn("r", incAndDouble($"c")

从我所看到的,在这个简单的例子中,性能是相同的.

你能解释一下原因吗？Spark如何在幕后工作？

它总是如此吗？

[更新]

当一个聪明的组合(不仅仅是一个简单的函数组合)成为可能时,我可能有一个反例,如下例所示

def filter = udf((s: Seq[String]) => s.startsWith("A"))
def size = udf((s: Seq[String]) => s.size)

val filterAndSize = udf((s: Seq[String]) => s.count(_.startsWith("A")))

因此,我认为filterAndSize是首选,因为它将避免一些中间集合实例化.

我正在使用F-bounded类型以便能够返回当前类型

trait Board[T <: Board[T]] {
  def updated : T
}

我正在尝试编写一个使用它的通用辅助方法.

问题是:为什么以下不编译？

object BoardOps {
  def updated(board: Board[_]) = {
    board.updated.updated
  }
}

错误是 value updated is not a member of _$1

我已经找到了这2个解决方法.它们是等价的吗？

object BoardOps {
  def updated(board: Board[_<:Board[_]]) = {
    board.updated.updated
  }
}

object BoardOps {
  def updated[T <: Board[T]](board: T) : T = {
    board.updated.updated
  }
}

根据设计，我们确信我们有一个 HourlyDateFormat

在这种情况下如何避免调用 asInstanceOf（即如何帮助编译器推断类型）？

  sealed trait StorageLayout extends Product with Serializable
  case object Hourly         extends StorageLayout
  case object Daily          extends StorageLayout

  sealed trait DateFormat[S <: StorageLayout]

  sealed abstract class HourlyDateFormat extends DateFormat[Hourly.type] {
    def format(localDate: LocalDate): String         = ???
    def format(localDateTime: LocalDateTime): String = ???
  }

  sealed abstract class DailyDateFormat extends DateFormat[Daily.type] {
    def format(localDate: LocalDate): String = ???
  }

  class Log[S <: StorageLayout](storageLayout: S, dateFormat: DateFormat[S]) {
    def getPath(date: LocalDate): String =
      dateFormat match {
        case hdf: HourlyDateFormat => …

我需要一个异构的,类型安全的容器来存储不相关的类型A,B,C.

这是一种类型级规范:

trait Container {
  putA(a: A) 
  putB(b: B)
  putC(c: C)
  put(o: Any) = { o match {
    case a: A => putA(a)
    case b: B => putB(b)
    case c: C => putC(c)
  }
  getAllAs : Seq[A]
  getAllBs : Seq[B]
  getAllCs : Seq[C]
}

哪种类型是支持此容器的最佳套件？

是否值得为类型A,B,C创建容器[T]类型类？

THKS.