Recursion 进入列表的列表？

我想将

（映射乐趣列表）

应用于列表或列表列表的内部列表，以便函数

（内部映射过程列表）

可以执行以下操作：

plain list(1d):
   (inner-map even? '(1 2 3))
   => (#f #t # f)

list of lists(2d):
   (inner-map even? '((1 2 3) (1 2 3) (1 2 3))
   => ((#f #t #f) (#f #t #f) (#f #t #f))

list of lists of lists (3d):
   (inner-map even? '(((1 2 3) (1 2 3) (1 2 3))
                      ((1 2 3) (1 2 3) (1 2 3))
                      ((1 2 3) (1 2 3) (1 2 3))))
   => (((#f #t #f) (#f #t #f) (#f #t #f)) ((#f #t #f) (#f #t #f) (#f #t #f)) ((#f #t #f) (#f #t #f) (#f #t #f)))
 ad nauseum

虽然对泛型不太确定，但我可以让它在这样的时间对列表的一维性起作用：

2d list:
(define (inner-map proc lis)       
  (map (lambda (y)
         (map (lambda (x)
                (proc x))
              y))
       lis))


3d list:
(define (inner-map proc lis)
  (map (lambda (z)
         (map (lambda (y)
                (map (lambda (x)
                       (proc x))
                     y))
              z))
       lis))

And even 4d list structs:
(define (inner-map proc lis)
  (map (lambda (l)
         (map (lambda (k)
                (map (lambda (j)
                       (map (lambda (i)
                              (proc i))
                            j))
                     k))
              l))
       lis))

因此，要使其在任何深度的列表中通用，您需要进行递归调用，将

（map（lambda（var）…var）

嵌套得更深，直到您到达原子列表为止。虽然这不起作用，但这是我对问题的看法：

(define (inner-map proc lis)
  (map (lambda (x)
         (cond ((atom? (car lis)) (proc x)))
         (else (inner-map proc x)))
       lis))

---

编辑：所以当我还在学习高阶函数时，折叠或递归折叠是否合适？

您的

内部映射

函数的唯一问题是

（atom？（car lis））

应该是

（atom？x）

。在错误的地方也有右括号。考虑：

(define (inner-map proc lis)
  (map (lambda (x)
         (cond ((atom? x) (proc x))
               (else (inner-map proc x))))
       lis))

---

内部映射

函数的唯一问题是

（atom？（car-lis））

应该是

（atom？x）

。在错误的地方也有右括号。考虑：

(define (inner-map proc lis)
  (map (lambda (x)
         (cond ((atom? x) (proc x))
               (else (inner-map proc x))))
       lis))

---

内部映射

函数的唯一问题是

（atom？（car-lis））

应该是

（atom？x）

。在错误的地方也有右括号。考虑：

(define (inner-map proc lis)
  (map (lambda (x)
         (cond ((atom? x) (proc x))
               (else (inner-map proc x))))
       lis))

---

内部映射

函数的唯一问题是

（atom？（car-lis））

应该是

（atom？x）

。在错误的地方也有右括号。考虑：

(define (inner-map proc lis)
  (map (lambda (x)
         (cond ((atom? x) (proc x))
               (else (inner-map proc x))))
       lis))

---

@dan-d已经用正确的密码回答了你的问题。我将添加以下分析

最后一段代码编译是因为变量

lis

在lambda的作用域内，所以

（atom？（car lis））

在语法上工作，但在算法上失败。函数

map

对列表中的每个元素进行操作，这意味着传递给lambda函数的

x

是（迭代地）列表中的每个元素。同时，

（car lis）

始终获取

lis

的第一个元素，因此您只能根据第一个元素的类型而不是当前元素的类型，在

x

上选择递归调用

proc

这就是问题所在

---

Scheme中lambda的强大之处在于它能够捕获其范围内所有变量的当前状态。对

lis

的引用，虽然没有传递到您的lambda中，但从该lambda的范围外和

内部映射

函数的范围内获取。

@dan-d已经用正确的代码回答了您的问题。我将添加以下分析

最后一段代码编译是因为变量

lis

在lambda的作用域内，所以

（atom？（car lis））

在语法上工作，但在算法上失败。函数

map

对列表中的每个元素进行操作，这意味着传递给lambda函数的

x

是（迭代地）列表中的每个元素。同时，

（car lis）

始终获取

lis

的第一个元素，因此您只能根据第一个元素的类型而不是当前元素的类型，在

x

上选择递归调用

proc

这就是问题所在

---

Scheme中lambda的强大之处在于它能够捕获其范围内所有变量的当前状态。对

lis

的引用，虽然没有传递到您的lambda中，但从该lambda的范围外和

内部映射

函数的范围内获取。

@dan-d已经用正确的代码回答了您的问题。我将添加以下分析

最后一段代码编译是因为变量

lis

在lambda的作用域内，所以

（atom？（car lis））

在语法上工作，但在算法上失败。函数

map

对列表中的每个元素进行操作，这意味着传递给lambda函数的

x

是（迭代地）列表中的每个元素。同时，

（car lis）

始终获取

lis

的第一个元素，因此您只能根据第一个元素的类型而不是当前元素的类型，在

x

上选择递归调用

proc

这就是问题所在

---

Scheme中lambda的强大之处在于它能够捕获其范围内所有变量的当前状态。对

lis

的引用，虽然没有传递到您的lambda中，但从该lambda的范围外和

内部映射

函数的范围内获取。

@dan-d已经用正确的代码回答了您的问题。我将添加以下分析

最后一段代码编译是因为变量

lis

在lambda的作用域内，所以

（atom？（car lis））

在语法上工作，但在算法上失败。函数

map

对列表中的每个元素进行操作，这意味着传递给lambda函数的

x

是（迭代地）列表中的每个元素。同时，

（car lis）

始终获取

lis

的第一个元素，因此您只能根据第一个元素的类型而不是当前元素的类型，在

x

上选择递归调用

proc

这就是问题所在

---

Scheme中lambda的强大之处在于它能够捕获其范围内所有变量的当前状态。对

lis

的引用，虽然没有传递到lambda中，但从lambda的范围外和

内部映射

函数的范围内获取。

这不起作用，您的内部映射也在某个地方缺少一个关闭参数，如果将其放在末尾，它将关闭，但我不确定你是否想把它放在这里。如果我在末尾放上结束符，使结尾看起来像

lis”）

，