Generics isomorphisms - Haskell

class Construct (Norm a) => ConstructNorm a where
    type Norm a
    toNorm :: a -> Norm a
    fromNorm :: Norm a -> a

instance ConstructNorm () where
    type Norm () = ()
    toNorm = Prelude.id
    fromNorm = Prelude.id

instance (ConstructNorm a, ConstructNorm b) => ConstructNorm (Either a b) where
    type Norm (Either a b) = Either (Norm a) (Norm b)
    toNorm = either (Left . toNorm) (Right . toNorm)
    fromNorm = either (Left . fromNorm) (Right . fromNorm)

-- Instance for other data types can be obtained mechanically using Generics
instance ConstructNorm Bool where
    type Norm Bool = Either () ()
    toNorm = bool (Left ()) (Right ())
    fromNorm = either (const False) (const True)

type family Count (d :: Type) :: Nat where
  Count (Natural n m) = (m - n) + 1
  Count (List a)      = (^) 2 (Count a)
  Count (Either a b)  = (+) (Count a) (Count b)
  Count (a, b)        = (*) (Count a) (Count b)
  Count (a -> b)      = (^) (Count b) (Count a)
  -- Generics
  Count (M1 _ _ f p)  = Count (f p)
  Count (K1 _ _ _)    = 1
  Count (V1 _)        = 0
  Count (U1 _)        = 1
  Count ((:*:) a b p) = Count (a p) * Count (b p)
  Count ((:+:) a b p) = Count (a p) + Count (b p)
  Count d             = Count (Rep d R)

type family FromNat (n :: Nat) :: Type where
  FromNat 0 = Void
  FromNat 1 = ()
  FromNat n = FromNat' (Mod n 2 == 0) (FromNat (Div n 2))

type family FromNat' (b :: Bool) (m :: Type) :: Type where
  FromNat' 'True m  = Either m m
  FromNat' 'False m = Either () (Either m m)

type family Normalize (d :: Type) :: Type where
  Normalize (Either a b) = Either (Normalize a) (Normalize b)
  Normalize d            = FromNat (Count d)

instance ConstructNorm Bool where
    type Norm Bool = Either () ()
    toNorm = bool (Left ()) (Right ())
    fromNorm = either (const False) (const True)

instance ConstructNorm (U1 p) where
  type Norm (U1 p) = ()
  toNorm U1 = ()
  fromNorm _ = U1

instance (ConstructNorm (a p), ConstructNorm (b p)) => ConstructNorm ((:+:) a b p) where
  type Norm ((:+:) a b p) = Either (Norm (a p)) (Norm (b p))
  toNorm (L1 a) = Left (toNorm a)
  toNorm (R1 b) = Right (toNorm b)
  fromNorm (Left a) = L1 (fromNorm a)
  fromNorm (Right b) = R1 (fromNorm b)

toNorm :: (Enum a, Enum (Normalize a)) => a -> Normalize a
toNorm = toEnum . fromEnum
fromNorm :: (Enum a, Enum (Normalize a)) =>Normalize a -> a
fromNorm = toEnum . fromEnum