Binary instance for Generically.

README.md

@@ -55,23 +55,40 @@ the ``Get`` and ``Put`` monads.
 
 More information in the haddock documentation.
 
-## Deriving binary instances using GHC's Generic ##
+## Deriving binary instances, ``Generically`` ##
 
-Beginning with GHC 7.2, it is possible to use binary serialization without
-writing any instance boilerplate code.
+Beginning with GHC 9.4 it is possible to derive binary serialization
+using the ``Generically`` newtype.
+
+This is achieved by deriving an instance of ``Generic`` and then
+deriving the appropriate ``Binary T`` instance via ``Generically T``.
 
 ```haskell
-{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE DeriveGeneric      #-}
+{-# LANGUAGE DerivingStrategies #-}
+{-# LANGUAGE DerivingVia        #-}
 
 import Data.Binary
-import GHC.Generics (Generic)
+import GHC.Generics (Generic, Generically(..))
+
+data Foo = Foo
+  deriving stock Generic
+  deriving Binary via Generically Foo
+```
 
-data Foo = Foo deriving (Generic)
+Beginning with GHC 7.2, a generic definition has been a part of the
+``Binary`` typeclass. This could also be derived using the
+``anyclass`` strategy:
 
--- GHC will automatically fill out the instance
-instance Binary Foo
+```haskell
+data Foo = Foo
+  deriving stock    Generic
+  deriving anyclass Binary
 ```
 
+Which means the same as an empty class declaration: ``instance
+Binary Foo``.
+
 ## Contributors ##
 
 * Lennart Kolmodin

changelog.md

@@ -6,6 +6,8 @@ binary-x.x.x.x
 
 - Don't reexport `Data.Word` from `Data.Binary`
 - Add `Binary (Proxy a)` instance
+- Add binary instance for `GHC.Generics.Generically`. `Binary T` can
+  be derived via `Generically T` for a suitable generic type `T`.
 
 binary-0.8.9.2
 --------------

src/Data/Binary.hs

@@ -226,19 +226,31 @@ decodeFileOrFail f =
 ------------------------------------------------------------------------
 -- $generics
 --
--- Beginning with GHC 7.2, it is possible to use binary serialization
--- without writing any instance boilerplate code.
+-- Beginning with GHC 9.4 it is possible to derive binary
+-- serialization using the 'GHC.Generics.Generically' newtype.
 --
--- > {-# LANGUAGE DeriveGeneric #-}
+-- This is achieved by deriving an instance of 'GHC.Generics.Generic'
+-- and then deriving the appropriate @'Binary' T@ instance via
+-- @Generically T@.
+--
+-- > {-# LANGUAGE DeriveGeneric      #-}
+-- > {-# LANGUAGE DerivingStrategies #-}
+-- > {-# LANGUAGE DerivingVia        #-}
 -- >
 -- > import Data.Binary
--- > import GHC.Generics (Generic)
+-- > import GHC.Generics (Generic, Generically(..))
 -- >
 -- > data Foo = Foo
--- >          deriving (Generic)
--- >
--- > -- GHC will automatically fill out the instance
--- > instance Binary Foo
+-- >   deriving stock Generic
+-- >   deriving Binary via Generically Foo
 --
--- This mechanism makes use of GHC's efficient built-in generics
--- support.
+-- Beginning with GHC 7.2, a generic definition has been a part of
+-- the 'Binary' typeclass. This could also be derived using the
+-- @anyclass@ strategy:
+--
+-- > data Foo = Foo
+-- >   deriving stock    Generic
+-- >   deriving anyclass Binary
+-- 
+-- Which means the same as an empty class declaration: @instance
+-- Binary Foo@.

src/Data/Binary/Class.hs

@@ -1,15 +1,21 @@
 {-# LANGUAGE CPP, FlexibleContexts #-}
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE GADTs #-}
+{-# LANGUAGE InstanceSigs #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE PatternGuards #-}
 {-# LANGUAGE PolyKinds #-}
+{-# LANGUAGE UndecidableInstances #-}
 {-# LANGUAGE Trustworthy #-}
 
 #if MIN_VERSION_base(4,16,0)
 #define HAS_TYPELITS_CHAR
 #endif
 
+#if MIN_VERSION_base(4,17,0)
+#define HAS_GENERICALLY
+#endif
+
 #if MIN_VERSION_base(4,8,0)
 #define HAS_NATURAL
 #define HAS_VOID
@@ -176,6 +182,15 @@
 defaultPutList :: Binary a => [a] -> Put
 defaultPutList xs = put (length xs) <> mapM_ put xs
 
+#ifdef HAS_GENERICALLY
+instance (Generic a, GBinaryPut (Rep a), GBinaryGet (Rep a)) => Binary (Generically a) where
+  put :: Generically a -> Put
+  put (Generically a) = gput (from a)
+
+  get :: Get (Generically a)
+  get = Generically . to <$> gget
+#endif
+
 ------------------------------------------------------------------------
 -- Simple instances
 
@@ -829,9 +844,9 @@
 
 #if __GLASGOW_HASKELL__ < 901
 -- | @since 0.8.4.0
 instance Binary a => Binary (Semigroup.Option a) where
   get = fmap Semigroup.Option get
   put = put . Semigroup.getOption
 #endif
 
 -- | @since 0.8.4.0