generic-data 0.9.1.0 → 0.9.2.0

raw patch · 4 files changed

+118/−15 lines, 4 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGELOG.md +4/−0
• generic-data.cabal +1/−1
• src/Generic/Data.hs +20/−14
• src/Generic/Data/Internal/Generically.hs +93/−0

@@ -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)

@@ -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.

@@ -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.

@@ -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