   (fn [state]
     (apply util/sprintf fmt
            (for [arg args]
-             (force
-               (arg state))))
+             (arg state)))
     (flush)
     (terminate? state)))
 

  [terminate? cutoff params]
  (fn [state]
    (or (terminate? state)
        (<= (m/distance (- (force (:params state))
                           params))
            cutoff))))


         initial-step true]
    (let [function (cp/update-parameters function params)
          gradient (cp/gradient function)
          state (util/->lazy-map
                  (merge
                    (if-not initial-step
                      (merge
                        ;; This *needs* to be first, because lazy maps will be coerced
                        ;; to regular maps if they appear in the tail of a merge, and
                        ;; the map returned by get-state might be lazy.
                        (cp/get-state optimiser)
                        {:last-step (delay (- params last-params))}))
                    {:params params
                     :value (delay (cp/output function))
                     :gradient gradient
                     :optimiser optimiser
                     :initial-step initial-step}))]
      (if-not (terminate? state)
        (let [optimiser (cp/compute-parameters optimiser gradient params)
              new-params (cp/parameters optimiser)]
