diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Revision history for general-allocate
 
+## 0.2.0.0 -- 2022-12-20
+
+* Break out `Exceptable` out from `MonadWithExceptable`
+
 ## 0.1.1.0 -- 2022-12-20
 
 * Add `transformers` instances for `MonadWith`.
diff --git a/general-allocate.cabal b/general-allocate.cabal
--- a/general-allocate.cabal
+++ b/general-allocate.cabal
@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               general-allocate
-version:            0.1.1.0
+version:            0.2.0.0
 license:            Apache-2.0
 license-file:       LICENSE
 author:             Shea Levy
@@ -45,6 +45,7 @@
     Control.Monad.NoContinuation.Resource.Internal
     Control.Monad.With
     Data.GeneralAllocate
+    Data.Exceptable
 
   build-depends:
     , base             ^>= { 4.14, 4.16, 4.17 }
diff --git a/src/Control/Monad/Allocate.hs b/src/Control/Monad/Allocate.hs
--- a/src/Control/Monad/Allocate.hs
+++ b/src/Control/Monad/Allocate.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE DerivingVia #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
@@ -46,6 +47,7 @@
 import qualified Control.Monad.Writer.Strict as Strict
 import Data.Acquire
 import Data.Acquire.Internal
+import Data.Exceptable
 import Data.GeneralAllocate
 import Data.Kind
 
@@ -95,6 +97,9 @@
   generalRelease
     ∷ GeneralReleaseKey m
     → AllocationContext m ()
+
+-- | A 'MonadAllocate' whose exception type can be projected into the Haskell exception hierarchy
+type MonadAllocateExceptable m = (MonadAllocate m, Exceptable (AllocationException m))
 
 {- | A helper for [DerivingVia](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/deriving_via.html) a
 'MonadAllocate' instance for any 'MonadResource'.
diff --git a/src/Control/Monad/With.hs b/src/Control/Monad/With.hs
--- a/src/Control/Monad/With.hs
+++ b/src/Control/Monad/With.hs
@@ -1,12 +1,13 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
+{-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE DerivingVia #-}
+{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE InstanceSigs #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 {-# LANGUAGE UnicodeSyntax #-}
@@ -38,6 +39,7 @@
 import Control.Monad.Trans.Resource.Internal
 import qualified Control.Monad.Writer.Lazy as L
 import Control.Monad.Writer.Strict
+import Data.Exceptable
 import Data.Functor
 import Data.Functor.Identity
 import Data.GeneralAllocate
@@ -140,9 +142,7 @@
   rel _ = fin
 
 -- | A 'MonadWith' whose exception type can be projected into the Haskell exception hierarchy
-class MonadWith m ⇒ MonadWithExceptable m where
-  -- |
-  withExceptionToException ∷ WithException m → SomeException
+type MonadWithExceptable m = (MonadWith m, Exceptable (WithException m))
 
 instance MonadWith IO where
   stateThreadingGeneralWith (GeneralAllocate allocA) go = mask $ \restore → do
@@ -154,9 +154,6 @@
     c ← releaseA $ ReleaseSuccess b
     pure (b, c)
 
-instance MonadWithExceptable IO where
-  withExceptionToException = id
-
 {- | A helper for [DerivingVia](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/deriving_via.html) a
 'MonadWith' and 'MonadWithExceptable' instance for any 'Monad'.
 
@@ -181,17 +178,10 @@
     c ← releaseA'
     pure (b, c)
 
-instance (Monad m) ⇒ MonadWithExceptable (WithNoContinuation m) where
-  withExceptionToException = absurd
-
 deriving via WithNoContinuation (ST s) instance MonadWith (ST s)
 
-deriving via WithNoContinuation (ST s) instance MonadWithExceptable (ST s)
-
 deriving via WithNoContinuation Identity instance MonadWith Identity
 
-deriving via WithNoContinuation Identity instance MonadWithExceptable Identity
-
 instance (MonadWith m) ⇒ MonadWith (ReaderT r m) where
   type WithException (ReaderT r m) = WithException m
   stateThreadingGeneralWith
@@ -212,9 +202,6 @@
         pure $ GeneralAllocated a releaseA'
     stateThreadingGeneralWith (GeneralAllocate allocA') (flip runReaderT r . go)
 
-instance (MonadWithExceptable m) ⇒ MonadWithExceptable (ReaderT r m) where
-  withExceptionToException = withExceptionToException @m
-
 instance (MonadWith m) ⇒ MonadWith (ResourceT m) where
   type WithException (ResourceT m) = WithException m
   stateThreadingGeneralWith
@@ -235,29 +222,18 @@
         pure $ GeneralAllocated a releaseA'
     stateThreadingGeneralWith (GeneralAllocate allocA') (flip unResourceT st . go)
 
-instance (MonadWithExceptable m) ⇒ MonadWithExceptable (ResourceT m) where
-  withExceptionToException = withExceptionToException @m
-
 instance MonadWith (Either e) where
-  type WithException (Either e) = e
+  type WithException (Either e) = EitherException e
   stateThreadingGeneralWith (GeneralAllocate allocA) go = do
     GeneralAllocated a releaseA ← allocA id
     b ← case go a of
       Left e → do
-        _ ← releaseA $ ReleaseFailure e
+        _ ← releaseA . ReleaseFailure $ EitherException e
         Left e
       x → x
     c ← releaseA $ ReleaseSuccess b
     pure (b, c)
 
--- | An 'Exception' representing a failure in the 'Either' monad.
-newtype EitherException e = EitherException e deriving stock (Show)
-
-instance (Show e, Typeable e) ⇒ Exception (EitherException e)
-
-instance (Show e, Typeable e) ⇒ MonadWithExceptable (Either e) where
-  withExceptionToException = toException . EitherException
-
 instance MonadWith m ⇒ MonadWith (MaybeT m) where
   type WithException (MaybeT m) = Maybe (WithException m)
   stateThreadingGeneralWith
@@ -283,15 +259,6 @@
       restore' ∷ ∀ x. MaybeT m x → MaybeT m x
       restore' = MaybeT . restore . runMaybeT
 
--- | An 'Exception' representing the 'Nothing' case in a 'MaybeT' monad.
-data NothingException = NothingException deriving (Show)
-
-instance Exception NothingException
-
-instance MonadWithExceptable m ⇒ MonadWithExceptable (MaybeT m) where
-  withExceptionToException (Just e) = withExceptionToException @m e
-  withExceptionToException Nothing = toException NothingException
-
 instance MonadWith m ⇒ MonadWith (ExceptT e m) where
   type WithException (ExceptT e m) = Either e (WithException m)
   stateThreadingGeneralWith
@@ -320,10 +287,6 @@
       restore' ∷ ∀ x. ExceptT e m x → ExceptT e m x
       restore' = ExceptT . restore . runExceptT
 
-instance (Show e, Typeable e, MonadWithExceptable m) ⇒ MonadWithExceptable (ExceptT e m) where
-  withExceptionToException (Right e) = withExceptionToException @m e
-  withExceptionToException (Left e) = toException $ EitherException e
-
 instance MonadWith m ⇒ MonadWith (IdentityT m) where
   type WithException (IdentityT m) = WithException m
   stateThreadingGeneralWith
@@ -342,9 +305,6 @@
       restore' ∷ ∀ x. IdentityT m x → IdentityT m x
       restore' = IdentityT . restore . runIdentityT
 
-instance MonadWithExceptable m ⇒ MonadWithExceptable (IdentityT m) where
-  withExceptionToException = withExceptionToException @m
-
 instance MonadWith m ⇒ MonadWith (L.StateT s m) where
   type WithException (L.StateT s m) = (WithException m, s)
   stateThreadingGeneralWith
@@ -366,9 +326,6 @@
       (a, s1) → L.runStateT (go a) s1
     pure ((b, c), s3)
 
-instance (MonadWithExceptable m) ⇒ MonadWithExceptable (L.StateT s m) where
-  withExceptionToException (e, _) = withExceptionToException @m e
-
 instance MonadWith m ⇒ MonadWith (StateT s m) where
   type WithException (StateT s m) = (WithException m, s)
   stateThreadingGeneralWith
@@ -390,9 +347,6 @@
       (a, s1) → runStateT (go a) s1
     pure ((b, c), s3)
 
-instance (MonadWithExceptable m) ⇒ MonadWithExceptable (StateT s m) where
-  withExceptionToException (e, _) = withExceptionToException @m e
-
 instance (MonadWith m, Monoid w) ⇒ MonadWith (L.WriterT w m) where
   type WithException (L.WriterT w m) = (WithException m, w)
   stateThreadingGeneralWith
@@ -420,9 +374,6 @@
         pure (b, w0 <> w1)
     pure ((b, c), w2)
 
-instance (MonadWithExceptable m, Monoid w) ⇒ MonadWithExceptable (L.WriterT w m) where
-  withExceptionToException (e, _) = withExceptionToException @m e
-
 instance (MonadWith m, Monoid w) ⇒ MonadWith (WriterT w m) where
   type WithException (WriterT w m) = (WithException m, w)
   stateThreadingGeneralWith
@@ -450,9 +401,6 @@
         pure (b, w0 <> w1)
     pure ((b, c), w2)
 
-instance (MonadWithExceptable m, Monoid w) ⇒ MonadWithExceptable (WriterT w m) where
-  withExceptionToException (e, _) = withExceptionToException @m e
-
 instance (MonadWith m, Monoid w) ⇒ MonadWith (L.RWST r w s m) where
   type WithException (L.RWST r w s m) = (WithException m, s, w)
   stateThreadingGeneralWith
@@ -480,9 +428,6 @@
         pure (b, s2, w0 <> w1)
     pure ((b, c), s3, w2)
 
-instance (MonadWithExceptable m, Monoid w) ⇒ MonadWithExceptable (L.RWST r w s m) where
-  withExceptionToException (e, _, _) = withExceptionToException @m e
-
 instance (MonadWith m, Monoid w) ⇒ MonadWith (RWST r w s m) where
   type WithException (RWST r w s m) = (WithException m, s, w)
   stateThreadingGeneralWith
@@ -509,6 +454,3 @@
         (b, s2, w1) ← runRWST (go a) r s1
         pure (b, s2, w0 <> w1)
     pure ((b, c), s3, w2)
-
-instance (MonadWithExceptable m, Monoid w) ⇒ MonadWithExceptable (RWST r w s m) where
-  withExceptionToException (e, _, _) = withExceptionToException @m e
diff --git a/src/Data/Exceptable.hs b/src/Data/Exceptable.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Exceptable.hs
@@ -0,0 +1,54 @@
+{-# LANGUAGE DerivingStrategies #-}
+{-# LANGUAGE UnicodeSyntax #-}
+
+{- |
+Description : Projections into the Haskell exception hierarchy
+Copyright   : Copyright 2022 Shea Levy.
+License     : Apache-2.0
+Maintainer  : shea@shealevy.com
+
+Provides 'Exceptable' for error types which can be projected into
+the Haskell exception hierarchy.
+-}
+module Data.Exceptable where
+
+import Control.Exception
+import Data.Typeable
+import Data.Void
+
+-- | Types which can be projected into the Haskell exception hierarchy
+class Exceptable e where
+  toSomeException ∷ e → SomeException
+
+instance Exceptable SomeException where
+  toSomeException = id
+
+instance Exceptable Void where
+  toSomeException = absurd
+
+-- | An 'Exception' representing a failure in the 'Either' monad.
+newtype EitherException e = EitherException e deriving stock (Show)
+
+instance (Show e, Typeable e) ⇒ Exception (EitherException e)
+
+instance (Show e, Typeable e) ⇒ Exceptable (EitherException e) where
+  toSomeException = toException
+
+-- | An 'Exception' representing the 'Nothing' case in a 'Maybe' monad.
+data NothingException = NothingException deriving (Show)
+
+instance Exception NothingException
+
+instance Exceptable e ⇒ Exceptable (Maybe e) where
+  toSomeException (Just e) = toSomeException e
+  toSomeException Nothing = toException NothingException
+
+instance (Show e, Typeable e, Exceptable e') ⇒ Exceptable (Either e e') where
+  toSomeException (Left e) = toException $ EitherException e
+  toSomeException (Right e) = toSomeException e
+
+instance Exceptable e ⇒ Exceptable (e, s) where
+  toSomeException (e, _) = toSomeException e
+
+instance Exceptable e ⇒ Exceptable (e, s, w) where
+  toSomeException (e, _, _) = toSomeException e