Схема → Clojure: мультиметоды с предикатами в методах?

Я конвертирую код схемы в Clojure. В оригинале используется шаблон диспетчеризации, который очень похож на мультиметоды, но с инвертированным подходом к совпадающим предикатам. Например, существует общая функция "assign-operations". Точные детали реализации не слишком важны на данный момент, но обратите внимание, что он может принимать список предикатов аргументов.

(define (assign-operation operator handler . argument-predicates)
  (let ((record
         (let ((record (get-operator-record operator))
               (arity (length argument-predicates)))
           (if record
               (begin
                 (if (not (fix:= arity (operator-record-arity record)))
                     (error "Incorrect operator arity:" operator))
                 record)
               (let ((record (make-operator-record arity)))
                 (hash-table/put! *generic-operator-table* operator record)
                 record)))))
    (set-operator-record-tree! record
                               (bind-in-tree argument-predicates
                                             handler
                                             (operator-record-tree record)))))

Отправленные функции предоставляют эти предикаты, по одному на аргумент в арности функции.

(assign-operation 'merge
  (lambda (content increment) content)
  any? nothing?)

(assign-operation 'merge
  (lambda (content increment) increment)
  nothing? any?)

(assign-operation 'merge
  (lambda (content increment)
    (let ((new-range (intersect-intervals content increment)))
      (cond ((interval-equal? new-range content) content)
            ((interval-equal? new-range increment) increment)
            ((empty-interval? new-range) the-contradiction)
            (else new-range))))
  interval? interval?)

Позже, когда вызывается универсальная функция "merge", каждый обработчик задается, работает ли он над операндами.

Как я понимаю многоточие, функция отправки определяется по множеству реализаций с отправкой на конкретный метод, основанный на возвращаемом значении отправки-fn. На приведенной выше схеме новые функции назначения-назначения могут произвольно определять предикаты.

Что было бы эквивалентной, идиоматической конструкцией в Clojure?

EDIT: приведенный выше код происходит от "Искусство Пропагатора" , Алексей Радул и Джеральд Суссман.

Ответ 1

Вы можете сделать это с помощью Clojure multimethods довольно легко - трюк заключается в создании диспетчерской функции, которая различает разные наборы предикатов.

Самый простой способ сделать это - это просто сохранить вектор "составных предикатов", который применяет все отдельные предикаты к полному списку аргументов и использует индекс этого вектора в качестве значения отправки:

(def pred-list (ref []))

(defn dispatch-function [& args] 
  (loop [i 0]
    (cond
      (>= i (count @pred-list))     (throw (Error. "No matching function!"))
      (apply (@pred-list i) args)   i
      :else                         (recur (inc i)))))

(defmulti handler dispatch-function)

(defn assign-operation [function & preds]    
  (dosync
    (let [i (count @pred-list)]
      (alter pred-list conj   
             (fn [& args] (every? identity (map #(%1 %2) preds args))))
      (defmethod handler i [& args] (apply function args)))))

Затем вы можете создавать операции для обработки любых предикатов, которые вам нравятся следующим образом:

(assign-operation (fn [x] (/ x 2)) even?)

(assign-operation (fn [x] (+ x 1)) odd?)

(take 15 (iterate handler 77))
=> (77 78 39 40 20 10 5 6 3 4 2 1 2 1 2)