diff --git a/.hlint.yaml b/.hlint.yaml
new file mode 100644
--- /dev/null
+++ b/.hlint.yaml
@@ -0,0 +1,4 @@
+- arguments: [--cpp-define=HLINT, --cpp-ansi]
+
+- ignore: {name: Use camelCase}
+- ignore: {name: Eta reduce}
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
--- a/.travis.yml
+++ /dev/null
@@ -1,1 +0,0 @@
-language: haskell
diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,78 @@
+0.8.10 [2025.12.07]
+-------------------
+* Deprecate `Data.Proxy.TH.{pr,pr1}`, as their functionality has been subsumed
+  by using `Proxy` with `TypeApplications` syntax. For instance, uses of
+  `[pr|T|]` should be migrated to `Proxy @T`. `Data.Proxy.TH` will be removed
+  in the next `tagged` release.
+* Allow disabling the `template-haskell` dependency by disabling a `cabal` flag
+  of the same name.
+* Support building with MicroHs.
+
+0.8.9 [2024.12.03]
+------------------
+* Allow building with GHC 9.12.
+* Drop support for GHC 7.10 and earlier.
+
+0.8.8 [2023.08.08]
+------------------
+* Allow building with GHC 9.8.
+
+0.8.7 [2023.02.18]
+------------------
+* Define `Foldable1` and `Bifoldable1` instances for `Tagged`. These instances
+  were originally defined in the `semigroupoids` library, and they have now
+  been migrated to `tagged` as a side effect of adapting to
+  [this Core Libraries Proposal](https://github.com/haskell/core-libraries-committee/issues/9),
+  which adds `Foldable1` and `Bifoldable1` to `base`.
+
+0.8.6.1 [2020.12.28]
+--------------------
+* Mark all modules as explicitly Safe or Trustworthy.
+
+0.8.6 [2018.07.02]
+------------------
+* Make the `Read(1)` instances for `Proxy` ignore the precedence argument,
+  mirroring similar changes to `base`
+  [here](http://git.haskell.org/ghc.git/commitdiff/8fd959998e900dffdb7f752fcd42df7aaedeae6e).
+* Fix a bug in the `Floating` instance for `Tagged` in which `logBase` was
+  defined in terms of `(**)`.
+* Avoid incurring some dependencies when using recent GHCs.
+
+0.8.5
+-----
+* Support `Data.Bifoldable`/`Data.Bitraversable` in `base` for GHC 8.1+.
+* Backport the `Eq1`, `Ord1`, `Read1`, and `Show1` instances for `Proxy` from `base-4.9`
+* Add `Eq1`/`2`, `Ord1`/`2`, `Read1`/`2`, and `Show1`/`2` instances for `Tagged`
+
+0.8.4
+-----
+* Backport the `Alternative`, `MonadPlus`, and `MonadZip` instances for `Proxy` from `base-4.9`
+* Add `Bits`, `FiniteBits`, `IsString`, and `Storable` instances for `Tagged`
+
+0.8.3
+-----
+* Manual `Generic1` support to work around a bug in GHC 7.6
+* Invert the dependency to supply the `Semigroup` instance ourselves when building on GHC 8
+
+0.8.2
+-------
+* `deepseq` support.
+* Widened `template-haskell` dependency bounds.
+
+0.8.1
+-----
+* Add `KProxy` to the backwards compatibility `Data.Proxy` module.
+* Add a `Generic` instance to `Proxy`.
+
+0.8.0.1
+-------
+* Fix builds on GHC 7.4.
+
+0.8
+---
+* Added `Data.Proxy.TH`, based on the code from `Frames` by Anthony Cowley.
+* Removed `reproxy` from `Data.Proxy`. This is a bad API decision, but it isn't present in GHC's `Data.Proxy`, and this makes the API more stable.
+
 0.7.3
 ---
 * Support `Data.Bifunctor` in `base` for GHC 7.9+.
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009-2013 Edward Kmett
+Copyright (c) 2009-2015 Edward Kmett
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/README.markdown b/README.markdown
--- a/README.markdown
+++ b/README.markdown
@@ -1,4 +1,6 @@
 tagged
 ======
 
-Values carrying an extra [phantom type](http://www.haskell.org/haskellwiki/Phantom_type) tag.
+[![Hackage](https://img.shields.io/hackage/v/tagged.svg)](https://hackage.haskell.org/package/tagged) [![Build Status](https://github.com/ekmett/tagged/workflows/Haskell-CI/badge.svg)](https://github.com/ekmett/tagged/actions?query=workflow%3AHaskell-CI)
+
+Values carrying an extra [phantom type](https://wiki.haskell.org/Phantom_type) tag.
diff --git a/old/Data/Proxy.hs b/old/Data/Proxy.hs
deleted file mode 100644
--- a/old/Data/Proxy.hs
+++ /dev/null
@@ -1,185 +0,0 @@
-{-# LANGUAGE CPP #-}
-#ifdef LANGUAGE_DeriveDataTypeable
-{-# LANGUAGE DeriveDataTypeable #-}
-#endif
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 706
-{-# LANGUAGE PolyKinds #-}
-#endif
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 707
-{-# LANGUAGE StandaloneDeriving #-}
-#endif
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702
-{-# LANGUAGE Trustworthy #-}
-#endif
-{-# OPTIONS_GHC -fno-warn-orphans #-}
-----------------------------------------------------------------------------
--- |
--- Module     : Data.Proxy
--- Copyright  : 2009-2013 Edward Kmett
--- License    : BSD3
---
--- Maintainer  : Edward Kmett <ekmett@gmail.com>
--- Stability   : experimental
--- Portability : portable
---
--------------------------------------------------------------------------------
-module Data.Proxy
-    (
-    -- * Proxy values
-      Proxy(..)
-    , reproxy
-    , asProxyTypeOf
-    ) where
-
-import Control.Applicative (Applicative(..))
-import Data.Traversable (Traversable(..))
-import Data.Foldable (Foldable(..))
-import Data.Ix (Ix(..))
-import Data.Monoid
-#ifdef __GLASGOW_HASKELL__
-import GHC.Arr (unsafeIndex, unsafeRangeSize)
-import Data.Data
-#endif
-
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 707
-deriving instance Typeable Proxy
-#else
-data Proxy s = Proxy
-#endif
-
-instance Eq (Proxy s) where
-  _ == _ = True
-
-instance Ord (Proxy s) where
-  compare _ _ = EQ
-
-instance Show (Proxy s) where
-  showsPrec _ _ = showString "Proxy"
-
-instance Read (Proxy s) where
-  readsPrec d = readParen (d > 10) (\r -> [(Proxy, s) | ("Proxy",s) <- lex r ])
-
-#ifdef __GLASGOW_HASKELL__
-#if __GLASGOW_HASKELL__ < 707
-instance Typeable1 Proxy where
-  typeOf1 _ = mkTyConApp proxyTyCon []
-
-proxyTyCon :: TyCon
-#if __GLASGOW_HASKELL__ < 704
-proxyTyCon = mkTyCon "Data.Proxy.Proxy"
-#else
-proxyTyCon = mkTyCon3 "tagged" "Data.Proxy" "Proxy"
-#endif
-{-# NOINLINE proxyTyCon #-}
-#endif
-
-instance Data s => Data (Proxy s) where
-  gfoldl _ z _ = z Proxy
-  toConstr _ = proxyConstr
-  gunfold _ z c = case constrIndex c of
-    1 -> z Proxy
-    _ -> error "gunfold"
-  dataTypeOf _ = proxyDataType
-  dataCast1 f = gcast1 f
-
-proxyConstr :: Constr
-proxyConstr = mkConstr proxyDataType "Proxy" [] Prefix
-{-# NOINLINE proxyConstr #-}
-
-proxyDataType :: DataType
-proxyDataType = mkDataType "Data.Proxy.Proxy" [proxyConstr]
-{-# NOINLINE proxyDataType #-}
-#endif
-
-instance Enum (Proxy s) where
-    succ _ = error "Proxy.succ"
-    pred _ = error "Proxy.pred"
-    fromEnum _ = 0
-    toEnum 0 = Proxy
-    toEnum _ = error "Proxy.toEnum: 0 expected"
-    enumFrom _ = [Proxy]
-    enumFromThen _ _ = [Proxy]
-    enumFromThenTo _ _ _ = [Proxy]
-    enumFromTo _ _ = [Proxy]
-
-instance Ix (Proxy s) where
-    range _ = [Proxy]
-    index _ _ = 0
-    inRange _ _ = True
-    rangeSize _ = 1
-#ifdef __GLASGOW_HASKELL__
-    unsafeIndex _ _ = 0
-    unsafeRangeSize _ = 1
-#endif
-
-instance Bounded (Proxy s) where
-    minBound = Proxy
-    maxBound = Proxy
-
-instance Functor Proxy where
-    fmap _ _ = Proxy
-    {-# INLINE fmap #-}
-
-instance Applicative Proxy where
-    pure _ = Proxy
-    {-# INLINE pure #-}
-    _ <*> _ = Proxy
-    {-# INLINE (<*>) #-}
-
-instance Monoid (Proxy s) where
-    mempty = Proxy
-    {-# INLINE mempty #-}
-    mappend _ _ = Proxy
-    {-# INLINE mappend #-}
-    mconcat _ = Proxy
-    {-# INLINE mconcat #-}
-
-instance Monad Proxy where
-    return _ = Proxy
-    {-# INLINE return #-}
-    _ >>= _ = Proxy
-    {-# INLINE (>>=) #-}
-
-instance Foldable Proxy where
-    foldMap _ _ = mempty
-    {-# INLINE foldMap #-}
-    fold _ = mempty
-    {-# INLINE fold #-}
-    foldr _ z _ = z
-    {-# INLINE foldr #-}
-    foldl _ z _ = z
-    {-# INLINE foldl #-}
-    foldl1 _ _ = error "foldl1: Proxy"
-    {-# INLINE foldl1 #-}
-    foldr1 _ _ = error "foldr1: Proxy"
-    {-# INLINE foldr1 #-}
-
-instance Traversable Proxy where
-    traverse _ _ = pure Proxy
-    {-# INLINE traverse #-}
-    sequenceA _ = pure Proxy
-    {-# INLINE sequenceA #-}
-    mapM _ _ = return Proxy
-    {-# INLINE mapM #-}
-    sequence _ = return Proxy
-    {-# INLINE sequence #-}
-
--- | Some times you need to change the proxy you have lying around.
--- Idiomatic usage is to make a new combinator for the relationship
--- between the proxies that you want to enforce, and define that
--- combinator using 'reproxy'.
---
--- > data Succ n
--- > reproxySucc :: proxy n -> Proxy (Succ n)
--- > reproxySucc = reproxy
-reproxy :: proxy s -> Proxy t
-reproxy _ = Proxy
-{-# INLINE reproxy #-}
-
--- | 'asProxyTypeOf' is a type-restricted version of 'const'.
--- It is usually used as an infix operator, and its typing forces its first
--- argument (which is usually overloaded) to have the same type as the tag
--- of the second.
-asProxyTypeOf :: a -> proxy a -> a
-asProxyTypeOf = const
-{-# INLINE asProxyTypeOf #-}
diff --git a/src/Data/Proxy/TH.hs b/src/Data/Proxy/TH.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Proxy/TH.hs
@@ -0,0 +1,90 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE TemplateHaskellQuotes #-}
+#ifndef MIN_VERSION_template_haskell
+#define MIN_VERSION_template_haskell(x,y,z) 1
+#endif
+-- template-haskell is only safe since GHC-8.2
+#if __GLASGOW_HASKELL__ >= 802
+{-# LANGUAGE Safe #-}
+#else
+{-# LANGUAGE Trustworthy #-}
+#endif
+module Data.Proxy.TH
+  ( pr
+  , pr1
+  ) where
+
+import Data.Char
+import Data.Proxy (Proxy(..))
+import Language.Haskell.TH
+import Language.Haskell.TH.Quote
+
+proxy_d, proxy_tc :: Name
+proxy_d  = 'Proxy
+proxy_tc = ''Proxy
+
+proxyTypeQ :: TypeQ -> TypeQ
+proxyTypeQ t = appT (conT proxy_tc) t
+
+proxyExpQ :: TypeQ -> ExpQ
+proxyExpQ t = sigE (conE proxy_d) (proxyTypeQ t)
+
+proxyPatQ :: TypeQ -> PatQ
+proxyPatQ t = sigP (conP proxy_d []) (proxyTypeQ t)
+
+-- | A proxy value quasiquoter. @[pr|T|]@ will splice an expression
+-- @Proxy::Proxy T@, while @[pr|A,B,C|]@ will splice in a value of
+-- @Proxy :: Proxy [A,B,C]@.
+
+-- TODO: parse a richer syntax for the types involved here so we can include spaces, applications, etc.
+{-# DEPRECATED
+      pr
+      [ "'pr' will be removed in the next release. Use 'Proxy' with @TypeApplications@ instead. "
+      , "Instead of using @[pr|T|]@, use @Proxy \\@T@ instead. "
+      , "Instead of using @[pr|A,B,C|]@, use @Proxy \\@[A,B,C]@ instead. "
+      ] #-}
+pr :: QuasiQuoter
+pr = QuasiQuoter (mkProxy proxyExpQ) (mkProxy proxyPatQ) (mkProxy proxyTypeQ) undefined where
+  mkProxy :: (TypeQ -> r) -> String -> r
+  mkProxy p s = case ts of
+    [h@(t:_)]
+       | isUpper t -> p $ conT $ mkName h
+       | otherwise -> p $ varT $ mkName h
+    _ -> p $ mkList <$> cons
+    where
+      ts = map strip $ splitOn ',' s
+      cons = mapM (conT . mkName) ts
+      mkList = foldr (AppT . AppT PromotedConsT) PromotedNilT
+
+-- | Like 'pr', but takes a single type, which is used to produce a
+-- 'Proxy' for a single-element list containing only that type. This
+-- is useful for passing a single type to a function that wants a list
+-- of types.
+
+-- TODO: parse a richer syntax for the types involved here so we can include spaces, applications, etc.
+{-# DEPRECATED
+      pr1
+      [ "'pr1' will be removed in the next release. Use 'Proxy' with @TypeApplications@ instead. "
+      , "Instead of using @[pr1|T|]@, use @Proxy \\@'[T]@ instead. "
+      ] #-}
+pr1 :: QuasiQuoter
+pr1 = QuasiQuoter (mkProxy proxyExpQ) (mkProxy proxyPatQ) (mkProxy proxyTypeQ) undefined where
+  sing x = AppT (AppT PromotedConsT x) PromotedNilT
+  mkProxy p s = case s of
+    t:_
+      | isUpper t -> p (fmap sing (conT $ mkName s))
+      | otherwise -> p (fmap sing (varT $ mkName s))
+    _ -> error "Empty string passed to pr1"
+
+-- | Split on a delimiter.
+splitOn :: Eq a => a -> [a] -> [[a]]
+splitOn d = go where
+  go [] = []
+  go xs = case t of
+      [] -> [h]
+      (_:t') -> h : go t'
+    where (h,t) = break (== d) xs
+
+-- | Remove white space from both ends of a 'String'.
+strip :: String -> String
+strip = takeWhile (not . isSpace) . dropWhile isSpace
diff --git a/src/Data/Tagged.hs b/src/Data/Tagged.hs
--- a/src/Data/Tagged.hs
+++ b/src/Data/Tagged.hs
@@ -1,17 +1,13 @@
 {-# LANGUAGE CPP #-}
-#ifdef LANGUAGE_DeriveDataTypeable
-{-# LANGUAGE DeriveDataTypeable #-}
-#endif
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 706
+{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE PolyKinds #-}
-#endif
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 702
-{-# LANGUAGE Trustworthy #-}
-#endif
+{-# LANGUAGE Safe #-}
+
+{-# OPTIONS_GHC -Wno-deprecations #-}
 ----------------------------------------------------------------------------
 -- |
 -- Module     : Data.Tagged
--- Copyright  : 2009-2013 Edward Kmett
+-- Copyright  : 2009-2015 Edward Kmett
 -- License    : BSD3
 --
 -- Maintainer  : Edward Kmett <ekmett@gmail.com>
@@ -34,23 +30,45 @@
     , proxy
     , unproxy
     , tagWith
+    -- * Proxy methods GHC dropped
+    , reproxy
     ) where
 
-import Control.Applicative ((<$>), liftA2, Applicative(..))
+#if !(MIN_VERSION_base(4,18,0))
+import Control.Applicative (liftA2)
+#endif
+import Data.Bits
+import Data.Foldable (Foldable(..))
+#ifdef MIN_VERSION_deepseq
+import Control.DeepSeq (NFData(..))
+#endif
+import Data.Functor.Classes ( Eq1(..), Ord1(..), Read1(..), Show1(..)
+                            , Eq2(..), Ord2(..), Read2(..), Show2(..)
+                            )
 import Control.Monad (liftM)
-#if __GLASGOW_HASKELL__ >= 709
 import Data.Bifunctor
+#if MIN_VERSION_base(4,10,0)
+import Data.Bifoldable (Bifoldable(..))
+import Data.Bitraversable (Bitraversable(..))
 #endif
-import Data.Traversable (Traversable(..))
-import Data.Foldable (Foldable(..))
+#if MIN_VERSION_base(4,18,0)
+import Data.Foldable1 (Foldable1(..))
+import Data.Bifoldable1 (Bifoldable1(..))
+#endif
 #ifdef __GLASGOW_HASKELL__
 import Data.Data
 #endif
 import Data.Ix (Ix(..))
-import Data.Monoid
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ < 707
-import Data.Proxy
+import Data.Semigroup (Semigroup(..))
+import Data.String (IsString(..))
+#ifdef __MHS__
+import Data.Traversable (Traversable(..))
 #endif
+import Foreign.Ptr (castPtr)
+import Foreign.Storable (Storable(..))
+#ifdef __GLASGOW_HASKELL__
+import GHC.Generics (Generic, Generic1)
+#endif
 
 -- | A @'Tagged' s b@ value is a value @b@ with an attached phantom type @s@.
 -- This can be used in place of the more traditional but less safe idiom of
@@ -59,27 +77,17 @@
 --
 -- Moreover, you don't have to rely on the compiler to inline away the extra
 -- argument, because the newtype is \"free\"
-newtype Tagged s b = Tagged { unTagged :: b } deriving
-  ( Eq, Ord, Ix, Bounded
-#if __GLASGOW_HASKELL__ >= 707
-  , Typeable
-#endif
-  )
-
+--
+-- 'Tagged' has kind @k -> * -> *@ if the compiler supports @PolyKinds@, therefore
+-- there is an extra @k@ showing in the instance haddocks that may cause confusion.
+newtype Tagged s b = Tagged { unTagged :: b }
+  deriving ( Eq, Ord, Ix, Bounded
 #ifdef __GLASGOW_HASKELL__
-#if __GLASGOW_HASKELL__ < 707
-instance Typeable2 Tagged where
-  typeOf2 _ = mkTyConApp taggedTyCon []
-
-taggedTyCon :: TyCon
-#if __GLASGOW_HASKELL__ < 704
-taggedTyCon = mkTyCon "Data.Tagged.Tagged"
-#else
-taggedTyCon = mkTyCon3 "tagged" "Data.Tagged" "Tagged"
-#endif
-
+           , Generic, Generic1
 #endif
+           )
 
+#ifdef __GLASGOW_HASKELL__
 instance (Data s, Data b) => Data (Tagged s b) where
   gfoldl f z (Tagged b) = z Tagged `f` b
   toConstr _ = taggedConstr
@@ -108,33 +116,93 @@
     readsPrec d = readParen (d > 10) $ \r ->
         [(Tagged a, t) | ("Tagged", s) <- lex r, (a, t) <- readsPrec 11 s]
 
-instance Monoid a => Monoid (Tagged s a) where
+instance Semigroup a => Semigroup (Tagged s a) where
+    Tagged a <> Tagged b = Tagged (a <> b)
+    stimes n (Tagged a)  = Tagged (stimes n a)
+
+instance (Semigroup a, Monoid a) => Monoid (Tagged s a) where
     mempty = Tagged mempty
-    mappend (Tagged a) (Tagged b) = Tagged (mappend a b)
+    mappend = (<>)
 
 instance Functor (Tagged s) where
     fmap f (Tagged x) = Tagged (f x)
     {-# INLINE fmap #-}
 
-#if __GLASGOW_HASKELL__ >= 709
 -- this instance is provided by the bifunctors package for GHC<7.9
 instance Bifunctor Tagged where
     bimap _ g (Tagged b) = Tagged (g b)
     {-# INLINE bimap #-}
+
+#if MIN_VERSION_base(4,10,0)
+-- these instances are provided by the bifunctors package for GHC<8.1
+instance Bifoldable Tagged where
+    bifoldMap _ g (Tagged b) = g b
+    {-# INLINE bifoldMap #-}
+
+instance Bitraversable Tagged where
+    bitraverse _ g (Tagged b) = Tagged <$> g b
+    {-# INLINE bitraverse #-}
 #endif
 
+#if MIN_VERSION_base(4,18,0)
+instance Foldable1 (Tagged a) where
+  foldMap1 f (Tagged a) = f a
+  {-# INLINE foldMap1 #-}
+
+instance Bifoldable1 Tagged where
+  bifoldMap1 _ g (Tagged b) = g b
+  {-# INLINE bifoldMap1 #-}
+#endif
+
+#ifdef MIN_VERSION_deepseq
+instance NFData b => NFData (Tagged s b) where
+    rnf (Tagged b) = rnf b
+#endif
+
+instance Eq1 (Tagged s) where
+    liftEq eq (Tagged a) (Tagged b) = eq a b
+
+instance Ord1 (Tagged s) where
+    liftCompare cmp (Tagged a) (Tagged b) = cmp a b
+
+instance Read1 (Tagged s) where
+    liftReadsPrec rp _ d = readParen (d > 10) $ \r ->
+        [(Tagged a, t) | ("Tagged", s) <- lex r, (a, t) <- rp 11 s]
+
+instance Show1 (Tagged s) where
+    liftShowsPrec sp _ n (Tagged b) = showParen (n > 10) $
+        showString "Tagged " .
+        sp 11 b
+
+instance Eq2 Tagged where
+    liftEq2 _ eq (Tagged a) (Tagged b) = eq a b
+
+instance Ord2 Tagged where
+    liftCompare2 _ cmp (Tagged a) (Tagged b) = cmp a b
+
+instance Read2 Tagged where
+    liftReadsPrec2 _ _ rp _ d = readParen (d > 10) $ \r ->
+        [(Tagged a, t) | ("Tagged", s) <- lex r, (a, t) <- rp 11 s]
+
+instance Show2 Tagged where
+    liftShowsPrec2 _ _ sp _ n (Tagged b) = showParen (n > 10) $
+        showString "Tagged " .
+        sp 11 b
+
 instance Applicative (Tagged s) where
     pure = Tagged
     {-# INLINE pure #-}
     Tagged f <*> Tagged x = Tagged (f x)
     {-# INLINE (<*>) #-}
+    _ *> n = n
+    {-# INLINE (*>) #-}
 
 instance Monad (Tagged s) where
-    return = Tagged
+    return = pure
     {-# INLINE return #-}
     Tagged m >>= k = k m
     {-# INLINE (>>=) #-}
-    _ >> n = n
+    (>>) = (*>)
     {-# INLINE (>>) #-}
 
 instance Foldable (Tagged s) where
@@ -218,7 +286,7 @@
     acosh = fmap acosh
     atanh = fmap atanh
     (**) = liftA2 (**)
-    logBase = liftA2 (**)
+    logBase = liftA2 logBase
 
 instance RealFrac a => RealFrac (Tagged s a) where
     properFraction (Tagged x) = (a, Tagged b) where
@@ -244,6 +312,52 @@
     isIEEE (Tagged x) = isIEEE x
     atan2 = liftA2 atan2
 
+instance Bits a => Bits (Tagged s a) where
+    Tagged a .&. Tagged b = Tagged (a .&. b)
+    Tagged a .|. Tagged b = Tagged (a .|. b)
+    xor (Tagged a) (Tagged b) = Tagged (xor a b)
+    complement (Tagged a) = Tagged (complement a)
+    shift (Tagged a) i = Tagged (shift a i)
+    shiftL (Tagged a) i = Tagged (shiftL a i)
+    shiftR (Tagged a) i = Tagged (shiftR a i)
+    rotate (Tagged a) i = Tagged (rotate a i)
+    rotateL (Tagged a) i = Tagged (rotateL a i)
+    rotateR (Tagged a) i = Tagged (rotateR a i)
+    bit i = Tagged (bit i)
+    setBit (Tagged a) i = Tagged (setBit a i)
+    clearBit (Tagged a) i = Tagged (clearBit a i)
+    complementBit (Tagged a) i = Tagged (complementBit a i)
+    testBit (Tagged a) i = testBit a i
+    isSigned (Tagged a) = isSigned a
+    bitSize (Tagged a) = bitSize a -- deprecated, but still required :(
+    unsafeShiftL (Tagged a) i = Tagged (unsafeShiftL a i)
+    unsafeShiftR (Tagged a) i = Tagged (unsafeShiftR a i)
+    popCount (Tagged a) = popCount a
+    bitSizeMaybe (Tagged a) = bitSizeMaybe a
+    zeroBits = Tagged zeroBits
+
+instance FiniteBits a => FiniteBits (Tagged s a) where
+    finiteBitSize (Tagged a) = finiteBitSize a
+    countLeadingZeros (Tagged a) = countLeadingZeros a
+    countTrailingZeros (Tagged a) = countTrailingZeros a
+
+instance IsString a => IsString (Tagged s a) where
+    fromString = Tagged . fromString
+
+instance Storable a => Storable (Tagged s a) where
+    sizeOf t = sizeOf a
+      where
+        Tagged a = Tagged undefined `asTypeOf` t
+    alignment t = alignment a
+      where
+        Tagged a = Tagged undefined `asTypeOf` t
+    peek ptr = Tagged <$> peek (castPtr ptr)
+    poke ptr (Tagged a) = poke (castPtr ptr) a
+    peekElemOff ptr i = Tagged <$> peekElemOff (castPtr ptr) i
+    pokeElemOff ptr i (Tagged a) = pokeElemOff (castPtr ptr) i a
+    peekByteOff ptr i = Tagged <$> peekByteOff (castPtr ptr) i
+    pokeByteOff ptr i (Tagged a) = pokeByteOff (castPtr ptr) i a
+
 -- | Some times you need to change the tag you have lying around.
 -- Idiomatic usage is to make a new combinator for the relationship between the
 -- tags that you want to enforce, and define that combinator using 'retag'.
@@ -296,3 +410,16 @@
 tagWith :: proxy s -> a -> Tagged s a
 tagWith _ = Tagged
 {-# INLINE tagWith #-}
+
+-- | Some times you need to change the proxy you have lying around.
+-- Idiomatic usage is to make a new combinator for the relationship
+-- between the proxies that you want to enforce, and define that
+-- combinator using 'reproxy'.
+--
+-- @
+-- data Succ n
+-- reproxySucc :: proxy n -> 'Proxy' (Succ n)
+-- reproxySucc = 'reproxy'
+-- @
+reproxy :: proxy a -> Proxy b
+reproxy _ = Proxy
diff --git a/tagged.cabal b/tagged.cabal
--- a/tagged.cabal
+++ b/tagged.cabal
@@ -1,5 +1,5 @@
 name:           tagged
-version:        0.7.3
+version:        0.8.10
 license:        BSD3
 license-file:   LICENSE
 author:         Edward A. Kmett
@@ -9,28 +9,65 @@
 synopsis:       Haskell 98 phantom types to avoid unsafely passing dummy arguments
 homepage:       http://github.com/ekmett/tagged
 bug-reports:    http://github.com/ekmett/tagged/issues
-copyright:      2009-2013 Edward A. Kmett
-description:    Haskell 98 phantom types to avoid unsafely passing dummy arguments
+copyright:      2009-2015 Edward A. Kmett
+description:    Haskell 98 phantom types to avoid unsafely passing dummy arguments.
 build-type:     Simple
 cabal-version:  >= 1.10
-extra-source-files: .travis.yml CHANGELOG.markdown README.markdown
+extra-source-files: .hlint.yaml CHANGELOG.markdown README.markdown
+tested-with:
+  GHC == 8.0.2
+  GHC == 8.2.2
+  GHC == 8.4.4
+  GHC == 8.6.5
+  GHC == 8.8.4
+  GHC == 8.10.7
+  GHC == 9.0.2
+  GHC == 9.2.8
+  GHC == 9.4.8
+  GHC == 9.6.6
+  GHC == 9.8.4
+  GHC == 9.10.1
+  GHC == 9.12.1
 
 source-repository head
   type: git
-  location: git://github.com/ekmett/tagged.git
+  location: https://github.com/ekmett/tagged.git
 
+flag deepseq
+  description:
+    You can disable the use of the `deepseq` package using `-f-deepseq`.
+    .
+    Disabing this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.
+  default: True
+  manual: True
+
+flag template-haskell
+  description:
+    You can disable the use of the `template-haskell` package using `-f-template-haskell`.
+    .
+    Disabling this is an unsupported configuration, but it may be useful for accelerating builds in sandboxes for expert users.
+  default: True
+  manual: True
+
 library
   default-language: Haskell98
   other-extensions: CPP
-  build-depends: base >= 2 && < 5
+  build-depends:
+    base >= 4.9 && < 5
   ghc-options: -Wall
   hs-source-dirs: src
-  exposed-modules: Data.Tagged
+  exposed-modules:
+    Data.Tagged
 
-  if !impl(hugs)
-    cpp-options: -DLANGUAGE_DeriveDataTypeable
-    other-extensions: DeriveDataTypeable
+  if impl(ghc >= 9.0)
+    -- these flags may abort compilation with GHC-8.10
+    -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295
+    ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode
 
-  if !impl(ghc>=7.7)
-    hs-source-dirs: old
-    exposed-modules: Data.Proxy
+  if flag(deepseq)
+    build-depends: deepseq >= 1.1 && < 1.6
+
+  if flag(template-haskell) && impl(ghc)
+    build-depends: template-haskell >= 2.11 && < 2.24
+    exposed-modules:
+      Data.Proxy.TH