替换方案列表中的值

Question

假设我有一个表示布尔表达式的任意列表：

'(a and (b or c)) 和另一个表示文字值的对列表

'((a . #t) (b . #f) (c . #t)))

我想要做的是使用第二个列表中的值替换第一个列表中的值，并返回一个新列表：

'(#t and (#f or #t))

因此，例如，此代码采用一个列表和一个关联列表，并成功替换了其中的值，尽管我正在尝试使用 conses 列表而不是关联列表来做同样的事情。它适用于'(a b) '((a 1) (b 2)) -> '(1 2)，但我想改用'((a . 1) (b . 2))。这是代码：

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

有人知道怎么做吗？非常感谢！

Answer 1

类似这样的：

(define bool '(a and (b or c)))
(define pairs '((a . #t) (b . #f) (c . #t)))

(define (value-for-key lst key)
  (cond ((empty? lst) 'none)
        ((eq? key (caar lst))
         (cdar lst))
        (#t (value-for-key (cdr lst) key))))

(define (replace-bool lst vals)
  (cond ((empty? lst) lst)
        ((pair? (car lst)) (cons (replace-bool (car lst) vals)
                                 (replace-bool (cdr lst) vals)))
        (#t (let ((val-for-key (value-for-key vals (car lst))))
                (if (not (eq? val-for-key 'none))
                    (cons val-for-key (replace-bool (cdr lst) vals))
                    (cons (car lst) (replace-bool (cdr lst) vals)))))))

(replace-bool bool pairs)

-> (#t and (#f or #t))

第一个函数用于在键值对列表中搜索并返回给定键的值或'none，如果该键不在该列表中。
第二个函数通过布尔表达式列表。在键值列表中搜索每个原子元素，如果找到，则替换。如果布尔表达式包含嵌套表达式，则递归遍历它们。

Answer 2

这里的真正问题似乎是需要一个适用于嵌套输入列表的解决方案。为此，可以编写一个map-nested 过程。这是一个类似于普通map 过程的简化版本的过程，但它适用于嵌套列表：

(define (map-nested proc xss)
  (if (null? xss)
      '()
      (let ((xs (car xss)))
        (if (pair? xs)
            (cons (map-nested proc xs)
                  (map-nested proc (cdr xss)))
            (cons (proc xs)
                  (map-nested proc (cdr xss)))))))

这与通常的map 不同的一个方式是map-nested 只接受一个列表作为输入；一个典型的map 过程采用任意数量的可以映射的列表。

map-nested 的上述实现不是尾递归的，这对于大型、深度嵌套的列表可能是个问题。将其重写为迭代（尾递归）过程并不太麻烦：

(define (map-nested proc xss)
  (let iter ((xss xss)
             (result '()))
    (if (null? xss)
        (reverse result)
        (let ((xs (car xss)))
          (if (pair? xs)
              (iter (cdr xss)
                    (cons (map-nested proc xs) result))
              (iter (cdr xss)
                    (cons (proc xs) result)))))))

这里的result 是一个累加器，用于跟踪要返回的结果，从而使递归调用无需保留堆栈帧。请注意，result 在返回之前必须反转，因为输入中的元素从输入列表的前面开始被 consed 到 result 的前面。这里使用了named let 形式；这是在另一个同时适用于 Scheme 和 Racket 的函数中设置本地过程的便捷方式。

要完成OP的问题，我们只需要使用map-nested；以上任何一个版本都可以使用：

;;; `substs` is an a-list of the form `((a . x) (b . y) ...)`
(define (replace-elts xss substs)
  (map-nested (lambda (x)
                (let ((subst-pair (assoc x substs)))
                  (if subst-pair        ; subst-pair is #f if x is not found
                      (cdr subst-pair)  ; otherwise, subst-pair is a dotted pair
                      x)))
              xss))

这里，map-nested 负责处理输入列表，无论它是否嵌套。给proc 的过程负责在substs 中查找替换，假定它是由点对 组成的关联列表。如果需要两个元素的正确列表而不是点对，则可以简单地将cdr 更改为cadr。当subst 不提供替换输入xss 中的值时，该值保持不变。

replace-elts 可以通过多种方式更改为或多或少方便，具体取决于实际使用条件。

示例交互：

nested-map.rkt> (replace-elts '(a (b (c d) e))
                              '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5)))
'(1 (2 (3 4) 5))

nested-map.rkt> (replace-elts '(a (b (c d) e))
                              '((a . 1) (b . 2) (c . 3) (d . 4)))
'(1 (2 (3 4) e))

nested-map.rkt> (replace-elts '(a and (b or c))
                              '((a . #t) (b . #f) (c . #t)))
'(#t and (#f or #t))