   concurrent."
   [x y]
   (case (relation x y)
-    :overlaps (narrow x (t/beginning y) (t/end x))
-    :overlapped-by (narrow x (t/beginning x) (t/end y))
+    :overlaps (slice x (t/beginning y) (t/end x))
+    :overlapped-by (slice x (t/beginning x) (t/end y))
     (:starts :finishes :during :equals) x
-    (:started-by :finished-by :contains) (narrow x (t/beginning y) (t/end y))
+    (:started-by :finished-by :contains) (slice x (t/beginning y) (t/end y))
     nil))
 
 (defn ^:experimental concurrencies

                  (intersection xs (assert-proper-head (next ys)))

                  :started-by
                  (cons (narrow x (t/beginning y) (t/end y))
                        (intersection
                          (assert-proper-head (cons (narrow x (t/end y) (t/end x)) (next xs)))
                          (assert-proper-head (next ys))))

                  :finished-by
                  (cons (narrow x (t/beginning y) (t/end y))
                        (intersection
                          (assert-proper-head (next xs))
                          (assert-proper-head (next ys))))

                  :overlaps
                  (cons (narrow x (t/beginning y) (t/end x))
                        (intersection
                          (assert-proper-head (cons (narrow x (t/beginning y) (t/end x)) (next xs)))
                          (assert-proper-head (cons (narrow y (t/end x) (t/end y)) (next ys)))))


                  :overlapped-by
                  (cons (narrow x (t/beginning x) (t/end y))
                        (intersection
                          (assert-proper-head (cons (narrow x (t/end y) (t/end x)) (next xs)))
                          (assert-proper-head (next ys))))

                  :contains
                  (cons (narrow x (t/beginning y) (t/end y))
                        (intersection
                          (assert-proper-head (cons (narrow x (t/end y) (t/end x)) (next xs)))
                          (assert-proper-head (next ys))))

                  :during
                  (cons x
                        (intersection
                          (assert-proper-head (next xs))
                          (assert-proper-head (cons (narrow y (t/end x) (t/end y)) (next ys)))))

                  :equals
                  (cons x

                       (:started-by :overlapped-by)
                       (difference
                         (assert-proper-head
                           (cons (slice x (t/end y) (t/end x)) (next xs)))
                         (assert-proper-head (next ys)))

                       :finished-by
                       (cons (slice x (t/beginning x) (t/beginning y))
                             (difference
                               (assert-proper-head (next xs))
                               (assert-proper-head (next ys))))

                       :overlaps
                       (cons (slice x (t/beginning x) (t/beginning y))
                             (difference
                               (assert-proper-head (next xs))
                               ys))

                       :contains
                       (cons (slice x (t/beginning x) (t/beginning y))
                             (difference
                               (assert-proper-head
                                 (cons (slice x (t/end y) (t/end x)) (next xs)))
                               (assert-proper-head (next ys))))))
                   ;; If xs but no ys
                   xs)
