Data.Profunctor.Product.TH

If you have a data declaration which is a polymorphic product, for example

data Foo a b c = Foo a b c

or

data Foo a b c = Foo { foo :: a, bar :: b, baz :: c }

then you can use Template Haskell to automatically derive the product-profunctor Default instances and product-profunctor "adaptor" with the following imports and splice:

import Data.Profunctor.Product (ProductProfunctor, p<n>)
import Data.Profunctor (dimap)
import Data.Profunctor.Product.Default (Default, def)

$(makeAdaptorAndInstance "pFoo" ''Foo)

• <n> is the number of fields in your record, so for Foo <n> would be 3.
• The adaptor for a type Foo is by convention called pFoo, but in practice you can call it anything.

Notice that currently the Template Haskell requires you import a number of other names from other modules. This is because it is badly written and this restriction will go away in a future release.

The instance generated will be

instance (ProductProfunctor p, Default p a a', Default p b b', Default p c c')
      => Default p (Foo a b c) (Foo a' b' c')

and pFoo will have the type

pFoo :: ProductProfunctor p =>
        Foo (p a a') (p b b') (p c c') -> p (Foo a b c) (Foo a' b' c')

Documentation

makeAdaptorAndInstance :: String -> Name -> Q [Dec]

type Error = String

makeAdaptorAndInstanceE :: String -> Info -> Either Error [Dec]

dataDecStuffOfInfo :: Info -> Either Error (Name, [Name], Name, [Name])

varNameOfType :: Type -> Either Error Name

varNameOfBinder :: TyVarBndr -> Name

conStuffOfConstructor :: Con -> Either Error (Name, [Name])

constructorOfConstructors :: [Con] -> Either Error Con

extractConstructorStuff :: [Con] -> Either Error (Name, [Name])

data MakeRecordT

Constructors

MakeRecordT

Fields

typeName :: String

constructorName :: String

fieldNames :: [String]

deriving_ :: [String]

adaptorName :: String

makeRecordData :: MakeRecordT -> Q [Dec]

makeRecord :: MakeRecordT -> Q [Dec]

datatype :: Name -> [String] -> String -> [String] -> Dec

instanceDefinition :: Name -> Int -> Int -> Name -> Name -> Dec

adaptorSig :: Name -> Int -> Name -> Dec

adaptorDefinition :: Int -> Name -> Name -> Dec

xTuple :: ([Pat] -> Pat) -> ([Exp] -> Exp) -> (Name, Int) -> Dec

fromTuple :: Name -> (Name, Int) -> Dec

toTuple :: Name -> (Name, Int) -> Dec

pArg' :: Name -> String -> Int -> Type

allTyVars :: Int -> [String]

o :: Exp -> Exp -> Exp

varS :: String -> Exp

conES :: String -> Exp

conPS :: String -> [Pat] -> Pat

varPS :: String -> Pat

mkTyVarsuffix :: String -> String -> TyVarBndr

mkTySuffix :: String -> String -> Type

mkVarTsuffix :: String -> String -> Type

varTS :: String -> Type

conTS :: String -> Type

appTAll :: Type -> [Type] -> Type

appEAll :: Exp -> [Exp] -> Exp

appArrow :: Type -> Type -> Type