 
   This is multiarity function that with arity pure/1
   it uses the dynamic scope to resolve the current
-  context. With pure/2, you can force a specific context
+  context. With `pure/2`, you can force a specific context
   value."
   ([v] (pure (get-current-context) v))
   ([ctx v] (p/pure ctx v)))


  Otherwise, returns the instance unchanged.

    (require '[cats.monad.moaybe :as maybe])
    (require '[cats.core :as m])

    (m/filter (partial < 2) (maybe/just 3))
    ;=> <Just [3]>

    (m/filter (partial < 4) (maybe/just 3))
    ;=> <Nothing>
  "
  [p mv]
  (with-monad (get-current-context mv)

   monadic context, map it into the given collection
   calling sequence on the results.

       (require '[cats.monad.maybe :as maybe])
       (require '[cats.core :as m])

       (m/mapseq maybe/just [2 3])
       ;=> <Just [[2 3]]>

       (m/mapseq (fn [v]
                    (if (odd? v)
                      (maybe/just v)
                      (maybe/nothing)))
                   [1 2])
       ;=> <Nothing>
  "
  [mf coll]
  (sequence (map mf coll)))

(defn forseq
  "Same as mapseq but with the arguments in reverse order.

      (require '[cats.monad.maybe :as maybe])
      (require '[cats.core :as m])

      (m/forseq [2 3] maybe/just)
      ;=> <Just [[2 3]]>

      (m/forseq [1 2]
                (fn [v]
                  (if (odd? v)
                    (maybe/just v)
                    (maybe/nothing))))
      ;=> <Nothing>
  "
  [vs mf]
  (mapseq mf vs))
