Lisp: Elegant way to strip trailing nil's from a list? (Review)

Question

I want to write a function that removes trailing nil's from a list. I first tried to write it elegantly with recursion, but ended up like this:

(defun strip-tail (lst)
  (let ((last-item-pos (position-if-not #'null lst :from-end t)))
    (if last-item-pos
      (subseq lst 0 (1+ last-item-pos)))))

; Test cases.
(assert (eq nil (strip-tail nil)))
(assert (eq nil (strip-tail '(nil))))
(assert (equal '(a b) (strip-tail '(a b nil nil))))
(assert (equal '(a nil b) (strip-tail '(a nil b nil))))
(assert (equal '(a b) (strip-tail '(a b))))

It's arguably clear, but I'm not convinced. Is there a more lispy way to do it?

Shouldn't it be lst instead of nil at the very end? I'm assuming (strip-tail '(a b c d)) should return (a b c d). — sigjuice, Jul 09 '09 at 22:59
Well, FWIW, you can simply remove the nil and make it a little shorter. — sigjuice, Jul 09 '09 at 23:20
Do you think strip-tail should handle things that are not lists? (strip-tail "abcde") => "abcde", (strip-tail 42) => The value 42 is not of type SEQUENCE — sigjuice, Jul 09 '09 at 23:29
I would call CHECK-TYPE to check the argument. I would return the original list if nothing is stripped. POSITION-IF-NOT #'null could be done with POSITION-IF #'identity - but then it does not help much. The uncertain thing is how efficient the implementation of POSITION-IF-NOT :from-end T is. — Rainer Joswig, Jul 10 '09 at 11:00

Rainer Joswig · Answer 1 · 2009-07-09T23:49:41.150

3

Well, a version would be:

reverse the list
remove leading nils
reverse the list

The code:

(defun list-right-trim (list &optional item)
  (setf list (reverse list))
  (loop for e in list while (eq item e) do (pop list))
  (reverse list))

Here is another variant:

iterate over the list and note the position of the first nil which is only followed by nils
return the sub-sequence

the code:

(defun list-right-trim (list &aux (p nil))
  (loop for i from 0 and e in list
    when (and (null p) (null e)) 
    do (setf p i)
    else when (and p e) do (setf p nil))
  (if p (subseq list 0 p) list))

edited Jul 09 '09 at 23:49

answered Jul 09 '09 at 23:43

Rainer Joswig

136,269
10
221
346

Curious, why the &aux parameter there instead of an explicit let to define p? Otherwise, I'd do basically the same thing (with dolist instead of loop, but that's just style): (defun list-right-trim (list) (let ((last-pos 0) (i 0)) (dolist (item list) (incf i) (when item (setf last-pos i))) (subseq list 0 last-pos))) – Michael H. Jul 10 '09 at 19:37
There is no special reason. &aux is just like a LET - with an indentation level less. – Rainer Joswig Jul 10 '09 at 20:09

dsm · Answer 2 · 2009-08-04T15:30:58.393

3

(defun strip-tail (ls)
    (labels ((strip-car (l)
                  (cond ((null l)       nil)
                        ((null (car l)) (strip-car (cdr l)))
                        (t              l))))
        (reverse (strip-car (reverse ls)))))

Sample run (against your test cases):

[1]> (assert (eq nil (strip-tail nil)))
NIL
[2]> (assert (eq nil (strip-tail '(nil)))) ;'
NIL
[3]> (assert (equal '(a b) (strip-tail '(a b nil nil))))
NIL
[4]> (assert (equal '(a nil b) (strip-tail '(a nil b nil))))
NIL
[5]> (assert (equal '(a b) (strip-tail '(a b))))
NIL
[6]>

edited Aug 04 '09 at 15:30

answered Jul 10 '09 at 07:54

dsm

10,263
1
38
72

Is this more efficient than the original proposal? It seems to me that it needs to reverse the list twice instead of once. – firefrorefiddle Apr 03 '13 at 11:25

Johan Kotlinski · Answer 3 · 2009-07-13T19:01:55.257

2

How about this?

(defun strip-tail (lst)
  (if lst
    (let ((lst (cons (car lst) (strip-tail (cdr lst)))))
      (if (not (equal '(nil) lst)) lst))))

...wonder how to make it tail-recursive though, this version would exhaust the stack for large lists.

edited Jul 13 '09 at 19:01

answered Jul 11 '09 at 01:35

Johan Kotlinski

25,185
9
78
101

kenm · Answer 4 · 2009-07-09T23:33:45.597

1

Here's what I came up with, assuming you don't mind this being destructive:

(defvar foo (list 'a 'b 'c nil 'd 'e 'nil 'nil 'f nil nil))

(defun get-last-non-nil (list &optional last-seen)
  (if list
      (if (car list)
          (get-last-non-nil (cdr list) list)
          (get-last-non-nil (cdr list) last-seen))
      last-seen))

(defun strip-tail (list)
  (let ((end (get-last-non-nil list)))
    (if (consp end)
        (when (car end) (setf (cdr end) nil) list))))

(strip-tail foo) -> (A B C NIL D E NIL NIL F)

edited Jul 09 '09 at 23:33

answered Jul 09 '09 at 23:09

kenm

23,127
2
43
62

@kotlinski Ok, now that I bother to check the asserts it seems to pass, though I wouldn't call it 'elegant'. The second assert is a case where it can't be trusted to do its thing in-place, so like nreverse you've got to use the return value. – kenm Jul 09 '09 at 23:28
+1 because it's propably the most efficient possible solution. Though, not functional it's still "lispy" in showing the flexibility. – firefrorefiddle Apr 03 '13 at 11:31

score 0 · Answer 5 · edited Jul 12 '09 at 17:42

0

I tried using recursion but it doesn't work on GNU CL:

(defun strip(lst) 
    (if (null (last lst))
        (strip (butlast lst))            
     lst))

the idea is:

test if the last list element is nil, if so make a recursive call with the last element removed (butlast)
then return the list itself

edited Jul 12 '09 at 17:42

Svante

50,694
11
78
122

answered Jul 09 '09 at 23:53

dfa

114,442
31
189
228

2

LAST returns the last cons and not the last element. This function gets inefficient if the list has lots of nils at the end, since for every removed NIL we have to traverse the list twice. – Rainer Joswig Jul 10 '09 at 00:03
why this function will traverse the list twice? – dfa Jul 10 '09 at 00:05
2

LAST traverses it once and BUTLAST again. – Rainer Joswig Jul 10 '09 at 00:23

score -1 · Answer 6 · answered Jul 10 '09 at 00:18

Well, this is not really an answer, but I thought I'd put this here as well so it has better visibility.

In your original implementation, do you think non-list items should be handled?

* (strip-tail "abcde")

"abcde"
* (strip-tail 42)

debugger invoked on a TYPE-ERROR in thread #<THREAD "initial thread" {A69E781}>:
  The value 42 is not of type SEQUENCE.

Lisp: Elegant way to strip trailing nil's from a list? (Review)

6 Answers6