क्लोजर: अपवाद पर पुनरावृत्ति कैसे करें?

Question

अपवादों को छोड़ने से पहले मैं कई बार एक func निष्पादित करने की कोशिश कर रहा हूं। लेकिन क्लोजर में कैच ब्लॉक से पुनरावृत्ति करने के लिए यह वैध नहीं है। यह कैसे प्राप्त किया जा सकता है?

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

Answer 1

मैक्रो बुला रहे हैं ... है

कैसे इस बारे में:

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

Answer 2

कोटरक का विचार जाने का तरीका है, लेकिन इस सवाल ने मेरी कल्पना को गुदगुदी कर दिया ताकि मैं एक ही विषय पर एक रिफ प्रदान करना चाहूंगा मैं पसंद करते हैं क्योंकि यह पाश/पुनरावृत्ति होना का उपयोग नहीं करता:

(defn try-times* [thunk times] 
    (let [res (first (drop-while #{::fail} 
           (repeatedly times 
              #(try (thunk) 
               (catch Throwable _ ::fail)))))] 
    (when-not (= ::fail res) 
     res))) 

और कोशिश बार मैक्रो वैसा ही छोड़ दें।

यदि आप थंक को वापस लौटने की अनुमति देना चाहते हैं, तो आप चलो/जब जोड़ी छोड़ सकते हैं, और चलो :: असफल "फ़ंक्शन असफल एन बार" का प्रतिनिधित्व करते हैं, जबकि नील का अर्थ है "फ़ंक्शन शून्य वापस आ गया"। यह व्यवहार और अधिक लचीला लेकिन कम सुविधाजनक हो सकता है (फोन करने वाले के लिए :: यदि यह सिर्फ शून्य के बजाय काम को देखने के लिए असफल जाँच करने के लिए है), इसलिए शायद यह सबसे अच्छा एक वैकल्पिक दूसरे पैरामीटर के रूप में लागू किया जाएगा:

(defn try-times* [thunk n & fail-value] 
    (first (drop-while #{fail-value} ...))) 

Answer 3

मेरा प्रस्ताव है कि:

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

"यहाँ कोई त्रुटि" प्रिंट होगा एक बार:

(try-times 3 (println "no errors here") 42) 

प्रिंट होगा "की कोशिश कर रहा" 3 बार, फिर शून्य से विभाजित फेंक:

(try-times 3 (println "trying") (/ 1 0)) 

Answer 4

एक और समाधान, बिना मैक्रो

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

Answer 5

एक try-times मैक्रो सुरुचिपूर्ण है, लेकिन एक बंद के लिए, बस try ब्लॉक से बाहर अपने when खींच:

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