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 -XFunctionalDependencies #-}
24 {-# OPTIONS_GHC -XNoGenerics #-}
27 -- * Generic representation types
28 V1, U1(..), Par1(..), Rec1(..), K1(..), M1(..)
29 , (:+:)(..), (:*:)(..), (:.:)(..)
31 -- ** Synonyms for convenience
36 , Datatype(..), Constructor(..), Selector(..), NoSelector
37 , Fixity(..), Associativity(..), Arity(..), prec
39 -- * Representable type classes
40 , Representable0(..), Representable1(..)
43 -- * Representations for base types
44 , Rep0Char, Rep0Int, Rep0Float
45 , Rep0Maybe, Rep1Maybe
50 import {-# SOURCE #-} GHC.Types -- ([](..), Int, Char, Bool(..))
52 --------------------------------------------------------------------------------
53 -- Representation types
54 --------------------------------------------------------------------------------
56 -- | Void: used for datatypes without constructors
59 -- | Unit: used for constructors without arguments
62 -- | Used for marking occurrences of the parameter
63 newtype Par1 p = Par1 { unPar1 :: p }
66 -- | Recursive calls of kind * -> *
67 newtype Rec1 f p = Rec1 { unRec1 :: f p }
69 -- | Constants, additional parameters and recursion of kind *
70 newtype K1 i c p = K1 { unK1 :: c }
72 -- | Meta-information (constructor names, etc.)
73 newtype M1 i c f p = M1 { unM1 :: f p }
75 -- | Sums: encode choice between constructors
77 data (:+:) f g p = L1 (f p) | R1 (g p)
79 -- | Products: encode multiple arguments to constructors
81 data (:*:) f g p = f p :*: g p
83 -- | Composition of functors
85 newtype (:.:) f g p = Comp1 { unComp1 :: f (g p) }
87 -- | Tag for K1: recursion (of kind *)
89 -- | Tag for K1: parameters (other than the last)
92 -- | Type synonym for encoding recursion (of kind *)
94 -- | Type synonym for encoding parameters (other than the last)
97 -- | Tag for M1: datatype
99 -- | Tag for M1: constructor
101 -- | Tag for M1: record selector
104 -- | Type synonym for encoding meta-information for datatypes
107 -- | Type synonym for encoding meta-information for constructors
110 -- | Type synonym for encoding meta-information for record selectors
114 -- | Class for datatypes that represent datatypes
115 class Datatype d where
116 -- | The name of the datatype (unqualified)
117 datatypeName :: t d (f :: * -> *) a -> [Char]
118 -- | The fully-qualified name of the module where the type is declared
119 moduleName :: t d (f :: * -> *) a -> [Char]
122 -- | Class for datatypes that represent records
123 class Selector s where
124 -- | The name of the selector
125 selName :: t s (f :: * -> *) a -> [Char]
127 -- | Used for constructor fields without a name
130 instance Selector NoSelector where selName _ = ""
132 -- | Class for datatypes that represent data constructors
133 class Constructor c where
134 -- | The name of the constructor
135 conName :: t c (f :: * -> *) a -> [Char]
137 -- | The fixity of the constructor
138 conFixity :: t c (f :: * -> *) a -> Fixity
141 -- | Marks if this constructor is a record
142 conIsRecord :: t c (f :: * -> *) a -> Bool
143 conIsRecord _ = False
145 -- | Marks if this constructor is a tuple,
146 -- returning arity >=0 if so, <0 if not
147 conIsTuple :: t c (f :: * -> *) a -> Arity
148 conIsTuple _ = NoArity
151 -- | Datatype to represent the arity of a tuple.
152 data Arity = NoArity | Arity Int
153 -- deriving (Eq, Show, Ord, Read)
154 -- TODO: Add these instances to the Prelude
156 -- | Datatype to represent the fixity of a constructor. An infix
157 -- | declaration directly corresponds to an application of 'Infix'.
158 data Fixity = Prefix | Infix Associativity Int
159 -- deriving (Eq, Show, Ord, Read)
160 -- TODO: Add these instances to the Prelude
162 -- | Get the precedence of a fixity value.
163 prec :: Fixity -> Int
167 -- | Datatype to represent the associativy of a constructor
168 data Associativity = LeftAssociative
171 -- deriving (Eq, Show, Ord, Read)
172 -- TODO: Add these instances to the Prelude
175 -- | Representable types of kind *
176 class Representable0 a rep | a -> rep where
177 -- | Convert from the datatype to its representation
179 -- | Convert from the representation to the datatype
182 -- | Representable types of kind * -> *
183 class Representable1 f rep | f -> rep where
184 -- | Convert from the datatype to its representation
185 from1 :: f a -> rep a
186 -- | Convert from the representation to the datatype
189 --------------------------------------------------------------------------------
190 -- Representation for base types
191 --------------------------------------------------------------------------------
193 -- Representation types
196 instance Representable1 Par1 Rep1Par1 where
200 type Rep1Rec1 f = Rec1 f
201 instance Representable1 (Rec1 f) (Rep1Rec1 f) where
208 type Rep0Char = Rec0 Char
209 instance Representable0 Char Rep0Char where
213 type Rep0Int = Rec0 Int
214 instance Representable0 Int Rep0Int where
218 type Rep0Float = Rec0 Float
219 instance Representable0 Float Rep0Float where
231 instance Datatype Maybe_ where
232 datatypeName _ = "Maybe"
233 moduleName _ = "Representation"
235 instance Constructor Nothing_ where
236 conName _ = "Nothing"
238 instance Constructor Just_ where
241 type Rep0Maybe a = D1 Maybe_ (C1 Nothing_ U1 :+: C1 Just_ (Par0 a))
242 instance Representable0 (Maybe a) (Rep0Maybe a) where
243 from0 Nothing = M1 (L1 (M1 U1))
244 from0 (Just x) = M1 (R1 (M1 (K1 x)))
245 to0 (M1 (L1 (M1 U1))) = Nothing
246 to0 (M1 (R1 (M1 (K1 x)))) = Just x
248 type Rep1Maybe = D1 Maybe_ (C1 Nothing_ U1 :+: C1 Just_ Par1)
249 instance Representable1 Maybe Rep1Maybe where
250 from1 Nothing = M1 (L1 (M1 U1))
251 from1 (Just x) = M1 (R1 (M1 (Par1 x)))
252 to1 (M1 (L1 (M1 U1))) = Nothing
253 to1 (M1 (R1 (M1 (Par1 x)))) = Just x
260 instance Datatype [a] where
261 datatypeName _ = "[]"
262 moduleName _ = "Data.List"
264 instance Constructor Nil__ where conName _ = "[]"
265 instance Constructor Cons__ where
267 conFixity _ = Infix RightAssociative 5
269 type Rep0List a = D1 List__ ((C1 Nil__ U1) :+: (C1 Cons__ (Par0 a :*: Rec0 [a])))
270 instance Representable0 [a] (Rep0List a) where
271 from0 [] = M1 (L1 (M1 U1))
272 from0 (h:t) = M1 (R1 (M1 (K1 h :*: K1 t)))
273 to0 (M1 (L1 (M1 U1))) = []
274 to0 (M1 (R1 (M1 (K1 h :*: K1 t)))) = h : t
276 type Rep1List = D1 List__ ((C1 Nil__ U1) :+: (C1 Cons__ (Par1 :*: Rec1 [])))
277 instance Representable1 [] Rep1List where
278 from1 [] = M1 (L1 (M1 U1))
279 from1 (h:t) = M1 (R1 (M1 (Par1 h :*: Rec1 t)))
280 to1 (M1 (L1 (M1 U1))) = []
281 to1 (M1 (R1 (M1 (Par1 h :*: Rec1 t)))) = h : t