替换方案列表中的列表

Question

So I have a function that replaces an element of a list with the corespondent element in a list o pairs for example if i have this : (i have a list) and ((have not) (list queue)) it will return (i not a queue)

   (define replacecoresp
(lambda (ls a-list)
    (map (lambda (x)
           (let ((lookup (assq x a-list)))
             (if lookup
                 (cadr lookup)
                 x)))
         ls)))

unfortunately it doesn't work for a list of lists of lists etc what I want is to do this : if I have a list (i have ( a list) of (list ( list and list ))) and ((list queue) (have not)) the result should be (I not (a queue) of (queue (queue and queue))) I hope you got the idea :) thanks a lot!

Answer 1

Try this:

(define (replacecoresp ls a-list)
  (cond ((null? ls) '())
        ((not (list? ls))
         (cond ((assq ls a-list) => cadr)
               (else  ls)))
        (else (cons (replacecoresp (car ls) a-list)
                    (replacecoresp (cdr ls) a-list)))))

It works as expected:

(replacecoresp '(I have (a list) of (list (list and list)))
               '((list queue) (have not)))

> (I not (a queue) of (queue (queue and queue)))

Explanation: When traversing a list of lists (say, ls ) you need to consider three cases:

1. ls is empty, return the empty list
2. ls is an atom not a list, process the element
3. ls is a list, invoke the recursion on both the car and the cdr of the list and combine the results

In the particular case of your question, cons is used in the third step for combining the solution; and the second case is the part where we check to see if the current symbol is in the association list, replacing it if it was found or leaving the symbol untouched if not. I used a shortcut for writing less code in this step, but you can replace the inner cond with this snippet of code if it's clearer:

(let ((lookup (assq ls a-list)))
  (if lookup
      (cadr lookup)
      ls))

Another way to express the solution is to use a map on the list like this:

(define(replacecoresp ls a-list)
  (if (not (list? ls))
      (cond ((assq ls a-list) => cadr)
            (else  ls))
      (map (lambda (l) (replacecoresp l a-list)) ls)))