如何从嵌套列表中删除元素？

Question

我有一个深度嵌套的列表，我想从列表中的所有事件中删除给定的元素。我有这样的代码：

(defn eliminate [value lst] 
      (defn sub-eliminate [lst] 
       (def currentItem (first lst)) 
       (if-not (empty? lst) 
       (if (seq? currentItem) 
        (cons (sub-eliminate currentItem) (sub-eliminate (rest lst))) 
        (if (= value currentItem) 
        (sub-eliminate (rest lst)) 
        (cons currentItem (sub-eliminate (rest lst))) 
        ) 
       ) 
       '() 
       ) 
      ) 
       (sub-eliminate lst) 
      ) 

但是，它不会在内层删除。为什么？？

Answer 1

对于学习的目的来看看这个函数：

(define rember* 
    (lambda (x l) 
    (cond ((null? l) '()) 
      ((atom? (car l)) 
      (if (eq? (car l) x) 
       (rember* x (cdr l)) 
       (cons (car l) 
        (rember* x (cdr l))))) 
      (else (cons (rember* x (car l)) 
         (rember* x (cdr l))))))) 

这是从书“的小策士”，这是一个很好的来源，学习如何写这样的递归函数的简单递归函数。

让我们看看，如果我们可以把它翻译成Clojure的：

(defn rember* [x l] 
    (cond (empty? l) '() 
     (seq? (first l)) (cons (rember* x (first l)) 
           (rember* x (rest l))) 
     :else (if (= (first l) x) 
       (recur x (rest l)) 
       (cons (first l) 
         (rember* x (rest l)))))) 

user> (rember* 'x '((x y) x (z (((((x)))))))) 
;; => ((y) (z ((((())))))) 

Answer 2

我的猜测是，你正在使用向量作为序列。

(eliminate 3 [3 3]) 
;() 

(eliminate 3 [3 [3]]) 
;([3]) 

这本来是小事找到了你向我们展示一个例子：啧！

---

这是怎么回事？

虽然载体seqable，他们不是序列：

(seq? []) 
;false 

在外部级，你把lst作序，所以first和rest工作，因为他们包装他们的论点的隐含seq。但是seq?将在任何立即封闭的矢量上失败，并且甚至不会看到那些矢量。

如果您将seq?替换为sequential?，则列表和向量将起作用。

(sequential? []) 
;true 

---

更为严重，因为@noisesmith指出的，是你在内部范围的def和defn使用。将它们替换为let或letfn。

你也可以提高你的风格：

1. 更换(if-not (empty? lst) ...)与(if (seq lst) ...)。
2. 使用cond来扁平化嵌套if s。这需要反转 （1）中的测试，因此不需要它。
3. 使用recur为尾递归的情况下，你发现value，因为 @Mark呢。

如果你不希望看到的结果，现在看起来远：

(defn eliminate [value lst] 
    (letfn [(sub-eliminate [lst] 
      (let [current-item (first lst)] 
       (cond 
       (empty? lst) '() 
       (sequential? current-item) (cons (sub-eliminate current-item) 
               (sub-eliminate (rest lst))) 
       (= value current-item) (recur (rest lst)) 
       :else (cons current-item (sub-eliminate (rest lst))))))] 
    (sub-eliminate lst))) 

有剩余的痛处：

• 你调用(first lst)你知道lst是前不是空的。没有 造成伤害：你只会得到nil，你忽略了。

---

使用解构

一种替代Apporach可以经常使用destructuring缩略序列的递归处理。我倾向于这样来表达你的函数：

(defn eliminate [x xs] 
    ((fn rem-x [xs] 
    (if-let [[y & ys] (seq xs)] 
     (if (= x y) 
     (recur ys) 
     (cons 
      (if (sequential? y) (rem-x y) y) 
      (rem-x ys))) 
     ())) 
    xs)) 

Answer 3

(defn expel [victim xs] 
    (mapcat (fn [x] 
      (cond 
       (sequential? x) [(expel victim x)] 
       (= x victim) [] 
       :else [x])) 
      xs))