     (t/forward-duration (t/beginning ival) (.multipliedBy (t/length ival) factor))))
 
 (extend-protocol t/ITimeShift
-  Interval
+  clojure.lang.APersistentMap
   (forward-duration [ival d]
-    (make-interval
-      (t/forward-duration (t/beginning ival) d)
-      (t/forward-duration (t/end ival) d)))
+    (-> ival
+        (update :tick/beginning #(t/forward-duration % d))
+        (update :tick/end #(t/forward-duration % d))))
   (backward-duration [ival d]
-    (make-interval
-      (t/backward-duration (t/beginning ival) d)
-      (t/backward-duration (t/end ival) d))))
+    (-> ival
+        (update :tick/beginning #(t/backward-duration % d))
+        (update :tick/end #(t/backward-duration % d)))))
 
 ;; An interval of duration d to t1 can be constructed like this:
 ;; (scale (interval t1 d) -1)
 
-
 ;; (>> _ d) to shift the interval into the future by duration d
 ;; (<< _ d) to shift the interval into the past by duration d
 

  (<= [x y] (t/<= (as-interval x) (as-interval y)))
  (> [x y] (t/> (as-interval x) (as-interval y)))
  (>= [x y] (t/>= (as-interval x) (as-interval y)))
  Interval
  (< [x y] (#{precedes? meets?} (basic-relation x y)))
  (<= [x y] (#{precedes? meets? equals? starts? overlaps? finished-by?} (basic-relation x y)))
  (> [x y] (#{preceded-by? met-by?} (basic-relation x y)))

  (split ival t))

(defn slice-interval [ival beginning end]
  (let [beginning (t/max (t/beginning ival) beginning)
        end (t/min (t/end ival) end)]
    (when (t/< beginning end)
      (if (associative? ival)
        (assoc ival :tick/beginning beginning :tick/end end)
        (make-interval beginning end)))))

(defn split-interval [ival t]
  [(slice-interval ival (t/beginning ival) t)
   (slice-interval ival t (t/end ival))])

(extend-protocol IIntervalOps
  clojure.lang.APersistentMap
  (slice [this beginning end]
    (slice-interval this beginning end))
  (splice [this ival]
    (assoc this
           :tick/beginning (t/min (t/beginning this) (t/beginning ival))
           :tick/end (t/max (t/end this) (t/end ival))))
  (split [this t]
    (split-interval this t))

  LocalDate
  (slice [this beginning end]
    (slice-interval this beginning end))
  (splice [this ival]
    (throw (ex-info "splice not implemented" {:this this :interval ival})))
  (split [this t]
    (split-interval this t))

  YearMonth
  (slice [this beginning end]
    (slice-interval this beginning end))
  (splice [this ival]
    (throw (ex-info "splice not implemented" {:this this :interval ival})))
  (split [this t]
    (split-interval this t))

  Year
  (slice [this beginning end]
    (slice-interval this beginning end))
  (splice [this ival]
    (throw (ex-info "splice not implemented" {:this this :interval ival})))
  (split [this t]
    (split-interval this t)))

(defn concur
  "Return the interval representing the interval, if there is one,
