(david-mcneil.com :blog)

Clojure try/finally usage

If you are writing Clojure code and find that you need to ensure that you call a cleanup function of some sort, then your first choice should be to use with-open if possible. However, let’s assume that is not what we are doing. Instead let us assume that invoking a function to create a resource of some sort also returns a function that will cleanup that resource. Something like this:

(defn setup-resource [n]
  (println (str "setup " n))
  (fn []
    (println (str "cleaned up " n))))

To use this we can do the following:

;; bad code
(let [cleanup-f (setup-resource 1)]
  (cleanup-f))
;; => setup 1
;; => cleaned up 1

That works fine as long as no exceptions are thrown, but in the following code the cleanup is never called.

;; bad code
(let [cleanup-f (setup-resource 1)]
  (/ 1 0)
  (cleanup-f))
;; => setup 1

An exception is thrown and our call to cleanup-f never happens.

To correct this we can use try/finally.

;; good code
(let [cleanup-f (setup-resource 1)]
  (try
    (/ 1 0)
    (finally
      (cleanup-f))))
;; => setup 1
;; => cleaned up 1

So even though an exception is thrown, we still cleanup the resource. Note however that the try must immediately follow the call to setup the resource. If we allow code to creep in between the setup call and the try then we are vulnerable to not cleaning up the resource.

;; bad code
(let [cleanup-f (setup-resource 1)]
  (/ 1 0)
  (try
    (finally
      (cleanup-f))))
;; => setup 1

Even if the additional code is in the let itself, we are still vulnerable:

;; bad code
(let [cleanup-f (setup-resource 1)
      _ (/ 1 0)]
  (try
    (finally
      (cleanup-f))))
;; => setup 1

So the lesson is that the try/finally must appear immediately after the function that sets up the resource.

There is a related rule regarding dealing with multiple resources. You might, naively, write code like the following.

;; bad code
(let [cleanup-f1 (setup-resource 1)
      cleanup-f2 (setup-resource 2)]
  (try
    (finally
      (cleanup-f1)
      (cleanup-f2))))
;; => setup 1
;; => setup 2
;; => cleaned up 1
;; => cleaned up 2

While this code apparently works for the happy path, it fails in the face of exceptions.

For example, if the setup function has behavior that causes it to throw when the second resource is created

(defn setup-resource [n]
  (when (= n 2)
    (throw (RuntimeException.)))
  (println (str "setup " n))
  (fn []
    (println (str "cleaned up " n))))

;; bad code
(let [cleanup-f1 (setup-resource 1)
      cleanup-f2 (setup-resource 2)]
  (try
    (finally
      (cleanup-f1)
      (cleanup-f2))))
;; => setup 1

The first resource is setup, but never cleaned up.

This same code also is not ideal when one of the cleanup functions throws. For example, if the code behaved like this:

(defn setup-resource [n]
  (println (str "setup " n))
  (fn []
    (when (= n 1)
      (throw (RuntimeException.)))
    (println (str "cleaned up " n))))

;; bad code
(let [cleanup-f1 (setup-resource 1)
      cleanup-f2 (setup-resource 2)]
  (try
    (finally
      (cleanup-f1)
      (cleanup-f2))))
;; => setup 1
;; => setup 2

The first cleanup call threw an exception, which in turn caused us not to call the second cleanup function.

This could be addressed by wrapping the cleanup calls in their own try/finally blocks.

;; good code
(let [cleanup-f1 (setup-resource 1)
      cleanup-f2 (setup-resource 2)]
  (try
    (finally
      (try (cleanup-f1)
           (finally
             (cleanup-f2))))))
;; => setup 1
;; => setup 2
;; => cleaned up 2

Now we see that we do as much cleanup as we can. Even though the call to cleanup-f1 threw an exception we still cleanup the second resource

An alternate pattern is to introduce a new try/finally for each resource created.

;; change this to fail on resource 2, since it will be cleaned up first in this new pattern
(defn setup-resource [n]
  (println (str "setup " n))
  (fn []
    (when (= n 2)
      (throw (RuntimeException.)))
    (println (str "cleaned up " n))))


;; good code
(let [cleanup-f1 (setup-resource 1)]
  (try
    (let [cleanup-f2 (setup-resource 2)]
      (try
        (finally
          (cleanup-f2))))
    (finally
      (cleanup-f1))))
;; => setup 1
;; => setup 2
;; => cleaned up 1

Again, we did as much cleanup as we could in the face of the exception thrown when cleaning up the second resource.

This final approach matches the first rule that was introduced above, as soon as a resource is created, the next statement needs to be a try/finally that cleans that resource up.

Finally, consider this pattern in light of an exception in the middle of the code

;; change this back to never throw
(defn setup-resource [n]
  (println (str "setup " n))
  (fn []
    (println (str "cleaned up " n))))

(let [cleanup-f1 (setup-resource 1)]
  (try
    (let [cleanup-f2 (setup-resource 2)]
      (try
        (/ 1 0)
        (finally
          (cleanup-f2))))
    (finally
      (cleanup-f1))))
;; => setup 1
;; => setup 2
;; => cleaned up 2
;; => cleaned up 1

Even though an exception was thrown in the body of the try, all of the resources are cleaned up.