Racket 地图功能在球拍中的实现

map函数是如何在racket中实现的，为什么是递归或迭代

可能是一些实现示例

如何实现map

map

函数遍历一个列表（或多个列表），并将给定函数应用于列表的每个值。例如，将

add1

映射到列表会导致：

> (map add1 '(1 2 3 4))
'(2 3 4 5)

因此，您可以将

map

实现为递归函数：

(define (map func lst)
  (if (empty? lst)
    '()
    (cons (func (first lst)) (map func (rest lst)))))

(define (map proc lst . lst*)
  (if (empty? lst)
      '()
      (cons (apply proc (first lst) (map first lst*))
            (apply map proc (rest lst) (map rest lst*)))))

当然，

map

可以接受任意数量的参数，每个元素都传递给给定的prop。例如，您可以使用

映射列表

将两个列表压缩在一起：

> (map list '(1 2 3) '(a b c))
'((1 a) (2 b) (3 c))

要实现此变量算术映射，我们需要使用

apply

函数：

(define (map func lst)
  (if (empty? lst)
    '()
    (cons (func (first lst)) (map func (rest lst)))))

(define (map proc lst . lst*)
  (if (empty? lst)
      '()
      (cons (apply proc (first lst) (map first lst*))
            (apply map proc (rest lst) (map rest lst*)))))

现在，假设所有给定的列表都具有相同的长度，否则会出现一些意外行为。要做到这一点，您需要在所有列表上运行

empty？

，而不仅仅是第一个列表。但是…当你使用它时，你会得到：

> (map list '(a b c) '(1 2 3))
'((a 1) (b 2) (c 3))

注意，

map

在这里递归调用自己3次。更快的实现可能会进行一些展开以更快地运行。更好的实现还可以进行适当的错误检查，我在本例中省略了这一点

球拍地图是如何实现的 如果您打开DrRacket（每晚使用最新的Racket 7），并制作以下文件：

#lang racket

map

现在，您可以右键单击

映射

，然后选择

打开定义文件

。从这里，您可以看到

map

是从定义

map2

重命名的。其定义为：

(define map2
   (let ([map
          (case-lambda
           [(f l)
            (if (or-unsafe (and (procedure? f)
                                (procedure-arity-includes? f 1)
                                (list? l)))
                (let loop ([l l])
                  (cond
                   [(null? l) null]
                   [else
                    (let ([r (cdr l)]) ; so `l` is not necessarily retained during `f`
                      (cons (f (car l)) (loop r)))]))
                (gen-map f (list l)))]
           [(f l1 l2)
            (if (or-unsafe
                 (and (procedure? f)
                      (procedure-arity-includes? f 2)
                      (list? l1)
                      (list? l2)
                      (= (length l1) (length l2))))
                (let loop ([l1 l1] [l2 l2])
                  (cond
                   [(null? l1) null]
                   [else 
                    (let ([r1 (cdr l1)]
                          [r2 (cdr l2)])
                      (cons (f (car l1) (car l2)) 
                            (loop r1 r2)))]))
                (gen-map f (list l1 l2)))]
           [(f l . args) (gen-map f (cons l args))])])
     map))

---

只要看看源代码。。。（map.rkt，在Dr.Racket中右键单击“打开定义文件”）感谢您提供的详细信息，但我的问题是map如何在Racket中实现，而不是我自己如何实现map。公平点。我已经更新了答案，还包括Racket7映射实现。