missionary is agnostic to that. I.e. If you don't have any blocking calls it will not block. If you have a blocking call you should use m/via

do you have a specific snippet?

(defn fetch-text []
  (Thread/sleep 2000)
  {:text "A text"})

(defn create-context []
  {:page (future (fetch-text))})

(def ctx (create-context))

;; Later

@(:page ctx)

so the goal is to run a task once and use the result multiple times ?

Yes

Currently, you can emulate future semantics with dfv :

(def fetch-text (m/sleep 2000 {:text "A text"}))

(defn create-context []
  (let [v (m/dfv)]
    (fetch-text v #(.printStackTrace ^Throwable %))
    {:page v}))

(def ctx (create-context))

(m/? (:page ctx))

However, this is not a pattern I want to encourage, because it breaks supervision. The solution I have in mind is a new construct called memo which memoizes a task result like future but the underlying process starts lazily and is cancelled when it has no more subscriber, this would look like this :

(defn create-context []
  {:page (m/memo fetch-text)})

Thanks for the info.

Hi! For the moment, you recommend to use future directly?

Sorry for confusion. future breaks supervision in the exact same way, so it is exactly as bad as dfv, which is still my current recommendation. Use this pattern https://github.com/leonoel/missionary/wiki/Task-interop#futures-promises-1

(defn future! [t]
  (let [v (m/dfv)]
    (t #(v (fn [] %)) #(v (fn [] (throw %))))
    (m/absolve v)))

(defn create-context []
  {:page (future! (fetch-text))})

clojure's future would work too but blocking more threads than needed

In your example fetch-text is a task, right?

function returning task