Clojure中的未来失败

Question

在Scala中，未来可能会失败，这可以异步发现：

f onComplete {
  case Success(_) => println("Great!")
  case Failure(t) => println("An error has occurred: " + t.getMessage)
}

你将如何“翻译”成Clojure？我的阅读让我相信Clojure未来/promise模型没有Scala的强大，你不能就这样抓住失败。那么该怎么办呢？

Scala的未来永远不需要被问到它的价值——当它好并准备好时，它会告诉你发生了什么（包括它是否失败——这是这个问题的关键）。这就是我所说的“异步”的意思。Scala的未来可以处于三种可能的状态之一——未完成、以失败告终、以成功告终。

Scala中一个典型的用例是一个返回Future[T]的远程调用，其中T是你真正想要得到的类型。如果远程JVM关闭，那么在超时之后，将会发生< code>case Failure(t)。

这是一个非常简单的模型。在这个问题中，我问的是一个简单的选择。顺便提一下，听说Clojure打算在某个时候采用Scala Futures模型是件好事。

Answer 1

未来宏只是包装一个Java未来，而deref阅读器宏只是针对未来调用. get（）的语法糖：

user=> (source future)
(defmacro future
  "Takes a body of expressions and yields a future object that will
  invoke the body in another thread, and will cache the result and
  return it on all subsequent calls to deref/@. If the computation has
  not yet finished, calls to deref/@ will block, unless the variant of
  deref with timeout is used. See also - realized?."
  {:added "1.1"}
  [& body] `(future-call (^{:once true} fn* [] ~@body)))
nil
user=> (source future-call)
(defn future-call 
  "Takes a function of no args and yields a future object that will
  invoke the function in another thread, and will cache the result and
  return it on all subsequent calls to deref/@. If the computation has
  not yet finished, calls to deref/@ will block, unless the variant
  of deref with timeout is used. See also - realized?."
  {:added "1.1"
   :static true}
  [f]
  (let [f (binding-conveyor-fn f)
        fut (.submit clojure.lang.Agent/soloExecutor ^Callable f)]
    (reify 
     clojure.lang.IDeref 
     (deref [] (deref-future fut)) clojure.lang.IBlockingDeref (deref [ timeout-ms timeout-val]
      (deref-future fut timeout-ms timeout-val))
     clojure.lang.IPending
     (isRealized [] (.isDone fut)) java.util.concurrent.Future (get [] (.get fut))
      (get [_ timeout unit] (.get fut timeout unit))
      (isCancelled [] (.isCancelled fut)) (isDone [] (.isDone fut))
      (cancel [_ interrupt?] (.cancel fut interrupt?)))))
nil
user=>

因此，测试失败与在java中没有什么不同:您捕捉到一个< code>ExecutionException，请参阅java文档以了解更多信息:

http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Future.html#get（）

因此，解决方案是从 deref 中捕获异常，如其他答案所示。

Answer 2

我想知道Clojure是否需要特定的结构来处理这种失败期货的情况。以下行为我提供了相同的功能：

(defn f-cond[f func-ok func-fail] 
   (future (try (func-ok @f) (catch Exception e (func-fail e))))) 

然后：

@(f-cond (future (throw (Exception. "hi"))) 
   identity #(println "Failed: " (.getCause %)))

结果

Failed:  #<Exception java.lang.Exception: hi>

Answer 3

我记得Scala中的期货是单子，所以在< code>algo.monads和< code > fluo kiten 中搜索合适的东西。最后，我找到了雷纳多·博尔赫斯的《迫在眉睫》图书馆。我想这是你想要的。

有了这个名称空间声明

(ns imminent-proof.core
  (:require [imminent.core :as i]
            [clojure.core.match :refer [match]])
  (:import  [imminent.result Success Failure]))

这就是失败案例

(-> (i/future (/ 1 0))
    (i/on-complete #(match [%]
                     [{Success v}] (prn "success: " v)
                     [{Failure e}] (prn "failure: " e))))

这就是成功的例子

(-> (i/future (Thread/sleep 1000) 42)
    (i/on-complete #(match [%]
                     [{Success v}] (prn "success: " v)
                     [{Failure e}] (prn "failure: " e))))

这是超时的情况

(-> (i/future (Thread/sleep 1000) 42)
    (i/await 500)
    (i/on-complete #(match [%]
                     [{Success v}] (prn "success: " v)
                     [{Failure e}] (prn "failure: " e))))