Topic: Perform operation to a single item in list

[Lee Mac]

Michael,

I see you use that "Double Defun" trick on this code too:

http://www.theswamp.org/index.php?topic=4903.0  (Great code btw)

But I am having real trouble understanding how it works/is evaluated...

If you have a bit of time, would you be able to shed some light for my confused mind... 

Thanks,

Lee

EDIT: just seen you have an explanation on a few pages later in that thread... never mind - I must be blind

[JohnK]

...(if (eq n (setq i (+ i j)))
            (progn (defun bar (a) a) (foo a))
            a
        )

hehehe ...nice. I could swear, i had used a redefinition (a quine is an exact reproduction but what would this be called?) recently but i cant for the life of me remember where or why.

[VovKa]

Michael, you code needs some fixing

(ApplyFooToNth (lambda (x) (+ 7 x)) 0 '(1 2 3 4 5))

=> (1 2 3 4 12)

[MP]

You're right vovka, juggling too much here and I combined 2 different approaches. Should have tried it before posting it. :facepalm:

Here's a quick alternate:

Code: [Select]

(defun ApplyFooToNth ( foo n lst / bar )

    (defun bar ( a )
        (if (eq n (setq i (1+ i)))
            (progn (defun bar (a) a) (foo a))
            a
        )
    )
   
    ((lambda (i) (mapcar 'bar lst)) -1)
   
)
(ApplyFooToNth (lambda (x) (+ 7 x)) 0 '(1 2 3 4 5)) => (8 2 3 4 5)

(ApplyFooToNth (lambda (x) (+ 7 x)) 1 '(1 2 3 4 5)) => (1 9 3 4 5)

(ApplyFooToNth (lambda (x) (+ 7 x)) 2 '(1 2 3 4 5)) => (1 2 10 4 5)

(ApplyFooToNth (lambda (x) (+ 7 x)) 3 '(1 2 3 4 5)) => (1 2 3 11 5)

(ApplyFooToNth (lambda (x) (+ 7 x)) 4 '(1 2 3 4 5)) => (1 2 3 4 12)

My apologies peeps and thank you vovka.

[ElpanovEvgeniy]

my version...

Code: [Select]

(defun f (a b c)
 (cond ((not c) c)
       ((> b 0) (cons (car c) (f a (1- b) (cdr c))))
       (t (cons (a (car c)) (cdr c)))
 ) ;_  cond
)test:

Code: [Select]

(f (lambda (x) (+ 7 x)) 0 '(1 2 3 4 5)) => (8 2 3 4 5)
(f (lambda (x) (+ 7 x)) 2 '(1 2 3 4 5)) => (1 2 10 4 5)
(f (lambda (x) (+ 7 x)) 5 '(1 2 3 4 5)) => (1 2 3 4 5)

[Binky]

OK here is what I think I will end up with, stealing a bit from here and another bit from there.

CAB that was short, sweet and to the point.  Nice!

MP, It took me a minute to see the value of redefining the function once the particular index was reached(never would have thought of that myself, thanks for the enlightenment), as it saves time from having to re-evaluate the test condition after the need for it no longer exists.  That would save time on large lists.

Tim makes a great point about ordering the arguments for readability, I often forget that.

Code: [Select]

(defun nthadjust (opr val pos lst / foo)
  (defun foo (x)
    (if (= pos (setq i (1+ i)))
      (progn
        (defun foo (x) x)
        (opr val x))
      x))

  ((lambda (i) (mapcar 'foo lst)) -1)
)

Thanks everybody

[Keith™]

OK here is what I think I will end up with, stealing a bit from here and another bit from there.

...

that is the point ... we supply various bits of information that you can decide whether it is useful or not, take the good bits, toss the rest ...

We like to think of it as teaching a man to fish