diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,17 @@
+0.9.1
+-----
+* Correct an improper use of `unsafeCoerce` in the internals of
+  `Data.Constraint.Nat` and `Data.Constraint.Symbol`
+* Correctly identify the mismatched types when you defer an unsatisfiable
+  equality constraint through `Data.Constraint.Deferrable`
+* Re-export the `(:~~:)` defined in `base` from `Data.Constraint.Deferred` with
+  GHC 8.2 or later
+* Add several new `(:=>)` instances for `Bits`, `Identity`, `Const`, `Natural`,
+  `IO`, and `Word`.
+* Modernize some existing `Class` and `(:=>)` instances to reflect the fact
+  that `Applicative` is now a superclass of `Monad` on recent versions of
+  `base`.
+
 0.9
 ---
 * Changes to `Data.Constraint`:
diff --git a/constraints.cabal b/constraints.cabal
--- a/constraints.cabal
+++ b/constraints.cabal
@@ -1,6 +1,6 @@
 name:          constraints
 category:      Constraints
-version:       0.9
+version:       0.9.1
 license:       BSD2
 cabal-version: >= 1.10
 license-file:  LICENSE
diff --git a/src/Data/Constraint.hs b/src/Data/Constraint.hs
--- a/src/Data/Constraint.hs
+++ b/src/Data/Constraint.hs
@@ -84,6 +84,14 @@
 import Data.Data
 import qualified GHC.Exts as Exts (Any)
 import GHC.Exts (Constraint)
+import Data.Bits (Bits)
+import Data.Functor.Identity (Identity)
+#if MIN_VERSION_base(4,8,0)
+import Numeric.Natural (Natural)
+#endif
+#if !MIN_VERSION_base(4,8,0)
+import Data.Word (Word)
+#endif
 
 -- | Values of type @'Dict' p@ capture a dictionary for a constraint of type @p@.
 --
@@ -172,7 +180,7 @@
 -- What are the two ways?
 --
 -- Well, we can go from @'Ord' a ':-' 'Eq' a@ via the
--- superclass relationship, and them from @'Eq' a ':-' 'Eq' [a]@ via the
+-- superclass relationship, and then from @'Eq' a ':-' 'Eq' [a]@ via the
 -- instance, or we can go from @'Ord' a ':-' 'Ord' [a]@ via the instance
 -- then from @'Ord' [a] ':-' 'Eq' [a]@ through the superclass relationship
 -- and this diagram by definition must \"commute\".
@@ -406,6 +414,12 @@
 instance (Eq a, Eq b) :=> Eq (Either a b) where ins = Sub Dict
 instance () :=> Eq (Dict a) where ins = Sub Dict
 instance () :=> Eq (a :- b) where ins = Sub Dict
+instance () :=> Eq Word where ins = Sub Dict
+instance Eq a :=> Eq (Identity a) where ins = Sub Dict
+#if MIN_VERSION_base(4,8,0)
+instance Eq a :=> Eq (Const a b) where ins = Sub Dict
+instance () :=> Eq Natural where ins = Sub Dict
+#endif
 
 -- Ord
 instance Class (Eq a) (Ord a) where cls = Sub Dict
@@ -423,6 +437,12 @@
 instance Integral a :=> Ord (Ratio a) where ins = Sub Dict
 instance () :=> Ord (Dict a) where ins = Sub Dict
 instance () :=> Ord (a :- b) where ins = Sub Dict
+instance () :=> Ord Word where ins = Sub Dict
+instance Ord a :=> Ord (Identity a) where ins = Sub Dict
+#if MIN_VERSION_base(4,8,0)
+instance Ord a :=> Ord (Const a b) where ins = Sub Dict
+instance () :=> Ord Natural where ins = Sub Dict
+#endif
 
 -- Show
 instance Class () (Show a) where cls = Sub Dict
@@ -438,6 +458,12 @@
 instance (Integral a, Show a) :=> Show (Ratio a) where ins = Sub Dict
 instance () :=> Show (Dict a) where ins = Sub Dict
 instance () :=> Show (a :- b) where ins = Sub Dict
+instance () :=> Show Word where ins = Sub Dict
+instance Show a :=> Show (Identity a) where ins = Sub Dict
+#if MIN_VERSION_base(4,8,0)
+instance Show a :=> Show (Const a b) where ins = Sub Dict
+instance () :=> Show Natural where ins = Sub Dict
+#endif
 
 -- Read
 instance Class () (Read a) where cls = Sub Dict
@@ -451,6 +477,12 @@
 instance (Read a, Read b) :=> Read (a, b) where ins = Sub Dict
 instance (Read a, Read b) :=> Read (Either a b) where ins = Sub Dict
 instance (Integral a, Read a) :=> Read (Ratio a) where ins = Sub Dict
+instance () :=> Read Word where ins = Sub Dict
+instance Read a :=> Read (Identity a) where ins = Sub Dict
+#if MIN_VERSION_base(4,8,0)
+instance Read a :=> Read (Const a b) where ins = Sub Dict
+instance () :=> Read Natural where ins = Sub Dict
+#endif
 
 -- Enum
 instance Class () (Enum a) where cls = Sub Dict
@@ -463,6 +495,14 @@
 instance () :=> Enum Float where ins = Sub Dict
 instance () :=> Enum Double where ins = Sub Dict
 instance Integral a :=> Enum (Ratio a) where ins = Sub Dict
+instance () :=> Enum Word where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance Enum a :=> Enum (Identity a) where ins = Sub Dict
+instance Enum a :=> Enum (Const a b) where ins = Sub Dict
+#endif
+#if MIN_VERSION_base(4,8,0)
+instance () :=> Enum Natural where ins = Sub Dict
+#endif
 
 -- Bounded
 instance Class () (Bounded a) where cls = Sub Dict
@@ -472,6 +512,11 @@
 instance () :=> Bounded Int where ins = Sub Dict
 instance () :=> Bounded Char where ins = Sub Dict
 instance (Bounded a, Bounded b) :=> Bounded (a,b) where ins = Sub Dict
+instance () :=> Bounded Word where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance Bounded a :=> Bounded (Identity a) where ins = Sub Dict
+instance Bounded a :=> Bounded (Const a b) where ins = Sub Dict
+#endif
 
 -- Num
 instance Class () (Num a) where cls = Sub Dict
@@ -481,6 +526,14 @@
 instance () :=> Num Double where ins = Sub Dict
 instance RealFloat a :=> Num (Complex a) where ins = Sub Dict
 instance Integral a :=> Num (Ratio a) where ins = Sub Dict
+instance () :=> Num Word where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance Num a :=> Num (Identity a) where ins = Sub Dict
+instance Num a :=> Num (Const a b) where ins = Sub Dict
+#endif
+#if MIN_VERSION_base(4,8,0)
+instance () :=> Num Natural where ins = Sub Dict
+#endif
 
 -- Real
 instance Class (Num a, Ord a) (Real a) where cls = Sub Dict
@@ -489,35 +542,81 @@
 instance () :=> Real Float where ins = Sub Dict
 instance () :=> Real Double where ins = Sub Dict
 instance Integral a :=> Real (Ratio a) where ins = Sub Dict
+instance () :=> Real Word where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance Real a :=> Real (Identity a) where ins = Sub Dict
+instance Real a :=> Real (Const a b) where ins = Sub Dict
+#endif
+#if MIN_VERSION_base(4,8,0)
+instance () :=> Real Natural where ins = Sub Dict
+#endif
 
 -- Integral
 instance Class (Real a, Enum a) (Integral a) where cls = Sub Dict
 instance () :=> Integral Int where ins = Sub Dict
 instance () :=> Integral Integer where ins = Sub Dict
+instance () :=> Integral Word where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance Integral a :=> Integral (Identity a) where ins = Sub Dict
+instance Integral a :=> Integral (Const a b) where ins = Sub Dict
+#endif
+#if MIN_VERSION_base(4,8,0)
+instance () :=> Integral Natural where ins = Sub Dict
+#endif
 
+-- Bits
+instance Class (Eq a) (Bits a) where cls = Sub Dict
+instance () :=> Bits Bool where ins = Sub Dict
+instance () :=> Bits Int where ins = Sub Dict
+instance () :=> Bits Integer where ins = Sub Dict
+instance () :=> Bits Word where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance Bits a :=> Bits (Identity a) where ins = Sub Dict
+instance Bits a :=> Bits (Const a b) where ins = Sub Dict
+#endif
+#if MIN_VERSION_base(4,8,0)
+instance () :=> Bits Natural where ins = Sub Dict
+#endif
+
 -- Fractional
 instance Class (Num a) (Fractional a) where cls = Sub Dict
 instance () :=> Fractional Float where ins = Sub Dict
 instance () :=> Fractional Double where ins = Sub Dict
 instance RealFloat a :=> Fractional (Complex a) where ins = Sub Dict
 instance Integral a :=> Fractional (Ratio a) where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance Fractional a :=> Fractional (Identity a) where ins = Sub Dict
+instance Fractional a :=> Fractional (Const a b) where ins = Sub Dict
+#endif
 
 -- Floating
 instance Class (Fractional a) (Floating a) where cls = Sub Dict
 instance () :=> Floating Float where ins = Sub Dict
 instance () :=> Floating Double where ins = Sub Dict
 instance RealFloat a :=> Floating (Complex a) where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance Floating a :=> Floating (Identity a) where ins = Sub Dict
+instance Floating a :=> Floating (Const a b) where ins = Sub Dict
+#endif
 
 -- RealFrac
 instance Class (Real a, Fractional a) (RealFrac a) where cls = Sub Dict
 instance () :=> RealFrac Float where ins = Sub Dict
 instance () :=> RealFrac Double where ins = Sub Dict
 instance Integral a :=> RealFrac (Ratio a) where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance RealFrac a :=> RealFrac (Identity a) where ins = Sub Dict
+instance RealFrac a :=> RealFrac (Const a b) where ins = Sub Dict
+#endif
 
 -- RealFloat
 instance Class (RealFrac a, Floating a) (RealFloat a) where cls = Sub Dict
 instance () :=> RealFloat Float where ins = Sub Dict
 instance () :=> RealFloat Double where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance RealFloat a :=> RealFloat (Identity a) where ins = Sub Dict
+instance RealFloat a :=> RealFloat (Const a b) where ins = Sub Dict
+#endif
 
 -- Monoid
 instance Class () (Monoid a) where cls = Sub Dict
@@ -526,6 +625,13 @@
 instance () :=> Monoid [a] where ins = Sub Dict
 instance Monoid a :=> Monoid (Maybe a) where ins = Sub Dict
 instance (Monoid a, Monoid b) :=> Monoid (a, b) where ins = Sub Dict
+instance Monoid a :=> Monoid (Const a b) where ins = Sub Dict
+#if MIN_VERSION_base(4,9,0)
+instance Monoid a :=> Monoid (Identity a) where ins = Sub Dict
+#endif
+#if MIN_VERSION_base(4,9,0)
+instance Monoid a :=> Monoid (IO a) where ins = Sub Dict
+#endif
 
 -- Functor
 instance Class () (Functor f) where cls = Sub Dict
@@ -536,6 +642,8 @@
 instance () :=> Functor ((,) a) where ins = Sub Dict
 instance () :=> Functor IO where ins = Sub Dict
 instance Monad m :=> Functor (WrappedMonad m) where ins = Sub Dict
+instance () :=> Functor Identity where ins = Sub Dict
+instance () :=> Functor (Const a) where ins = Sub Dict
 
 -- Applicative
 instance Class (Functor f) (Applicative f) where cls = Sub Dict
@@ -545,6 +653,7 @@
 instance () :=> Applicative ((->)a) where ins = Sub Dict
 instance () :=> Applicative IO where ins = Sub Dict
 instance Monoid a :=> Applicative ((,)a) where ins = Sub Dict
+instance Monoid a :=> Applicative (Const a) where ins = Sub Dict
 instance Monad m :=> Applicative (WrappedMonad m) where ins = Sub Dict
 
 -- Alternative
@@ -554,14 +663,23 @@
 instance MonadPlus m :=> Alternative (WrappedMonad m) where ins = Sub Dict
 
 -- Monad
+#if MIN_VERSION_base(4,8,0)
+instance Class (Applicative f) (Monad f) where cls = Sub Dict
+#else
 instance Class () (Monad f) where cls = Sub Dict
+#endif
 instance () :=> Monad [] where ins = Sub Dict
 instance () :=> Monad ((->) a) where ins = Sub Dict
 instance () :=> Monad (Either a) where ins = Sub Dict
 instance () :=> Monad IO where ins = Sub Dict
+instance () :=> Monad Identity where ins = Sub Dict
 
 -- MonadPlus
+#if MIN_VERSION_base(4,8,0)
+instance Class (Monad f, Alternative f) (MonadPlus f) where cls = Sub Dict
+#else
 instance Class (Monad f) (MonadPlus f) where cls = Sub Dict
+#endif
 instance () :=> MonadPlus [] where ins = Sub Dict
 instance () :=> MonadPlus Maybe where ins = Sub Dict
 
diff --git a/src/Data/Constraint/Deferrable.hs b/src/Data/Constraint/Deferrable.hs
--- a/src/Data/Constraint/Deferrable.hs
+++ b/src/Data/Constraint/Deferrable.hs
@@ -51,6 +51,10 @@
 import GHC.Types (type (~~))
 #endif
 
+#if __GLASGOW_HASKELL__ >= 801
+import Data.Type.Equality ((:~~:)(HRefl))
+#endif
+
 data UnsatisfiedConstraint = UnsatisfiedConstraint String
   deriving (Typeable, Show)
 
@@ -82,7 +86,7 @@
 deferEither_ r = deferEither @p Proxy r
 #endif
 
-#if __GLASGOW_HASKELL__ >= 800
+#if __GLASGOW_HASKELL__ >= 800 && __GLASGOW_HASKELL__ < 801
 -- | Kind heterogeneous propositional equality. Like '(:~:)', @a :~~: b@ is
 -- inhabited by a terminating value if and only if @a@ is the same type as @b@.
 --
@@ -112,7 +116,7 @@
   deferEither _ r = case cast (Refl :: a :~: a) :: Maybe (a :~: b) of
     Just Refl -> Right r
     Nothing   -> Left $
-      "deferred type equality: type mismatch between `" ++ showTypeRep (Proxy :: Proxy a) ++ "’ and `"  ++ showTypeRep (Proxy :: Proxy a) ++ "'"
+      "deferred type equality: type mismatch between `" ++ showTypeRep (Proxy :: Proxy a) ++ "’ and `"  ++ showTypeRep (Proxy :: Proxy b) ++ "'"
 
 #if __GLASGOW_HASKELL__ >= 800
 -- | Deferrable heterogenous equality constraints.
@@ -122,7 +126,7 @@
   deferEither _ r = case cast (HRefl :: a :~~: a) :: Maybe (a :~~: b) of
     Just HRefl -> Right r
     Nothing   -> Left $
-      "deferred type equality: type mismatch between `" ++ showTypeRep (Proxy :: Proxy a) ++ "’ and `"  ++ showTypeRep (Proxy :: Proxy a) ++ "'"
+      "deferred type equality: type mismatch between `" ++ showTypeRep (Proxy :: Proxy a) ++ "’ and `"  ++ showTypeRep (Proxy :: Proxy b) ++ "'"
 #endif
 
 instance (Deferrable a, Deferrable b) => Deferrable (a, b) where
diff --git a/src/Data/Constraint/Nat.hs b/src/Data/Constraint/Nat.hs
--- a/src/Data/Constraint/Nat.hs
+++ b/src/Data/Constraint/Nat.hs
@@ -54,10 +54,10 @@
 
 type Divides n m = n ~ Gcd n m
 
-newtype Magic n r = Magic (KnownNat n => r)
+newtype Magic n = Magic (KnownNat n => Dict (KnownNat n))
 
 magic :: forall n m o. (Integer -> Integer -> Integer) -> (KnownNat n, KnownNat m) :- KnownNat o
-magic f = Sub $ unsafeCoerce (Magic id) (natVal (Proxy :: Proxy n) `f` natVal (Proxy :: Proxy m))
+magic f = Sub $ unsafeCoerce (Magic Dict) (natVal (Proxy :: Proxy n) `f` natVal (Proxy :: Proxy m))
 
 axiom :: forall a b. Dict (a ~ b)
 axiom = unsafeCoerce (Dict :: Dict (a ~ a))
diff --git a/src/Data/Constraint/Symbol.hs b/src/Data/Constraint/Symbol.hs
--- a/src/Data/Constraint/Symbol.hs
+++ b/src/Data/Constraint/Symbol.hs
@@ -48,16 +48,16 @@
 
 -- implementation details
 
-newtype Magic n r = Magic (KnownSymbol n => r)
+newtype Magic n = Magic (KnownSymbol n => Dict (KnownSymbol n))
 
 magicNSS :: forall n m o. (Int -> String -> String) -> (KnownNat n, KnownSymbol m) :- KnownSymbol o
-magicNSS f = Sub $ unsafeCoerce (Magic id) (fromIntegral (natVal (Proxy :: Proxy n)) `f` symbolVal (Proxy :: Proxy m))
+magicNSS f = Sub $ unsafeCoerce (Magic Dict) (fromIntegral (natVal (Proxy :: Proxy n)) `f` symbolVal (Proxy :: Proxy m))
 
 magicSSS :: forall n m o. (String -> String -> String) -> (KnownSymbol n, KnownSymbol m) :- KnownSymbol o
-magicSSS f = Sub $ unsafeCoerce (Magic id) (symbolVal (Proxy :: Proxy n) `f` symbolVal (Proxy :: Proxy m))
+magicSSS f = Sub $ unsafeCoerce (Magic Dict) (symbolVal (Proxy :: Proxy n) `f` symbolVal (Proxy :: Proxy m))
 
 magicSN :: forall a n. (String -> Int) -> KnownSymbol a :- KnownNat n
-magicSN f = Sub $ unsafeCoerce (Magic id) (toInteger (f (symbolVal (Proxy :: Proxy a))))
+magicSN f = Sub $ unsafeCoerce (Magic Dict) (toInteger (f (symbolVal (Proxy :: Proxy a))))
 
 axiom :: forall a b. Dict (a ~ b)
 axiom = unsafeCoerce (Dict :: Dict (a ~ a))