3 {-# OPTIONS_GHC -XNoImplicitPrelude -XTypeOperators #-}
5 module GHC.Generics where
11 data (:+:) a b = Inl a | Inr b
12 data (:*:) a b = a :*: b
17 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
18 {-# OPTIONS_GHC -XEmptyDataDecls #-}
19 {-# OPTIONS_GHC -XMultiParamTypeClasses #-}
20 {-# OPTIONS_GHC -XTypeSynonymInstances #-}
21 {-# OPTIONS_GHC -XTypeOperators #-}
22 {-# OPTIONS_GHC -XKindSignatures #-}
23 {-# OPTIONS_GHC -XTypeFamilies #-}
26 -- * Generic representation types
27 V1, U1(..), Par1(..), Rec1(..), K1(..), M1(..)
28 , (:+:)(..), (:*:)(..), (:.:)(..)
30 -- ** Synonyms for convenience
35 , Datatype(..), Constructor(..), Selector(..), NoSelector
36 , Fixity(..), Associativity(..), Arity(..), prec
38 -- * Representation type families
41 -- * Representable type classes
42 , Representable0(..), Representable1(..)
45 -- * Representations for base types
46 , Rep0Char, Rep0Int, Rep0Float
47 , Rep0Maybe, Rep1Maybe
52 import {-# SOURCE #-} GHC.Types
54 --------------------------------------------------------------------------------
55 -- Representation types
56 --------------------------------------------------------------------------------
58 -- | Void: used for datatypes without constructors
61 -- | Unit: used for constructors without arguments
64 -- | Used for marking occurrences of the parameter
65 newtype Par1 p = Par1 { unPar1 :: p }
68 -- | Recursive calls of kind * -> *
69 newtype Rec1 f p = Rec1 { unRec1 :: f p }
71 -- | Constants, additional parameters and recursion of kind *
72 newtype K1 i c p = K1 { unK1 :: c }
74 -- | Meta-information (constructor names, etc.)
75 newtype M1 i c f p = M1 { unM1 :: f p }
77 -- | Sums: encode choice between constructors
79 data (:+:) f g p = L1 (f p) | R1 (g p)
81 -- | Products: encode multiple arguments to constructors
83 data (:*:) f g p = f p :*: g p
85 -- | Composition of functors
87 newtype (:.:) f g p = Comp1 { unComp1 :: f (g p) }
89 -- | Tag for K1: recursion (of kind *)
91 -- | Tag for K1: parameters (other than the last)
94 -- | Type synonym for encoding recursion (of kind *)
96 -- | Type synonym for encoding parameters (other than the last)
99 -- | Tag for M1: datatype
101 -- | Tag for M1: constructor
103 -- | Tag for M1: record selector
106 -- | Type synonym for encoding meta-information for datatypes
109 -- | Type synonym for encoding meta-information for constructors
112 -- | Type synonym for encoding meta-information for record selectors
116 -- | Class for datatypes that represent datatypes
117 class Datatype d where
118 -- | The name of the datatype (unqualified)
119 datatypeName :: t d (f :: * -> *) a -> [Char]
120 -- | The fully-qualified name of the module where the type is declared
121 moduleName :: t d (f :: * -> *) a -> [Char]
124 -- | Class for datatypes that represent records
125 class Selector s where
126 -- | The name of the selector
127 selName :: t s (f :: * -> *) a -> [Char]
129 -- | Used for constructor fields without a name
132 instance Selector NoSelector where selName _ = ""
134 -- | Class for datatypes that represent data constructors
135 class Constructor c where
136 -- | The name of the constructor
137 conName :: t c (f :: * -> *) a -> [Char]
139 -- | The fixity of the constructor
140 conFixity :: t c (f :: * -> *) a -> Fixity
143 -- | Marks if this constructor is a record
144 conIsRecord :: t c (f :: * -> *) a -> Bool
145 conIsRecord _ = False
147 -- | Marks if this constructor is a tuple,
148 -- returning arity >=0 if so, <0 if not
149 conIsTuple :: t c (f :: * -> *) a -> Arity
150 conIsTuple _ = NoArity
153 -- | Datatype to represent the arity of a tuple.
154 data Arity = NoArity | Arity Int
155 -- deriving (Eq, Show, Ord, Read)
156 -- TODO: Add these instances to the Prelude
158 -- | Datatype to represent the fixity of a constructor. An infix
159 -- | declaration directly corresponds to an application of 'Infix'.
160 data Fixity = Prefix | Infix Associativity Int
161 -- deriving (Eq, Show, Ord, Read)
162 -- TODO: Add these instances to the Prelude
164 -- | Get the precedence of a fixity value.
165 prec :: Fixity -> Int
169 -- | Datatype to represent the associativy of a constructor
170 data Associativity = LeftAssociative
173 -- deriving (Eq, Show, Ord, Read)
174 -- TODO: Add these instances to the Prelude
177 -- | Representable types of kind *
178 class Representable0 a where
179 -- | Representation type
180 type Rep0 a :: * -> *
181 -- | Convert from the datatype to its representation
182 from0 :: a -> Rep0 a x
183 -- | Convert from the representation to the datatype
186 -- | Representable types of kind * -> *
187 class Representable1 f rep where
188 -- | Representation type
189 type Rep1 f :: * -> *
190 -- | Convert from the datatype to its representation
191 from1 :: f a -> Rep1 f a
192 -- | Convert from the representation to the datatype
193 to1 :: Rep1 f a -> f a
195 --------------------------------------------------------------------------------
196 -- Representation for base types
197 --------------------------------------------------------------------------------
199 -- Representation types
202 instance Representable1 Par1 Rep1Par1 where
206 type Rep1Rec1 f = Rec1 f
207 instance Representable1 (Rec1 f) (Rep1Rec1 f) where
214 type Rep0Char = Rec0 Char
215 instance Representable0 Char Rep0Char where
219 type Rep0Int = Rec0 Int
220 instance Representable0 Int Rep0Int where
224 type Rep0Float = Rec0 Float
225 instance Representable0 Float Rep0Float where
237 instance Datatype Maybe_ where
238 datatypeName _ = "Maybe"
239 moduleName _ = "Representation"
241 instance Constructor Nothing_ where
242 conName _ = "Nothing"
244 instance Constructor Just_ where
247 type Rep0Maybe a = D1 Maybe_ (C1 Nothing_ U1 :+: C1 Just_ (Par0 a))
248 instance Representable0 (Maybe a) (Rep0Maybe a) where
249 from0 Nothing = M1 (L1 (M1 U1))
250 from0 (Just x) = M1 (R1 (M1 (K1 x)))
251 to0 (M1 (L1 (M1 U1))) = Nothing
252 to0 (M1 (R1 (M1 (K1 x)))) = Just x
254 type Rep1Maybe = D1 Maybe_ (C1 Nothing_ U1 :+: C1 Just_ Par1)
255 instance Representable1 Maybe Rep1Maybe where
256 from1 Nothing = M1 (L1 (M1 U1))
257 from1 (Just x) = M1 (R1 (M1 (Par1 x)))
258 to1 (M1 (L1 (M1 U1))) = Nothing
259 to1 (M1 (R1 (M1 (Par1 x)))) = Just x
266 instance Datatype [a] where
267 datatypeName _ = "[]"
268 moduleName _ = "Data.List"
270 instance Constructor Nil__ where conName _ = "[]"
271 instance Constructor Cons__ where
273 conFixity _ = Infix RightAssociative 5
275 type Rep0List a = D1 List__ ((C1 Nil__ U1) :+: (C1 Cons__ (Par0 a :*: Rec0 [a])))
276 instance Representable0 [a] (Rep0List a) where
277 from0 [] = M1 (L1 (M1 U1))
278 from0 (h:t) = M1 (R1 (M1 (K1 h :*: K1 t)))
279 to0 (M1 (L1 (M1 U1))) = []
280 to0 (M1 (R1 (M1 (K1 h :*: K1 t)))) = h : t
282 type Rep1List = D1 List__ ((C1 Nil__ U1) :+: (C1 Cons__ (Par1 :*: Rec1 [])))
283 instance Representable1 [] Rep1List where
284 from1 [] = M1 (L1 (M1 U1))
285 from1 (h:t) = M1 (R1 (M1 (Par1 h :*: Rec1 t)))
286 to1 (M1 (L1 (M1 U1))) = []
287 to1 (M1 (R1 (M1 (Par1 h :*: Rec1 t)))) = h : t