Generics.hs 41.3 KB
Newer Older
1
{-# LANGUAGE CPP                    #-}
2
3
{-# LANGUAGE DataKinds              #-}
{-# LANGUAGE DeriveGeneric          #-}
4
5
6
{-# LANGUAGE FlexibleContexts       #-}
{-# LANGUAGE FlexibleInstances      #-}
{-# LANGUAGE GADTs                  #-}
7
8
9
{-# LANGUAGE KindSignatures         #-}
{-# LANGUAGE MagicHash              #-}
{-# LANGUAGE NoImplicitPrelude      #-}
10
11
{-# LANGUAGE PolyKinds              #-}
{-# LANGUAGE ScopedTypeVariables    #-}
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
12
{-# LANGUAGE StandaloneDeriving     #-}
13
14
15
16
17
{-# LANGUAGE Trustworthy            #-}
{-# LANGUAGE TypeFamilies           #-}
{-# LANGUAGE TypeOperators          #-}
{-# LANGUAGE TypeSynonymInstances   #-}
{-# LANGUAGE UndecidableInstances   #-}
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
18

19
20
21
-----------------------------------------------------------------------------
-- |
-- Module      :  GHC.Generics
22
-- Copyright   :  (c) Universiteit Utrecht 2010-2011, University of Oxford 2012-2014
23
-- License     :  see libraries/base/LICENSE
24
--
25
26
27
28
-- Maintainer  :  libraries@haskell.org
-- Stability   :  internal
-- Portability :  non-portable
--
29
-- @since 4.6.0.0
30
--
dreixel's avatar
dreixel committed
31
-- If you're using @GHC.Generics@, you should consider using the
32
-- <http://hackage.haskell.org/package/generic-deriving> package, which
dreixel's avatar
dreixel committed
33
-- contains many useful generic functions.
34

jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
35
module GHC.Generics  (
dreixel's avatar
dreixel committed
36
37
38
39
-- * Introduction
--
-- |
--
Gabor Greif's avatar
Gabor Greif committed
40
-- Datatype-generic functions are based on the idea of converting values of
dreixel's avatar
dreixel committed
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
-- a datatype @T@ into corresponding values of a (nearly) isomorphic type @'Rep' T@.
-- The type @'Rep' T@ is
-- built from a limited set of type constructors, all provided by this module. A
-- datatype-generic function is then an overloaded function with instances
-- for most of these type constructors, together with a wrapper that performs
-- the mapping between @T@ and @'Rep' T@. By using this technique, we merely need
-- a few generic instances in order to implement functionality that works for any
-- representable type.
--
-- Representable types are collected in the 'Generic' class, which defines the
-- associated type 'Rep' as well as conversion functions 'from' and 'to'.
-- Typically, you will not define 'Generic' instances by hand, but have the compiler
-- derive them for you.

-- ** Representing datatypes
--
-- |
--
-- The key to defining your own datatype-generic functions is to understand how to
-- represent datatypes using the given set of type constructors.
--
-- Let us look at an example first:
--
-- @
-- data Tree a = Leaf a | Node (Tree a) (Tree a)
--   deriving 'Generic'
-- @
--
-- The above declaration (which requires the language pragma @DeriveGeneric@)
-- causes the following representation to be generated:
--
-- @
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
73
-- instance 'Generic' (Tree a) where
dreixel's avatar
dreixel committed
74
--   type 'Rep' (Tree a) =
75
76
--     'D1' ('MetaData \"Tree\" \"Main\" \"package-name\" 'False)
--       ('C1' ('MetaCons \"Leaf\" 'PrefixI 'False)
77
78
79
80
81
--          ('S1' '(MetaSel 'Nothing
--                           'NoSourceUnpackedness
--                           'NoSourceStrictness
--                           'DecidedLazy)
--                 ('Rec0' a))
dreixel's avatar
dreixel committed
82
--        ':+:'
83
--        'C1' ('MetaCons \"Node\" 'PrefixI 'False)
84
85
86
87
88
--          ('S1' ('MetaSel 'Nothing
--                          'NoSourceUnpackedness
--                          'NoSourceStrictness
--                          'DecidedLazy)
--                ('Rec0' (Tree a))
dreixel's avatar
dreixel committed
89
--           ':*:'
90
91
92
93
94
--           'S1' ('MetaSel 'Nothing
--                          'NoSourceUnpackedness
--                          'NoSourceStrictness
--                          'DecidedLazy)
--                ('Rec0' (Tree a))))
dreixel's avatar
dreixel committed
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
--   ...
-- @
--
-- /Hint:/ You can obtain information about the code being generated from GHC by passing
-- the @-ddump-deriv@ flag. In GHCi, you can expand a type family such as 'Rep' using
-- the @:kind!@ command.
--
-- This is a lot of information! However, most of it is actually merely meta-information
-- that makes names of datatypes and constructors and more available on the type level.
--
-- Here is a reduced representation for 'Tree' with nearly all meta-information removed,
-- for now keeping only the most essential aspects:
--
-- @
-- instance 'Generic' (Tree a) where
--   type 'Rep' (Tree a) =
111
--     'Rec0' a
dreixel's avatar
dreixel committed
112
113
114
115
116
117
118
119
--     ':+:'
--     ('Rec0' (Tree a) ':*:' 'Rec0' (Tree a))
-- @
--
-- The @Tree@ datatype has two constructors. The representation of individual constructors
-- is combined using the binary type constructor ':+:'.
--
-- The first constructor consists of a single field, which is the parameter @a@. This is
120
-- represented as @'Rec0' a@.
dreixel's avatar
dreixel committed
121
122
123
124
125
126
127
--
-- The second constructor consists of two fields. Each is a recursive field of type @Tree a@,
-- represented as @'Rec0' (Tree a)@. Representations of individual fields are combined using
-- the binary type constructor ':*:'.
--
-- Now let us explain the additional tags being used in the complete representation:
--
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
--    * The @'S1' ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness
--      'DecidedLazy)@ tag indicates several things. The @'Nothing@ indicates
--      that there is no record field selector associated with this field of
--      the constructor (if there were, it would have been marked @'Just
--      \"recordName\"@ instead). The other types contain meta-information on
--      the field's strictness:
--
--      * There is no @{\-\# UNPACK \#-\}@ or @{\-\# NOUNPACK \#-\}@ annotation
--        in the source, so it is tagged with @'NoSourceUnpackedness@.
--
--      * There is no strictness (@!@) or laziness (@~@) annotation in the
--        source, so it is tagged with @'NoSourceStrictness@.
--
--      * The compiler infers that the field is lazy, so it is tagged with
--        @'DecidedLazy@. Bear in mind that what the compiler decides may be
--        quite different from what is written in the source. See
--        'DecidedStrictness' for a more detailed explanation.
--
--      The @'MetaSel@ type is also an instance of the type class 'Selector',
--      which can be used to obtain information about the field at the value
--      level.
dreixel's avatar
dreixel committed
149
--
150
151
--    * The @'C1' ('MetaCons \"Leaf\" 'PrefixI 'False)@ and
--      @'C1' ('MetaCons \"Node\" 'PrefixI 'False)@ invocations indicate that the enclosed part is
dreixel's avatar
dreixel committed
152
--      the representation of the first and second constructor of datatype @Tree@, respectively.
153
154
155
156
157
158
159
160
161
162
163
164
--      Here, the meta-information regarding constructor names, fixity and whether
--      it has named fields or not is encoded at the type level. The @'MetaCons@
--      type is also an instance of the type class 'Constructor'. This type class can be used
--      to obtain information about the constructor at the value level.
--
--    * The @'D1' ('MetaData \"Tree\" \"Main\" \"package-name\" 'False)@ tag
--      indicates that the enclosed part is the representation of the
--      datatype @Tree@. Again, the meta-information is encoded at the type level.
--      The @'MetaData@ type is an instance of class 'Datatype', which
--      can be used to obtain the name of a datatype, the module it has been
--      defined in, the package it is located under, and whether it has been
--      defined using @data@ or @newtype@ at the value level.
dreixel's avatar
dreixel committed
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180

-- ** Derived and fundamental representation types
--
-- |
--
-- There are many datatype-generic functions that do not distinguish between positions that
-- are parameters or positions that are recursive calls. There are also many datatype-generic
-- functions that do not care about the names of datatypes and constructors at all. To keep
-- the number of cases to consider in generic functions in such a situation to a minimum,
-- it turns out that many of the type constructors introduced above are actually synonyms,
-- defining them to be variants of a smaller set of constructors.

-- *** Individual fields of constructors: 'K1'
--
-- |
--
181
-- The type constructor 'Rec0' is a variant of 'K1':
dreixel's avatar
dreixel committed
182
183
184
185
186
--
-- @
-- type 'Rec0' = 'K1' 'R'
-- @
--
187
188
189
190
-- Here, 'R' is a type-level proxy that does not have any associated values.
--
-- There used to be another variant of 'K1' (namely 'Par0'), but it has since
-- been deprecated.
dreixel's avatar
dreixel committed
191
192
193
194
195
196
197
198
199
200
201
202
203

-- *** Meta information: 'M1'
--
-- |
--
-- The type constructors 'S1', 'C1' and 'D1' are all variants of 'M1':
--
-- @
-- type 'S1' = 'M1' 'S'
-- type 'C1' = 'M1' 'C'
-- type 'D1' = 'M1' 'D'
-- @
--
204
-- The types 'S', 'C' and 'D' are once again type-level proxies, just used to create
dreixel's avatar
dreixel committed
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
-- several variants of 'M1'.

-- *** Additional generic representation type constructors
--
-- |
--
-- Next to 'K1', 'M1', ':+:' and ':*:' there are a few more type constructors that occur
-- in the representations of other datatypes.

-- **** Empty datatypes: 'V1'
--
-- |
--
-- For empty datatypes, 'V1' is used as a representation. For example,
--
-- @
-- data Empty deriving 'Generic'
-- @
--
-- yields
--
-- @
-- instance 'Generic' Empty where
228
229
--   type 'Rep' Empty =
--     'D1' ('MetaData \"Empty\" \"Main\" \"package-name\" 'False) 'V1'
dreixel's avatar
dreixel committed
230
231
232
233
234
235
236
237
238
239
240
241
-- @

-- **** Constructors without fields: 'U1'
--
-- |
--
-- If a constructor has no arguments, then 'U1' is used as its representation. For example
-- the representation of 'Bool' is
--
-- @
-- instance 'Generic' Bool where
--   type 'Rep' Bool =
242
243
--     'D1' ('MetaData \"Bool\" \"Data.Bool\" \"package-name\" 'False)
--       ('C1' ('MetaCons \"False\" 'PrefixI 'False) 'U1' ':+:' 'C1' ('MetaCons \"True\" 'PrefixI 'False) 'U1')
dreixel's avatar
dreixel committed
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
-- @

-- *** Representation of types with many constructors or many fields
--
-- |
--
-- As ':+:' and ':*:' are just binary operators, one might ask what happens if the
-- datatype has more than two constructors, or a constructor with more than two
-- fields. The answer is simple: the operators are used several times, to combine
-- all the constructors and fields as needed. However, users /should not rely on
-- a specific nesting strategy/ for ':+:' and ':*:' being used. The compiler is
-- free to choose any nesting it prefers. (In practice, the current implementation
-- tries to produce a more or less balanced nesting, so that the traversal of the
-- structure of the datatype from the root to a particular component can be performed
-- in logarithmic rather than linear time.)

-- ** Defining datatype-generic functions
--
-- |
--
-- A datatype-generic function comprises two parts:
--
--    1. /Generic instances/ for the function, implementing it for most of the representation
--       type constructors introduced above.
--
--    2. A /wrapper/ that for any datatype that is in `Generic`, performs the conversion
--       between the original value and its `Rep`-based representation and then invokes the
--       generic instances.
--
-- As an example, let us look at a function 'encode' that produces a naive, but lossless
-- bit encoding of values of various datatypes. So we are aiming to define a function
--
-- @
-- encode :: 'Generic' a => a -> [Bool]
-- @
--
-- where we use 'Bool' as our datatype for bits.
--
-- For part 1, we define a class @Encode'@. Perhaps surprisingly, this class is parameterized
-- over a type constructor @f@ of kind @* -> *@. This is a technicality: all the representation
-- type constructors operate with kind @* -> *@ as base kind. But the type argument is never
-- being used. This may be changed at some point in the future. The class has a single method,
-- and we use the type we want our final function to have, but we replace the occurrences of
-- the generic type argument @a@ with @f p@ (where the @p@ is any argument; it will not be used).
--
-- > class Encode' f where
-- >   encode' :: f p -> [Bool]
--
-- With the goal in mind to make @encode@ work on @Tree@ and other datatypes, we now define
-- instances for the representation type constructors 'V1', 'U1', ':+:', ':*:', 'K1', and 'M1'.

-- *** Definition of the generic representation types
--
-- |
--
-- In order to be able to do this, we need to know the actual definitions of these types:
--
-- @
-- data    'V1'        p                       -- lifted version of Empty
-- data    'U1'        p = 'U1'                  -- lifted version of ()
-- data    (':+:') f g p = 'L1' (f p) | 'R1' (g p) -- lifted version of 'Either'
305
-- data    (':*:') f g p = (f p) ':*:' (g p)     -- lifted version of (,)
dreixel's avatar
dreixel committed
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
-- newtype 'K1'    i c p = 'K1' { 'unK1' :: c }    -- a container for a c
-- newtype 'M1'  i t f p = 'M1' { 'unM1' :: f p }  -- a wrapper
-- @
--
-- So, 'U1' is just the unit type, ':+:' is just a binary choice like 'Either',
-- ':*:' is a binary pair like the pair constructor @(,)@, and 'K1' is a value
-- of a specific type @c@, and 'M1' wraps a value of the generic type argument,
-- which in the lifted world is an @f p@ (where we do not care about @p@).

-- *** Generic instances
--
-- |
--
-- The instance for 'V1' is slightly awkward (but also rarely used):
--
-- @
-- instance Encode' 'V1' where
--   encode' x = undefined
-- @
--
-- There are no values of type @V1 p@ to pass (except undefined), so this is
-- actually impossible. One can ask why it is useful to define an instance for
-- 'V1' at all in this case? Well, an empty type can be used as an argument to
-- a non-empty type, and you might still want to encode the resulting type.
-- As a somewhat contrived example, consider @[Empty]@, which is not an empty
-- type, but contains just the empty list. The 'V1' instance ensures that we
-- can call the generic function on such types.
--
-- There is exactly one value of type 'U1', so encoding it requires no
-- knowledge, and we can use zero bits:
--
-- @
-- instance Encode' 'U1' where
--   encode' 'U1' = []
-- @
--
-- In the case for ':+:', we produce 'False' or 'True' depending on whether
-- the constructor of the value provided is located on the left or on the right:
--
-- @
-- instance (Encode' f, Encode' g) => Encode' (f ':+:' g) where
--   encode' ('L1' x) = False : encode' x
--   encode' ('R1' x) = True  : encode' x
-- @
--
-- In the case for ':*:', we append the encodings of the two subcomponents:
--
-- @
-- instance (Encode' f, Encode' g) => Encode' (f ':*:' g) where
--   encode' (x ':*:' y) = encode' x ++ encode' y
-- @
--
-- The case for 'K1' is rather interesting. Here, we call the final function
-- 'encode' that we yet have to define, recursively. We will use another type
-- class 'Encode' for that function:
--
-- @
-- instance (Encode c) => Encode' ('K1' i c) where
--   encode' ('K1' x) = encode x
-- @
--
-- Note how 'Par0' and 'Rec0' both being mapped to 'K1' allows us to define
-- a uniform instance here.
--
-- Similarly, we can define a uniform instance for 'M1', because we completely
-- disregard all meta-information:
--
-- @
-- instance (Encode' f) => Encode' ('M1' i t f) where
--   encode' ('M1' x) = encode' x
-- @
--
-- Unlike in 'K1', the instance for 'M1' refers to 'encode'', not 'encode'.

-- *** The wrapper and generic default
--
-- |
--
-- We now define class 'Encode' for the actual 'encode' function:
--
-- @
-- class Encode a where
--   encode :: a -> [Bool]
Ben Gamari's avatar
Ben Gamari committed
389
--   default encode :: (Generic a, Encode' (Rep a)) => a -> [Bool]
dreixel's avatar
dreixel committed
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
--   encode x = encode' ('from' x)
-- @
--
-- The incoming 'x' is converted using 'from', then we dispatch to the
-- generic instances using 'encode''. We use this as a default definition
-- for 'encode'. We need the 'default encode' signature because ordinary
-- Haskell default methods must not introduce additional class constraints,
-- but our generic default does.
--
-- Defining a particular instance is now as simple as saying
--
-- @
-- instance (Encode a) => Encode (Tree a)
-- @
--
#if 0
-- /TODO:/ Add usage example?
--
#endif
-- The generic default is being used. In the future, it will hopefully be
-- possible to use @deriving Encode@ as well, but GHC does not yet support
-- that syntax for this situation.
--
-- Having 'Encode' as a class has the advantage that we can define
-- non-generic special cases, which is particularly useful for abstract
-- datatypes that have no structural representation. For example, given
-- a suitable integer encoding function 'encodeInt', we can define
--
-- @
-- instance Encode Int where
--   encode = encodeInt
-- @

-- *** Omitting generic instances
--
-- |
--
-- It is not always required to provide instances for all the generic
-- representation types, but omitting instances restricts the set of
-- datatypes the functions will work for:
--
--    * If no ':+:' instance is given, the function may still work for
--      empty datatypes or datatypes that have a single constructor,
--      but will fail on datatypes with more than one constructor.
--
--    * If no ':*:' instance is given, the function may still work for
--      datatypes where each constructor has just zero or one field,
--      in particular for enumeration types.
--
--    * If no 'K1' instance is given, the function may still work for
--      enumeration types, where no constructor has any fields.
--
--    * If no 'V1' instance is given, the function may still work for
--      any datatype that is not empty.
--
--    * If no 'U1' instance is given, the function may still work for
--      any datatype where each constructor has at least one field.
--
-- An 'M1' instance is always required (but it can just ignore the
-- meta-information, as is the case for 'encode' above).
#if 0
-- *** Using meta-information
--
-- |
--
-- TODO
#endif
-- ** Generic constructor classes
--
-- |
--
-- Datatype-generic functions as defined above work for a large class
-- of datatypes, including parameterized datatypes. (We have used 'Tree'
-- as our example above, which is of kind @* -> *@.) However, the
-- 'Generic' class ranges over types of kind @*@, and therefore, the
-- resulting generic functions (such as 'encode') must be parameterized
-- by a generic type argument of kind @*@.
--
-- What if we want to define generic classes that range over type
-- constructors (such as 'Functor', 'Traversable', or 'Foldable')?

-- *** The 'Generic1' class
--
-- |
--
-- Like 'Generic', there is a class 'Generic1' that defines a
-- representation 'Rep1' and conversion functions 'from1' and 'to1',
-- only that 'Generic1' ranges over types of kind @* -> *@.
-- The 'Generic1' class is also derivable.
--
-- The representation 'Rep1' is ever so slightly different from 'Rep'.
-- Let us look at 'Tree' as an example again:
--
-- @
-- data Tree a = Leaf a | Node (Tree a) (Tree a)
--   deriving 'Generic1'
-- @
--
-- The above declaration causes the following representation to be generated:
--
490
-- @
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
491
-- instance 'Generic1' Tree where
dreixel's avatar
dreixel committed
492
--   type 'Rep1' Tree =
493
494
--     'D1' ('MetaData \"Tree\" \"Main\" \"package-name\" 'False)
--       ('C1' ('MetaCons \"Leaf\" 'PrefixI 'False)
495
496
497
498
499
--          ('S1' ('MetaSel 'Nothing
--                          'NoSourceUnpackedness
--                          'NoSourceStrictness
--                          'DecidedLazy)
--                'Par1')
dreixel's avatar
dreixel committed
500
--        ':+:'
501
--        'C1' ('MetaCons \"Node\" 'PrefixI 'False)
502
503
504
505
506
--          ('S1' ('MetaSel 'Nothing
--                          'NoSourceUnpackedness
--                          'NoSourceStrictness
--                          'DecidedLazy)
--                ('Rec1' Tree)
dreixel's avatar
dreixel committed
507
--           ':*:'
508
509
510
511
512
--           'S1' ('MetaSel 'Nothing
--                          'NoSourceUnpackedness
--                          'NoSourceStrictness
--                          'DecidedLazy)
--                ('Rec1' Tree)))
dreixel's avatar
dreixel committed
513
--   ...
514
--  @
dreixel's avatar
dreixel committed
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
--
-- The representation reuses 'D1', 'C1', 'S1' (and thereby 'M1') as well
-- as ':+:' and ':*:' from 'Rep'. (This reusability is the reason that we
-- carry around the dummy type argument for kind-@*@-types, but there are
-- already enough different names involved without duplicating each of
-- these.)
--
-- What's different is that we now use 'Par1' to refer to the parameter
-- (and that parameter, which used to be @a@), is not mentioned explicitly
-- by name anywhere; and we use 'Rec1' to refer to a recursive use of @Tree a@.

-- *** Representation of @* -> *@ types
--
-- |
--
530
-- Unlike 'Rec0', the 'Par1' and 'Rec1' type constructors do not
dreixel's avatar
dreixel committed
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
-- map to 'K1'. They are defined directly, as follows:
--
-- @
-- newtype 'Par1'   p = 'Par1' { 'unPar1' ::   p } -- gives access to parameter p
-- newtype 'Rec1' f p = 'Rec1' { 'unRec1' :: f p } -- a wrapper
-- @
--
-- In 'Par1', the parameter @p@ is used for the first time, whereas 'Rec1' simply
-- wraps an application of @f@ to @p@.
--
-- Note that 'K1' (in the guise of 'Rec0') can still occur in a 'Rep1' representation,
-- namely when the datatype has a field that does not mention the parameter.
--
-- The declaration
--
-- @
-- data WithInt a = WithInt Int a
--   deriving 'Generic1'
-- @
--
-- yields
--
-- @
-- class 'Rep1' WithInt where
--   type 'Rep1' WithInt =
556
557
--     'D1' ('MetaData \"WithInt\" \"Main\" \"package-name\" 'False)
--       ('C1' ('MetaCons \"WithInt\" 'PrefixI 'False)
558
559
560
561
562
--         ('S1' ('MetaSel 'Nothing
--                         'NoSourceUnpackedness
--                         'NoSourceStrictness
--                         'DecidedLazy)
--               ('Rec0' Int)
dreixel's avatar
dreixel committed
563
--          ':*:'
564
565
566
567
568
--          'S1' ('MetaSel 'Nothing
--                          'NoSourceUnpackedness
--                          'NoSourceStrictness
--                          'DecidedLazy)
--               'Par1'))
dreixel's avatar
dreixel committed
569
570
571
572
573
574
575
576
577
578
579
580
581
582
-- @
--
-- If the parameter @a@ appears underneath a composition of other type constructors,
-- then the representation involves composition, too:
--
-- @
-- data Rose a = Fork a [Rose a]
-- @
--
-- yields
--
-- @
-- class 'Rep1' Rose where
--   type 'Rep1' Rose =
583
584
--     'D1' ('MetaData \"Rose\" \"Main\" \"package-name\" 'False)
--       ('C1' ('MetaCons \"Fork\" 'PrefixI 'False)
585
586
587
588
589
--         ('S1' ('MetaSel 'Nothing
--                         'NoSourceUnpackedness
--                         'NoSourceStrictness
--                         'DecidedLazy)
--               'Par1'
dreixel's avatar
dreixel committed
590
--          ':*:'
591
592
593
594
595
--          'S1' ('MetaSel 'Nothing
--                          'NoSourceUnpackedness
--                          'NoSourceStrictness
--                          'DecidedLazy)
--               ([] ':.:' 'Rec1' Rose)))
dreixel's avatar
dreixel committed
596
597
598
599
600
601
602
-- @
--
-- where
--
-- @
-- newtype (':.:') f g p = 'Comp1' { 'unComp1' :: f (g p) }
-- @
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654

-- *** Representation of unlifted types
--
-- |
--
-- If one were to attempt to derive a Generic instance for a datatype with an
-- unlifted argument (for example, 'Int#'), one might expect the occurrence of
-- the 'Int#' argument to be marked with @'Rec0' 'Int#'@. This won't work,
-- though, since 'Int#' is of kind @#@ and 'Rec0' expects a type of kind @*@.
-- In fact, polymorphism over unlifted types is disallowed completely.
--
-- One solution would be to represent an occurrence of 'Int#' with 'Rec0 Int'
-- instead. With this approach, however, the programmer has no way of knowing
-- whether the 'Int' is actually an 'Int#' in disguise.
--
-- Instead of reusing 'Rec0', a separate data family 'URec' is used to mark
-- occurrences of common unlifted types:
--
-- @
-- data family URec a p
--
-- data instance 'URec' ('Ptr' ()) p = 'UAddr'   { 'uAddr#'   :: 'Addr#'   }
-- data instance 'URec' 'Char'     p = 'UChar'   { 'uChar#'   :: 'Char#'   }
-- data instance 'URec' 'Double'   p = 'UDouble' { 'uDouble#' :: 'Double#' }
-- data instance 'URec' 'Int'      p = 'UFloat'  { 'uFloat#'  :: 'Float#'  }
-- data instance 'URec' 'Float'    p = 'UInt'    { 'uInt#'    :: 'Int#'    }
-- data instance 'URec' 'Word'     p = 'UWord'   { 'uWord#'   :: 'Word#'   }
-- @
--
-- Several type synonyms are provided for convenience:
--
-- @
-- type 'UAddr'   = 'URec' ('Ptr' ())
-- type 'UChar'   = 'URec' 'Char'
-- type 'UDouble' = 'URec' 'Double'
-- type 'UFloat'  = 'URec' 'Float'
-- type 'UInt'    = 'URec' 'Int'
-- type 'UWord'   = 'URec' 'Word'
-- @
--
-- The declaration
--
-- @
-- data IntHash = IntHash Int#
--   deriving 'Generic'
-- @
--
-- yields
--
-- @
-- instance 'Generic' IntHash where
--   type 'Rep' IntHash =
655
656
--     'D1' ('MetaData \"IntHash\" \"Main\" \"package-name\" 'False)
--       ('C1' ('MetaCons \"IntHash\" 'PrefixI 'False)
657
658
659
660
661
--         ('S1' ('MetaSel 'Nothing
--                         'NoSourceUnpackedness
--                         'NoSourceStrictness
--                         'DecidedLazy)
--               'UInt'))
662
663
664
665
-- @
--
-- Currently, only the six unlifted types listed above are generated, but this
-- may be extended to encompass more unlifted types in the future.
dreixel's avatar
dreixel committed
666
667
668
669
670
671
672
673
674
675
676
677
#if 0
-- *** Limitations
--
-- |
--
-- /TODO/
--
-- /TODO:/ Also clear up confusion about 'Rec0' and 'Rec1' not really indicating recursion.
--
#endif
-----------------------------------------------------------------------------

jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
678
679
680
681
  -- * Generic representation types
    V1, U1(..), Par1(..), Rec1(..), K1(..), M1(..)
  , (:+:)(..), (:*:)(..), (:.:)(..)

682
683
684
685
686
  -- ** Unboxed representation types
  , URec(..)
  , type UAddr, type UChar, type UDouble
  , type UFloat, type UInt, type UWord

jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
687
  -- ** Synonyms for convenience
688
  , Rec0, R
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
689
690
691
  , D1, C1, S1, D, C, S

  -- * Meta-information
692
  , Datatype(..), Constructor(..), Selector(..)
693
  , Fixity(..), FixityI(..), Associativity(..), prec
694
  , SourceUnpackedness(..), SourceStrictness(..), DecidedStrictness(..)
695
  , Meta(..)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
696
697
698
699
700
701
702

  -- * Generic type classes
  , Generic(..), Generic1(..)

  ) where

-- We use some base types
703
import GHC.Integer ( Integer, integerToInt )
704
705
import GHC.Prim ( Addr#, Char#, Double#, Float#, Int#, Word# )
import GHC.Ptr ( Ptr )
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
706
import GHC.Types
707
import Data.Maybe  ( Maybe(..), fromMaybe )
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
708
709
710
import Data.Either ( Either(..) )

-- Needed for instances
711
import GHC.Base    ( String )
712
import GHC.Classes ( Eq, Ord )
713
714
715
716
717
718
import GHC.Read    ( Read )
import GHC.Show    ( Show )

-- Needed for metadata
import Data.Proxy   ( Proxy(..), KProxy(..) )
import GHC.TypeLits ( Nat, Symbol, KnownSymbol, KnownNat, symbolVal, natVal )
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
719
720
721
722
723
724

--------------------------------------------------------------------------------
-- Representation types
--------------------------------------------------------------------------------

-- | Void: used for datatypes without constructors
725
data V1 (p :: *)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
726
727

-- | Unit: used for constructors without arguments
728
data U1 (p :: *) = U1
729
  deriving (Eq, Ord, Read, Show, Generic)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
730
731
732

-- | Used for marking occurrences of the parameter
newtype Par1 p = Par1 { unPar1 :: p }
733
  deriving (Eq, Ord, Read, Show, Generic)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
734
735

-- | Recursive calls of kind * -> *
736
newtype Rec1 f (p :: *) = Rec1 { unRec1 :: f p }
737
  deriving (Eq, Ord, Read, Show, Generic)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
738
739

-- | Constants, additional parameters and recursion of kind *
740
newtype K1 (i :: *) c (p :: *) = K1 { unK1 :: c }
741
  deriving (Eq, Ord, Read, Show, Generic)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
742
743

-- | Meta-information (constructor names, etc.)
744
newtype M1 (i :: *) (c :: Meta) f (p :: *) = M1 { unM1 :: f p }
745
  deriving (Eq, Ord, Read, Show, Generic)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
746
747
748

-- | Sums: encode choice between constructors
infixr 5 :+:
749
data (:+:) f g (p :: *) = L1 (f p) | R1 (g p)
750
  deriving (Eq, Ord, Read, Show, Generic)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
751
752
753

-- | Products: encode multiple arguments to constructors
infixr 6 :*:
754
data (:*:) f g (p :: *) = f p :*: g p
755
  deriving (Eq, Ord, Read, Show, Generic)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
756
757
758

-- | Composition of functors
infixr 7 :.:
759
newtype (:.:) f (g :: * -> *) (p :: *) = Comp1 { unComp1 :: f (g p) }
760
  deriving (Eq, Ord, Read, Show, Generic)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
761

762
763
764
765
-- | Constants of kind @#@
data family URec (a :: *) (p :: *)

-- | Used for marking occurrences of 'Addr#'
766
data instance URec (Ptr ()) _p = UAddr { uAddr# :: Addr# }
767
768
769
  deriving (Eq, Ord, Generic)

-- | Used for marking occurrences of 'Char#'
770
data instance URec Char _p = UChar { uChar# :: Char# }
771
772
773
  deriving (Eq, Ord, Show, Generic)

-- | Used for marking occurrences of 'Double#'
774
data instance URec Double _p = UDouble { uDouble# :: Double# }
775
776
777
  deriving (Eq, Ord, Show, Generic)

-- | Used for marking occurrences of 'Float#'
778
data instance URec Float _p = UFloat { uFloat# :: Float# }
779
780
781
  deriving (Eq, Ord, Show, Generic)

-- | Used for marking occurrences of 'Int#'
782
data instance URec Int _p = UInt { uInt# :: Int# }
783
784
785
  deriving (Eq, Ord, Show, Generic)

-- | Used for marking occurrences of 'Word#'
786
data instance URec Word _p = UWord { uWord# :: Word# }
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
  deriving (Eq, Ord, Show, Generic)

-- | Type synonym for 'URec': 'Addr#'
type UAddr   = URec (Ptr ())
-- | Type synonym for 'URec': 'Char#'
type UChar   = URec Char
-- | Type synonym for 'URec': 'Double#'
type UDouble = URec Double
-- | Type synonym for 'URec': 'Float#'
type UFloat  = URec Float
-- | Type synonym for 'URec': 'Int#'
type UInt    = URec Int
-- | Type synonym for 'URec': 'Word#'
type UWord   = URec Word

jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
-- | Tag for K1: recursion (of kind *)
data R

-- | Type synonym for encoding recursion (of kind *)
type Rec0  = K1 R

-- | Tag for M1: datatype
data D
-- | Tag for M1: constructor
data C
-- | Tag for M1: record selector
data S

-- | Type synonym for encoding meta-information for datatypes
type D1 = M1 D

-- | Type synonym for encoding meta-information for constructors
type C1 = M1 C

-- | Type synonym for encoding meta-information for record selectors
type S1 = M1 S

-- | Class for datatypes that represent datatypes
825
class Datatype d where
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
826
  -- | The name of the datatype (unqualified)
827
  datatypeName :: t d (f :: * -> *) a -> [Char]
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
828
  -- | The fully-qualified name of the module where the type is declared
829
  moduleName   :: t d (f :: * -> *) a -> [Char]
830
  -- | The package name of the module where the type is declared
831
  packageName :: t d (f :: * -> *) a -> [Char]
832
  -- | Marks if the datatype is actually a newtype
833
  isNewtype    :: t d (f :: * -> *) a -> Bool
834
  isNewtype _ = False
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
835

836
837
838
839
840
841
instance (KnownSymbol n, KnownSymbol m, KnownSymbol p, SingI nt)
    => Datatype ('MetaData n m p nt) where
  datatypeName _ = symbolVal (Proxy :: Proxy n)
  moduleName   _ = symbolVal (Proxy :: Proxy m)
  packageName  _ = symbolVal (Proxy :: Proxy p)
  isNewtype    _ = fromSing  (sing  :: Sing nt)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
842
843

-- | Class for datatypes that represent data constructors
844
class Constructor c where
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
845
  -- | The name of the constructor
846
  conName :: t c (f :: * -> *) a -> [Char]
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
847
848

  -- | The fixity of the constructor
849
  conFixity :: t c (f :: * -> *) a -> Fixity
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
850
851
852
  conFixity _ = Prefix

  -- | Marks if this constructor is a record
853
  conIsRecord :: t c (f :: * -> *) a -> Bool
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
854
855
  conIsRecord _ = False

856
857
858
859
860
instance (KnownSymbol n, SingI f, SingI r)
    => Constructor ('MetaCons n f r) where
  conName     _ = symbolVal (Proxy :: Proxy n)
  conFixity   _ = fromSing  (sing  :: Sing f)
  conIsRecord _ = fromSing  (sing  :: Sing r)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
861
862
863
864

-- | Datatype to represent the fixity of a constructor. An infix
-- | declaration directly corresponds to an application of 'Infix'.
data Fixity = Prefix | Infix Associativity Int
865
  deriving (Eq, Show, Ord, Read, Generic)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
866

867
868
869
-- | This variant of 'Fixity' appears at the type level.
data FixityI = PrefixI | InfixI Associativity Nat

jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
870
871
872
873
874
875
876
877
878
-- | Get the precedence of a fixity value.
prec :: Fixity -> Int
prec Prefix      = 10
prec (Infix _ n) = n

-- | Datatype to represent the associativity of a constructor
data Associativity = LeftAssociative
                   | RightAssociative
                   | NotAssociative
879
  deriving (Eq, Show, Ord, Read, Generic)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
880

881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
-- | The unpackedness of a field as the user wrote it in the source code. For
-- example, in the following data type:
--
-- @
-- data E = ExampleConstructor     Int
--            {\-\# NOUNPACK \#-\} Int
--            {\-\#   UNPACK \#-\} Int
-- @
--
-- The fields of @ExampleConstructor@ have 'NoSourceUnpackedness',
-- 'SourceNoUnpack', and 'SourceUnpack', respectively.
data SourceUnpackedness = NoSourceUnpackedness
                        | SourceNoUnpack
                        | SourceUnpack
  deriving (Eq, Show, Ord, Read, Generic)

-- | The strictness of a field as the user wrote it in the source code. For
-- example, in the following data type:
--
-- @
-- data E = ExampleConstructor Int ~Int !Int
-- @
--
-- The fields of @ExampleConstructor@ have 'NoSourceStrictness',
-- 'SourceLazy', and 'SourceStrict', respectively.
data SourceStrictness = NoSourceStrictness
                      | SourceLazy
                      | SourceStrict
  deriving (Eq, Show, Ord, Read, Generic)

-- | The strictness that GHC infers for a field during compilation. Whereas
-- there are nine different combinations of 'SourceUnpackedness' and
-- 'SourceStrictness', the strictness that GHC decides will ultimately be one
-- of lazy, strict, or unpacked. What GHC decides is affected both by what the
-- user writes in the source code and by GHC flags. As an example, consider
-- this data type:
--
-- @
-- data E = ExampleConstructor {\-\# UNPACK \#-\} !Int !Int Int
-- @
--
-- * If compiled without optimization or other language extensions, then the
--   fields of @ExampleConstructor@ will have 'DecidedStrict', 'DecidedStrict',
--   and 'DecidedLazy', respectively.
--
-- * If compiled with @-XStrictData@ enabled, then the fields will have
--   'DecidedStrict', 'DecidedStrict', and 'DecidedStrict', respectively.
--
-- * If compiled with @-O2@ enabled, then the fields will have 'DecidedUnpack',
--   'DecidedStrict', and 'DecidedLazy', respectively.
data DecidedStrictness = DecidedLazy
                       | DecidedStrict
                       | DecidedUnpack
  deriving (Eq, Show, Ord, Read, Generic)

936
937
938
939
-- | Class for datatypes that represent records
class Selector s where
  -- | The name of the selector
  selName :: t s (f :: * -> *) a -> [Char]
940
941
942
943
944
945
946
947
948
949
950
951
952
  -- | The selector's unpackedness annotation (if any)
  selSourceUnpackedness :: t s (f :: * -> *) a -> SourceUnpackedness
  -- | The selector's strictness annotation (if any)
  selSourceStrictness :: t s (f :: * -> *) a -> SourceStrictness
  -- | The strictness that the compiler inferred for the selector
  selDecidedStrictness :: t s (f :: * -> *) a -> DecidedStrictness

instance (SingI mn, SingI su, SingI ss, SingI ds)
    => Selector ('MetaSel mn su ss ds) where
  selName _ = fromMaybe "" (fromSing (sing :: Sing mn))
  selSourceUnpackedness _ = fromSing (sing :: Sing su)
  selSourceStrictness   _ = fromSing (sing :: Sing ss)
  selDecidedStrictness  _ = fromSing (sing :: Sing ds)
953

jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
954
955
956
957
958
959
960
961
962
963
964
-- | Representable types of kind *.
-- This class is derivable in GHC with the DeriveGeneric flag on.
class Generic a where
  -- | Generic representation type
  type Rep a :: * -> *
  -- | Convert from the datatype to its representation
  from  :: a -> (Rep a) x
  -- | Convert from the representation to the datatype
  to    :: (Rep a) x -> a


965
966
-- | Representable types of kind * -> *.
-- This class is derivable in GHC with the DeriveGeneric flag on.
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
967
968
969
970
971
972
973
974
class Generic1 f where
  -- | Generic representation type
  type Rep1 f :: * -> *
  -- | Convert from the datatype to its representation
  from1  :: f a -> (Rep1 f) a
  -- | Convert from the representation to the datatype
  to1    :: (Rep1 f) a -> f a

975
976
977
978
979
--------------------------------------------------------------------------------
-- Meta-data
--------------------------------------------------------------------------------

-- | Datatype to represent metadata associated with a datatype (@MetaData@),
980
-- constructor (@MetaCons@), or field selector (@MetaSel@).
981
982
983
984
985
986
987
988
--
-- * In @MetaData n m p nt@, @n@ is the datatype's name, @m@ is the module in
--   which the datatype is defined, @p@ is the package in which the datatype
--   is defined, and @nt@ is @'True@ if the datatype is a @newtype@.
--
-- * In @MetaCons n f s@, @n@ is the constructor's name, @f@ is its fixity,
--   and @s@ is @'True@ if the constructor contains record selectors.
--
989
990
991
992
-- * In @MetaSel mn su ss ds@, if the field is uses record syntax, then @mn@ is
--   'Just' the record name. Otherwise, @mn@ is 'Nothing. @su@ and @ss@ are the
--   field's unpackedness and strictness annotations, and @ds@ is the
--   strictness that GHC infers for the field.
993
994
data Meta = MetaData Symbol Symbol Symbol Bool
          | MetaCons Symbol FixityI Bool
995
996
          | MetaSel  (Maybe Symbol)
                     SourceUnpackedness SourceStrictness DecidedStrictness
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
997
998
999
1000

--------------------------------------------------------------------------------
-- Derived instances
--------------------------------------------------------------------------------
1001

jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
1002
1003
1004
1005
1006
deriving instance Generic [a]
deriving instance Generic (Maybe a)
deriving instance Generic (Either a b)
deriving instance Generic Bool
deriving instance Generic Ordering
1007
deriving instance Generic (Proxy t)
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
deriving instance Generic ()
deriving instance Generic ((,) a b)
deriving instance Generic ((,,) a b c)
deriving instance Generic ((,,,) a b c d)
deriving instance Generic ((,,,,) a b c d e)
deriving instance Generic ((,,,,,) a b c d e f)
deriving instance Generic ((,,,,,,) a b c d e f g)

deriving instance Generic1 []
deriving instance Generic1 Maybe
deriving instance Generic1 (Either a)
1019
deriving instance Generic1 Proxy
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
1020
1021
1022
1023
1024
1025
1026
1027
deriving instance Generic1 ((,) a)
deriving instance Generic1 ((,,) a b)
deriving instance Generic1 ((,,,) a b c)
deriving instance Generic1 ((,,,,) a b c d)
deriving instance Generic1 ((,,,,,) a b c d e)
deriving instance Generic1 ((,,,,,,) a b c d e f)

--------------------------------------------------------------------------------
1028
-- Copied from the singletons package
jpm@cs.ox.ac.uk's avatar
jpm@cs.ox.ac.uk committed
1029
1030
--------------------------------------------------------------------------------

1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
-- | The singleton kind-indexed data family.
data family Sing (a :: k)

-- | A 'SingI' constraint is essentially an implicitly-passed singleton.
-- If you need to satisfy this constraint with an explicit singleton, please
-- see 'withSingI'.
class SingI (a :: k) where
  -- | Produce the singleton explicitly. You will likely need the @ScopedTypeVariables@
  -- extension to use this method the way you want.
  sing :: Sing a

-- | The 'SingKind' class is essentially a /kind/ class. It classifies all kinds
-- for which singletons are defined. The class supports converting between a singleton
-- type and the base (unrefined) type which it is built from.
class (kparam ~ 'KProxy) => SingKind (kparam :: KProxy k) where
  -- | Get a base type from a proxy for the promoted kind. For example,
  -- @DemoteRep ('KProxy :: KProxy Bool)@ will be the type @Bool@.
  type DemoteRep kparam :: *

  -- | Convert a singleton to its unrefined version.
  fromSing :: Sing (a :: k) -> DemoteRep kparam

1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
-- Singleton symbols
data instance Sing (_s :: Symbol) where
  SSym :: KnownSymbol s => Sing s

instance KnownSymbol a => SingI a where sing = SSym

instance SingKind ('KProxy :: KProxy Symbol) where
  type DemoteRep ('KProxy :: KProxy Symbol) = String
  fromSing (SSym :: Sing s) = symbolVal (Proxy :: Proxy s)

1063
-- Singleton booleans
1064
data instance Sing (_a :: Bool) where
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
  STrue  :: Sing 'True
  SFalse :: Sing 'False

instance SingI 'True  where sing = STrue
instance SingI 'False where sing = SFalse

instance SingKind ('KProxy :: KProxy Bool) where
  type DemoteRep ('KProxy :: KProxy Bool) = Bool
  fromSing STrue  = True
  fromSing SFalse = False

1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
-- Singleton Maybe
data instance Sing (_b :: Maybe _a) where
  SNothing :: Sing 'Nothing
  SJust    :: Sing a -> Sing ('Just a)

instance            SingI 'Nothing  where sing = SNothing
instance SingI a => SingI ('Just a) where sing = SJust sing

instance SingKind ('KProxy :: KProxy a) =>
    SingKind ('KProxy :: KProxy (Maybe a)) where
  type DemoteRep ('KProxy :: KProxy (Maybe a)) =
      Maybe (DemoteRep ('KProxy :: KProxy a))
  fromSing SNothing  = Nothing
  fromSing (SJust a) = Just (fromSing a)

1091
-- Singleton Fixity
1092
data instance Sing (_a :: FixityI) where
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
  SPrefix :: Sing 'PrefixI
  SInfix  :: Sing a -> Integer -> Sing ('InfixI a n)

instance SingI 'PrefixI where sing = SPrefix
instance (SingI a, KnownNat n) => SingI ('InfixI a n) where
  sing = SInfix (sing :: Sing a) (natVal (Proxy :: Proxy n))

instance SingKind ('KProxy :: KProxy FixityI) where
  type DemoteRep ('KProxy :: KProxy FixityI) = Fixity
  fromSing SPrefix      = Prefix
  fromSing (SInfix a n) = Infix (fromSing a) (I# (integerToInt n))

-- Singleton Associativity
1106
data instance Sing (_a :: Associativity) where
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
  SLeftAssociative  :: Sing 'LeftAssociative
  SRightAssociative :: Sing 'RightAssociative
  SNotAssociative   :: Sing 'NotAssociative

instance SingI 'LeftAssociative  where sing = SLeftAssociative
instance SingI 'RightAssociative where sing = SRightAssociative
instance SingI 'NotAssociative   where sing = SNotAssociative

instance SingKind ('KProxy :: KProxy Associativity) where
  type DemoteRep ('KProxy :: KProxy Associativity) = Associativity
  fromSing SLeftAssociative  = LeftAssociative
  fromSing SRightAssociative = RightAssociative
  fromSing SNotAssociative   = NotAssociative
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167

-- Singleton SourceUnpackedness
data instance Sing (_a :: SourceUnpackedness) where
  SNoSourceUnpackedness :: Sing 'NoSourceUnpackedness
  SSourceNoUnpack       :: Sing 'SourceNoUnpack
  SSourceUnpack         :: Sing 'SourceUnpack

instance SingI 'NoSourceUnpackedness where sing = SNoSourceUnpackedness
instance SingI 'SourceNoUnpack       where sing = SSourceNoUnpack
instance SingI 'SourceUnpack         where sing = SSourceUnpack

instance SingKind ('KProxy :: KProxy SourceUnpackedness) where
  type DemoteRep ('KProxy :: KProxy SourceUnpackedness) = SourceUnpackedness
  fromSing SNoSourceUnpackedness = NoSourceUnpackedness
  fromSing SSourceNoUnpack       = SourceNoUnpack
  fromSing SSourceUnpack         = SourceUnpack

-- Singleton SourceStrictness
data instance Sing (_a :: SourceStrictness) where
  SNoSourceStrictness :: Sing 'NoSourceStrictness
  SSourceLazy         :: Sing 'SourceLazy
  SSourceStrict       :: Sing 'SourceStrict

instance SingI 'NoSourceStrictness where sing = SNoSourceStrictness
instance SingI 'SourceLazy         where sing = SSourceLazy
instance SingI 'SourceStrict       where sing = SSourceStrict

instance SingKind ('KProxy :: KProxy SourceStrictness) where
  type DemoteRep ('KProxy :: KProxy SourceStrictness) = SourceStrictness
  fromSing SNoSourceStrictness = NoSourceStrictness
  fromSing SSourceLazy         = SourceLazy
  fromSing SSourceStrict       = SourceStrict

-- Singleton DecidedStrictness
data instance Sing (_a :: DecidedStrictness) where
  SDecidedLazy   :: Sing 'DecidedLazy
  SDecidedStrict :: Sing 'DecidedStrict
  SDecidedUnpack :: Sing 'DecidedUnpack

instance SingI 'DecidedLazy   where sing = SDecidedLazy
instance SingI 'DecidedStrict where sing = SDecidedStrict
instance SingI 'DecidedUnpack where sing = SDecidedUnpack

instance SingKind ('KProxy :: KProxy DecidedStrictness) where
  type DemoteRep ('KProxy :: KProxy DecidedStrictness) = DecidedStrictness
  fromSing SDecidedLazy   = DecidedLazy
  fromSing SDecidedStrict = DecidedStrict
  fromSing SDecidedUnpack = DecidedUnpack