Hello,
I am trying to create the following recursive function:

Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)

(defun doubleodd (list)
(when list
(if (oddp (car list)) (setf (car list) (* (car list) 2)))
(doubleodd (cdr list))
)
)

When i evaluate i am not getting back a list and it's missing some values in the list. What am i doing wrong?

(doubleodd '(1 2 3 4 5))

evaluates to:
26410
NIL

Thank you for your help.
Mark

On 2022-11-22, ME Jones <markjones@shawday.com> wrote:
> Hello,
> I am trying to create the following recursive function:
>
> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> (defun doubleodd (list)
> (when list
> (if (oddp (car list)) (setf (car list) (* (car list) 2)))
> (doubleodd (cdr list))
> )
> )
>
> When i evaluate i am not getting back a list and it's missing some values in the list. What am i doing wrong?

(defun doubleodd (l)
(if (null l)
nil
(if (oddp (car l))
(cons (* 2 (car l)) (doubleodd (cdr l)))
(cons (car l) (doubleodd (cdr l))))))

In a recursive function with a list, 2 important things to remember:

you apply the function on the car of the list then your recursive call
goes on the cdr.

Once the list is null, you return a nil to end the recursion.

Lisp is mostly a functional language, avoid the usage of (setf) inside
a function unless it's to change the value of a lexical
variable. Otherwise, you function is called destructive.

2 books to read absolutely to understand Lisp and its philosophy:

Ansi Common Lisp
On Lisp

Both from Paul Graham. The second one is not printed anymore, but
available at low cost from lulu.com

>
> (doubleodd '(1 2 3 4 5))
>
> evaluates to:
> 26410
> NIL
>
> Thank you for your help.
> Mark

ME Jones <markjones@shawday.com> writes:
> I am trying to create the following recursive function:
> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)

I would first break this out into a function that conditionally doubles
a single number:

(defun double-odd-1 (n)
(cond ((oddp n) (+ n n))
(t n)))

and then a tail-recursive function that applies DOUBLE-ODD-1 to each
element of a list, consing it up into a new list that is in reverse
order. Then, at the end, reverse the new list "in place" using
nreverse:

(defun double-odd (xs &optional acc)
(defun f (n) (+ n n))
(cond ((null xs) (nreverse acc))
(t (double-odd (cdr xs) (cons (double-odd-1 (car xs)) acc)))))

Using an accumulation parameter allows the recursive call to be the
function's final value, which means the compiler can actually turn it
into a simple jump rather than pushing one level deeper into a stack on
every call. That is kind of a lame explanation, but it is a very
important idiom in functional programming, so you should probably spend
some time studying it to understand it, e.g. by doing a web search on
"tail recursion" and looking at explanations in the results.

Pure functional style would also prefer using reverse instead of
nreverse, but using nreverse this way is a Common Lisp idiom.

Finally, notice that the pattern of creating a new list by applying some
function to every element of an old list is very common, and CL (and
related languages) usually have a built-in for it, called some variant
of "map". In CL's case, that function is called MAPCAR, so you would
simply write:

(defun double-odd (xs)
(mapcar #'double-odd-1 xs))

where DOUBLE-ODD-1 is as defined above.

On Mon, 21 Nov 2022 20:32:08 -0800 (PST)
ME Jones <markjones@shawday.com> wrote:
> Hello,
> I am trying to create the following recursive function:
>
> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> (defun doubleodd (list)
> (when list
> (if (oddp (car list)) (setf (car list) (* (car list) 2)))
> (doubleodd (cdr list))
> )
> )
>
> When i evaluate i am not getting back a list and it's missing some values
> in the list. What am i doing wrong?
>
> (doubleodd '(1 2 3 4 5))
>
> evaluates to:
> 26410
> NIL

Others have explained what you're doing wrong but I'm wondering in which
implementation (doubleodd '(1 2 3 4 5)) returns 26410 .I tried clisp
and SBCL and the code just returns NIL which is what I would have expected.
No matter what happens earlier , the recursion will terminate by calling
doubleodd with argument NIL .Try the following modified version and study
its output.

(defun doubleodd2 (list &aux ret)
(format t "Received ~S~%" list)
(when list
(if (oddp (car list)) (setf (car list) (* (car list) 2)))
(setq ret (doubleodd (cdr list)))
(format t "Got back ~S~%" ret)
ret))
--
And my personal favourite - carries out > 400 circumcisions per week. I
think he uses the foreskins in his Fortune 500 company making wallets
that expand into suitcases when rubbed.
http://www.freeratio.org/showthread.php?p=7302620#post7302620

On Tue, 22 Nov 2022 00:44:24 -0800
Paul Rubin <no.email@nospam.invalid> wrote:
> ME Jones <markjones@shawday.com> writes:
> > I am trying to create the following recursive function:
> > Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> I would first break this out into a function that conditionally doubles
> a single number:
>
> (defun double-odd-1 (n)
> (cond ((oddp n) (+ n n))
> (t n)))
>
> and then a tail-recursive function that applies DOUBLE-ODD-1 to each
> element of a list, consing it up into a new list that is in reverse
> order. Then, at the end, reverse the new list "in place" using
> nreverse:
>
> (defun double-odd (xs &optional acc)
> (defun f (n) (+ n n))
What's this for ?

> (cond ((null xs) (nreverse acc))
> (t (double-odd (cdr xs) (cons (double-odd-1 (car xs)) acc)))))
>
> Using an accumulation parameter allows the recursive call to be the
> function's final value, which means the compiler can actually turn it
> into a simple jump rather than pushing one level deeper into a stack on
> every call. That is kind of a lame explanation, but it is a very
> important idiom in functional programming, so you should probably spend
> some time studying it to understand it, e.g. by doing a web search on
> "tail recursion" and looking at explanations in the results.

On Tue, 22 Nov 2022 05:54:33 -0000 (UTC)
ST <usenet.233ph@slmail.me> wrote:
> On 2022-11-22, ME Jones <markjones@shawday.com> wrote:
> > Hello,
> > I am trying to create the following recursive function:
> >
> > Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
> >
> > (defun doubleodd (list)
> > (when list
> > (if (oddp (car list)) (setf (car list) (* (car list) 2)))
> > (doubleodd (cdr list))
> > )
> > )
> >
> > When i evaluate i am not getting back a list and it's missing some values in the list. What am i doing wrong?
>
>
> (defun doubleodd (l)
> (if (null l)
> nil
> (if (oddp (car l))
> (cons (* 2 (car l)) (doubleodd (cdr l)))
> (cons (car l) (doubleodd (cdr l))))))
>
> In a recursive function with a list, 2 important things to remember:
>
> you apply the function on the car of the list then your recursive call
> goes on the cdr.
>
> Once the list is null, you return a nil to end the recursion.
>
> Lisp is mostly a functional language, avoid the usage of (setf) inside
> a function unless it's to change the value of a lexical
> variable. Otherwise, you function is called destructive.

Common Lisp is a multi-paradigm language and it is up to individual preference
when one should use SETF .But SETF is specified to return the new value assigned
so that is another reason the general idea the opening poster had would not
work. For example

* (let ((l (list 1 2)))
(setf (car l) (* 2 (car l))))
2

* (let ((l (list 1 2)))
(setf (car l) (* 2 (car l)))
l)

(2 2)

> 2 books to read absolutely to understand Lisp and its philosophy:
>
> Ansi Common Lisp
> On Lisp
>
> Both from Paul Graham. The second one is not printed anymore, but
> available at low cost from lulu.com

Personally I don't believe in language "philosophies" , the concept is
too vague and subjective. I'll just note that "On Lisp" also exists at
http://www.paulgraham.com/onlisptext.html .

Paul Rubin <no.email@nospam.invalid> writes:

> ME Jones <markjones@shawday.com> writes:
>> I am trying to create the following recursive function:
>> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> I would first break this out into a function that conditionally doubles
> a single number:
>
> (defun double-odd-1 (n)
> (cond ((oddp n) (+ n n))
> (t n)))

This is specific enough that I would make it a lambda. Are we going to
need it for anything other than this exercise?

> and then a tail-recursive function that applies DOUBLE-ODD-1 to each
> element of a list, consing it up into a new list that is in reverse
> order.

I don't see this as a use-case for an accumulating parameter. Some
tutorials will want the plain hand-written recursive solution, but
really the way to go is surely with mapcar as you suggest:

> Finally, notice that the pattern of creating a new list by applying some
> function to every element of an old list is very common, and CL (and
> related languages) usually have a built-in for it, called some variant
> of "map". In CL's case, that function is called MAPCAR, so you would
> simply write:
>
> (defun double-odd (xs)
> (mapcar #'double-odd-1 xs))
>
> where DOUBLE-ODD-1 is as defined above.

(defun doubleodd (list)
(mapcar (lambda (x) (if (oddp x) (* 2 x) x)) list))

--
Ben.

On Monday, November 21, 2022 at 8:32:11 PM UTC-8, mark...@shawday.com wrote:
> Hello,
> I am trying to create the following recursive function:
>
> Example: (doubleodd '(1 2 3 4 5)) -> (2 2 6 4 10)
>
> (defun doubleodd (list)
> (when list
> (if (oddp (car list)) (setf (car list) (* (car list) 2)))
> (doubleodd (cdr list))
> )
> )
>
> When i evaluate i am not getting back a list and it's missing some values in the list. What am i doing wrong?
>
> (doubleodd '(1 2 3 4 5))

There are a lot of other answers about how to update the function. I just want to
point out some other somewhat subtle issues with the code as presented here.

First off, the code uses (SETF (CAR LIST) ...) which will destructively mutate
the list. Generally as a beginner in the language you don't want to do destructive
list operations. It is really an optimization and can cause some very hard-to-debug
problems. So it is best to avoid it until you have a good understanding of lisp.

As an example of that, you are invoking your DOUBLEODD function with a constant
argument of '(1 2 3 4 5). And the code then destructively modifies that constant
list. This is undefined behavior in Common Lisp and must be avoided. You cannot
predict the results of doing this. There is no requirement that the compiler or in
this case the run time warn you about doing something like this. Common Lisp
allows you to do unwise things that might be prohibited in other languages.