diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,3 +1,7 @@
+0.11.0.0
+===
+* fixes for numhask-0.11
+
 0.9.0
 ===
 * added emptyHistogram
diff --git a/Setup.hs b/Setup.hs
deleted file mode 100644
--- a/Setup.hs
+++ /dev/null
@@ -1,3 +0,0 @@
-import Distribution.Simple
-
-main = defaultMain
diff --git a/numhask-space.cabal b/numhask-space.cabal
--- a/numhask-space.cabal
+++ b/numhask-space.cabal
@@ -1,6 +1,6 @@
-cabal-version:      2.4
+cabal-version:      3.0
 name:               numhask-space
-version:            0.10.0.1
+version:            0.11.0.0
 synopsis:           Numerical spaces.
 description:
   @numhask-space@ provides support for spaces where [space](https://en.wikipedia.org/wiki/Space_(mathematics\)) is defined as a set of numbers with a lower and upper bound.
@@ -22,32 +22,95 @@
 license-file:       LICENSE
 build-type:         Simple
 tested-with:
-  GHC ==8.6.5 || ==8.8.4 || ==8.10.7 || ==9.2.5 || ==9.4.4
-extra-source-files: ChangeLog.md
+  GHC ==8.10.7 || ==9.2.8 || ==9.4.5 || ==9.6.2
+extra-doc-files: ChangeLog.md
 
 source-repository head
   type:     git
   location: https://github.com/tonyday567/numhask-space
 
-library
-  hs-source-dirs:     src
+common ghc2021-stanza
+  if impl(ghc >=9.2)
+    default-language:
+      GHC2021
+  if impl(ghc <9.2)
+    default-language:
+      Haskell2010
+    default-extensions:
+      BangPatterns
+      BinaryLiterals
+      ConstrainedClassMethods
+      ConstraintKinds
+      DeriveDataTypeable
+      DeriveFoldable
+      DeriveFunctor
+      DeriveGeneric
+      DeriveLift
+      DeriveTraversable
+      DoAndIfThenElse
+      EmptyCase
+      EmptyDataDecls
+      EmptyDataDeriving
+      ExistentialQuantification
+      ExplicitForAll
+      FlexibleContexts
+      FlexibleInstances
+      ForeignFunctionInterface
+      GADTSyntax
+      GeneralisedNewtypeDeriving
+      HexFloatLiterals
+      ImplicitPrelude
+      InstanceSigs
+      KindSignatures
+      MonomorphismRestriction
+      MultiParamTypeClasses
+      NamedFieldPuns
+      NamedWildCards
+      NumericUnderscores
+      PatternGuards
+      PolyKinds
+      PostfixOperators
+      RankNTypes
+      RelaxedPolyRec
+      ScopedTypeVariables
+      StandaloneDeriving
+      StarIsType
+      TraditionalRecordSyntax
+      TupleSections
+      TypeApplications
+      TypeOperators
+      TypeSynonymInstances
+  if impl(ghc <9.2) && impl(ghc >=8.10)
+    default-extensions:
+      ImportQualifiedPost
+      StandaloneKindSignatures
+
+common ghc-options-stanza
   ghc-options:
-    -Wall -Wcompat -Wincomplete-record-updates
-    -Wincomplete-uni-patterns -Wredundant-constraints
+    -Wall
+    -Wcompat
+    -Wincomplete-record-updates
+    -Wincomplete-uni-patterns
+    -Wredundant-constraints
+    -Widentities
+    -Wpartial-fields
 
-  default-extensions:
+library
+  import: ghc2021-stanza
+  import: ghc-options-stanza
+  hs-source-dirs: src
   build-depends:
-    , adjunctions    >=4.0     && <5
-    , base           >=4.7     && <5
+    , adjunctions    >=4.0 && <5
+    , base           >=4.7 && <5
     , containers     ^>=0.6
-    , distributive   >=0.2.2   && <1
-    , numhask        >=0.10.0  && <0.11
+    , distributive   >=0.2.2 && <1
+    , numhask        >=0.11 && <0.12
     , random         ^>=1.2
-    , semigroupoids  >=5       && <5.4
-    , tdigest        ^>=0.2.1
+    , semigroupoids  >=5 && <6.1
+    , tdigest        >=0.2.1 && <0.4
     , text           >=1.2.3.1 && <3
-    , time           >=1.9.1   && <1.13
-    , vector         >=0.12    && <0.14
+    , time           >=1.9.1 && <1.13
+    , vector         >=0.12 && <0.14
 
   exposed-modules:
     NumHask.Space
@@ -57,15 +120,3 @@
     NumHask.Space.Rect
     NumHask.Space.Time
     NumHask.Space.Types
-
-  other-modules:
-  default-language:   Haskell2010
-
-test-suite doctests
-  type:             exitcode-stdio-1.0
-  main-is:          doctests.hs
-  hs-source-dirs:   test
-  default-language: Haskell2010
-  build-depends:
-    , base
-    , QuickCheck
diff --git a/src/NumHask/Space.hs b/src/NumHask/Space.hs
--- a/src/NumHask/Space.hs
+++ b/src/NumHask/Space.hs
@@ -1,7 +1,5 @@
 {-# LANGUAGE NegativeLiterals #-}
 {-# LANGUAGE RebindableSyntax #-}
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -fno-warn-type-defaults #-}
 
 -- | Mathematics does not rigorously define a [space](https://en.wikipedia.org/wiki/Space_(mathematics\)), leaving library devs free to explore.
 --
diff --git a/src/NumHask/Space/Histogram.hs b/src/NumHask/Space/Histogram.hs
--- a/src/NumHask/Space/Histogram.hs
+++ b/src/NumHask/Space/Histogram.hs
@@ -1,7 +1,5 @@
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE RebindableSyntax #-}
-{-# LANGUAGE StrictData #-}
-{-# OPTIONS_GHC -Wall #-}
 {-# OPTIONS_GHC -fno-warn-name-shadowing #-}
 
 -- | A histogram, if you squint, is a series of contiguous 'Range's, annotated with values.
@@ -22,9 +20,9 @@
   )
 where
 
-import qualified Data.Map as Map
-import qualified Data.TDigest as TD
-import qualified Data.Vector as V
+import Data.Map qualified as Map
+import Data.TDigest qualified as TD
+import Data.Vector qualified as V
 import NumHask.Prelude
 import NumHask.Space.Range
 import NumHask.Space.Rect
diff --git a/src/NumHask/Space/Point.hs b/src/NumHask/Space/Point.hs
--- a/src/NumHask/Space/Point.hs
+++ b/src/NumHask/Space/Point.hs
@@ -1,12 +1,5 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DeriveTraversable #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE RebindableSyntax #-}
-{-# LANGUAGE StrictData #-}
 {-# LANGUAGE TypeFamilies #-}
-{-# OPTIONS_GHC -Wall #-}
 
 -- | A 2-dimensional point.
 module NumHask.Space.Point
@@ -32,7 +25,6 @@
 import Data.Functor.Classes
 import Data.Functor.Rep
 import NumHask.Prelude hiding (Distributive)
-import qualified NumHask.Prelude as P
 import NumHask.Space.Range
 import NumHask.Space.Types
 import System.Random
@@ -123,14 +115,6 @@
   (Point a0 b0) * (Point a1 b1) = Point (a0 * a1) (b0 * b1)
   one = Point one one
 
-instance (P.Distributive a) => P.Distributive (Point a)
-
-instance (Field a) => Field (Point a)
-
-instance (Signed a) => Signed (Point a) where
-  sign = fmap sign
-  abs = fmap abs
-
 instance (Divisive a) => Divisive (Point a) where
   recip = fmap recip
 
@@ -140,17 +124,19 @@
       getL (Point l _) = l
       getR (Point _ r) = r
 
-instance (Additive a) => AdditiveAction (Point a) a where
-  (.+) a (Point x y) = Point (a + x) (a + y)
+instance (Additive a) => AdditiveAction (Point a) where
+  type AdditiveScalar (Point a) = a
+  (|+) (Point x y) a = Point (a + x) (a + y)
 
-instance (Subtractive a) => SubtractiveAction (Point a) a where
-  (.-) a (Point x y) = Point (a - x) (a - y)
+instance (Subtractive a) => SubtractiveAction (Point a) where
+  (|-) (Point x y) a = Point (x - a) (y - a)
 
-instance (Multiplicative a) => MultiplicativeAction (Point a) a where
-  (.*) a (Point x y) = Point (a * x) (a * y)
+instance (Multiplicative a) => MultiplicativeAction (Point a) where
+  type Scalar (Point a) = a
+  (|*) (Point x y) a = Point (a * x) (a * y)
 
-instance (Divisive a) => DivisiveAction (Point a) a where
-  (./) a (Point x y) = Point (a / x) (a / y)
+instance (Divisive a) => DivisiveAction (Point a) where
+  (|/) (Point x y) a = Point (x / a) (y / a)
 
 instance Representable Point where
   type Rep Point = Bool
@@ -168,13 +154,17 @@
 
 instance
   (ExpField a, Eq a) =>
-  Norm (Point a) a
+  Basis (Point a)
   where
-  norm (Point x y) = sqrt (x * x + y * y)
-  basis p = let m = norm p in bool (p /. m) zero (m == zero)
+  type Mag (Point a) = a
+  type Base (Point a) = Point a
 
+  magnitude (Point x y) = sqrt (x * x + y * y)
+  basis p = let m = magnitude p in bool (p |/ m) zero (m == zero)
+
 -- | angle formed by a vector from the origin to a Point and the x-axis (Point 1 0). Note that an angle between two points p1 & p2 is thus angle p2 - angle p1
-instance (TrigField a) => Direction (Point a) a where
+instance (TrigField a) => Direction (Point a) where
+  type Dir (Point a) = a
   angle (Point x y) = atan2 y x
   ray x = Point (cos x) (sin x)
 
@@ -276,10 +266,10 @@
 
 -- | Calculate the intersection of two lines.  If the determinant is
 -- less than tolerance (parallel or coincident lines), return Nothing.
-lineIntersect :: (Ord a, Epsilon a, Signed a, Field a) => Line a -> Line a -> Maybe (Point a)
+lineIntersect :: (Ord a, Epsilon a, Absolute a, Field a) => Line a -> Line a -> Maybe (Point a)
 lineIntersect (Line p1 p2) (Line p3 p4)
   | abs det <= epsilon = Nothing
-  | otherwise = Just $ (a .* d2 - b .* d1) /. det
+  | otherwise = Just $ (a *| d2 - b *| d1) |/ det
   where
     d1 = p1 - p2
     d2 = p3 - p4
diff --git a/src/NumHask/Space/Range.hs b/src/NumHask/Space/Range.hs
--- a/src/NumHask/Space/Range.hs
+++ b/src/NumHask/Space/Range.hs
@@ -1,12 +1,6 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE RebindableSyntax #-}
-{-# LANGUAGE StrictData #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wall #-}
-{-# OPTIONS_GHC -Wno-redundant-constraints #-}
 
 -- | A Space containing numerical elements
 module NumHask.Space.Range
@@ -19,8 +13,6 @@
 import Data.Functor.Apply (Apply (..))
 import Data.Functor.Classes
 import Data.Functor.Rep
-import Data.Semigroup.Foldable (Foldable1 (..))
-import Data.Semigroup.Traversable (Traversable1 (..))
 import GHC.Show (show)
 import NumHask.Prelude hiding (show)
 import NumHask.Space.Types as S
@@ -88,14 +80,9 @@
 instance Foldable Range where
   foldMap f (Range a b) = f a `mappend` f b
 
-instance Foldable1 Range
-
 instance Traversable Range where
   traverse f (Range a b) = Range <$> f a <*> f b
 
-instance Traversable1 Range where
-  traverse1 f (Range a b) = Range <$> f a Data.Functor.Apply.<.> f b
-
 instance D.Distributive Range where
   collect f x = Range (getL . f <$> x) (getR . f <$> x)
     where
@@ -168,15 +155,17 @@
       m = mid a
       r = width a
 
-instance (Field a, Ord a) => Signed (Range a) where
-  sign (Range l u) = bool (negate one) one (u >= l)
-  abs (Range l u) = bool (u ... l) (l ... u) (u >= l)
+instance (Field a, Ord a) => Basis (Range a) where
+  type Mag (Range a) = Range a
+  type Base (Range a) = a
+  basis (Range l u) = bool (negate one) one (u >= l)
+  magnitude (Range l u) = bool (u ... l) (l ... u) (u >= l)
 
-stepSensible :: Pos -> Double -> Integer -> Double
+stepSensible :: Pos -> Double -> Int -> Double
 stepSensible tp span' n =
   step + bool 0 (step / 2) (tp == MidPos)
   where
-    step' = 10.0 ^^ (floor (logBase 10 (span' / fromInteger n)) :: Integer)
+    step' = 10.0 ^^ floor (logBase 10 (span' / fromIntegral n))
     err = fromIntegral n / span' * step'
     step
       | err <= 0.15 = 10.0 * step'
@@ -192,7 +181,7 @@
   Pos ->
   Bool ->
   Range Double ->
-  Integer ->
+  Int ->
   [Double]
 gridSensible tp inside r@(Range l u) n =
   bool id (filter (`memberOf` r)) inside $
@@ -201,12 +190,12 @@
     posns = (first' +) . (step *) . fromIntegral <$> [i0 .. i1]
     span' = u - l
     step = stepSensible tp span' n
-    first' = step * fromIntegral (floor (l / step + 1e-6) :: Integer)
-    last' = step * fromIntegral (ceiling (u / step - 1e-6) :: Integer)
+    first' = step * fromIntegral (floor (l / step + 1e-6))
+    last' = step * fromIntegral (ceiling (u / step - 1e-6))
     n' = round ((last' - first') / step)
     (i0, i1) =
       case tp of
-        OuterPos -> (0 :: Integer, n')
+        OuterPos -> (0, n')
         InnerPos -> (1, n' - 1)
         LowerPos -> (0, n' - 1)
         UpperPos -> (1, n')
diff --git a/src/NumHask/Space/Rect.hs b/src/NumHask/Space/Rect.hs
--- a/src/NumHask/Space/Rect.hs
+++ b/src/NumHask/Space/Rect.hs
@@ -1,15 +1,8 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE DeriveTraversable #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE NegativeLiterals #-}
 {-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE RebindableSyntax #-}
-{-# LANGUAGE StrictData #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
-{-# OPTIONS_GHC -Wall #-}
 
 -- | A (finite) two-dimensional plane, implemented as a composite of a 'Point' of 'Range's.
 module NumHask.Space.Rect
@@ -239,9 +232,11 @@
 instance (Ord a, Field a) => Divisive (Rect a) where
   recip (Ranges x y) = Ranges (recip x) (recip y)
 
-instance (Ord a, Field a) => Signed (Rect a) where
-  sign (Rect x z y w) = bool (negate one) one (z >= x && (w >= y))
-  abs (Ranges x y) = Ranges (abs x) (abs y)
+instance (Ord a, Field a) => Basis (Rect a) where
+  type Mag (Rect a) = Rect a
+  type Base (Rect a) = a
+  basis (Rect x z y w) = bool (negate one) one (z >= x && (w >= y))
+  magnitude (Ranges x y) = Ranges (magnitude x) (magnitude y)
 
 -- | convex hull union of Rect's
 --
diff --git a/src/NumHask/Space/Time.hs b/src/NumHask/Space/Time.hs
--- a/src/NumHask/Space/Time.hs
+++ b/src/NumHask/Space/Time.hs
@@ -1,11 +1,5 @@
-{-# LANGUAGE DeriveGeneric #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE RebindableSyntax #-}
-{-# LANGUAGE StrictData #-}
-{-# OPTIONS_GHC -Wall #-}
 {-# OPTIONS_GHC -fno-warn-name-shadowing #-}
-{-# OPTIONS_GHC -fno-warn-type-defaults #-}
 
 -- | data algorithms related to time (as a Space)
 module NumHask.Space.Time
@@ -26,7 +20,7 @@
 
 import Data.Containers.ListUtils (nubOrd)
 import Data.Fixed (Fixed (MkFixed))
-import qualified Data.Sequence as Seq
+import Data.Sequence qualified as Seq
 import Data.Text (Text, pack, unpack)
 import Data.Time
 import NumHask.Prelude
@@ -45,7 +39,7 @@
 
 -- | a step in time
 data TimeGrain
-  = Years Integer
+  = Years Int
   | Months Int
   | Days Int
   | Hours Int
@@ -74,7 +68,7 @@
       days = floor (x / fromNominalDiffTime nominalDay)
       secs = x - fromIntegral days * fromNominalDiffTime nominalDay
       t0 = UTCTime d0 (picosecondsToDiffTime 0)
-      t1 = UTCTime (addDays days d0) (picosecondsToDiffTime $ floor (secs / 1.0e-12))
+      t1 = UTCTime (addDays (fromIntegral days) d0) (picosecondsToDiffTime . fromIntegral $ floor (secs / 1.0e-12))
    in diffUTCTime t1 t0
 
 -- | Convert from 'DiffTime' to seconds (as a Double)
@@ -88,7 +82,7 @@
 -- >>> toDiffTime 1
 -- 1s
 toDiffTime :: Double -> DiffTime
-toDiffTime = picosecondsToDiffTime . floor . (* 1e12)
+toDiffTime = picosecondsToDiffTime . fromIntegral . floor . (* 1e12)
 
 -- | add a TimeGrain to a UTCTime
 --
@@ -105,7 +99,7 @@
 -- 2015-02-28 00:01:00.001 UTC
 addGrain :: TimeGrain -> Int -> UTCTime -> UTCTime
 addGrain (Years n) x (UTCTime d t) =
-  UTCTime (addDays (-1) $ addGregorianYearsClip (n * fromIntegral x) (addDays 1 d)) t
+  UTCTime (addDays (-1) $ addGregorianYearsClip (fromIntegral n * fromIntegral x) (addDays 1 d)) t
 addGrain (Months n) x (UTCTime d t) =
   UTCTime (addDays (-1) $ addGregorianMonthsClip (fromIntegral (n * x)) (addDays 1 d)) t
 addGrain (Days n) x (UTCTime d t) = UTCTime (addDays (fromIntegral x * fromIntegral n) d) t
@@ -117,7 +111,7 @@
 addHalfGrain (Years n) (UTCTime d t) =
   UTCTime
     ( addDays (-1) . (if m' == 1 then addGregorianMonthsClip 6 else id) $
-        addGregorianYearsClip d' (addDays 1 d)
+        addGregorianYearsClip (fromIntegral d') (addDays 1 d)
     )
     t
   where
@@ -160,24 +154,24 @@
 floorGrain (Years n) (UTCTime d _) = UTCTime (addDays (-1) $ fromGregorian y' 1 1) (secondsToDiffTime 0)
   where
     (y, _, _) = toGregorian (addDays 1 d)
-    y' = fromIntegral $ 1 + n * floor (fromIntegral (y - 1) / fromIntegral n :: Double)
+    y' = fromIntegral $ 1 + n * fromIntegral (floor (fromIntegral (y - 1) / fromIntegral n :: Double))
 floorGrain (Months n) (UTCTime d _) = UTCTime (addDays (-1) $ fromGregorian y m' 1) (secondsToDiffTime 0)
   where
     (y, m, _) = toGregorian (addDays 1 d)
-    m' = fromIntegral (1 + fromIntegral n * floor (fromIntegral (m - 1) / fromIntegral n :: Double) :: Integer)
+    m' = fromIntegral (1 + fromIntegral n * floor (fromIntegral (m - 1) / fromIntegral n :: Double))
 floorGrain (Days _) (UTCTime d _) = UTCTime d (secondsToDiffTime 0)
 floorGrain (Hours h) u@(UTCTime _ t) = addUTCTime x u
   where
     s = fromDiffTime t
-    x = toNominalDiffTime $ fromIntegral (h * 3600 * fromIntegral (floor (s / (fromIntegral h * 3600)) :: Integer)) - s
+    x = toNominalDiffTime $ fromIntegral (h * 3600 * fromIntegral (floor (s / (fromIntegral h * 3600)))) - s
 floorGrain (Minutes m) u@(UTCTime _ t) = addUTCTime x u
   where
     s = fromDiffTime t
-    x = toNominalDiffTime $ fromIntegral (m * 60 * fromIntegral (floor (s / (fromIntegral m * 60)) :: Integer)) - s
+    x = toNominalDiffTime $ fromIntegral (m * 60 * fromIntegral (floor (s / (fromIntegral m * 60)))) - s
 floorGrain (Seconds secs) u@(UTCTime _ t) = addUTCTime x u
   where
     s = fromDiffTime t
-    x = toNominalDiffTime $ (secs * fromIntegral (floor (s / secs) :: Integer)) - s
+    x = toNominalDiffTime $ (secs * fromIntegral (floor (s / secs))) - s
 
 -- | compute the ceiling UTCTime based on the timegrain
 --
@@ -199,7 +193,7 @@
 ceilingGrain (Years n) (UTCTime d _) = UTCTime (addDays (-1) $ fromGregorian y' 1 1) (secondsToDiffTime 0)
   where
     (y, _, _) = toGregorian (addDays 1 d)
-    y' = fromIntegral $ 1 + n * ceiling (fromIntegral (y - 1) / fromIntegral n :: Double)
+    y' = fromIntegral $ 1 + n * fromIntegral (ceiling (fromIntegral (y - 1) / fromIntegral n :: Double))
 ceilingGrain (Months n) (UTCTime d _) = UTCTime (addDays (-1) $ fromGregorian y' m'' 1) (secondsToDiffTime 0)
   where
     (y, m, _) = toGregorian (addDays 1 d)
@@ -209,15 +203,15 @@
 ceilingGrain (Hours h) u@(UTCTime _ t) = addUTCTime x u
   where
     s = fromDiffTime t
-    x = toNominalDiffTime $ fromIntegral (h * 3600 * fromIntegral (ceiling (s / (fromIntegral h * 3600)) :: Integer)) - s
+    x = toNominalDiffTime $ fromIntegral (h * 3600 * fromIntegral (ceiling (s / (fromIntegral h * 3600)))) - s
 ceilingGrain (Minutes m) u@(UTCTime _ t) = addUTCTime x u
   where
     s = fromDiffTime t
-    x = toNominalDiffTime $ fromIntegral (m * 60 * fromIntegral (ceiling (s / (fromIntegral m * 60)) :: Integer)) - s
+    x = toNominalDiffTime $ fromIntegral (m * 60 * fromIntegral (ceiling (s / (fromIntegral m * 60)))) - s
 ceilingGrain (Seconds secs) u@(UTCTime _ t) = addUTCTime x u
   where
     s = fromDiffTime t
-    x = toNominalDiffTime $ (secs * fromIntegral (ceiling (s / secs) :: Integer)) - s
+    x = toNominalDiffTime $ (secs * fromIntegral (ceiling (s / secs))) - s
 
 -- | whether to include lower and upper times
 data PosDiscontinuous = PosInnerOnly | PosIncludeBoundaries
@@ -288,8 +282,7 @@
       Just f -> unpack f
       Nothing -> autoFormat grain
     labels = pack . formatTime defaultTimeLocale fmt <$> tps'
-    (Range l' u') = unsafeSpace1 tps'
-    r' = fromNominalDiffTime $ diffUTCTime u' l'
+    r' = fromNominalDiffTime $ diffUTCTime u l
     tpsd = (/ r') . fromNominalDiffTime . flip diffUTCTime l <$> tps'
 
 -- | compute a sensible TimeGrain and list of UTCTimes
@@ -315,8 +308,7 @@
     n' =
       round $
         fromNominalDiffTime (diffUTCTime last' first')
-          / grainSecs grain ::
-        Integer
+          / grainSecs grain
     posns = case p of
       OuterPos -> take (fromIntegral $ n' + 1)
       InnerPos ->
@@ -345,7 +337,7 @@
       then step / 2
       else 0
   where
-    step' = 10 ^^ (floor (logBase 10 (span' / fromIntegral n)) :: Integer)
+    step' = 10 ^^ floor (logBase 10 (span' / fromIntegral n))
     err = fromIntegral n / span' * step'
     step
       | err <= 0.15 = 10 * step'
@@ -366,7 +358,7 @@
       then step / 2
       else 0
   where
-    step' = 10 ^^ (floor (logBase 10 (span' / fromIntegral n)) :: Integer)
+    step' = 10 ^^ floor (logBase 10 (span' / fromIntegral n))
     err = fromIntegral n / span' * step'
     step
       | err <= 0.05 = 12 * step'
@@ -378,10 +370,10 @@
 stepSensibleTime :: Pos -> NominalDiffTime -> Int -> TimeGrain
 stepSensibleTime tp span' n
   | yearsstep >= 1 = Years (floor yearsstep)
-  | monthsstep >= 1 = Months (fromIntegral (floor monthsstep :: Integer))
-  | daysstep >= 1 = Days (fromIntegral (floor daysstep :: Integer))
-  | hoursstep >= 1 = Hours (fromIntegral (floor hoursstep :: Integer))
-  | minutesstep >= 1 = Minutes (fromIntegral (floor minutesstep :: Integer))
+  | monthsstep >= 1 = Months (fromIntegral (floor monthsstep))
+  | daysstep >= 1 = Days (fromIntegral (floor daysstep))
+  | hoursstep >= 1 = Hours (fromIntegral (floor hoursstep))
+  | minutesstep >= 1 = Minutes (fromIntegral (floor minutesstep))
   | secondsstep >= 1 = Seconds secondsstep3
   | otherwise = Seconds secondsstep
   where
diff --git a/src/NumHask/Space/Types.hs b/src/NumHask/Space/Types.hs
--- a/src/NumHask/Space/Types.hs
+++ b/src/NumHask/Space/Types.hs
@@ -1,7 +1,4 @@
 {-# LANGUAGE DefaultSignatures #-}
-{-# LANGUAGE DeriveTraversable #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE FunctionalDependencies #-}
 {-# LANGUAGE RebindableSyntax #-}
 {-# LANGUAGE TypeFamilies #-}
@@ -44,7 +41,7 @@
 import Control.Monad
 import NumHask.Prelude
 import System.Random.Stateful
-import qualified Prelude as P
+import Prelude qualified as P
 
 -- $setup
 -- >>> import NumHask.Prelude
diff --git a/test/doctests.hs b/test/doctests.hs
deleted file mode 100644
--- a/test/doctests.hs
+++ /dev/null
@@ -1,8 +0,0 @@
-module Main where
-
-main :: IO ()
-main = do
-  putStrLn "This test-suite exists only to add dependencies"
-  putStrLn "To run doctests: "
-  putStrLn "    cabal build all --enable-tests"
-  putStrLn "    cabal-docspec"