¿Qué es idiomático Clojure para "eliminar" una sola instancia de muchas en una lista?

Question

Tengo una lista, que puede contener elementos que se puedan comparar como iguales. Me gustaría una lista similar, pero con un elemento eliminado. Así que de (: a: b: c: b: d) Me gustaría poder "eliminar" solo uno: b para obtener (: a: c: b: d).

El contexto es una mano en un juego de cartas donde dos mazos de cartas estándar están en juego, por lo que puede haber cartas duplicadas, pero todavía se juegan de a una por vez.

Tengo un código de trabajo, consulte a continuación. ¿Hay formas más idiomáticas de hacer esto en Clojure?

(defn remove-one [c left right] 
    (if (= right()) 
    left 
    (if (= c (first right)) 
     (concat (reverse left) (rest right)) 
     (remove-one c (cons (first right) left) (rest right))))) 

(defn remove-card [c cards] 
    (remove-one c() cards)) 

Estas son las respuestas Scala llegué hace un tiempo: What is an idiomatic Scala way to "remove" one element from an immutable List?

Answer 1

Cómo sobre: ​​

(let [[n m] (split-with (partial not= :b) [:a :b :c :b :d])] (concat n (rest m))) 

que divide la lista en: b y luego elimina el: b y concats los dos liza.

Answer 2

Normalmente resuelvo estos problemas con una función de orden superior como split-with, pero alguien ya lo ha hecho. A veces es más legible o más eficiente trabajar en un nivel más primitivo, así que aquí hay una versión mejorada del código de bucle original, usando secuencias perezosas y generalizado para tomar un predicado para eliminar en lugar de limitarse a verificaciones de igualdad:

(defn remove-once [pred coll] 
    ((fn inner [coll] 
    (lazy-seq 
     (when-let [[x & xs] (seq coll)] 
     (if (pred x) 
      xs 
      (cons x (inner xs)))))) 
    coll)) 


user> (remove-once #{:b} [:a :b :c :b :d]) 
(:a :c :b :d) 

Answer 3

Es sorprendente que no haya una API de alto nivel para hacer algo como esto. Aquí hay otra versión similar a @amalloy y @James que usa recurre para no apilar el desbordamiento.

(defn remove-once [x c]                                                      
    (letfn [(rmv [x c1 c2 b]                                                     
      (if-let [[v & c] (seq c1)]                                                  
       (if (and (= x v) b)                                                   
       (recur x c c2 false)                                                   
       (recur x c (cons v c2) b))                                                 
       c2))]                                                       
    (lazy-seq (reverse (rmv x c '() true)))))                                                

(remove-once :b [:a :b :c :b :d]) 
;; (:a :c :b :d)