如何在球拍中实现地图功能

Question

如何在球拍中实现地图功能以及为什么，递归或迭代。

也许是一些实现示例

Answer 1

如何实施地图

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)))))

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

将两个列表压缩在一起

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

要实现此变量arity映射，我们需要使用apply函数：

(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并选择Open Defining File。从这里，您可以看到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))