       (-> (c/new-request handler)
           (c/to :get :endpoint)
           c/send
-          (c/then :success [response
-                    (write-success-to-log (:body response))
-                    response]
-
-                  :pass-failure))
+          (c/then
+            :success [response
+                       (write-success-to-log (:body response))
+                      response]
+
+            :pass-failure))
 
 
   It is necessary to provide a handler for all success and failure cases; an unmatched status code

  makes it easier to work with that channel, branching based on status code, and returning a new
  result from the channel.

  then makes use of <! (to park until the response form the channle is available),
  and can therefore only be used inside a go block. Use [[then*]] outside of a go block.

  channel - the expression which produces the channel, e.g., the result of invoking [[send]].

  A clause can either be :pass-success, :pass-failure, or a status code followed by vector.
  The first elmeent in the vector is a symbol to which the response will be bound before evaluating
  the other forms in the vector. The result of the then block is the value of the last form
  in the selected block.

  Instead of a status code, you may use :success (any 2xx status code), :failure (any other
  status code), or :else (which matches regardless of status code).

  :pass-success is equvalent to :success [x x] and :pass-failure is equivalent to :failure [x x].


  (let [->cond-block' (partial ->cond-block form response-sym)]
    (loop [cond-clauses []
           [selector clause-block & remaining-clauses] clauses]
      (case selector
        nil cond-clauses

        :else
        (recur (conj cond-clauses true (->cond-block' clause-block))
               remaining-clauses)

        :success
        (recur (conj cond-clauses
                     `(is-success? ~status-sym)
                     (->cond-block' clause-block))
               remaining-clauses)

        :failure
        (recur (conj cond-clauses
                     `(not (is-success? ~status-sym))
                     (->cond-block' clause-block))
               remaining-clauses)

        :pass-success
        (recur (conj cond-clauses
                     `(is-success? ~status-sym)
                     response-sym)
               ;; There is no clause block after :pass-success or :pass-failure
               (cons clause-block remaining-clauses))

        :pass-failure
        (recur (conj cond-clauses
                     `(not (is-success? ~status-sym))
                     response-sym)
               ;; There is no clause block after :pass-success or :pass-failure
               (cons clause-block remaining-clauses))

        (recur (conj cond-clauses
                     `(= ~status-sym ~selector)
                     (->cond-block' clause-block))
