Modulegenerics-sop-0.5.1.4Haskell2010

Generics.SOP.TH

Generate generics-sop boilerplate instances using Template Haskell.

7 values

Packagegenerics-sop-0.5.1.4
Exports7
LanguageHaskell2010
LicenceBSD-3-Clause
SourceTH.hs

valuederiveGeneric :: Name -> Q [Dec]

Generate generics-sop boilerplate for the given datatype.

This function takes the name of a datatype and generates:

a Code instance
a Generic instance
a HasDatatypeInfo instance

Note that the generated code will require the TypeFamilies and DataKinds extensions to be enabled for the module.

Example: If you have the datatype

data Tree = Leaf Int | Node Tree Tree

and say

deriveGeneric ''Tree

then you get code that is equivalent to:

instance Generic Tree where

  type Code Tree = '[ '[Int], '[Tree, Tree] ]

  from (Leaf x)   = SOP (   Z (I x :* Nil))
  from (Node l r) = SOP (S (Z (I l :* I r :* Nil)))

  to (SOP    (Z (I x :* Nil)))         = Leaf x
  to (SOP (S (Z (I l :* I r :* Nil)))) = Node l r
  to (SOP (S (S x)))                   = x `seq` error "inaccessible"

instance HasDatatypeInfo Tree where
  type DatatypeInfoOf Tree =
    T.ADT "Main" "Tree"
      '[ T.Constructor "Leaf", T.Constructor "Node" ]

  datatypeInfo _ =
    T.demoteDatatypeInfo (Proxy :: Proxy (DatatypeInfoOf Tree))

Limitations: Generation does not work for GADTs, for datatypes that involve existential quantification, for datatypes with unboxed fields.

valuederiveGenericOnly :: Name -> Q [Dec]

Like deriveGeneric, but omit the HasDatatypeInfo instance.

valuederiveGenericSubst :: Name -> (Name -> Q Type) -> Q [Dec]

Variant of deriveGeneric that allows to restrict the type parameters.

Experimental function, exposed primarily for benchmarking.

valuederiveGenericOnlySubst :: Name -> (Name -> Q Type) -> Q [Dec]

Variant of deriveGenericOnly that allows to restrict the type parameters.

Experimental function, exposed primarily for benchmarking.

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

Like deriveGenericOnly, but don't derive class instance, only functions.

Example: If you say

deriveGenericFunctions ''Tree "TreeCode" "fromTree" "toTree"

then you get code that is equivalent to:

type TreeCode = '[ '[Int], '[Tree, Tree] ]

fromTree :: Tree -> SOP I TreeCode
fromTree (Leaf x)   = SOP (   Z (I x :* Nil))
fromTree (Node l r) = SOP (S (Z (I l :* I r :* Nil)))

toTree :: SOP I TreeCode -> Tree
toTree (SOP    (Z (I x :* Nil)))         = Leaf x
toTree (SOP (S (Z (I l :* I r :* Nil)))) = Node l r
toTree (SOP (S (S x)))                   = x `seq` error "inaccessible"

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

Deprecated. Use deriveMetadataType and demoteDatatypeInfo instead.

Derive DatatypeInfo value for the type.

Example: If you say

deriveMetadataValue ''Tree "TreeCode" "treeDatatypeInfo"

then you get code that is equivalent to:

treeDatatypeInfo :: DatatypeInfo TreeCode
treeDatatypeInfo = ADT "Main" "Tree"
    (Constructor "Leaf" :* Constructor "Node" :* Nil)

Note: CodeType needs to be derived with deriveGenericFunctions.

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

Derive DatatypeInfo type for the type.

Example: If you say

deriveMetadataType ''Tree "TreeDatatypeInfo"

then you get code that is equivalent to:

type TreeDatatypeInfo =
  T.ADT "Main" "Tree"
    [ T.Constructor "Leaf", T.Constructor "Node" ]