    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]
+       (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)))
-                 [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>
+                    (maybe/nothing))))
+      ;=> <Nothing>
   "
   [vs mf]
   (mapseq mf vs))

  "Lifts a function with the given fixed number of arguments to a
  monadic context.

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

    (def monad+ (m/lift-m 2 +))

    (monad+ (maybe/just 1) (maybe/just 2))
    ;=> <Just [3]>

    (monad+ (maybe/just 1) (maybe/nothing))
    ;=> <Nothing>

    (monad+ [0 2 4] [1 2])
    ;=> [1 2 3 4 5 6]
  "
  [n f]
  (let [val-syms (repeatedly n gensym)


  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
  value."
  ([v] (pure (get-current-context) v))
  ([ctx v] (p/pure ctx v)))
