RowToList with type families

RowToList-tf.hs

{-# LANGUAGE AllowAmbiguousTypes  #-}
{-# LANGUAGE DataKinds            #-}
{-# LANGUAGE DeriveGeneric        #-}
{-# LANGUAGE ExplicitForAll       #-}
{-# LANGUAGE FlexibleContexts     #-}
{-# LANGUAGE FlexibleInstances    #-}
{-# LANGUAGE PolyKinds            #-}
{-# LANGUAGE TypeFamilies         #-}
{-# LANGUAGE TypeOperators        #-}
{-# LANGUAGE UndecidableInstances #-}

module RowToList where

import GHC.Generics
import Data.Kind (Type)
import GHC.TypeLits (Symbol)
import Data.Proxy (Proxy(..))

--------------------------------------------------------------------------------
-- * RowToList for Generics

type family GRowToList (rep :: Type -> Type) :: [(Symbol, Type)] where

  GRowToList (l :*: r)
    = GRowToList l ++ GRowToList r

  GRowToList (S1 ('MetaSel ('Just name) _ _ _) (Rec0 a))
    = '[ '(name, a)]

  GRowToList (M1 _ m a)
    = GRowToList a

  GRowToList U1 = '[]

--------------------------------------------------------------------------------
-- * Utilities

type family (a :: [k]) ++ (b :: [k]) :: [k] where
  '[] ++ bs = bs
  (a ': as) ++ bs = a ': (as ++ bs)

--------------------------------------------------------------------------------
-- * RowToList for records (becomes just a type synyonym)

type RowToList (record :: Type) = GRowToList (Rep record)

--------------------------------------------------------------------------------
-- An example

data Tom = Tom
  deriving Generic

data MyRecord = MyRecord
  { apple  :: Int
  , banana :: String
  , orange :: Int
  } deriving Generic

test :: forall record. Proxy (RowToList record)
test = Proxy

-- >>> :t test @MyRecord
-- test @MyRecord
--   :: Proxy '['("apple", Int), '("banana", [Char]), '("orange", Int)]
--
-- >>> :t test @Tom
-- test @Tom :: Proxy '[]