diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,9 +1,8 @@
 # Revision history for interval-patterns
 
-## 0.6.0.0 - 2022-12-04
+## 0.6.0.1
 
 * drop `relude` dependency
-* preemptively import `type (~)` where necessary
 
 ## 0.5.1.0 - 2022-08-04
 
diff --git a/interval-patterns.cabal b/interval-patterns.cabal
--- a/interval-patterns.cabal
+++ b/interval-patterns.cabal
@@ -1,27 +1,29 @@
-cabal-version: 3.0
-name: interval-patterns
-version: 0.6.0.0
-author: Melanie Phoenix
-synopsis: Intervals, and monoids thereof
-description: Please see the README at https://github.com/mixphix/interval-patterns
-category: Algebra, Charts, Data Structures, Math, Statistics
-maintainer: brown.m@pm.me
-license: BSD-3-Clause
-license-file: LICENSE
-homepage: https://github.com/mixphix/interval-patterns
-bug-reports: https://github.com/mixphix/interval-patterns/issues
+cabal-version:      3.0
+name:               interval-patterns
+version:            0.6.0.1
+author:             Melanie Brown
+synopsis:           Intervals, and monoids thereof
+category:           Algebra, Charts, Data Structures, Math, Statistics
+maintainer:         brown.m@pm.me
+license:            BSD-3-Clause
+license-file:       LICENSE
+homepage:           https://github.com/mixphix/interval-patterns
+bug-reports:        https://github.com/mixphix/interval-patterns/issues
 extra-source-files: CHANGELOG.md
-copyright: 2022 Melanie Phoenix
+copyright:          2023 Melanie Brown
+description:
+  Please see the README at https://github.com/mixphix/interval-patterns
 
 common interval-patterns
   build-depends:
-    , base >= 4.11 && < 5
+    , base         >=4.11    && <5
     , containers
-    , groups >= 0.2.2
-    , lattices >= 2.0.3 && < 2.1
-    , semirings >= 0.6 && < 0.7
+    , groups       >=0.2.2
+    , lattices     >=2.0.3   && <2.1
+    , semirings    >=0.6     && <0.7
     , time
-    , time-compat >= 1.9.6.1 && < 1.10
+    , time-compat  >=1.9.6.1 && <1.10
+
   default-extensions:
     BangPatterns
     ConstraintKinds
@@ -58,25 +60,26 @@
     TypeFamilies
     TypeOperators
     ViewPatterns
-  default-language: Haskell2010
-  ghc-options: -Wall -Wcompat -Wno-unticked-promoted-constructors
 
+  default-language:   Haskell2010
+  ghc-options:        -Wall -Wcompat -Wno-unticked-promoted-constructors
+
 library
-  import: interval-patterns
-  hs-source-dirs: src
+  import:          interval-patterns
+  hs-source-dirs:  src
   exposed-modules:
+    Data.Calendar
     Data.Interval
-    Data.Interval.Layers
     Data.Interval.Borel
+    Data.Interval.Layers
     Data.OneOrTwo
     Data.Timeframe
-    Data.Calendar
 
 test-suite tests
-  import: interval-patterns
-  type: exitcode-stdio-1.0
+  import:         interval-patterns
+  type:           exitcode-stdio-1.0
   hs-source-dirs: tests
-  main-is: Main.hs
+  main-is:        Main.hs
   build-depends:
     , hspec
     , interval-patterns
diff --git a/src/Data/Calendar.hs b/src/Data/Calendar.hs
--- a/src/Data/Calendar.hs
+++ b/src/Data/Calendar.hs
@@ -19,13 +19,13 @@
 import Control.Applicative (liftA2)
 import Data.Data (Typeable)
 import Data.Foldable (fold)
-import Data.Maybe (fromMaybe)
-import Data.Monoid (Sum (Sum, getSum))
 import Data.Interval qualified as I
 import Data.Interval.Layers (Layers)
 import Data.Interval.Layers qualified as Layers
 import Data.Map.Strict (Map)
 import Data.Map.Strict qualified as Map
+import Data.Maybe (fromMaybe)
+import Data.Semigroup hiding (diff)
 import Data.Time.Compat
 import Data.Timeframe
 
@@ -51,10 +51,7 @@
 -- all of the simultaneous happenings over a given span (on average)?
 erlangs :: (Real n) => Timeframe -> Event n -> Maybe Rational
 erlangs ix e =
-  let
-    infixr 9 <<$>>
-    (<<$>>) = fmap . fmap
-    diff = realToFrac <<$>> flip diffUTCTime
+  let diff = fmap realToFrac <$> flip diffUTCTime
    in liftA2
         (/)
         (Layers.integrate diff (realToFrac . getSum) ix e)
@@ -99,10 +96,7 @@
 Calendar c ! ev = fromMaybe mempty (c Map.!? ev)
 
 toList :: (Ord ev, Num n) => Calendar ev n -> [(ev, [(Interval UTCTime, n)])]
-toList (Calendar c) = fmap (fmap getSum) <<$>> Layers.toList <<$>> Map.assocs c
- where
-  infixr 9 <<$>>
-  (<<$>>) = fmap . fmap
+toList (Calendar c) = fmap (fmap (fmap getSum) . Layers.toList) <$> Map.assocs c
 
 -- |
 -- What, and how many events are happening
diff --git a/src/Data/Interval.hs b/src/Data/Interval.hs
--- a/src/Data/Interval.hs
+++ b/src/Data/Interval.hs
@@ -74,18 +74,18 @@
   OneOrTwo (..),
 ) where
 
-import Algebra.Lattice.Levitated
-import Control.Applicative (Const (Const), liftA2)
+import Algebra.Lattice.Levitated (Levitated (..), foldLevitated)
+import Control.Applicative (liftA2)
 import Control.Monad (join)
 import Data.Data
 import Data.Function (on)
-import Data.Kind (Type, Constraint)
+import Data.Functor.Const (Const (Const))
+import Data.Kind (Constraint, Type)
 import Data.List (sort)
 import Data.List.NonEmpty (NonEmpty ((:|)))
 import Data.OneOrTwo (OneOrTwo (..))
 import Data.Ord (comparing)
-import Data.Type.Equality (type (~))
-import GHC.Generics hiding (Infix)
+import GHC.Generics (Generic (..), type (:*:) (..))
 
 -- | The kinds of extremum an interval can have.
 data Extremum
diff --git a/src/Data/Interval/Borel.hs b/src/Data/Interval/Borel.hs
--- a/src/Data/Interval/Borel.hs
+++ b/src/Data/Interval/Borel.hs
@@ -27,7 +27,7 @@
 import Algebra.Heyting (Heyting ((==>)))
 import Algebra.Lattice
 import Control.Arrow ((>>>))
-import Data.Data (Data, Typeable)
+import Data.Data
 import Data.Foldable (fold)
 import Data.Functor ((<&>))
 import Data.Interval (Interval)
@@ -112,7 +112,7 @@
 
 -- | The maximal 'Borel' set, that covers the entire range.
 whole :: (Ord x) => Borel x
-whole = Borel (Set.singleton I.Whole)
+whole = singleton I.Whole
 
 -- |
 -- Completely remove an 'Interval' from a 'Borel' set.
diff --git a/src/Data/Interval/Layers.hs b/src/Data/Interval/Layers.hs
--- a/src/Data/Interval/Layers.hs
+++ b/src/Data/Interval/Layers.hs
@@ -23,21 +23,14 @@
   nestings,
 ) where
 
-import Algebra.Lattice.Levitated
+import Algebra.Lattice.Levitated (Levitated (Top))
 import Data.Data (Data, Typeable)
 import Data.Group (Group (..))
-import Data.List (sortOn)
-import Data.Interval (
-  Adjacency (..),
-  Interval,
-  OneOrTwo (..),
-  pattern Whole,
-  pattern (:---:),
-  pattern (:<>:)
- )
+import Data.Interval (Adjacency (..), Interval, OneOrTwo (..), pattern Whole, pattern (:---:), pattern (:<>:))
 import Data.Interval qualified as I
 import Data.Interval.Borel (Borel)
 import Data.Interval.Borel qualified as Borel
+import Data.List (sortOn)
 import Data.Map.Strict (Map)
 import Data.Map.Strict qualified as Map
 import GHC.Generics (Generic)
@@ -210,41 +203,49 @@
     Meets i j k -> (i, iy) : nestings ((j, iy <> jy) : (k, jy) : js)
     Overlaps i j k ->
       nestings $
-        (i, iy) :
-        (j, iy <> jy) :
-        (k, jy) : js
+        (i, iy)
+          : (j, iy <> jy)
+          : (k, jy)
+          : js
     Starts i j ->
       nestings $
-        (i, iy <> jy) :
-        (j, jy) : js
+        (i, iy <> jy)
+          : (j, jy)
+          : js
     During i j k ->
       nestings $
-        (i, jy) :
-        (j, iy <> jy) :
-        (k, jy) : js
+        (i, jy)
+          : (j, iy <> jy)
+          : (k, jy)
+          : js
     Finishes i j ->
       nestings $
-        (i, iy) :
-        (j, iy <> jy) : js
+        (i, iy)
+          : (j, iy <> jy)
+          : js
     Identical i -> nestings ((i, iy <> jy) : js)
     FinishedBy i j ->
       nestings $
-        (i, iy) :
-        (j, iy <> jy) : js
+        (i, iy)
+          : (j, iy <> jy)
+          : js
     Contains i j k ->
       nestings $
-        (i, iy) :
-        (j, iy <> jy) :
-        (k, iy) : js
+        (i, iy)
+          : (j, iy <> jy)
+          : (k, iy)
+          : js
     StartedBy i j ->
       nestings $
-        (i, iy <> jy) :
-        (j, iy) : js
+        (i, iy <> jy)
+          : (j, iy)
+          : js
     OverlappedBy i j k ->
       nestings $
-        (i, jy) :
-        (j, iy <> jy) :
-        (k, iy) : js
+        (i, jy)
+          : (j, iy <> jy)
+          : (k, iy)
+          : js
     MetBy i j k -> (i, jy) : nestings ((j, iy <> jy) : (k, iy) : js)
     After i j -> (i, jy) : nestings ((j, iy) : js)
   x -> x
diff --git a/src/Data/Timeframe.hs b/src/Data/Timeframe.hs
--- a/src/Data/Timeframe.hs
+++ b/src/Data/Timeframe.hs
@@ -7,7 +7,7 @@
   duration,
 ) where
 
-import Control.Monad.IO.Class (MonadIO, liftIO)
+import Control.Monad.IO.Class (MonadIO (..))
 import Data.Function (on)
 import Data.Functor ((<&>))
 import Data.Interval