   "Lifts a function to a monadic context.
 
       (require '[cats.types :as t])
-
-      (def monad+ (lift-m +))
+      (require '[cats.core :as m])
+
+      (def monad+ (m/lift-m +))
 
       (monad+ (t/just 1) (t/just 2))
       ;=> <Just [3]>

  Otherwise, returns the instance unchanged.

      (require '[cats.types :as t])

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

      (filter-m (partial < 4) (t/just 3))
      ;=> <Nothing>
  "
  [p mv]

            (return []))
          mvs))

(defn map-m
   "Given a function that takes a value and puts it into a
   monadic context, map it into the given collection
   calling sequence-m on the results.

       (require '[cats.types :as t])
       (require '[cats.core :as m])

       (m/map-m t/just [2 3])
       ;=> <Just [[2 3]]>

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

(defn for-m
  "Same as map-m but with the arguments in reverse order.

      (require '[cats.types :as t])
      (require '[cats.core :as m])

      (m/for-m [2 3] t/just)
      ;=> <Just [[2 3]]>

      (m/for-m [1 2]
               (fn [v]
                  (if (odd? v)
                    (t/just v)
                    (t/nothing))))
      ;=> <Nothing>
   "
  [vs mf]
  (map-m mf vs))

