Common lisp 如何展平嵌套序列？

使用，我希望从嵌套系列中创建平面系列。例如：

(map-fn t (lambda (x)
            (map-fn t (lambda (y)
                        (cons x y))
                    (scan '(1 2 3))))
        (scan '(4 5 6)))

=> #Z( #Z( (4 . 1) (4 . 2) (4 . 3) )
       #Z( (5 . 1) (5 . 2) (5 . 3) )
       #Z( (6 . 1) (6 . 2) (6 . 3) ) )

我想把这个系列变成一个系列，如下所示：

=> #Z( (4 . 1) (4 . 2) (4 . 3)
       (5 . 1) (5 . 2) (5 . 3)
       (6 . 1) (6 . 2) (6 . 3) )

如果我有一个合适的串联函数，那就好了。尽管series库具有CATENATE函数，但它只接受其&rest参数中的一些级数。我可以

(apply #'catenate list-of-series)

但是它接受一个系列的列表，而不是系列的系列。不幸的是，没有任何用于折叠序列的函数，而有用于映射和过滤的函数。如A.4所示的生成宏。CLTL2中的Primitives部分对我来说不起作用，因为它似乎也不能展平嵌套循环。我不能在嵌套情况下使用NEXT-OUT宏

(apply #'catenate
       (collect (map-fn t (lambda (x)
                            (map-fn t (lambda (y)
                                        (cons x y))
                                    (scan '(1 2 3))))
                        (scan '(4 5 6)))))

但这有点骗人。要正确地进行串联，请执行以下操作：

(producing (prod) ((zz (generator (map-fn t (lambda (x)
                                              (map-fn t (lambda (y)
                                                          (cons x y))
                                                      (scan '(1 2 3))))
                                          (scan '(4 5 6)))))
                   cur)
           (loop
              (tagbody
               redo
                 (if (null cur)
                     (setq cur (generator (next-in zz (terminate-producing)))))
                 (next-out prod (next-in cur (progn 
                                               (setq cur nil)
                                               (go redo)))))))

=> #Z((4 . 1) (4 . 2) (4 . 3)
      (5 . 1) (5 . 2) (5 . 3)
      (6 . 1) (6 . 2) (6 . 3))