Qual è un modo idiomatico di Scala per "rimuovere" un elemento da una lista immutabile?

Ho un elenco, che può contenere elementi che verranno confrontati come uguali. Vorrei un elenco simile, ma con un elemento rimosso. Quindi da (A, B, C, B, D) vorrei essere in grado di "rimuovere" solo un B per ottenere ad esempio (A, C, B, D). L'ordine degli elementi nel risultato non ha importanza.

Ho del codice funzionante, scritto in modo ispirato al Lisp in Scala. C'è un modo più idiomatico per farlo?

Il contesto è un gioco di carte in cui sono in gioco due mazzi di carte standard, quindi potrebbero esserci carte duplicate ma ancora giocate una alla volta.

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)
}

Non ho visto questa possibilità nelle risposte sopra, quindi:

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)

Modificare:

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

A meraviglia :-).

Potresti usare il filterNotmetodo.

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

Potresti provare questo:

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)

E come metodo:

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

Purtroppo, la gerarchia collezioni sé entrato in un po 'di confusione con -il List. Perché ArrayBufferfunziona proprio come potresti sperare:

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

ma, purtroppo, si è Listconclusa con filterNotun'implementazione in stile e quindi fa la "cosa sbagliata" e ti lancia un avvertimento di deprecazione (abbastanza sensato, dal momento che in realtà è filterNoting):

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)

Quindi, probabilmente, la cosa più semplice da fare è convertire Listin una raccolta che funzioni correttamente e quindi riconvertire di nuovo:

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

In alternativa, potresti mantenere la logica del codice che hai ma rendere lo stile più idiomatico:

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
 }

Che ne dite di

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

Se vedi return, c'è qualcosa che non va.

// 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
}

Come una possibile soluzione puoi trovare l'indice del primo elemento adatto e quindi rimuovere l'elemento in questo indice:

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

Solo un altro pensiero su come farlo usando una piega:

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

Soluzione generica per la ricorsione della coda:

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)

    }

}