На defun.ru не так давно выкладывали ссылку на библиотеку RDNZL для Common Lisp, которая предоставляет FFI к .NET
http://www.weitz.de/rdnzl/

Единственное, чего мне очень не хватало в CL это нормальной библиотеки для GUI.
Теперь есть, и это охуенно.

Вот пример:

(asdf:operate 'asdf:load-op :rdnzl)
(use-package :rdnzl)

(import-assembly "mscorlib")
(import-assembly "System.Windows.Forms")

(use-namespace "System.Windows.Forms")

(enable-rdnzl-syntax)

(let ((form (new "Form"))
      (textBox (new "TextBox"))) 
  (setf
    [%Multiline textBox] t
    [%ScrollBars textBox] [$ScrollBars.Vertical]
    [%Text form] "Main"
    [%Width form] 350
    [%Height form] 250
    [%StartPosition form] [$FormStartPosition.CenterScreen]
    [%Parent textBox] form
    [%Text textBox] (reduce #'(lambda (x y) (concatenate 'string
                                                                                     (string x)
                                                                                     (string #\Return)
                                                                                     (string #\Newline)
                                                                                     (string y)))
                                      (remove-if-not #'(lambda (x)
                                                                        (search "RDNZL:" (write-to-string x)))
                                           (apropos-list "")))
    [%Dock textBox] [$DockStyle.Fill])
  [Application.Run form])

Накатал вот непонятно чо. Функция, в которую раскрывается этот макрос, сравнивает несколько последовательностей (минимум 1, саму с собой) по длине и элементам, выдавая NIL на первом несовпадении реляционного оператора или отличии длины от первой последовательности в списке.

(defmacro comparse-arrays (rel-operator &rest sequences)
  (let ((length-first (gensym))
        (rest-arg (gensym))
        (seq-count (gensym)))
    `(let* ((,rest-arg (list ,@sequences))
            (,seq-count (length ,rest-arg))
            (,length-first (length (first ,rest-arg))))
       (dotimes (i ,seq-count)
         (when (and (< i 1) (> ,seq-count 1))
           (setf i 1))
         (when (/= (length (nth i ,rest-arg)) ,length-first)
           (return NIL))
         (when (/= (count NIL (map 'list ,rel-operator (nth i ,rest-arg) (first ,rest-arg))) 0)
           (return NIL))
         (when (= i (1- ,seq-count))
           (return T)))))) 

Т. е. типо вот
(comparse-arrays #'> '(1 2 3) #(4 5 6) #(3 4 5)) ==> T
(comparse-arrays #'= #(1 2 3) '(1 2 3)) ==> T
а (comparse-arrays #'= '(1 2 3) '(4 5 6)) ==> NIL

Надо бы допилить, конешно, чтобы последовательно с предыдущим списком, а не только с первым, сравнивался.
И наверное, еще приделаю, чтобы при NIL возвращался кортеж - NIL, отличающуюся последовательность и номер элемента первого несовпадения.

Я очень долго не врубался в алгоритм быстрой сортировки. Фактически, до сегодняшнего дня.
С утра несколько раз пробовал написать на Лиспе в таком варианте, в каком он здесь на Си, но не получалось нифига, постоянно либо не полностью сортировался, либо индекс за границы последовательности вылетал(в лиспе нет цикла for в таком виде, в каком он есть в паскале и Си-подобных языках, пришлось и это велосипедить). Вот.
Но потом я заглянул на английскую страницу, увидел там псеводкод: 

схему:

И внезапно просветлел. 

(defun qsort (array sort-function)
  (if (<= (length array) 1)         
    array
    (let ((pivot (elt array (round (/ (length array) 2)))) less greater pivots)
      (map nil (lambda (x)
                          (cond ((equalp x pivot) (push x pivots))
                                   ((funcall sort-function x pivot) (push x less))
                                   ((not (funcall sort-function x pivot)) (push x greater))))
                  array)
      (concatenate (typecase array (string 'string)
                                                 (vector 'vector)
                                                 (list 'list))
                          (qsort less sort-function) pivots (qsort greater sort-function)))))

Моя функция принимает последовательность, функцию - реляционный оператор, выбирает pivot как элемент из середины и с помощью map(когда тип возвращаемой последовательности указывается nil, эта функция не возвращает ничего и используется просто для побочных эффектов), используя переданный реляционный оператор, раскидывает элементы по спискам - в less, greater или в pivots соответственно. Потом она создает новый массив из less, pivots и greater списков, предварительно рекурсивно вызывая себя для сортировки less и greater.
Не совсем корректо, правда, работает с функциями вроде =, string= итд - просто как попало перемешивает массив. Но, во-первых, кому придет в голову сортировать оператором равенства, и во-вторых, это можно поправить, например, поставив в if наверху вместо (<= (length array) 1) что-нибудь типо
 (or (<= (length array) 1)
    (member sort-function (list #'= #'string= #'string-equal #'char= #'char-equal #'eq #'eql #'equal #'equalp)))

Работает вобщем так:
(qsort #(1 9 8 7 3 5 0 2 4 6) #'<)
вернет #(0 1 2 3 4 5 6 7 8 9)

(qsort "ХУИТА" #'char<)
соответственно "АИТУХ"

UPD: Внезапно.
(defun prob-qsort (array rel-operator)
  (if (<= (length array) 1)
    array
    (let ((pivot (elt array (random (length array)))))
      (concatenate (typecase array (string 'string)
                                                   (bit-vector 'bit-vector)
                                                   (vector 'vector)
                                                   (list 'list))
                   (prob-qsort (remove-if #'(lambda (x) (or (equalp x pivot)
                                                                               (not (funcall rel-operator x pivot)))) array) rel-operator)
                   (remove-if-not #'(lambda (x) (equalp x pivot)) array)
                   (prob-qsort (remove-if #'(lambda (x) (or (equalp x pivot)
                                                                               (funcall rel-operator x pivot))) array) rel-operator)))))

http://local.joelonsoftware.com/mediawiki/index.php/А ваш язык программирования так может?

В Common Lisp уже есть встроенные функции Map и Reduce.
Однако, если бы их не было, реализовать их было бы не так уж и сложно. 

Вот довольно простая версия Map. Я не знаю точно, как map реализована в Common Lisp - итеративно или рекурсивно, но предполагаю, что итеративно, ради увеличения производительности. 
Моя версия использует итерацию, во всяком случае.
Работает только с одной последовательностью. Но этого достаточно, чтобы использовать ее, например, в foreach здесь. 

(defun my-map (seq-type fun seq)

  (let* ((seq-length (length seq))

	 (new-seq (cond

		     ((eq seq-type 'string)

		          (make-array  seq-length :element-type 'character))

		     ((eq seq-type 'vector)

		          (make-array seq-length))

		     ((eq seq-type 'list)

		          (make-list seq-length)))))    

      (dotimes (n seq-length)

	(setf (elt new-seq n) (funcall fun (elt seq n))))

      new-seq))

Reduce:

(defun my-reduce (fn seq)
  (let ((len (length seq))
        (temp (elt seq 0)))
    (dotimes (i len)
      (when (= i (1- len)) (return temp))
      (setf temp (funcall fn temp (elt seq (1+ i)))))))

Ну и функции sum и join из статьи:
Sum:

(defun sum (arr) (my-reduce #'+ arr))

(defun to-string (element)
  (cond   
    ((or (symbolp element)
         (characterp element)
         (stringp element)) (string element))
    (T (write-to-string element))))

И собственно join:

(defun join (arr)
   (my-reduce #'(lambda (x y) (concatenate 'string (to-string x) (to-string y))) arr))