Wanted: mapcar() without nils

Wanted: mapcar() without nils

[Nordlöw]

How do I apply a function for each element in a sequence a return the
non-nil result only? I have used mapcar() but it returns the nils
aswell. Do I have to filter out the non-nils explicitly or is there a
builtin function that does all this?

/Nordlöw

Re: Wanted: mapcar() without nils

[Lennart Borgman]

(delq nil ...)

On Sat, Jun 13, 2009 at 2:19 PM, Nordlöw<per.nordlow@gmail.com> wrote:
> How do I apply a function for each element in a sequence a return the
> non-nil result only? I have used mapcar() but it returns the nils
> aswell. Do I have to filter out the non-nils explicitly or is there a
> builtin function that does all this?
>
> /Nordlöw
>

Re: Wanted: mapcar() without nils

[Nordlöw]

This is my mockup:

(defun extract-elements (pred seq)
  "Extract a copy of SEQ containing all elements fullfilling
PRED."
  (delq nil (mapcar `(lambda (elm) (when (,pred elm)) elm) seq)))
;; Use: (extract-elements 'symbolp '(a b 1 2)) => '(a b)
;; Use: (extract-elements 'numberp '(a b 1 2)) => '(1 2)

But why does my test-cases return '(a b 1 2) all the time? The first
should return (a b) and second (1 2).
I have tried edebugging it but because mapcar is a builtin I didn't
get any help that way.

/Nordlöw

Re: Wanted: mapcar() without nils

[Thierry Volpiatto]

Hi, you can use loop: (easier)

ELISP> (mapcar #'(lambda (x) (when (stringp x) x)) '("a" "b" "c" 1 2 "d" 3))
("a" "b" "c" nil nil "d" nil)

ELISP> (loop for i in '("a" "b" "c" 1 2 "d" 3) when (stringp i) collect i)
("a" "b" "c" "d")

Nordlöw <per.nordlow@gmail.com> writes:

> This is my mockup:
>
> (defun extract-elements (pred seq)
>   "Extract a copy of SEQ containing all elements fullfilling
> PRED."
>   (delq nil (mapcar `(lambda (elm) (when (,pred elm)) elm) seq)))
> ;; Use: (extract-elements 'symbolp '(a b 1 2)) => '(a b)
> ;; Use: (extract-elements 'numberp '(a b 1 2)) => '(1 2)
>
> But why does my test-cases return '(a b 1 2) all the time? The first
> should return (a b) and second (1 2).
> I have tried edebugging it but because mapcar is a builtin I didn't
> get any help that way.
>
> /Nordlöw
>

-- 
A + Thierry Volpiatto
Location: Saint-Cyr-Sur-Mer - France

Re: Wanted: mapcar() without nils

[Nordlöw]

On Jun 13, 9:05 pm, Thierry Volpiatto <thierry.volpia...@gmail.com>
wrote:
> Hi, you can use loop: (easier)
>
> ELISP> (mapcar #'(lambda (x) (when (stringp x) x)) '("a" "b" "c" 1 2 "d" 3))
> ("a" "b" "c" nil nil "d" nil)
>
> ELISP> (loop for i in '("a" "b" "c" 1 2 "d" 3) when (stringp i) collect i)
> ("a" "b" "c" "d")
>
>
>
>
>
> Nordlöw <per.nord...@gmail.com> writes:
> > This is my mockup:
>
> > (defun extract-elements (pred seq)
> >   "Extract a copy of SEQ containing all elements fullfilling
> > PRED."
> >   (delq nil (mapcar `(lambda (elm) (when (,pred elm)) elm) seq)))
> > ;; Use: (extract-elements 'symbolp '(a b 1 2)) => '(a b)
> > ;; Use: (extract-elements 'numberp '(a b 1 2)) => '(1 2)
>
> > But why does my test-cases return '(a b 1 2) all the time? The first
> > should return (a b) and second (1 2).
> > I have tried edebugging it but because mapcar is a builtin I didn't
> > get any help that way.
>
> > /Nordlöw
>
> --
> A + Thierry Volpiatto
> Location: Saint-Cyr-Sur-Mer - France

I know the meaning of backquotes and commas to specify what should be
evaluated. But what meaning does '#' have in your example?:
> ELISP> (mapcar #'(lambda (x) (when (stringp x) x)) '("a" "b" "c" 1 2 "d" 3))

/Nordlöw

Re: Wanted: mapcar() without nils

[Nordlöw]

Oopps, my mistake got a parenthesis wrong...

Now it works:

(defun extract-elements (pred seq)
  "Extract a copy of SEQ containing all elements fullfilling
PRED."
  (delq nil (mapcar `(lambda (elm) (when (,pred elm) elm)) seq)))
;; Use: (extract-elements 'symbolp '(a b 1 2)) => '(a b)
;; Use: (extract-elements 'numberp '(a b 1 2)) => '(1 2)

Thanks,
Nordlöw

Re: Wanted: mapcar() without nils

[Lennart Borgman]

You misplaced a closing paren in the lambda

On Sat, Jun 13, 2009 at 8:24 PM, Nordlöw<per.nordlow@gmail.com> wrote:
> (defun extract-elements (pred seq)
>  "Extract a copy of SEQ containing all elements fullfilling
> PRED."
>  (delq nil (mapcar `(lambda (elm) (when (,pred elm)) elm) seq)))

 (delq nil (mapcar `(lambda (elm) (when (,pred elm) elm)) seq)))

> ;; Use: (extract-elements 'symbolp '(a b 1 2)) => '(a b)
> ;; Use: (extract-elements 'numberp '(a b 1 2)) => '(1 2)

RE: Wanted: mapcar() without nils

[Drew Adams]

> (defun extract-elements (pred seq)
>   (delq nil (mapcar `(lambda (elm)
>                        (when (,pred elm)) elm)
>                     seq)))
> 
> But why does my test-cases return '(a b 1 2) all the time?

The body of your lambda is this: (when X) Y
The body is an implicit progn. It returns the value of the last sexp, which is
Y.

You meant (when X Y), not (when X) Y.

Better yet, you meant (and X Y), since you are interested in the value returned
- you are not interested only in some side effect.

(defun extract-elements (pred seq)
  (delq nil (mapcar (lambda (elm)
                      (and (funcall pred elm) elm))
                    seq)))

Or instead of constructing a list and then filtering it, construct it with only
the elements you want. IOW, promote the filter to be inside the iteration/map.

(defun extract-elements (pred seq)
  (let ((r  ()))
    (dolist (e seq) (when (funcall pred e) (push e r)))
    (nreverse r)))

That's not better or worse - just a different style (in this case).

You can debug problems like this yourself, by using `M-x debug-on-entry
extract-elements'.

Or try evaluating parts of your code using your concrete test args:
(mapcar (lambda (elm) (when (symbolp elm)) elm) '(a b 1 2))
(progn (when (symbolp 1)) 1)

Doing that, you see right away that the problem is a misplaced paren, not
something particular to `delq' or `mapcar' or backquote syntax or... IOW,
simplify the problem.