                   (cons x
                         (intersection
                           (assert-proper-head (next xs))
-                          (assert-proper-head (cons (narrow y (t/end x) (t/end y))
+                          (assert-proper-head (cons (slice y (t/end x) (t/end y))
                                                     (next ys))))))
 
                 ;; List of nothing because one of the collections is

              (next intervals)
              groups
              result
              (clojure.core/conj current-intervals (narrow ival (t/beginning group) (t/end ival))))))

        ;; No more groups
        result)

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

                  :started-by
                  (cons (slice x (t/beginning y) (t/end y))
                        (intersection
                          (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 y) (t/end y))
                        (intersection
                          (assert-proper-head (next xs))
                          (assert-proper-head (next ys))))

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


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

                  :contains
                  (cons (slice x (t/beginning y) (t/end y))
                        (intersection
                          (assert-proper-head (cons (slice 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 (slice y (t/end x) (t/end y)) (next ys)))))

                  :equals
                  (cons x
