Come agganciare in Clojure

Question

Ho una situazione in cui creo e distruggo oggetti in uno spazio dei nomi clojure e voglio che un altro spazio dei nomi sia coordinato. Comunque non voglio che il primo namespace debba chiamare il secondo esplicitamente sulla distruzione dell'oggetto.

In Java, potrei usare un listener. Sfortunatamente le librerie java sottostanti non segnalano eventi sulla distruzione degli oggetti. Se fossi in Emacs-Lisp, allora userei i ganci che fanno il trucco.

Ora, in clojure non ne sono così sicuro. Ho trovato la biblioteca di Robert Hooke https://github.com/technomancy/robert-hooke. Ma questo è più come defadvice in termini elis: sto componendo funzioni. Più oltre la documentazione dice:

"I ganci sono pensati per estendere le funzioni che non controlli, se possiedi la funzione obiettivo ci sono ovviamente modi migliori per cambiare il suo comportamento."

Purtroppo non lo trovo così ovvio.

Un'altra possibilità sarebbe utilizzare add-watch, ma questo è contrassegnato come alfa.

Mi manca un'altra soluzione ovvia?

Esempio Aggiunto:

Quindi, prima dello spazio dei nomi ....

(ns scratch-clj.first 
    (:require [scratch-clj.another])) 

(def listf (ref())) 

(defn add-object [] 
    (dosync 
    (ref-set listf (conj 
       @listf (Object.)))) 
    (println listf)) 


(defn remove-object [] 
    (scratch-clj.another/do-something-useful (first @listf)) 
    (dosync 
    (ref-set listf (rest @listf))) 
    (println listf)) 


(add-object) 
(remove-object) 

Seconda namespace

(ns scratch-clj.another) 


(defn do-something-useful [object] 
    (println "object removed is:" object)) 

Il problema qui è che graffi clj.first deve richiedere un'altra ed esplicitamente spingere gli eventi di rimozione attraverso. Questo è un po 'goffo, ma non funziona anche se avessi uno spazio dei nomi "ancora-un altro", che voleva anche ascoltare.

Quindi ho pensato di agganciare la prima funzione.

Answer 1

È questa soluzione adatta alle vostre esigenze?

graffi clj.first:

(ns scratch-clj.first) 

(def listf (atom [])) 
(def destroy-listeners (atom [])) 
(def add-listeners (atom [])) 

(defn add-destroy-listener [f] 
    (swap! destroy-listeners conj f)) 

(defn add-add-listener [f] 
    (swap! add-listeners conj f)) 

(defn add-object [] 
    (let [o (Object.)] 
    (doseq [f @add-listeners] (f o)) 
    (swap! listf conj o) 
    (println @listf))) 

(defn remove-object [] 
    (doseq [f @destroy-listeners] (f (first @listf))) 
    (swap! listf rest) 
    (println @listf)) 

Alcuni ascoltatori:

(ns scratch-clj.another 
    (:require [scratch-clj.first :as fst])) 

(defn do-something-useful-on-remove [object] 
    (println "object removed is:" object)) 

(defn do-something-useful-on-add [object] 
    (println "object added is:" object)) 

Init lega:

(ns scratch-clj.testit 
    (require [scratch-clj.another :as another] 
      [scratch-clj.first :as fst])) 

(defn add-listeners [] 
    (fst/add-destroy-listener another/do-something-useful-on-remove) 
    (fst/add-add-listener another/do-something-useful-on-add)) 

(defn test-it [] 
    (add-listeners) 
    (fst/add-object) 
    (fst/remove-object)) 

prova:

(test-it) 
=> object added is: #<Object java.lang.Object@c7aaef> 
    [#<Object java.lang.Object@c7aaef>] 
    object removed is: #<Object java.lang.Object@c7aaef> 
    () 

Answer 2

Sembra molto simile a quello che stai descrivendo è callback.

Qualcosa di simile:

(defn make-object 
    [destructor-fn] 
    {:destructor destructor-fn :other-data "data"}) 

(defn destroy-object 
    [obj] 
    ((:destructor obj) obj)) 

; somewhere at the calling code... 

user> (defn my-callback [o] (pr [:destroying o])) 
#'user/my-callback 
user> (destroy-object (make-object my-callback)) 
[:destroying {:destructor #<user$my_callback user$my_callback@73b8cdd5>, :other-data "data"}] 
nil 
user> 

Answer 3

Quindi, ecco la mia soluzione finale seguendo il suggerimento mobytes. Un po 'più di lavoro, ma Sospetto che lo vorrò in futuro.

Grazie per tutto l'aiuto

;; hook system 
(defn make-hook [] 
    (atom [])) 

(defn add-hook [hook func] 
    (do 
    (when-not 
     (some #{func} @hook) 
     (swap! hook conj func)) 
    @hook)) 

(defn remove-hook [hook func] 
    (swap! hook 
     (partial 
      remove #{func}))) 

(defn clear-hook [hook] 
    (reset! hook [])) 

(defn run-hook 
    ([hook] 
     (doseq [func @hook] (func))) 
    ([hook & rest] 
     (doseq [func @hook] (apply func rest)))) 

(defn phils-hook [] 
    (println "Phils hook")) 

(defn phils-hook2 [] 
    (println "Phils hook2")) 


(def test-hook (make-hook)) 
(add-hook test-hook phils-hook) 
(add-hook test-hook phils-hook2) 
(run-hook test-hook) 
(remove-hook test-hook phils-hook) 
(run-hook test-hook)