Qu'est-ce qu'une manière Scala idiomatique de «supprimer» un élément d'une liste immuable?

J'ai une liste, qui peut contenir des éléments qui se compareront comme égaux. Je voudrais une liste similaire, mais avec un élément supprimé. Donc à partir de (A, B, C, B, D), je voudrais pouvoir "supprimer" un seul B pour obtenir par exemple (A, C, B, D). L'ordre des éléments dans le résultat n'a pas d'importance.

J'ai du code de travail, écrit d'une manière inspirée de Lisp dans Scala. Y a-t-il une manière plus idiomatique de faire cela?

Le contexte est un jeu de cartes où deux jeux de cartes standard sont en jeu, il peut donc y avoir des cartes en double mais toujours jouées une à la fois.

def removeOne(c: Card, left: List[Card], right: List[Card]): List[Card] = {
  if (Nil == right) {
    return left
  }
  if (c == right.head) {
    return left ::: right.tail
  }
  return removeOne(c, right.head :: left, right.tail)
}

def removeCard(c: Card, cards: List[Card]): List[Card] = {
  return removeOne(c, Nil, cards)
}

Je n'ai pas vu cette possibilité dans les réponses ci-dessus, donc:

scala> def remove(num: Int, list: List[Int]) = list diff List(num)
remove: (num: Int,list: List[Int])List[Int]

scala> remove(2,List(1,2,3,4,5))
res2: List[Int] = List(1, 3, 4, 5)

Éditer:

scala> remove(2,List(2,2,2))
res0: List[Int] = List(2, 2)

Comme un charme :-).

Vous pouvez utiliser la filterNotméthode.

val data = "test"
list = List("this", "is", "a", "test")
list.filterNot(elm => elm == data)

Vous pouvez essayer ceci:

scala> val (left,right) = List(1,2,3,2,4).span(_ != 2)
left: List[Int] = List(1)
right: List[Int] = List(2, 3, 2, 4)

scala> left ::: right.tail                            
res7: List[Int] = List(1, 3, 2, 4)

Et comme méthode:

def removeInt(i: Int, li: List[Int]) = {
   val (left, right) = li.span(_ != i)
   left ::: right.drop(1)
}

Malheureusement, la hiérarchie des collections s'est un peu gâchée avec -on List. Car ArrayBuffercela fonctionne comme vous pourriez l'espérer:

scala> collection.mutable.ArrayBuffer(1,2,3,2,4) - 2
res0: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 3, 2, 4)

mais, malheureusement, Lists'est retrouvé avec une filterNotimplémentation -style et fait donc la "mauvaise chose" et vous lance un avertissement de dépréciation (assez sensible, car il s'agit en fait filterNot):

scala> List(1,2,3,2,4) - 2                          
warning: there were deprecation warnings; re-run with -deprecation for details
res1: List[Int] = List(1, 3, 4)

La chose la plus simple à faire est donc sans doute de la convertir Listen une collection qui fait cela correctement, puis de la reconvertir:

import collection.mutable.ArrayBuffer._
scala> ((ArrayBuffer() ++ List(1,2,3,2,4)) - 2).toList
res2: List[Int] = List(1, 3, 2, 4)

Alternativement, vous pouvez conserver la logique du code que vous avez mais rendre le style plus idiomatique:

def removeInt(i: Int, li: List[Int]) = {
  def removeOne(i: Int, left: List[Int], right: List[Int]): List[Int] = right match {
    case r :: rest =>
      if (r == i) left.reverse ::: rest
      else removeOne(i, r :: left, rest)
    case Nil => left.reverse
  }
  removeOne(i, Nil, li)
}

scala> removeInt(2, List(1,2,3,2,4))
res3: List[Int] = List(1, 3, 2, 4)

 def removeAtIdx[T](idx: Int, listToRemoveFrom: List[T]): List[T] = {
    assert(listToRemoveFrom.length > idx && idx >= 0)
    val (left, _ :: right) = listToRemoveFrom.splitAt(idx)
    left ++ right
 }

Que diriez-vous

def removeCard(c: Card, cards: List[Card]) = {
  val (head, tail) = cards span {c!=}   
  head ::: 
  (tail match {
    case x :: xs => xs
    case Nil => Nil
  })
}

Si vous voyez return, il y a quelque chose qui ne va pas.

// throws a MatchError exception if i isn't found in li
def remove[A](i:A, li:List[A]) = {
   val (head,_::tail) = li.span(i != _)
   head ::: tail
}

Comme solution possible, vous pouvez trouver l'index du premier élément approprié, puis supprimer l'élément à cet index:

def removeOne(l: List[Card], c: Card) = l indexOf c match {
    case -1 => l
    case n => (l take n) ++ (l drop (n + 1))
}

Juste une autre réflexion sur la façon de faire cela en utilisant un pli:

def remove[A](item : A, lst : List[A]) : List[A] = {
    lst.:\[List[A]](Nil)((lst, lstItem) => 
       if (lstItem == item) lst else lstItem::lst )
}

Solution générique de récursivité de queue:

def removeElement[T](list: List[T], ele: T): List[T] = {
    @tailrec
    def removeElementHelper(list: List[T],
                            accumList: List[T] = List[T]()): List[T] = {
      if (list.length == 1) {
        if (list.head == ele) accumList.reverse
        else accumList.reverse ::: list
      } else {
        list match {
          case head :: tail if (head != ele) =>
            removeElementHelper(tail, head :: accumList)
          case head :: tail if (head == ele) => (accumList.reverse ::: tail)
          case _                             => accumList
        }
      }
    }
    removeElementHelper(list)
  }

val list : Array[Int] = Array(6, 5, 3, 1, 8, 7, 2)
val test2 = list.splitAt(list.length / 2)._2
val res = test2.patch(1, Nil, 1)

object HelloWorld {

    def main(args: Array[String]) {

        var months: List[String] = List("December","November","October","September","August", "July","June","May","April","March","February","January")

        println("Deleting the reverse list one by one")

        var i = 0

        while (i < (months.length)){

            println("Deleting "+months.apply(i))

            months = (months.drop(1))

        }

        println(months)

    }

}