Блог

Я новичок в clojure и пытался решить проблему, когда вектор отображений

 ({:disease Asthma, :st-dt 2018-2-1, :en-dt 2018-4-1, :dose 0.25} 
{:disease Asthma, :st-dt 2018-3-1, :en-dt 2018-6-5, :dose 0.65} 
{:disease BP, :st-dt 2018-5-1, :en-dt 2018-9-1, :dose 0.75})
  

задано, и я должен получить неперекрывающиеся данные примерно так

 ({:disease Asthma, :st-dt 2018-2-1, :en-dt 2018-2-28, :dose 0.25} 
{:disease Asthma, :st-dt 2018-3-1, :en-dt 2018-4-1, :dose 0.25} 
{:disease Asthma, :st-dt 2018-3-1, :en-dt 2018-4-1, :dose 0.65} 
{:disease Asthma, :st-dt 2018-4-2, :en-dt 2018-4-30, :dose 0.65} 
{:disease Asthma, :st-dt 2018-5-1, :en-dt 2018-6-5, :dose 0.65} 
{:disease BP, :st-dt 2018-5-1, :en-dt 2018-6-5, :dose 0.75}
{:disease BP, :st-dt 2018-6-6, :en-dt 2018-9-1, :dose 0.75})
  

Я пробовал использовать цикл и повторять, но я думаю, что повторение в обоих условиях if невозможно.

 (defn ab [x] (let [temp x olap (f/overlap (f/interval ((first temp ):st-dt) ((first temp ):en-dt)) 
                                          (f/interval ((second temp):st-dt) ((second temp):en-dt) ))]
               (if olap 
                 (into [] (concat [{:med-type ((first temp ):med-type) :st-dt ((first temp ):st-dt)
                                    :en-dt (f/minus ((second temp) :st-dt) (f/days 1)) :dose ((first temp):dose )}
                                   {:med-type ((first temp ):med-type) :st-dt ((second temp ):st-dt)
                                    :en-dt ((first temp) :en-dt) :dose ((first temp):dose )}
                                   {:med-type ((second temp ):med-type) :st-dt ((second temp ):st-dt)
                                    :en-dt ((first temp) :en-dt) :dose ((second temp):dose )}
                                   {:med-type ((second temp ):med-type) :st-dt (f/plus ((first temp ):en-dt) (f/days 1))
                                    :en-dt ((second temp) :en-dt) :dose ((second temp):dose )}] 
                                  (into [] (rest (rest x))))))))
  

Чтобы просто ответить на вопрос (не вдаваясь в то, что вы пытаетесь реализовать): вы можете повторяться в любом положении хвоста, и обе ветви if находятся в положении хвоста. Вам просто нужно обработать базовый вариант, прежде чем:

 (loop [a arg]
  (if (base-case? a)
    a
    (if (my-pred? a)
      (recur (frob a))
      (recur (whozzle a)))))
  

Однако вы, вероятно, выразили бы это путем ветвления, чтобы аргумент повторился (но это работает так же).:

 (loop [a arg]
  (if (base-case? a)
    a
    (recur (if (my-pred? a)
             (frob a)
             (whozzle a)))))
  

Не отвечаю напрямую на ваш вопрос, но хотел бы предложить другой подход к решению проблемы:

 (->> [{:disease :Asthma :start 20 :end 41 :dose 0.25}
      {:disease :Asthma :start 31 :end 65 :dose 0.65}
      {:disease :BP :start 51 :end 91 :dose 0.75}]

     ;; EXPAND TO DATE SEQUENCE
     ;;
     (mapcat (fn [{:keys [start end] :as d}]
               (let [x (dissoc d :start :end)]
                 (map (partial assoc x :dt) (range start end)))))
     (sort-by :dt)

     ;; ({:disease :Asthma, :dose 0.25, :dt 20}
     ;;  {:disease :Asthma, :dose 0.25, :dt 21}
     ;;  {:disease :Asthma, :dose 0.25, :dt 22}

     ;; 'GROUP' SUBSCRIPTIONS BY DATE
     ;;
     (partition-by :dt)
     (map #(reduce (fn [s e] (update s :subscriptions conj (dissoc e :dt)))
                   {:subscriptions #{}
                    :dt            (-> % first :dt)}
                  %))
     (partition-by :subscriptions)

     ;; (({:subscriptions #{{:disease :Asthma, :dose 0.25}}, :dt 20}
     ;;   ...
     ;;   {:subscriptions #{{:disease :Asthma, :dose 0.25}}, :dt 30})
     ;;  ({:subscriptions
     ;;    #{{:disease :Asthma, :dose 0.25} {:disease :Asthma, :dose 0.65}},
     ;;    :dt 31}
     ;;    ...
     ;;   {:subscriptions
     ;;    #{{:disease :Asthma, :dose 0.25} {:disease :Asthma, :dose 0.65}},
     ;;    :dt 40})

     ;; GET BACK DATE RANGE FROM PARTITIONS OF SUBSCRIPTIONS
     ;;
     (map #(-> %
               first
               (dissoc :dt)
               (assoc :start (-> % first :dt)
                      :end (-> % last :dt))))

     ;; ({:subscriptions #{{:disease :Asthma, :dose 0.25}}, :start 20, :end 30}
     ;;  {:subscriptions
     ;;   #{{:disease :Asthma, :dose 0.25} {:disease :Asthma, :dose 0.65}},
     ;;   :start 31,
     ;;   :end 40}


     ;; FLATTEN THE LIST BY SUBSCRIPTIONS
     ;;
     (mapcat (fn [{:keys [subscriptions start end]}]
               (map #(assoc % :start start :end end) subscriptions)))
     (sort-by (juxt :start :disease :dose)))

    ;; ({:disease :Asthma, :dose 0.25, :start 20, :end 30}
    ;;  {:disease :Asthma, :dose 0.25, :start 31, :end 40}
    ;;  {:disease :Asthma, :dose 0.65, :start 31, :end 40}
    ;;  {:disease :Asthma, :dose 0.65, :start 41, :end 50}
    ;;  {:disease :Asthma, :dose 0.65, :start 51, :end 64}
    ;;  {:disease :BP, :dose 0.75, :start 51, :end 64}
    ;;  {:disease :BP, :dose 0.75, :start 65, :end 90})

  

• Я использую целое число в качестве даты здесь, чтобы упростить чтение