我试图在遇到异常前多次执行一个函数，但在Clojure中从catch块中进行recur不被认为是有效的。如何实现这一点？
(loop [tries 10]
(try
(might-throw-exception)
(catch Exception e
(when (pos? tries) (recur (dec tries))))))
java.lang.UnsupportedOperationException: Cannot recur from catch/finally
我能找到的最好解决方案是以下笨拙的方法（将其包装在函数中并调用它）
(defn do-it []
(try
(might-throw-exception)
(catch Exception e nil)))
(loop [times 10]
(when (and (nil? (do-it)) (pos? times))
(recur (dec times))))
宏调用...
这样怎么样：
(defn try-times*
"Executes thunk. If an exception is thrown, will retry. At most n retries
are done. If still some exception is thrown it is bubbled upwards in
the call chain."
[n thunk]
(loop [n n]
(if-let [result (try
[(thunk)]
(catch Exception e
(when (zero? n)
(throw e))))]
(result 0)
(recur (dec n)))))
(defmacro try-times
"Executes body. If an exception is thrown, will retry. At most n retries
are done. If still some exception is thrown it is bubbled upwards in
the call chain."
[n & body]
`(try-times* ~n (fn [] ~@body)))kotarak的想法是可行的，但这个问题引起了我的兴趣，我想提供一个同样的主题来改进它，因为它不使用循环/递归：
(defn try-times* [thunk times]
(let [res (first (drop-while #{::fail}
(repeatedly times
#(try (thunk)
(catch Throwable _ ::fail)))))]
(when-not (= ::fail res)
res)))
保持try-times宏不变。
如果你想允许thunk返回nil，可以去掉let/when对，并让::fail表示“函数连续失败n次”，而nil则表示“函数返回了nil”。这种行为会更加灵活但不太方便（调用者必须检查::fail来确定是否成功，而不能只是检查nil），因此最好实现为可选的第二个参数：
(defn try-times* [thunk n & fail-value]
(first (drop-while #{fail-value} ...)))
一个try-times宏是优雅的，但对于一次性的操作，只需将您的when从try块中取出：
(loop [tries 10]
(when (try
(might-throw-exception)
false ; so 'when' is false, whatever 'might-throw-exception' returned
(catch Exception e
(pos? tries)))
(recur (dec tries))))
我的建议：
(defmacro try-times
"Retries expr for times times,
then throws exception or returns evaluated value of expr"
[times & expr]
`(loop [err# (dec ~times)]
(let [[result# no-retry#] (try [(do ~@expr) true]
(catch Exception e#
(when (zero? err#)
(throw e#))
[nil false]))]
(if no-retry#
result#
(recur (dec err#))))))
一旦运行，将会打印出“no errors here”：
(try-times 3 (println "no errors here") 42)
将会打印3次"trying"，然后抛出除以零错误：
(try-times 3 (println "trying") (/ 1 0))
还有一种解决方案，不需要宏
(defn retry [& {:keys [fun waits ex-handler]
:or {ex-handler #(log/error (.getMessage %))}}]
(fn [ctx]
(loop [[time & rem] waits]
(let [{:keys [res ex]} (try
{:res (fun ctx)}
(catch Exception e
(when ex-handler
(ex-handler e))
{:ex e}))]
(if-not ex
res
(do
(Thread/sleep time)
(if (seq rem)
(recur rem)
(throw ex))))))))
result的参数，您可以将(try)块嵌套在(recur)中。我是这样解决的：(loop [result nil tries 10]
(cond (some? result) result
(neg? tries) nil
:else (recur (try (might-throw-exception)
(catch Exception e nil))
(dec tries))))
(defmacro try-n-times
"Try running the body `n` times, catching listed exceptions."
{:style/indent [2 :form :form [1]]}
[n exceptions & body]
`(loop [n# ~n
causes# []]
(if (> n# 0)
(let [result#
(try
~@body
~@(map (partial apply list 'catch) exceptions (repeat `(e# e#))))]
(if (some #(instance? % result#) ~exceptions)
(recur (dec n#) (conj causes# result#))
result#))
(throw (ex-info "Maximum retries exceeded!"
{:retries ~n
:causes causes#})))))
这里是另一种方法：
(loop [tries 10]
(let [res (try
(might-throw-exception)
(catch Exception e
(if (pos? tries)
::retry
(throw e))))]
(if (#{::retry} res)
(recur (dec tries))
res)))
但我也可以推荐一个很酷的小技巧，不要设置重试次数，而是提供一系列休眠时间：
(loop [tries [10 10 100 1000]]
(let [res (try
(might-throw-exception)
(catch Exception e
(if tries
::retry
(throw e))))]
(if (#{::retry} res)
(do
(Thread/sleep (first tries))
(recur (next tries)))
res)))
(defmacro with-retries
[retries & body]
`(loop [retries# ~retries]
(let [res# (try ~@body
(catch Exception e#
(if retries#
'retry#
(throw e#))))]
(if (= 'retry# res#)
(do (Thread/sleep (first retries#))
(recur (next retries#)))
res#))))
(with-retries [10 10 100 1000]
(might-throw-exception))
#，以供调用者创建thunk。在Clojure中使用宏仅仅为了省略#是惯用的吗？ - Dax Fohl