diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 0.9.2.0
+
+- Add instance of `Bounded` for `FiniteEnumeration` (the same as `Generically`)
+
 # 0.9.1.0
 
 - Fix `conIdToString` (it was completely broken)
diff --git a/generic-data.cabal b/generic-data.cabal
--- a/generic-data.cabal
+++ b/generic-data.cabal
@@ -1,5 +1,5 @@
 name:                generic-data
-version:             0.9.1.0
+version:             0.9.2.0
 synopsis:            Deriving instances with GHC.Generics and related utilities
 description:
   Generic implementations of standard type classes.
diff --git a/src/Generic/Data.hs b/src/Generic/Data.hs
--- a/src/Generic/Data.hs
+++ b/src/Generic/Data.hs
@@ -56,21 +56,30 @@
 --
 -- === Functor composition
 --
--- Fields of functors involving the composition of two or more
--- functors @f (g (h a))@ cannot be handled nicely using @GHC.Generics@.
--- Some overhead cannot be safely avoided.
+-- Fields of functors involving the composition of two or more functors
+-- @f (g (h a))@ result in some overhead using "GHC.Generics.Generic1".
 --
 -- This is due to a particular encoding choice of @GHC.Generics@, where
 -- composition are nested to the right instead of to the left. @f (g (h _))@ is
--- represented by the functor @f ':.:' (g ':.:' 'Rec1' h)@. A better choice is to
--- encode it as @('Rec1' f ':.:' g) ':.:' h@, because that is coercible back to
--- @f (g (h _))@.
+-- represented by the functor @f ':.:' (g ':.:' 'Rec1' h)@, so one must use
+-- `fmap` on `f` to convert that back to `f (g (h _))`. A better choice would
+-- have been to encode it as @('Rec1' f ':.:' g) ':.:' h@, because that is
+-- coercible back to @f (g (h _))@.
 
 module Generic.Data
-  ( -- * Regular classes
+  ( -- * Newtypes for Deriving Via
+    Generically(..)
+  , GenericProduct(..)
+  , FiniteEnumeration(..)
+  , Generically1(..)
 
+    -- * Regular classes
+
+    -- | Default implementations for classes indexed by types
+    -- (kind @Type@).
+
     -- ** 'Data.Semigroup.Semigroup'
-    gmappend
+  , gmappend
 
     -- ** 'Monoid'
   , gmempty
@@ -130,6 +139,9 @@
 
     -- * Higher-kinded classes
 
+    -- | Default implementations for classes indexed by type constructors
+    -- (kind @Type -> Type@).
+
     -- ** 'Functor'
     -- | Can also be derived by GHC (@DeriveFunctor@ extension).
   , gfmap
@@ -174,12 +186,6 @@
   , Id1(..)
   , Opaque(..)
   , Opaque1(..)
-
-    -- * Carriers of generic instances
-  , Generically(..)
-  , GenericProduct(..)
-  , FiniteEnumeration(..)
-  , Generically1(..)
 
     -- * Newtype
     -- | Generic pack/unpack.
diff --git a/src/Generic/Data/Internal/Generically.hs b/src/Generic/Data/Internal/Generically.hs
--- a/src/Generic/Data/Internal/Generically.hs
+++ b/src/Generic/Data/Internal/Generically.hs
@@ -32,6 +32,38 @@
 import Generic.Data.Internal.Traversable (GFoldable, GTraversable, gfoldMap, gtraverse, gsequenceA)
 
 -- | Type with instances derived via 'Generic'.
+--
+-- === Examples
+--
+-- ==== __Deriving 'Eq', 'Ord', 'Show', 'Read'__
+--
+-- >>> :set -XDerivingVia -XDeriveGeneric
+-- >>> :{
+-- data T = C Int Bool
+--   deriving Generic
+--   deriving (Eq, Ord, Show, Read) via (Generically T)
+-- :}
+--
+-- ==== __Deriving 'Semigroup', 'Monoid'__
+--
+-- The type must have only one constructor.
+--
+-- >>> :{
+-- data U = D [Int] (Sum Int)
+--   deriving Generic
+--   deriving (Semigroup, Monoid) via (Generically U)
+-- :}
+--
+-- ==== __Deriving 'Enum', 'Bounded'__
+--
+-- The type must have only nullary constructors.
+-- To lift that restriction, see 'FiniteEnumeration'.
+--
+-- >>> :{
+-- data V = X | Y | Z
+--   deriving Generic
+--   deriving (Eq, Ord, Enum, Bounded) via (Generically V)
+-- :}
 newtype Generically a = Generically { unGenerically :: a }
 
 instance Generic a => Generic (Generically a) where
@@ -80,6 +112,17 @@
   maxBound = gmaxBound
 
 -- | Type with 'Enum' instance derived via 'Generic' with 'FiniteEnum' option.
+-- This allows deriving 'Enum' for types whose constructors have fields.
+--
+-- Some caution is advised; see details in 'FiniteEnum'.
+--
+-- === __Example__
+--
+-- >>> :{
+-- data Booool = Booool Bool Bool
+--   deriving Generic
+--   deriving (Enum, Bounded) via (FiniteEnumeration Booool)
+-- :}
 newtype FiniteEnumeration a = FiniteEnumeration { unFiniteEnumeration :: a }
 
 instance Generic a => Generic (FiniteEnumeration a) where
@@ -95,7 +138,57 @@
   enumFromTo = gfiniteEnumFromTo
   enumFromThenTo = gfiniteEnumFromThenTo
 
+-- | The same instance as 'Generically', for convenience.
+instance (Generic a, GBounded (Rep a)) => Bounded (FiniteEnumeration a) where
+  minBound = gminBound
+  maxBound = gmaxBound
+
 -- | Type with instances derived via 'Generic1'.
+--
+-- === Examples
+--
+-- ==== __Deriving 'Functor', 'Applicative', 'Alternative'__
+--
+-- 'Applicative' can be derived for types with only one
+-- constructor, aka. products.
+--
+-- >>> :{
+-- data F a = F1 a | F2 (Maybe a) | F3 [Either Bool a] (Int, a)
+--   deriving Generic1
+--   deriving Functor via (Generically1 F)
+-- :}
+--
+-- >>> :{
+-- data G a = G a (Maybe a) [a] (IO a)
+--   deriving Generic1
+--   deriving (Functor, Applicative) via (Generically1 G)
+-- :}
+--
+-- >>> :{
+-- data G' a = G' (Maybe a) [a]
+--   deriving Generic1
+--   deriving (Functor, Applicative, Alternative) via (Generically1 G')
+-- :}
+--
+-- ==== __Deriving 'Foldable'__
+--
+-- >>> import Generic.Data.Orphans ()
+-- >>> :{
+-- data H a = H1 a | H2 (Maybe a)
+--   deriving Generic1
+--   deriving (Functor, Foldable) via (Generically1 H)
+-- :}
+--
+-- Note: we can't use @DerivingVia@ for 'Traversable'.
+-- One may implement 'Traversable' explicitly using 'gtraverse'.
+--
+-- ==== __Deriving 'Eq1', 'Ord1'__
+--
+-- >>> :{
+-- data I a = I [a] (Maybe a)
+--   deriving Generic1
+--   deriving (Eq1, Ord1) via (Generically1 I)
+-- :}
 newtype Generically1 f a = Generically1 { unGenerically1 :: f a }
 
 instance Generic (f a) => Generic (Generically1 f a) where