Podania stan kompilacji czas pomiędzy zagnieżdżonych makr w Clojure

Question

Próbuję napisać makro, które mogą być wykorzystywane zarówno w globalnym i zagnieżdżonego sposób, jak w przykładzie:

;;; global: 
(do-stuff 1) 

;;; nested, within a "with-context" block: 
(with-context {:foo :bar} 
    (do-stuff 2) 
    (do-stuff 3)) 

Przy stosowaniu w zagnieżdżonej sposób, do-stuff powinien mieć dostęp do {:foo :bar} zestawu przez with-context.

byłem w stanie realizować to tak:

(def ^:dynamic *ctx* nil) 

(defmacro with-context [ctx & body] 
    `(binding [*ctx* ~ctx] 
    (do ~@body))) 

(defmacro do-stuff [v] 
    `(if *ctx* 
    (println "within context" *ctx* ":" ~v) 
    (println "no context:" ~v))) 

Jednak ja już próbuje przesunąć if ciągu do-stuff od wykonywania na czasie kompilacji, bo czy do-stuff jest nazywany od wewnątrz treść with-context lub globalnie jest informacją, która jest już dostępna podczas kompilacji.

Niestety, nie udało się znaleźć rozwiązanie, gdyż zagnieżdżone makra wydają się rozszerzył w wielu seriach „makr”, więc wiązanie *ctx* (jak określono w ciągu with-context) dynamiczny nie jest dostępny już przy do-stuff zostaje rozszerzony. Więc to nie działa:

(def ^:dynamic *ctx* nil) 

(defmacro with-context [ctx & body] 
    (binding [*ctx* ctx] 
    `(do ~@body))) 

(defmacro do-stuff [v] 
    (if *ctx* 
    `(println "within context" ~*ctx* ":" ~v) 
    `(println "no context:" ~v))) 

Jakieś pomysły, jak to osiągnąć?

Czy moje podejście jest całkowicie szalone i istnieje wzorzec, w jaki sposób przekazywać stan w taki sposób, od jednego makra do zagnieżdżonego?

EDIT:

Ciało with-context powinien być w stanie pracować z dowolnych wyrażeń, nie tylko z do-stuff (lub innym kontekście świadomych funkcji/makr). Więc coś jak to powinno być również możliwe:

(with-context {:foo :bar} 
    (do-stuff 2) 
    (some-arbitrary-function) 
    (do-stuff 3)) 

(Jestem świadomy, że some-arbitrary-function chodzi o skutki uboczne, to może napisać coś do bazy danych, na przykład).

Answer 1

Gdy kod jest macroexpanded, Clojure computesfixpoint:

(defn macroexpand 
    "Repeatedly calls macroexpand-1 on form until it no longer 
    represents a macro form, then returns it. Note neither 
    macroexpand-1 nor macroexpand expand macros in subforms." 
    {:added "1.0" 
    :static true} 
    [form] 
    (let [ex (macroexpand-1 form)] 
     (if (identical? ex form) 
     form 
     (macroexpand ex)))) 

Wszelkie wiążące można ustalić w trakcie wykonywania makra nie jest bardziej na miejscu po wyjściu z makra (dzieje się to wewnątrz macroexpand-1). Do czasu rozbudowy wewnętrznego makra kontekst już dawno minął.

Można jednak zadzwonić bezpośrednio pod numer macroexpand, w którym to przypadku połączenie będzie nadal skuteczne. Pamiętaj jednak, że w twoim przypadku prawdopodobnie musisz zadzwonić pod numer macroexpand-all. This answer objaśnia różnice między macroexpand i clojure.walk/macroexpand-all: w zasadzie musisz upewnić się, że wszystkie wewnętrzne formy są makroexanded. Kod źródłowy dla macroexpand-all pokazuje how it is implemented.

Tak, można zaimplementować makra w następujący sposób:

(defmacro with-context [ctx form] 
    (binding [*ctx* ctx] 
    (clojure.walk/macroexpand-all form))) 

W takim przypadku, dynamiczne wiązanie powinno być widoczne od wewnątrz wewnętrznych makr.

Answer 2

bym keep it simple. To rozwiązanie pozwala uniknąć stanu w dodatkowej zmiennej *ctx*. Myślę, że to bardziej funkcjonalne podejście.

(defmacro do-stuff 
    ([arg1 context] 
    `(do (prn :arg1 ~arg1 :context ~context)) 
     {:a 4 :b 5}) 
    ([arg1] 
    `(prn :arg1 ~arg1 :no-context))) 

(->> {:a 3 :b 4} 
    (do-stuff 1) 
    (do-stuff 2)) 

wyjściowa:

:arg1 1 :context {:a 3, :b 4} 
:arg1 2 :context {:b 5, :a 4} 

Answer 3

jest jeszcze jeden wariant, aby to zrobić, stosując pewne makro magii:

(defmacro with-context [ctx & body] 
    (let [ctx (eval ctx)] 
    `(let [~'&ctx ~ctx] 
     (binding [*ctx* ~ctx] 
     (do ~@body))))) 

w tej definicji wprowadzamy inny let wiążące dla ctx. System makro Clojure następnie umieściłby go w zmiennej &env, dostępnej przez wewnętrzne makra podczas kompilacji. Zauważ, że zachowujemy także bindings, aby mogły z niego korzystać wewnętrzne funkcje.

teraz musimy zdefiniować funkcję, aby uzyskać wartość kontekstowego z makra &env:

(defn env-ctx [env] 
    (some-> env ('&ctx) .init .eval)) 

a następnie można łatwo określić do-stuff:

(defmacro do-stuff [v] 
    (if-let [ctx (env-ctx &env)] 
    `(println "within context" ~ctx ":" ~v) 
    `(println "no context:" ~v))) 

w repl:

user> (defn my-fun [] 
     (println "context in fn is: " *ctx*)) 
#'user/my-fun 

user> (defmacro my-macro [] 
     `(do-stuff 100)) 
#'user/my-macro 

user> (with-context {:a 10 :b 20} 
     (do-stuff 1) 
     (my-fun) 
     (my-macro) 
     (do-stuff 2)) 
;;within context {:a 10, :b 20} : 1 
;;context in fn is: {:a 10, :b 20} 
;;within context {:a 10, :b 20} : 100 
;;within context {:a 10, :b 20} : 2 
nil 

user> (do (do-stuff 1) 
      (my-fun) 
      (my-macro) 
      (do-stuff 2)) 
;;no context: 1 
;;context in fn is: nil 
;;no context: 100 
;;no context: 2 
nil