广义Lisp函数

Question

为了快速原型化的目的，我想开始构建一个通用版本的库，它是由Common提供的一些基本函数组成的，而不仅仅是为手头的任务收集(或导入)特殊用途函数。例如，map函数被适度地推广到对任何类型的序列进行操作，但不处理可调向量。编写下面的特殊目的扩展部分似乎足以满足目前的需要，但仍然有限：

(defun map-adjustable-vector (function adjustable-vector)
  "Provides mapping across items in an adjustable vector."
  (let ((new-adj-vec 
          (make-array (array-total-size adjustable-vector)
                        :element-type (array-element-type adjustable-vector)
                        :adjustable t
                        :fill-pointer (fill-pointer adjustable-vector))))
    (dotimes (i (array-total-size adjustable-vector))
      (setf (aref new-adj-vec i) (funcall function (aref adjustable-vector i))))
    new-adj-vec))

我想要看到的是，如何编写这样一个函数，它还需要一个输出类型规范(包括一个新的‘可调向量类型)，并允许多种类型的列表和向量作为输入--换句话说，它是以map为模式的。

更广泛地说，理解是否存在与编写这类广义函数有关的基本原则或想法是有益的。例如，专门处理输出类型规范的泛型方法是否是上述函数的可行方法？或者，或许，是否可以利用map本身在泛化中发挥作用，就像在Mapping into a tree of nested sequences上的一篇文章中所展示的那样？我不知道泛化是否有任何限制(除了某些低效率外)，但我想看看它能走多远。

Answer 1

在这种情况下，可以认为map使用make-sequence来创建结果序列。

然而，你的问题太宽泛了，任何回答基本上都是一种意见。您可以做您想做的任何事情，但实际上，最直接的方法是扩展序列类型参数，以包含带有填充指针和/或可调整的向量：

;;; For use by the following deftype only
(defun my-vector-typep (obj &key (adjustable '*) (fill-pointer '*))
  (and (or (eql adjustable '*)
           ;; (xor adjustable (adjustable-array-p obj))
           (if adjustable
               (adjustable-array-p obj)
               (not (adjustable-array-p obj))))
       (or (eql fill-pointer '*)
           (if (null fill-pointer)
               (not (array-has-fill-pointer-p obj))
               (and (array-has-fill-pointer-p obj)
                    (or (eql fill-pointer t)
                        (eql fill-pointer (fill-pointer obj))))))))

;;; A type whose purpose is to describe vectors
;;; with fill pointers and/or that are adjustable.
;;; 
;;; element-type and size are the same as in the type vector
;;; adjustable is a generalized boolean, or *
;;; fill-pointer is a valid fill pointer, or t or nil, or *
(deftype my-vector (&key element-type size adjustable fill-pointer)
  (if (and (eql adjustable '*) (eql fill-pointer '*))
      `(vector element-type size)
      ;; TODO: memoize combinations of adjustable = true/false/* and fill-pointer = t/nil/*
      (let ((function-name (gensym (symbol-name 'my-vector-p))))
        (setf (symbol-function function-name)
              #'(lambda (obj)
                  (my-vector-p obj :adjustable adjustable :fill-pointer fill-pointer)))
        `(and (vector ,element-type ,size)
              (satisfies ,function-name)))))

(defun my-make-sequence (resulting-sequence-type size &key initial-element)
  (when (eql resulting-sequence-type 'my-vector)
    (setf resulting-sequence-type '(my-vector)))
  (if (and (consp resulting-sequence-type)
           (eql (first resulting-sequence-type) 'my-vector))
      (destructuring-bind (&key (element-type '*) (type-size '* :size) (adjustable '*) (fill-pointer '*))
          (rest resulting-sequence-type)
        (assert (or (eql type-size '*) (<= size type-size)))
        (make-array (if (eql type-size '*) size type-size)
                    :element-type (if (eql element-type '*) t element-type)
                    :initial-element initial-element
                    :adjustable (if (eql adjustable '*) nil adjustable)
                    :fill-pointer (if (eql fill-pointer '*) nil fill-pointer)))
      (make-sequence resulting-sequence-type size
                     :initial-element initial-element)))

;; > (my-make-sequence '(my-vector :adjustable t) 10)

(defun my-map (resulting-sequence-type function &rest sequences)
  (apply #'map-into
         (my-make-sequence resulting-sequence-type
                           (if (null sequences)
                               0
                               (reduce #'min (rest sequences)
                                       :key #'length
                                       :initial-value (length (first sequence))))
         function
         sequences)))

;; > (my-map '(my-vector :adjustable t) #'+ '(1 2 3) '(3 2 1))

还有许多其他选择，比如简单地显式地提供目标序列(map-into)、提供带有特定参数的序列工厂函数或使用可指定的泛型函数(如果可能的话)、使用包装器对象来决定如何在内部存储元素(例如，如果对元素进行排序，则可能使用树；如果它有很少的元素，则可能使用conses)，并且可以返回任何类型的序列。

真的，这是一个开放的问题，它主要取决于你的需要和/或想象力。