Макрос потока отладки -> или - >> в Clojure

Question

Я хочу понять, как работает следующий код, предназначенный для задачи: «Учитывая последовательность целых чисел, найдите непрерывную подпоследовательность, которая максимизирует сумму ее элементов»

defn max-subseq-sum [coll]
(->> (take-while seq (iterate rest coll)) ; tails (1)
   (mapcat #(reductions conj [] %)) ; inits   (2)
   (apply max-key #(reduce + %)))) ; max sum

, поэтому я 'Хотелось бы увидеть вывод форм (1), (2) и других.Я могу установить контрольные точки в Cursive, но пока не знаю, как получить эти значения.Я пытался определить переменные локали, например,

(defn max-subseq-sum [coll]
 (->> (take-while seq (iterate rest coll)) ; tails
      (let [d #(reductions conj [] %)]
       d  ) ; inits
      (apply  max-key #(reduce + %)))
 )

(max-subseq-sum [-1, -2, 3, 5, 6, -2, -1, 4, -4, 2, -1])

Но я до сих пор не понимаю, как увидеть d, например

Как решить эту проблему?

Answer 1

Есть хорошая библиотека под названием debux

(use '[debux.core])

(defn max-subseq-sum [coll]
    (dbg (->> (take-while seq (iterate rest coll))                 ; tails (1)
          (mapcat #(reductions conj [] %))                        ; inits   (2)
          (apply max-key #(reduce + %)))))

(max-subseq-sum [1 2 3])


dbg: (->> (take-while seq (iterate rest coll)) (mapcat (fn* [p1__1991#] (re ... =>
| (take-while seq (iterate rest coll)) =>
|   ([1 2 3] (2 3) (3))
| (mapcat (fn* [p1__1991#] (reductions conj [] p1__1991#))) =>
|   ([] [1] [1 2] [1 2 3] [] [2] [2 3] [] [3])
| (apply max-key (fn* [p1__1992#] (reduce + p1__1992#))) =>
|   [1 2 3]

Answer 2

В цепочку можно вставить простую функцию, которая печатает и возвращает входные данные:

(defn debug [x]
  (println x)
  x)

(defn max-subseq-sum [coll]
  (->> (take-while seq (iterate rest coll))
       (debug)
       (mapcat #(reductions conj [] %))
       (apply max-key #(reduce + %))))

(max-subseq-sum [-1, -2, 3, 5, 6, -2, -1, 4, -4, 2, -1])
([-1 -2 3 5 6 -2 -1 4 -4 2 -1] (-2 3 5 6 -2 -1 4 -4 2 -1) (3 5 6 -2 -1 4 -4 2 -1) (5 6 -2 -1 4 -4 2 -1) (6 -2 -1 4 -4 2 -1) (-2 -1 4 -4 2 -1) (-1 4 -4 2 -1) (4 -4 2 -1) (-4 2 -1) (2 -1) (-1))
=> [3 5 6 -2 -1 4]

Или, если вы хотите улучшить отслеживание и не беспокоиться о небольшом объеме, вы можете использовать макросэто включает в себя выражение в распечатке:

(defmacro debugM [expr]
  `(let [x# ~expr] ; Save the result of the expression so it isn't evaluated twice
     (println '~expr "\n\t" x#)
     x#))

(defn max-subseq-sum [coll]
  (->> (take-while seq (iterate rest coll))
       (debugM)
       (mapcat #(reductions conj [] %))
       (apply max-key #(reduce + %))))

(max-subseq-sum [-1, -2, 3, 5, 6, -2, -1, 4, -4, 2, -1])
(take-while seq (iterate rest coll)) 
     ([-1 -2 3 5 6 -2 -1 4 -4 2 -1] (-2 3 5 6 -2 -1 4 -4 2 -1) (3 5 6 -2 -1 4 -4 2 -1) (5 6 -2 -1 4 -4 2 -1) (6 -2 -1 4 -4 2 -1) (-2 -1 4 -4 2 -1) (-1 4 -4 2 -1) (4 -4 2 -1) (-4 2 -1) (2 -1) (-1))
=> [3 5 6 -2 -1 4]