File: generic-deriving.cabal

package info (click to toggle)
haskell-generic-deriving 1.14.5-2
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 576 kB
  • sloc: haskell: 8,941; makefile: 2
file content (162 lines) | stat: -rw-r--r-- 7,090 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
name:                   generic-deriving
version:                1.14.5
synopsis:               Generic programming library for generalised deriving.
description:

  This package provides functionality for generalising the deriving mechanism
  in Haskell to arbitrary classes. It was first described in the paper:
  .
  *  /A generic deriving mechanism for Haskell/.
     Jose Pedro Magalhaes, Atze Dijkstra, Johan Jeuring, and Andres Loeh.
     Haskell'10.
  .
  The current implementation integrates with the new GHC Generics. See
  <http://www.haskell.org/haskellwiki/GHC.Generics> for more information.
  Template Haskell code is provided for supporting older GHCs.
  .
  This library is organized as follows:
  .
  * "Generics.Deriving.Base" defines the core functionality for GHC generics,
    including the @Generic(1)@ classes and representation data types.
    On modern versions of GHC, this simply re-exports "GHC.Generics" from
    @base@. On older versions of GHC, this module backports parts of
    "GHC.Generics" that were not included at the time, including @Generic(1)@
    instances.
  .
  * "Generics.Deriving.TH" implements Template Haskell functionality for
    deriving instances of @Generic(1)@.
  .
  * Educational code: in order to provide examples of how to define and use
    "GHC.Generics"-based defaults, this library offers a number of modules
    which define examples of type classes along with default implementations
    for the classes' methods. Currently, the following modules are provided:
    "Generics.Deriving.Copoint", "Generics.Deriving.ConNames",
    "Generics.Deriving.Enum", "Generics.Deriving.Eq",
    "Generics.Deriving.Foldable", "Generics.Deriving.Functor",
    "Generics.Deriving.Monoid", "Generics.Deriving.Semigroup",
    "Generics.Deriving.Show", "Generics.Deriving.Traversable",
    and "Generics.Deriving.Uniplate".
    .
    It is worth emphasizing that these modules are primarly intended for
    educational purposes. Many of the classes in these modules resemble other
    commonly used classes—for example, @GShow@ from "Generics.Deriving.Show"
    resembles @Show@ from @base@—but in general, the classes that
    @generic-deriving@ defines are not drop-in replacements. Moreover, the
    generic defaults that @generic-deriving@ provide often make simplifying
    assumptions that may violate expectations of how these classes might work
    elsewhere. For example, the generic default for @GShow@ does not behave
    exactly like @deriving Show@ would.
    .
    If you are seeking "GHC.Generics"-based defaults for type classes in
    @base@, consider using the
    @<http://hackage.haskell.org/package/generic-data generic-data>@ library.
  .
  * "Generics.Deriving.Default" provides newtypes that allow leveraging the
    generic defaults in this library using the @DerivingVia@ GHC language
    extension.
  .
  * "Generics.Deriving" re-exports "Generics.Deriving.Base",
    "Generics.Deriving.Default", and a selection of educational modules.

homepage:               https://github.com/dreixel/generic-deriving
bug-reports:            https://github.com/dreixel/generic-deriving/issues
category:               Generics
copyright:              2011-2013 Universiteit Utrecht, University of Oxford
license:                BSD3
license-file:           LICENSE
author:                 José Pedro Magalhães
maintainer:             generics@haskell.org
stability:              experimental
build-type:             Simple
cabal-version:          >= 1.10
tested-with:            GHC == 7.0.4
                      , GHC == 7.2.2
                      , GHC == 7.4.2
                      , GHC == 7.6.3
                      , GHC == 7.8.4
                      , GHC == 7.10.3
                      , GHC == 8.0.2
                      , GHC == 8.2.2
                      , GHC == 8.4.4
                      , GHC == 8.6.5
                      , GHC == 8.8.4
                      , GHC == 8.10.7
                      , GHC == 9.0.2
                      , GHC == 9.2.8
                      , GHC == 9.4.5
                      , GHC == 9.6.2
extra-source-files:     CHANGELOG.md
                      , README.md

source-repository head
  type: git
  location: https://github.com/dreixel/generic-deriving

flag base-4-9
  description:          Use base-4.9 or later. This version of base uses a
                        DataKinds-based encoding of GHC generics metadata.
  default:              True

library
  hs-source-dirs:       src
  exposed-modules:      Generics.Deriving
                        Generics.Deriving.Base
                        Generics.Deriving.Instances
                        Generics.Deriving.Copoint
                        Generics.Deriving.ConNames
                        Generics.Deriving.Default
                        Generics.Deriving.Enum
                        Generics.Deriving.Eq
                        Generics.Deriving.Foldable
                        Generics.Deriving.Functor
                        Generics.Deriving.Monoid
                        Generics.Deriving.Semigroup
                        Generics.Deriving.Show
                        Generics.Deriving.Traversable
                        Generics.Deriving.Uniplate

                        Generics.Deriving.TH

  other-modules:        Generics.Deriving.Base.Internal
                        Generics.Deriving.Monoid.Internal
                        Generics.Deriving.Semigroup.Internal
                        Generics.Deriving.TH.Internal
                        Paths_generic_deriving
  if flag(base-4-9)
    build-depends:      base >= 4.9 && < 5
    other-modules:      Generics.Deriving.TH.Post4_9
  else
    build-depends:      base >= 4.3 && < 4.9
    other-modules:      Generics.Deriving.TH.Pre4_9

  build-depends:        containers       >= 0.1   && < 0.7
                      , ghc-prim                     < 1
                      , template-haskell >= 2.4   && < 2.22
                        -- TODO: Eventually, we should bump the lower version
                        -- bounds to >=0.6 so that we can remove some CPP in
                        -- Generics.Deriving.TH.Internal.
                      , th-abstraction   >= 0.4   && < 0.7

  default-language:     Haskell2010
  ghc-options:          -Wall

test-suite spec
  type:                 exitcode-stdio-1.0
  main-is:              Spec.hs
  other-modules:        DefaultSpec
                        EmptyCaseSpec
                        ExampleSpec
                        T68Spec
                        T80Spec
                        T82Spec
                        TypeInTypeSpec
  build-depends:        base             >= 4.3  && < 5
                      , generic-deriving
                      , hspec            >= 2    && < 3
                      , template-haskell >= 2.4  && < 2.22
  build-tool-depends:   hspec-discover:hspec-discover
  hs-source-dirs:       tests
  default-language:     Haskell2010
  ghc-options:          -Wall -threaded -rtsopts
  if impl(ghc >= 8.6)
    ghc-options:        -Wno-star-is-type