Try-with-resources in Clojure

Question

Does Clojure have an equivalent of Java's try-with-resources construct?

If not, what is the normal way to handle this idiom in Clojure code?

The pre-Java-7 idiom for safely opening and closing resources is verbose enough that they actually added support for try-with-resources to the language. It seems strange to me that I can't find a macro for this use case in the standard Clojure library.

An example to a mainstream Clojure-based project repository—showing how this issue is handled in practice—would be very helpful.

Answer 1

You can use with-open to bind a resource to a symbol and make sure the resource is closed once the control flow left the block.

The following example is from 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)))))

This will be expanded to the following:

(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))))

You can see that a let block is created with a try-finally to the call .close() method.

Answer 2

you can do something more close to java, making up some macro on top of with-open. It could look like this:

(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)))

so you can pass additional clauses alongside the binding.

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

expands to simple with-open:

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

while additional clauses lead to wrapping the it in try-catch:

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

expands to

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

But still it is quite an opinionated solution.