4

我喜欢创建带有无限数量参数的函数，并且能够将它们作为列表处理。它在创建二叉树时对我很有用，我现在正在使用它来改进最近邻算法。然而，我的方法真的很糟糕：因为我想不出一种方法来迭代不正确的列表（这很可能是不正确的和退化的），我尝试使用各种列表函数来强制不正确的列表变成列表形式。

这是我在一个简单的函数中确定地图节点之间差异的最佳尝试（有效，只是不确定它为什么有效）：

(define distance-between
  (lambda xs
    (let ([input-list (list* xs null)])
      (letrec 
          ([f (lambda (xs acc)
               (if (null? (cdr xs))
                   acc
                   (f (cdr xs) 
                      (+ (abs (- (map-node-x (car xs)) 
                                 (map-node-x (cadr xs))))
                         (abs (- (map-node-y (car xs)) 
                                 (map-node-y (cadr xs))))
                         acc))))])                   
       (f (car input-list) 0)))))

如您所见，这是一个丑陋的解决方案，并且涉及一些对我来说似乎很神奇的东西 - 为什么当我将不正确的列表包含在列表中时，它会被强制转换为列表形式*？（注意：这句话具有误导性，这不会发生）。

我宁愿有一个漂亮的解决方案，没有魔法。任何人都可以帮忙吗？

例如，典型的输入是：

(distance-between (map-node 1 2) (map-node 2 3) (map-node 3 4))

与预期的结果：

4

（地图节点（a）和mn（b）之间的距离为2，加上地图节点（b）和地图节点（c）之间的距离为2）。

或者，可以简单地输入：

(distance-between (map-node 1 2) (map-node 2 2))

并得到以下答案：

1

如果我在原始输入上尝试此操作，而没有我的 (let ([input-list...])...) 语句，则会导致错误，因为 (? 实际上不确定为什么要回答这个问题)。

该功能按预期工作。

4

3 回答 3

8

作为可变参数列表接收的列表没有什么不妥（意思是：可变数量的参数）。例如：

(define test-list
  (lambda xs
    (length xs))) ; xs is a normal list, use it like any other list

(test-list 1 2 3 4)
=> 4

在上面的例子中，xs参数是一个普通的、普通的、普通的列表，没有什么不妥之处。您可以像遍历任何其他列表一样遍历它。没必要car，已经是清单了！另外，请注意同样的函数可以写成这样：

(define (test-list . xs)
  (length xs))   ; xs is a normal list, use it like any other list

仅供参考：不正确的列表是不以空列表结尾的列表。例如：'(1 2 3 . 4)。同样，这不是可变参数列表的外观。

于 2013-08-13T14:51:36.057 回答
4

我也不明白您的可变参数列表如何不合适。

但是要回答您的原始问题（如何更优雅地迭代可能不正确的列表），这是一种使用方法match：

#lang racket

(define (properly-sum-improper-list xs)
  (let loop ([acc 0]
             [xs xs])
    (match xs
      [(list) acc]
      [(cons x more) (loop (+ acc x) more)]
      [x (+ acc x)]))) ;last item of improper list

(require rackunit)
(check-equal? (properly-sum-improper-list '(1 2 3 4))   10)
(check-equal? (properly-sum-improper-list '(1 2 3 . 4)) 10)

但是，根本需要这样做可能表明您想要修复或更改其他内容。

于 2013-08-13T15:02:19.370 回答
3

你的名单没有错。当您的论点不是一对时，您的论点(lambda xs body ...)或(define (fun . xs) body ...)所有论点都会被放入一个列表中。例如..(fun 1 2 3)会使 xs '(1 2 3)。做(list* '(1 2 3) '())这件事'((1 2 3)，你可以通过调用你的循环来立即撤销car它'(1 2 3)。

除此之外，您的程序按预期工作。您可能会稍微清理一下您的过程，但是由于没有列表推导可以滑过折叠在两个下一个元素上的列表，因此它不会变得更小。下面是基本相同的代码，但抽象出完成工作的过程（如果存在您可以使用的 foldl 对）并使用 anamed let作为迭代器循环（这是 letrec+call 的语法糖）。

(define (distance-between e1 . lst)
  (define (add-diff-acc e1 e2 acc)
    (+ (abs (- (map-node-x e1) (map-node-x e2)))
       (abs (- (map-node-y e1) (map-node-y e2)))
       acc))

  (let iterate ((e1 e1) (lst lst) (acc 0))
    (if (pair? lst)
        (let ((e2 (car lst)))
          (iterate e2 (cdr lst) (add-diff-acc e1 e2 acc)))
        acc)))

编辑：关于语法糖named let和letrec.

(let ((x 10) (y 19)) 
  body)

是匿名过程调用的语法糖

((lambda (x y) 
    body) 
  10 19)

Anamed let只是给该过程一个名称，尽管好像 by letrec，进行递归绑定。你用你给的名字来调用它，参数将是你提供的，而不是 let 中的初始值。我已经习惯了，今天更喜欢它们。不过可能需要一些时间来适应。

我们编写的大部分代码都是一些较低级别内容的语法糖。宏是嵌套的，因此您的letrec表单最终可以减少 lambda。没有语法糖的整个过程如下所示：

(define distance-between 
  (lambda (e1 . lst)
    ((lambda (add-diff-acc)
       ((lambda (iterate e1 lst acc) ; emulate Y to substitute `letrec`
          (iterate iterate e1 lst acc))
        (lambda (iterate e1 lst acc)
          (if (pair? lst)
              ((lambda (e2)
                 (iterate iterate e2 (cdr lst) (add-diff-acc e1 e2 acc)))
               (car lst))
              acc))
        e1 lst 0))
     (lambda (e1 e2 acc)
       (+ (abs (- (map-node-x e1) (map-node-x e2)))
          (abs (- (map-node-y e1) (map-node-y e2)))
          acc)))))
于 2013-08-13T22:50:43.387 回答