在方案中，
“映射”功能通常可以方便地根据一个列表计算另一个列表。
事实上，在方案中，map采用“n个参数”函数和“n”个列表并调用
每个列表的每个对应元素的函数：
> (map * '(3 4 5) '(1 2 3))
(3 8 15)
但对此的一个非常自然的补充是“笛卡尔映射”函数，它将调用“n-参数”函数，并使用从每个列表中选取一个元素的所有不同方式。我花了一段时间才弄清楚到底该怎么做，但现在你可以了：
; curry takes:
; * a p-argument function AND
; * n actual arguments,
; and returns a function requiring only (p-n) arguments
; where the first "n" arguments are already bound. A simple
; example
; (define add1 (curry + 1))
; (add1 3)
; => 4
; Many other languages implicitly "curry" whenever you call
; a function with not enough arguments.
(define curry
(lambda (f . c) (lambda x (apply f (append c x)))))
; take a list of tuples and an element, return another list
; with that element stitched on to each of the tuples:
; e.g.
; > (stitch '(1 2 3) 4)
; ((4 . 1) (4 . 2) (4 . 3))
(define stitch
(lambda (tuples element)
(map (curry cons element) tuples)))
; Flatten takes a list of lists and produces a single list
; e.g.
; > (flatten '((1 2) (3 4)))
; (1 2 3 4)
(define flatten
(curry apply append))
; cartesian takes two lists and returns their cartesian product
; e.g.
; > (cartesian '(1 2 3) '(4 5))
; ((1 . 4) (1 . 5) (2 . 4) (2 . 5) (3 . 4) (3 . 5))
(define cartesian
(lambda (l1 l2)
(flatten (map (curry stitch l2) l1))))
; cartesian-lists takes a list of lists
; and returns a single list containing the cartesian product of all of the lists.
; We start with a list containing a single 'nil', so that we create a
; "list of lists" rather than a list of "tuples".
; The other interesting function we use here is "fold-right" (sometimes called
; "foldr" or "reduce" in other implementations). It can be used
; to collapse a list from right to left using some binary operation and an
; initial value.
; e.g.
; (fold-right cons '() '(1 2 3))
; is equivalent to
; ((cons 1 (cons 2 (cons 3 '())))
; In our case, we have a list of lists, and our binary operation is to get the
; "cartesian product" between each list.
(define cartesian-lists
(lambda (lists)
(fold-right cartesian '(()) lists)))
; cartesian-map takes a n-argument function and n lists
; and returns a single list containing the result of calling that
; n-argument function for each combination of elements in the list:
; > (cartesian-map list '(a b) '(c d e) '(f g))
; ((a c f) (a c g) (a d f) (a d g) (a e f) (a e g) (b c f)
; (b c g) (b d f) (b d g) (b e f) (b e g))
(define cartesian-map
(lambda (f . lists)
(map (curry apply f) (cartesian-lists lists))))
没有所有注释和一些更紧凑的函数定义语法，我们有：
(define (curry f . c) (lambda x (apply f (append c x))))
(define (stitch tuples element)
(map (curry cons element) tuples))
(define flatten (curry apply append))
(define (cartesian l1 l2)
(flatten (map (curry stitch l2) l1)))
(define cartesian-lists (curry fold-right cartesian '(()))))
(define (cartesian-map f . lists)
(map (curry apply f) (cartesian-lists lists)))
我认为上面的内容相当“优雅”......直到有人向我展示了等效的 Haskell 定义：
cartes f (a:b:[]) = [ f x y | x <- a , y <- b ]
cartes f (a:b:bs) = cartes f ([ f x y | x <- a , y <- b ]:bs)
2行！！！
我对我的实现效率不太有信心 - 特别是“展平”步骤写得很快，但最终可能会调用“追加”
具有大量列表，这在某些方案上可能会或可能不会非常有效
实施。
为了最终的实用性/有用性，您需要一个可以采用“惰性评估”列表/流/迭代器而不是完全指定的列表的版本...如果您愿意，可以使用“笛卡尔映射流”函数，然后它将返回“结果的“流”...但这取决于上下文（我正在考虑 SICP 中引入的“流”概念）...并且由于它的惰性求值，将免费从 Haskell 版本中获得。
一般来说，在Scheme中，如果你想在某个时刻“打破”循环，你也可以使用延续（比如抛出异常，但这是Scheme中控制流的公认做法）。
我写这篇文章很开心！
