Try-with-resources dans Clojure

Question

Est-ce que Clojure a un équivalent de construction try-with-resources de Java? Si ce n'est pas le cas, quelle est la manière normale de gérer ce langage dans le code de Clojure?

L'idiome pré-Java-7 pour l'ouverture et la fermeture de ressources en toute sécurité est suffisamment détaillé pour qu'ils ajoutent un support pour les ressources d'essai au langage. Il me semble étrange que je ne trouve pas de macro pour ce cas d'utilisation dans la bibliothèque Clojure standard.

Un exemple pour un référentiel de projet basé sur Clojure, qui montre comment ce problème est traité dans la pratique, serait très utile.

Answer 1

Vous pouvez utiliser with-open pour lier une ressource à un symbole et vous assurer que la ressource est fermée une fois que le flux de contrôle a quitté le bloc.

L'exemple suivant provient de clojuredocs.

(with-open [r (clojure.java.io/input-stream "myfile.txt")] 
    (loop [c (.read r)] 
     (when (not= c -1) 
     (print (char c)) 
     (recur (.read r))))) 

Ce sera étendu à ce qui suit:

(let [r (clojure.java.io/input-stream "myfile.txt")] 
    (try 
    (loop [c (.read r)] 
     (when (not= c -1) 
     (print (char c)) 
     (recur (.read r)))) 
    (finally (.close r)))) 

Vous pouvez voir qu'un bloc let est créé avec un try - finally la méthode appel .close().

Answer 2

vous pouvez faire quelque chose de plus proche de Java, en faisant de la macro au-dessus de with-open. Il pourrait ressembler à ceci:

(defmacro with-open+ [[var-name resource & clauses] & body] 
    (if (seq clauses) 
    `(try (with-open [~var-name ~resource] ~@body) 
      ~@clauses) 
    `(with-open [~var-name ~resource] ~@body))) 

de sorte que vous pouvez passer des clauses supplémentaires à côté de la liaison.

(with-open+ [x 111] 
    (println "body")) 

étend à de simples with-open:

(let* 
    [x 111] 
    (try (do (println "body")) (finally (. x clojure.core/close)))) 

tandis que des clauses supplémentaires conduisent à envelopper le dans try-catch:

(with-open+ [x 111 
      (catch RuntimeException ex (println ex)) 
      (finally (println "finally!"))] 
    (println "body")) 

étend à

(try 
    (let* 
    [x 111] 
    (try (do (println "body")) (finally (. x clojure.core/close)))) 
    (catch RuntimeException ex (println ex)) 
    (finally (println "finally!"))) 

Mais encore c'est plutôt un avis solution ed.