Scala 基于任意数量的选项筛选集合

如何重构以下Scala函数以使用惯用的最佳实践

  def getFilteredList(ids: Seq[Int], 
      idsMustBeInThisListIfItExists: Option[Seq[Int]], 
      idsMustAlsoBeInThisListIfItExists: Option[Seq[Int]]): Seq[Int] = {

    var output = ids

    if (idsMustBeInThisListIfItExists.isDefined) {
      output = output.intersect(idsMustBeInThisListIfItExists.get)
    }
    if (idsMustAlsoBeInThisListIfItExists.isDefined) {
      output = output.intersect(idsMustAlsoBeInThisListIfItExists.get)
    }

    output 
  }

预期IO：

val ids = Seq(1,2,3,4,5)
val output1 = getFilteredList(ids, None, Some(Seq(3,5))) // 3, 5
val output2 = getFilteredList(ids, None, None) // 1,2,3,4,5
val output3 = getFilteredList(ids, Some(Seq(1,2)), None) // 1,2
val output4 = getFilteredList(ids, Some(Seq(1)), Some(Seq(5))) // 1,5

---

谢谢您的时间。

这里有一个简单的方法：

  implicit class SeqAugmenter[T](val seq: Seq[T]) extends AnyVal {
    def intersect(opt: Option[Seq[T]]): Seq[T] = {
      opt.fold(seq)(seq intersect _)
    }
  }

  def getFilteredList(ids: Seq[Int],
    idsMustBeInThisListIfItExists: Option[Seq[Int]],
    idsMustAlsoBeInThisListIfItExists: Option[Seq[Int]]
  ): Seq[Int] = {
    ids intersect
      idsMustBeInThisListIfItExists intersect 
      idsMustAlsoBeInThisListIfItExists
  }

---

下面是一个简单的方法：

  implicit class SeqAugmenter[T](val seq: Seq[T]) extends AnyVal {
    def intersect(opt: Option[Seq[T]]): Seq[T] = {
      opt.fold(seq)(seq intersect _)
    }
  }

  def getFilteredList(ids: Seq[Int],
    idsMustBeInThisListIfItExists: Option[Seq[Int]],
    idsMustAlsoBeInThisListIfItExists: Option[Seq[Int]]
  ): Seq[Int] = {
    ids intersect
      idsMustBeInThisListIfItExists intersect 
      idsMustAlsoBeInThisListIfItExists
  }

---

另一种类似的方式，没有含蓄

def getFilteredList[A](ids: Seq[A],
                       idsMustBeInThisListIfItExists: Option[Seq[A]],
                       idsMustAlsoBeInThisListIfItExists: Option[Seq[A]]): Seq[A] = {
  val  a = intersect(Some(ids), idsMustBeInThisListIfItExists)(ids)
  val  b = intersect(Some(a), idsMustAlsoBeInThisListIfItExists)(a)
  b
}

def intersect[A](ma: Option[Seq[A]], mb: Option[Seq[A]])(default: Seq[A]) = {
  (for {
     a <- ma
     b <- mb
   } yield {
     a.intersect(b)
   }).getOrElse(default)
}

def getFilteredList[A]（id:Seq[A]，
IDSMustbeinthilistifitExists:选项[Seq[A]]，
idsMustAlsoBeInThisListIfItExists:Option[Seq[A]]：Seq[A]={
val a=intersect（某些（ID），ID必须在ISLISTIFITFITEXISTS（ID）
val b=相交（某些（a），ID必须同时显示列表索引（a）
B
}
def intersect[A]（ma:Option[Seq[A]]，mb:Option[Seq[A]]）（默认值：Seq[A]）={
（用于{
a另一种类似的方式，没有隐含的含义

def getFilteredList[A](ids: Seq[A],
                       idsMustBeInThisListIfItExists: Option[Seq[A]],
                       idsMustAlsoBeInThisListIfItExists: Option[Seq[A]]): Seq[A] = {
  val  a = intersect(Some(ids), idsMustBeInThisListIfItExists)(ids)
  val  b = intersect(Some(a), idsMustAlsoBeInThisListIfItExists)(a)
  b
}

def intersect[A](ma: Option[Seq[A]], mb: Option[Seq[A]])(default: Seq[A]) = {
  (for {
     a <- ma
     b <- mb
   } yield {
     a.intersect(b)
   }).getOrElse(default)
}

def getFilteredList[A]（id:Seq[A]，
IDSMustbeinthilistifitExists:选项[Seq[A]]，
idsMustAlsoBeInThisListIfItExists:Option[Seq[A]]：Seq[A]={
val a=intersect（某些（ID），ID必须在ISLISTIFITFITEXISTS（ID）
val b=相交（某些（a），ID必须同时显示列表索引（a）
B
}
def intersect[A]（ma:Option[Seq[A]]，mb:Option[Seq[A]]）（默认值：Seq[A]）={
（用于{
另一种没有理解和暗示的方式：

def getFilteredList(ids: Seq[Int],
                  idsMustBeInThisListIfItExists: Option[Seq[Int]],
                  idsMustAlsoBeInThisListIfItExists: Option[Seq[Int]]): Seq[Int] = {

  val output1 = ids.intersect(idsMustBeInThisListIfItExists.getOrElse(ids))
  val output2 = output1.intersect(idsMustAlsoBeInThisListIfItExists.getOrElse(output1))

  output2
}

另一种没有理解和暗示的方式：

def getFilteredList(ids: Seq[Int],
                  idsMustBeInThisListIfItExists: Option[Seq[Int]],
                  idsMustAlsoBeInThisListIfItExists: Option[Seq[Int]]): Seq[Int] = {

  val output1 = ids.intersect(idsMustBeInThisListIfItExists.getOrElse(ids))
  val output2 = output1.intersect(idsMustAlsoBeInThisListIfItExists.getOrElse(output1))

  output2
}

感谢您花时间回复一个惯用代码示例。我认为这个解决方案很讽刺，因为它回到了Java遗留的匿名（或“隐式”）解决方案类来解决问题。这与匿名类无关，我认为你弄错了概念。这只是为了让代码更流畅，仅此而已。有一个相当简单的控制结构来实现预期的输出；scala的方法是不惜一切代价避免#isDefined，这就是我问Q的原因，它是铁的我认为惯用的解决方案是在避免类时求助于类，这是使用Scala而不是Java的一个原因。@newToScala是公平的，但真正的诀窍是
隐式
和使用
AnyVal
来避免装箱，所以有相当多的事情是Java无法做到的，类位肯定是混合的一部分，但不一定是简单的这里有一些细节：感谢您花时间回复一个惯用代码示例。我认为这个解决方案很讽刺，因为它回到了Java遗留的匿名（或“隐式”）模式类来解决问题。这与匿名类无关，我认为你弄错了概念。这只是为了让代码更流畅，仅此而已。有一个相当简单的控制结构来实现预期的输出；scala的方法是不惜一切代价避免#isDefined，这就是我问Q的原因，它是铁的我认为惯用的解决方案是在避免类时求助于类，这是使用Scala而不是Java的一个原因。@newToScala是公平的，但真正的诀窍是
隐式
和使用
AnyVal
来避免装箱，所以有相当多的事情是Java无法做到的，类位肯定是混合的一部分，但不一定是简单的这里有一些细节：