   same as mlet but specifying the monadic context.
   So, instead of writing:
 
-    (with-monad (maybe-transformer vector-monad)
-      (mlet [a [(just 1) (just 2)]
-             b [(just (inc a))]]
-        (return (* b 2))))
-    ;=> [#<Just [4]> #<Just [6]>]
+      (with-monad (maybe-transformer vector-monad)
+        (mlet [a [(just 1) (just 2)]
+               b [(just (inc a))]]
+          (return (* b 2))))
+      ;=> [#<Just [4]> #<Just [6]>]
 
   You can just write:
 
-    (mlet-with (maybe-transformer vector-monad)
-      [a [(just 1) (just 2)]
-       b [(just (inc a))]]
-      (return (* b 2)))
-    ;=> [#<Just [4]> #<Just [6]>]
+      (mlet-with (maybe-transformer vector-monad)
+        [a [(just 1) (just 2)]
+         b [(just (inc a))]]
+        (return (* b 2)))
+      ;=> [#<Just [4]> #<Just [6]>]
   "
   [monad bindings & body]
   `(with-monad ~monad

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


  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)
