Устранение циклических зависимостей Clojure

Я помню ряд обсуждений пространств имен в Clojure - в списке рассылки и в других местах - и я должен сказать вам, что консенсус (и, AFAICT, текущая ориентация дизайна Clojure) заключается в том, что круговые зависимости - это призыв дизайна к рефакторинг. Временами могут быть возможны обходные пути, но они уродливы, возможно, проблематичны для производительности (если вы делаете вещи излишне «динамическими»), не гарантируете, что они будут работать вечно и т. Д.

Теперь вы говорите, что круглая структура проекта хороша и имеет модульную структуру. Но почему это так, если все зависит от всего ...? Кроме того, «каждый раз, когда у вас есть зависимость, которую нужно разрешить» не должно быть очень частым явлением, если вы заранее планируете древовидную структуру зависимостей. И чтобы обратиться к вашей идее размещения некоторых базовых протоколов и тому подобного в их собственном пространстве имен, я должен сказать, что много раз мне хотелось, чтобы проекты делали именно это. Я считаю, что это чрезвычайно полезно для моей способности бегло просмотреть кодовую базу и быстро понять, с какими абстракциями она работает.

Подводя итог, я отдаю свой голос рефакторингу.

У меня была аналогичная проблема с некоторым графическим кодом, в итоге я сделал следующее:

(defn- frame [args]
  ((resolve 'project.gui/frame) args))

Это позволило мне разрешить вызов во время выполнения, это вызывается из пункта меню во фрейме, поэтому я был на 100% уверен, что фрейм был определен, потому что он был вызван из самого фрейма, имейте в виду, что разрешение может вернуть nil.

У меня постоянно возникает одна и та же проблема. Хотя многие разработчики не хотят этого признавать, это серьезный недостаток дизайна языка. Круговые зависимости - нормальное состояние реальных объектов. Тело не может выжить без сердца, а сердце не может выжить без тела.

Решение во время звонка возможно, но не будет оптимальным. Возьмем случай, когда у вас есть API, поскольку часть этого API - это методы сообщения об ошибках, но API создает объект, который имеет свои собственные методы, этим объектам потребуется отчет об ошибках, и у вас есть циклическая зависимость. Функции проверки ошибок и составления отчетов будут вызываться часто, поэтому устранение ошибок во время их вызова не является вариантом.

Решение в этом случае и в большинстве случаев состоит в том, чтобы переместить код, не имеющий зависимостей, в отдельные (util) пространства имен, где к ним можно будет свободно делиться. Я еще не сталкивался со случаем, когда проблема не могла быть решена с помощью этой техники. Это делает поддержание полных, функциональных бизнес-объектов практически невозможным, но, похоже, это единственный вариант. Clojure предстоит пройти долгий путь, прежде чем он станет зрелым языком, способным точно моделировать реальный мир, и до тех пор нелогичное разделение кода - единственный способ устранить эти зависимости.

Если Aa () зависит от Ba (), а Bb () полагается на Ab (), единственное решение - переместить Ba () в Ca () и / или Ab () в Cb (), даже если C технически не существует в реальный мир.

Либо переместите все в один гигантский исходный файл, чтобы не было внешних зависимостей, либо выполните рефакторинг. Лично я бы пошел с рефакторингом, но когда вы действительно приступите к делу, все дело в эстетике. Некоторым нравится KLOCS и спагетти-код, так что о вкусах не спорят.

Над дизайном хорошо подумать. Циклические зависимости могут говорить нам, что мы запутались в чем-то важном.

Вот трюк, который я использовал для обхода круговых зависимостей в одном или двух случаях.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; example/a.cljc

(ns example.a
  (:require [example.b :as b]))

(defn foo []
  (println "foo"))

#?(

   :clj
   (alter-var-root #'b/foo (constantly foo))                ; <- in clojure do this

   :cljs
   (set! b/foo foo)                                         ; <- in clojurescript do this

   )

(defn barfoo []
  (b/bar)
  (foo))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; example/b.cljc

(ns example.b)

;; Avoid circular dependency.  This gets set by example.a
(defonce foo nil)

(defn bar []
  (println "bar"))

(defn foobar []
  (foo)
  (bar))

Я научился этому трюку из кода Дэна Холмсанда в Reagent.