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 import and splice:

import Data.Profunctor.Product (p<n>)

$(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 pn manually. 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

tupleAdaptors :: Int -> Name

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

varPS :: String -> Pat

mkTyVarsuffix :: String -> String -> TyVarBndr

mkTySuffix :: String -> String -> Type

mkVarTsuffix :: String -> String -> Type

varTS :: String -> Type

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

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

appArrow :: Type -> Type -> Type