extend-record-data-th: TH to define a new record data type that extends the existing record data type.

[ bsd3, data, library ] [ Propose Tags ]

Please see the README on GitHub at https://github.com/nakaji-dayo/extend-record-data-th#readme

[Skip to Readme]
Versions [faq],,
Change log ChangeLog.md
Dependencies attoparsec, base (>=4.7 && <5), template-haskell, text [details]
License BSD-3-Clause
Copyright 2019 Daishi Nakajima
Author Daishi Nakajima
Maintainer nakaji.dayo@gmail.com
Category Data
Home page https://github.com/nakaji-dayo/extend-record-data-th#readme
Bug tracker https://github.com/nakaji-dayo/extend-record-data-th/issues
Source repo head: git clone https://github.com/nakaji-dayo/extend-record-data-th
Uploaded by nakaji_dayo at 2019-07-07T06:38:29Z
Distributions NixOS:
Downloads 941 total (2 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Hackage Matrix CI
Docs available [build log]
Last success reported on 2019-07-07 [all 1 reports]


[Index] [Quick Jump]


Maintainer's Corner

For package maintainers and hackage trustees

Readme for extend-record-data-th-

[back to package description]


TH to define a new record data type that extends the existing simple record data type.

This library should be useful when used with generic-lens.


$(extendD "data T = T1 <> T2 <> { f1 :: T3, f2 :: T4 } deriving (c1, c2) ")


unioning existing record data type

data Animal = Animal
  { name :: String
  , age  :: Int
  } deriving (Show, Eq, Generic)

data HumanInfo = HumanInfo
  { address :: String
  } deriving (Show, Eq, Generic)

$(extendD "data Human = Animal <> HumanInfo deriving (Show, Generic) ")

data Human

:i Human
data Human
  = Human {name :: String,
           age :: Int,
           address :: String}
instance Show Human
instance Generic Human

higher kind, define field records anonymously

data X a = X {f1 :: a Int} deriving (Generic)
data Y a = Y {f2 :: Maybe a} deriving (Generic, Show)
data Z a = Z { x :: X a } deriving(Generic)
$(extendD "data XY = X <> Y <> { e1 :: String, e2 :: String } <> Z deriving (Generic)")


data XY (a :: * -> *) a1 (a2 :: * -> *)
  = XY {f1 :: a Int,
        f2 :: Maybe a1,
        e1 :: String,
        e2 :: String,
        x :: X a2}
instance Generic (XY a1 a2 a3)