timelines.cljc

(ns com.widdindustries.timelines
  "create timelines which are (possibly infinite) sequences of maps with a ::time key.
  
  Multiple timelines can be merged into a single timeline
  
  Zero dependency - BYO time lib
    
  Demo in comment at the end
  ")

(defn merge-timelines [timelines]
  (let [[tl-with-soonest & others] (sort-by (comp ::time first) (remove nil? timelines))
        [next-soonest & remainder] tl-with-soonest]
    (if-not next-soonest
      []
      (lazy-seq
        (cons next-soonest
          (merge-timelines (cons remainder others)))))))

(defn timeline [{:keys [start
                        end-pred next-tick]}]
  (let [tl (iterate (fn [prev]
                      (update prev ::time
                        next-tick)) 
             start)]
    (if end-pred
      (take-while #(end-pred (::time %))
        tl)
      tl)))

(comment
  (require '[tick.alpha.api :as t])
  
  (def foo-timeline 
    (timeline {:start     {::time (t/today)
                           :timeline-name "foo"}
               :next-tick (fn [x] (t/>> x (t/new-period 2 :days)))}))

  (def bar-timeline
    (timeline {:start     {::time (t/yesterday)
                           :timeline-name "bar"}
               :next-tick (fn [x] (t/>> x (t/new-period 1 :days)))
               :end-pred  (fn [x] (t/<= x (t/>> (t/today)
                                            (t/new-period 4 :days))))}))

  ; see bar is finite - only 6 in the seq
  (take 10 bar-timeline)
  
  (def foo-bar-timeline (merge-timelines [foo-timeline bar-timeline]))
  ; see foo and bar interleaved
  (take 10 foo-bar-timeline)
  

  )