Update base for latest Safe Haskell.
[packages/base.git] / Data / Data.hs
1 {-# LANGUAGE Trustworthy #-}
2 {-# LANGUAGE CPP, Rank2Types, ScopedTypeVariables #-}
3
4 -----------------------------------------------------------------------------
5 -- |
6 -- Module : Data.Data
7 -- Copyright : (c) The University of Glasgow, CWI 2001--2004
8 -- License : BSD-style (see the file libraries/base/LICENSE)
9 --
10 -- Maintainer : libraries@haskell.org
11 -- Stability : experimental
12 -- Portability : non-portable (local universal quantification)
13 --
14 -- \"Scrap your boilerplate\" --- Generic programming in Haskell.
15 -- See <http://www.cs.vu.nl/boilerplate/>. This module provides
16 -- the 'Data' class with its primitives for generic programming, along
17 -- with instances for many datatypes. It corresponds to a merge between
18 -- the previous "Data.Generics.Basics" and almost all of
19 -- "Data.Generics.Instances". The instances that are not present
20 -- in this module were moved to the @Data.Generics.Instances@ module
21 -- in the @syb@ package.
22 --
23 -- For more information, please visit the new
24 -- SYB wiki: <http://www.cs.uu.nl/wiki/bin/view/GenericProgramming/SYB>.
25 --
26 -----------------------------------------------------------------------------
27
28 module Data.Data (
29
30 -- * Module Data.Typeable re-exported for convenience
31 module Data.Typeable,
32
33 -- * The Data class for processing constructor applications
34 Data(
35 gfoldl, -- :: ... -> a -> c a
36 gunfold, -- :: ... -> Constr -> c a
37 toConstr, -- :: a -> Constr
38 dataTypeOf, -- :: a -> DataType
39 dataCast1, -- mediate types and unary type constructors
40 dataCast2, -- mediate types and binary type constructors
41 -- Generic maps defined in terms of gfoldl
42 gmapT,
43 gmapQ,
44 gmapQl,
45 gmapQr,
46 gmapQi,
47 gmapM,
48 gmapMp,
49 gmapMo
50 ),
51
52 -- * Datatype representations
53 DataType, -- abstract, instance of: Show
54 -- ** Constructors
55 mkDataType, -- :: String -> [Constr] -> DataType
56 mkIntType, -- :: String -> DataType
57 mkFloatType, -- :: String -> DataType
58 mkStringType, -- :: String -> DataType
59 mkCharType, -- :: String -> DataType
60 mkNoRepType, -- :: String -> DataType
61 mkNorepType, -- :: String -> DataType
62 -- ** Observers
63 dataTypeName, -- :: DataType -> String
64 DataRep(..), -- instance of: Eq, Show
65 dataTypeRep, -- :: DataType -> DataRep
66 -- ** Convenience functions
67 repConstr, -- :: DataType -> ConstrRep -> Constr
68 isAlgType, -- :: DataType -> Bool
69 dataTypeConstrs,-- :: DataType -> [Constr]
70 indexConstr, -- :: DataType -> ConIndex -> Constr
71 maxConstrIndex, -- :: DataType -> ConIndex
72 isNorepType, -- :: DataType -> Bool
73
74 -- * Data constructor representations
75 Constr, -- abstract, instance of: Eq, Show
76 ConIndex, -- alias for Int, start at 1
77 Fixity(..), -- instance of: Eq, Show
78 -- ** Constructors
79 mkConstr, -- :: DataType -> String -> Fixity -> Constr
80 mkIntConstr, -- :: DataType -> Integer -> Constr
81 mkFloatConstr, -- :: DataType -> Double -> Constr
82 mkIntegralConstr,-- :: (Integral a) => DataType -> a -> Constr
83 mkRealConstr, -- :: (Real a) => DataType -> a -> Constr
84 mkStringConstr, -- :: DataType -> String -> Constr
85 mkCharConstr, -- :: DataType -> Char -> Constr
86 -- ** Observers
87 constrType, -- :: Constr -> DataType
88 ConstrRep(..), -- instance of: Eq, Show
89 constrRep, -- :: Constr -> ConstrRep
90 constrFields, -- :: Constr -> [String]
91 constrFixity, -- :: Constr -> Fixity
92 -- ** Convenience function: algebraic data types
93 constrIndex, -- :: Constr -> ConIndex
94 -- ** From strings to constructors and vice versa: all data types
95 showConstr, -- :: Constr -> String
96 readConstr, -- :: DataType -> String -> Maybe Constr
97
98 -- * Convenience functions: take type constructors apart
99 tyconUQname, -- :: String -> String
100 tyconModule, -- :: String -> String
101
102 -- * Generic operations defined in terms of 'gunfold'
103 fromConstr, -- :: Constr -> a
104 fromConstrB, -- :: ... -> Constr -> a
105 fromConstrM -- :: Monad m => ... -> Constr -> m a
106
107 ) where
108
109
110 ------------------------------------------------------------------------------
111
112 import Prelude -- necessary to get dependencies right
113
114 import Data.Typeable
115 import Data.Maybe
116 import Control.Monad
117
118 -- Imports for the instances
119 import Data.Int -- So we can give Data instance for Int8, ...
120 import Data.Word -- So we can give Data instance for Word8, ...
121 #ifdef __GLASGOW_HASKELL__
122 import GHC.Real( Ratio(..) ) -- So we can give Data instance for Ratio
123 --import GHC.IOBase -- So we can give Data instance for IO, Handle
124 import GHC.Ptr -- So we can give Data instance for Ptr
125 import GHC.ForeignPtr -- So we can give Data instance for ForeignPtr
126 --import GHC.Stable -- So we can give Data instance for StablePtr
127 --import GHC.ST -- So we can give Data instance for ST
128 --import GHC.Conc -- So we can give Data instance for MVar & Co.
129 import GHC.Arr -- So we can give Data instance for Array
130 #else
131 # ifdef __HUGS__
132 import Hugs.Prelude( Ratio(..) )
133 # endif
134 import Foreign.Ptr
135 import Foreign.ForeignPtr
136 import Data.Array
137 #endif
138
139 #include "Typeable.h"
140
141
142
143 ------------------------------------------------------------------------------
144 --
145 -- The Data class
146 --
147 ------------------------------------------------------------------------------
148
149 {- |
150 The 'Data' class comprehends a fundamental primitive 'gfoldl' for
151 folding over constructor applications, say terms. This primitive can
152 be instantiated in several ways to map over the immediate subterms
153 of a term; see the @gmap@ combinators later in this class. Indeed, a
154 generic programmer does not necessarily need to use the ingenious gfoldl
155 primitive but rather the intuitive @gmap@ combinators. The 'gfoldl'
156 primitive is completed by means to query top-level constructors, to
157 turn constructor representations into proper terms, and to list all
158 possible datatype constructors. This completion allows us to serve
159 generic programming scenarios like read, show, equality, term generation.
160
161 The combinators 'gmapT', 'gmapQ', 'gmapM', etc are all provided with
162 default definitions in terms of 'gfoldl', leaving open the opportunity
163 to provide datatype-specific definitions.
164 (The inclusion of the @gmap@ combinators as members of class 'Data'
165 allows the programmer or the compiler to derive specialised, and maybe
166 more efficient code per datatype. /Note/: 'gfoldl' is more higher-order
167 than the @gmap@ combinators. This is subject to ongoing benchmarking
168 experiments. It might turn out that the @gmap@ combinators will be
169 moved out of the class 'Data'.)
170
171 Conceptually, the definition of the @gmap@ combinators in terms of the
172 primitive 'gfoldl' requires the identification of the 'gfoldl' function
173 arguments. Technically, we also need to identify the type constructor
174 @c@ for the construction of the result type from the folded term type.
175
176 In the definition of @gmapQ@/x/ combinators, we use phantom type
177 constructors for the @c@ in the type of 'gfoldl' because the result type
178 of a query does not involve the (polymorphic) type of the term argument.
179 In the definition of 'gmapQl' we simply use the plain constant type
180 constructor because 'gfoldl' is left-associative anyway and so it is
181 readily suited to fold a left-associative binary operation over the
182 immediate subterms. In the definition of gmapQr, extra effort is
183 needed. We use a higher-order accumulation trick to mediate between
184 left-associative constructor application vs. right-associative binary
185 operation (e.g., @(:)@). When the query is meant to compute a value
186 of type @r@, then the result type withing generic folding is @r -> r@.
187 So the result of folding is a function to which we finally pass the
188 right unit.
189
190 With the @-XDeriveDataTypeable@ option, GHC can generate instances of the
191 'Data' class automatically. For example, given the declaration
192
193 > data T a b = C1 a b | C2 deriving (Typeable, Data)
194
195 GHC will generate an instance that is equivalent to
196
197 > instance (Data a, Data b) => Data (T a b) where
198 > gfoldl k z (C1 a b) = z C1 `k` a `k` b
199 > gfoldl k z C2 = z C2
200 >
201 > gunfold k z c = case constrIndex c of
202 > 1 -> k (k (z C1))
203 > 2 -> z C2
204 >
205 > toConstr (C1 _ _) = con_C1
206 > toConstr C2 = con_C2
207 >
208 > dataTypeOf _ = ty_T
209 >
210 > con_C1 = mkConstr ty_T "C1" [] Prefix
211 > con_C2 = mkConstr ty_T "C2" [] Prefix
212 > ty_T = mkDataType "Module.T" [con_C1, con_C2]
213
214 This is suitable for datatypes that are exported transparently.
215
216 -}
217
218 class Typeable a => Data a where
219
220 -- | Left-associative fold operation for constructor applications.
221 --
222 -- The type of 'gfoldl' is a headache, but operationally it is a simple
223 -- generalisation of a list fold.
224 --
225 -- The default definition for 'gfoldl' is @'const' 'id'@, which is
226 -- suitable for abstract datatypes with no substructures.
227 gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
228 -- ^ defines how nonempty constructor applications are
229 -- folded. It takes the folded tail of the constructor
230 -- application and its head, i.e., an immediate subterm,
231 -- and combines them in some way.
232 -> (forall g. g -> c g)
233 -- ^ defines how the empty constructor application is
234 -- folded, like the neutral \/ start element for list
235 -- folding.
236 -> a
237 -- ^ structure to be folded.
238 -> c a
239 -- ^ result, with a type defined in terms of @a@, but
240 -- variability is achieved by means of type constructor
241 -- @c@ for the construction of the actual result type.
242
243 -- See the 'Data' instances in this file for an illustration of 'gfoldl'.
244
245 gfoldl _ z = z
246
247 -- | Unfolding constructor applications
248 gunfold :: (forall b r. Data b => c (b -> r) -> c r)
249 -> (forall r. r -> c r)
250 -> Constr
251 -> c a
252
253 -- | Obtaining the constructor from a given datum.
254 -- For proper terms, this is meant to be the top-level constructor.
255 -- Primitive datatypes are here viewed as potentially infinite sets of
256 -- values (i.e., constructors).
257 toConstr :: a -> Constr
258
259
260 -- | The outer type constructor of the type
261 dataTypeOf :: a -> DataType
262
263
264
265 ------------------------------------------------------------------------------
266 --
267 -- Mediate types and type constructors
268 --
269 ------------------------------------------------------------------------------
270
271 -- | Mediate types and unary type constructors.
272 -- In 'Data' instances of the form @T a@, 'dataCast1' should be defined
273 -- as 'gcast1'.
274 --
275 -- The default definition is @'const' 'Nothing'@, which is appropriate
276 -- for non-unary type constructors.
277 dataCast1 :: Typeable1 t
278 => (forall d. Data d => c (t d))
279 -> Maybe (c a)
280 dataCast1 _ = Nothing
281
282 -- | Mediate types and binary type constructors.
283 -- In 'Data' instances of the form @T a b@, 'dataCast2' should be
284 -- defined as 'gcast2'.
285 --
286 -- The default definition is @'const' 'Nothing'@, which is appropriate
287 -- for non-binary type constructors.
288 dataCast2 :: Typeable2 t
289 => (forall d e. (Data d, Data e) => c (t d e))
290 -> Maybe (c a)
291 dataCast2 _ = Nothing
292
293
294
295 ------------------------------------------------------------------------------
296 --
297 -- Typical generic maps defined in terms of gfoldl
298 --
299 ------------------------------------------------------------------------------
300
301
302 -- | A generic transformation that maps over the immediate subterms
303 --
304 -- The default definition instantiates the type constructor @c@ in the
305 -- type of 'gfoldl' to an identity datatype constructor, using the
306 -- isomorphism pair as injection and projection.
307 gmapT :: (forall b. Data b => b -> b) -> a -> a
308
309 -- Use an identity datatype constructor ID (see below)
310 -- to instantiate the type constructor c in the type of gfoldl,
311 -- and perform injections ID and projections unID accordingly.
312 --
313 gmapT f x0 = unID (gfoldl k ID x0)
314 where
315 k :: Data d => ID (d->b) -> d -> ID b
316 k (ID c) x = ID (c (f x))
317
318
319 -- | A generic query with a left-associative binary operator
320 gmapQl :: forall r r'. (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
321 gmapQl o r f = unCONST . gfoldl k z
322 where
323 k :: Data d => CONST r (d->b) -> d -> CONST r b
324 k c x = CONST $ (unCONST c) `o` f x
325 z :: g -> CONST r g
326 z _ = CONST r
327
328 -- | A generic query with a right-associative binary operator
329 gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
330 gmapQr o r0 f x0 = unQr (gfoldl k (const (Qr id)) x0) r0
331 where
332 k :: Data d => Qr r (d->b) -> d -> Qr r b
333 k (Qr c) x = Qr (\r -> c (f x `o` r))
334
335
336 -- | A generic query that processes the immediate subterms and returns a list
337 -- of results. The list is given in the same order as originally specified
338 -- in the declaratoin of the data constructors.
339 gmapQ :: (forall d. Data d => d -> u) -> a -> [u]
340 gmapQ f = gmapQr (:) [] f
341
342
343 -- | A generic query that processes one child by index (zero-based)
344 gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> a -> u
345 gmapQi i f x = case gfoldl k z x of { Qi _ q -> fromJust q }
346 where
347 k :: Data d => Qi u (d -> b) -> d -> Qi u b
348 k (Qi i' q) a = Qi (i'+1) (if i==i' then Just (f a) else q)
349 z :: g -> Qi q g
350 z _ = Qi 0 Nothing
351
352
353 -- | A generic monadic transformation that maps over the immediate subterms
354 --
355 -- The default definition instantiates the type constructor @c@ in
356 -- the type of 'gfoldl' to the monad datatype constructor, defining
357 -- injection and projection using 'return' and '>>='.
358 gmapM :: forall m. Monad m => (forall d. Data d => d -> m d) -> a -> m a
359
360 -- Use immediately the monad datatype constructor
361 -- to instantiate the type constructor c in the type of gfoldl,
362 -- so injection and projection is done by return and >>=.
363 --
364 gmapM f = gfoldl k return
365 where
366 k :: Data d => m (d -> b) -> d -> m b
367 k c x = do c' <- c
368 x' <- f x
369 return (c' x')
370
371
372 -- | Transformation of at least one immediate subterm does not fail
373 gmapMp :: forall m. MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
374
375 {-
376
377 The type constructor that we use here simply keeps track of the fact
378 if we already succeeded for an immediate subterm; see Mp below. To
379 this end, we couple the monadic computation with a Boolean.
380
381 -}
382
383 gmapMp f x = unMp (gfoldl k z x) >>= \(x',b) ->
384 if b then return x' else mzero
385 where
386 z :: g -> Mp m g
387 z g = Mp (return (g,False))
388 k :: Data d => Mp m (d -> b) -> d -> Mp m b
389 k (Mp c) y
390 = Mp ( c >>= \(h, b) ->
391 (f y >>= \y' -> return (h y', True))
392 `mplus` return (h y, b)
393 )
394
395 -- | Transformation of one immediate subterm with success
396 gmapMo :: forall m. MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
397
398 {-
399
400 We use the same pairing trick as for gmapMp,
401 i.e., we use an extra Bool component to keep track of the
402 fact whether an immediate subterm was processed successfully.
403 However, we cut of mapping over subterms once a first subterm
404 was transformed successfully.
405
406 -}
407
408 gmapMo f x = unMp (gfoldl k z x) >>= \(x',b) ->
409 if b then return x' else mzero
410 where
411 z :: g -> Mp m g
412 z g = Mp (return (g,False))
413 k :: Data d => Mp m (d -> b) -> d -> Mp m b
414 k (Mp c) y
415 = Mp ( c >>= \(h,b) -> if b
416 then return (h y, b)
417 else (f y >>= \y' -> return (h y',True))
418 `mplus` return (h y, b)
419 )
420
421
422 -- | The identity type constructor needed for the definition of gmapT
423 newtype ID x = ID { unID :: x }
424
425
426 -- | The constant type constructor needed for the definition of gmapQl
427 newtype CONST c a = CONST { unCONST :: c }
428
429
430 -- | Type constructor for adding counters to queries
431 data Qi q a = Qi Int (Maybe q)
432
433
434 -- | The type constructor used in definition of gmapQr
435 newtype Qr r a = Qr { unQr :: r -> r }
436
437
438 -- | The type constructor used in definition of gmapMp
439 newtype Mp m x = Mp { unMp :: m (x, Bool) }
440
441
442
443 ------------------------------------------------------------------------------
444 --
445 -- Generic unfolding
446 --
447 ------------------------------------------------------------------------------
448
449
450 -- | Build a term skeleton
451 fromConstr :: Data a => Constr -> a
452 fromConstr = fromConstrB (error "Data.Data.fromConstr")
453
454
455 -- | Build a term and use a generic function for subterms
456 fromConstrB :: Data a
457 => (forall d. Data d => d)
458 -> Constr
459 -> a
460 fromConstrB f = unID . gunfold k z
461 where
462 k :: forall b r. Data b => ID (b -> r) -> ID r
463 k c = ID (unID c f)
464
465 z :: forall r. r -> ID r
466 z = ID
467
468
469 -- | Monadic variation on 'fromConstrB'
470 fromConstrM :: forall m a. (Monad m, Data a)
471 => (forall d. Data d => m d)
472 -> Constr
473 -> m a
474 fromConstrM f = gunfold k z
475 where
476 k :: forall b r. Data b => m (b -> r) -> m r
477 k c = do { c' <- c; b <- f; return (c' b) }
478
479 z :: forall r. r -> m r
480 z = return
481
482
483
484 ------------------------------------------------------------------------------
485 --
486 -- Datatype and constructor representations
487 --
488 ------------------------------------------------------------------------------
489
490
491 --
492 -- | Representation of datatypes.
493 -- A package of constructor representations with names of type and module.
494 --
495 data DataType = DataType
496 { tycon :: String
497 , datarep :: DataRep
498 }
499
500 deriving Show
501
502 -- | Representation of constructors. Note that equality on constructors
503 -- with different types may not work -- i.e. the constructors for 'False' and
504 -- 'Nothing' may compare equal.
505 data Constr = Constr
506 { conrep :: ConstrRep
507 , constring :: String
508 , confields :: [String] -- for AlgRep only
509 , confixity :: Fixity -- for AlgRep only
510 , datatype :: DataType
511 }
512
513 instance Show Constr where
514 show = constring
515
516
517 -- | Equality of constructors
518 instance Eq Constr where
519 c == c' = constrRep c == constrRep c'
520
521
522 -- | Public representation of datatypes
523 data DataRep = AlgRep [Constr]
524 | IntRep
525 | FloatRep
526 | CharRep
527 | NoRep
528
529 deriving (Eq,Show)
530 -- The list of constructors could be an array, a balanced tree, or others.
531
532
533 -- | Public representation of constructors
534 data ConstrRep = AlgConstr ConIndex
535 | IntConstr Integer
536 | FloatConstr Rational
537 | CharConstr Char
538
539 deriving (Eq,Show)
540
541
542 -- | Unique index for datatype constructors,
543 -- counting from 1 in the order they are given in the program text.
544 type ConIndex = Int
545
546
547 -- | Fixity of constructors
548 data Fixity = Prefix
549 | Infix -- Later: add associativity and precedence
550
551 deriving (Eq,Show)
552
553
554 ------------------------------------------------------------------------------
555 --
556 -- Observers for datatype representations
557 --
558 ------------------------------------------------------------------------------
559
560
561 -- | Gets the type constructor including the module
562 dataTypeName :: DataType -> String
563 dataTypeName = tycon
564
565
566
567 -- | Gets the public presentation of a datatype
568 dataTypeRep :: DataType -> DataRep
569 dataTypeRep = datarep
570
571
572 -- | Gets the datatype of a constructor
573 constrType :: Constr -> DataType
574 constrType = datatype
575
576
577 -- | Gets the public presentation of constructors
578 constrRep :: Constr -> ConstrRep
579 constrRep = conrep
580
581
582 -- | Look up a constructor by its representation
583 repConstr :: DataType -> ConstrRep -> Constr
584 repConstr dt cr =
585 case (dataTypeRep dt, cr) of
586 (AlgRep cs, AlgConstr i) -> cs !! (i-1)
587 (IntRep, IntConstr i) -> mkIntConstr dt i
588 (FloatRep, FloatConstr f) -> mkRealConstr dt f
589 (CharRep, CharConstr c) -> mkCharConstr dt c
590 _ -> error "Data.Data.repConstr"
591
592
593
594 ------------------------------------------------------------------------------
595 --
596 -- Representations of algebraic data types
597 --
598 ------------------------------------------------------------------------------
599
600
601 -- | Constructs an algebraic datatype
602 mkDataType :: String -> [Constr] -> DataType
603 mkDataType str cs = DataType
604 { tycon = str
605 , datarep = AlgRep cs
606 }
607
608
609 -- | Constructs a constructor
610 mkConstr :: DataType -> String -> [String] -> Fixity -> Constr
611 mkConstr dt str fields fix =
612 Constr
613 { conrep = AlgConstr idx
614 , constring = str
615 , confields = fields
616 , confixity = fix
617 , datatype = dt
618 }
619 where
620 idx = head [ i | (c,i) <- dataTypeConstrs dt `zip` [1..],
621 showConstr c == str ]
622
623
624 -- | Gets the constructors of an algebraic datatype
625 dataTypeConstrs :: DataType -> [Constr]
626 dataTypeConstrs dt = case datarep dt of
627 (AlgRep cons) -> cons
628 _ -> error "Data.Data.dataTypeConstrs"
629
630
631 -- | Gets the field labels of a constructor. The list of labels
632 -- is returned in the same order as they were given in the original
633 -- constructor declaration.
634 constrFields :: Constr -> [String]
635 constrFields = confields
636
637
638 -- | Gets the fixity of a constructor
639 constrFixity :: Constr -> Fixity
640 constrFixity = confixity
641
642
643
644 ------------------------------------------------------------------------------
645 --
646 -- From strings to constr's and vice versa: all data types
647 --
648 ------------------------------------------------------------------------------
649
650
651 -- | Gets the string for a constructor
652 showConstr :: Constr -> String
653 showConstr = constring
654
655
656 -- | Lookup a constructor via a string
657 readConstr :: DataType -> String -> Maybe Constr
658 readConstr dt str =
659 case dataTypeRep dt of
660 AlgRep cons -> idx cons
661 IntRep -> mkReadCon (\i -> (mkPrimCon dt str (IntConstr i)))
662 FloatRep -> mkReadCon ffloat
663 CharRep -> mkReadCon (\c -> (mkPrimCon dt str (CharConstr c)))
664 NoRep -> Nothing
665 where
666
667 -- Read a value and build a constructor
668 mkReadCon :: Read t => (t -> Constr) -> Maybe Constr
669 mkReadCon f = case (reads str) of
670 [(t,"")] -> Just (f t)
671 _ -> Nothing
672
673 -- Traverse list of algebraic datatype constructors
674 idx :: [Constr] -> Maybe Constr
675 idx cons = let fit = filter ((==) str . showConstr) cons
676 in if fit == []
677 then Nothing
678 else Just (head fit)
679
680 ffloat :: Double -> Constr
681 ffloat = mkPrimCon dt str . FloatConstr . toRational
682
683 ------------------------------------------------------------------------------
684 --
685 -- Convenience funtions: algebraic data types
686 --
687 ------------------------------------------------------------------------------
688
689
690 -- | Test for an algebraic type
691 isAlgType :: DataType -> Bool
692 isAlgType dt = case datarep dt of
693 (AlgRep _) -> True
694 _ -> False
695
696
697 -- | Gets the constructor for an index (algebraic datatypes only)
698 indexConstr :: DataType -> ConIndex -> Constr
699 indexConstr dt idx = case datarep dt of
700 (AlgRep cs) -> cs !! (idx-1)
701 _ -> error "Data.Data.indexConstr"
702
703
704 -- | Gets the index of a constructor (algebraic datatypes only)
705 constrIndex :: Constr -> ConIndex
706 constrIndex con = case constrRep con of
707 (AlgConstr idx) -> idx
708 _ -> error "Data.Data.constrIndex"
709
710
711 -- | Gets the maximum constructor index of an algebraic datatype
712 maxConstrIndex :: DataType -> ConIndex
713 maxConstrIndex dt = case dataTypeRep dt of
714 AlgRep cs -> length cs
715 _ -> error "Data.Data.maxConstrIndex"
716
717
718
719 ------------------------------------------------------------------------------
720 --
721 -- Representation of primitive types
722 --
723 ------------------------------------------------------------------------------
724
725
726 -- | Constructs the 'Int' type
727 mkIntType :: String -> DataType
728 mkIntType = mkPrimType IntRep
729
730
731 -- | Constructs the 'Float' type
732 mkFloatType :: String -> DataType
733 mkFloatType = mkPrimType FloatRep
734
735
736 -- | This function is now deprecated. Please use 'mkCharType' instead.
737 {-# DEPRECATED mkStringType "Use mkCharType instead" #-}
738 mkStringType :: String -> DataType
739 mkStringType = mkCharType
740
741 -- | Constructs the 'Char' type
742 mkCharType :: String -> DataType
743 mkCharType = mkPrimType CharRep
744
745
746 -- | Helper for 'mkIntType', 'mkFloatType', 'mkStringType'
747 mkPrimType :: DataRep -> String -> DataType
748 mkPrimType dr str = DataType
749 { tycon = str
750 , datarep = dr
751 }
752
753
754 -- Makes a constructor for primitive types
755 mkPrimCon :: DataType -> String -> ConstrRep -> Constr
756 mkPrimCon dt str cr = Constr
757 { datatype = dt
758 , conrep = cr
759 , constring = str
760 , confields = error "Data.Data.confields"
761 , confixity = error "Data.Data.confixity"
762 }
763
764 -- | This function is now deprecated. Please use 'mkIntegralConstr' instead.
765 {-# DEPRECATED mkIntConstr "Use mkIntegralConstr instead" #-}
766 mkIntConstr :: DataType -> Integer -> Constr
767 mkIntConstr = mkIntegralConstr
768
769 mkIntegralConstr :: (Integral a, Show a) => DataType -> a -> Constr
770 mkIntegralConstr dt i = case datarep dt of
771 IntRep -> mkPrimCon dt (show i) (IntConstr (toInteger i))
772 _ -> error "Data.Data.mkIntegralConstr"
773
774 -- | This function is now deprecated. Please use 'mkRealConstr' instead.
775 {-# DEPRECATED mkFloatConstr "Use mkRealConstr instead" #-}
776 mkFloatConstr :: DataType -> Double -> Constr
777 mkFloatConstr dt = mkRealConstr dt . toRational
778
779 mkRealConstr :: (Real a, Show a) => DataType -> a -> Constr
780 mkRealConstr dt f = case datarep dt of
781 FloatRep -> mkPrimCon dt (show f) (FloatConstr (toRational f))
782 _ -> error "Data.Data.mkRealConstr"
783
784 -- | This function is now deprecated. Please use 'mkCharConstr' instead.
785 {-# DEPRECATED mkStringConstr "Use mkCharConstr instead" #-}
786 mkStringConstr :: DataType -> String -> Constr
787 mkStringConstr dt str =
788 case datarep dt of
789 CharRep -> case str of
790 [c] -> mkPrimCon dt (show c) (CharConstr c)
791 _ -> error "Data.Data.mkStringConstr: input String must contain a single character"
792 _ -> error "Data.Data.mkStringConstr"
793
794 -- | Makes a constructor for 'Char'.
795 mkCharConstr :: DataType -> Char -> Constr
796 mkCharConstr dt c = case datarep dt of
797 CharRep -> mkPrimCon dt (show c) (CharConstr c)
798 _ -> error "Data.Data.mkCharConstr"
799
800
801 ------------------------------------------------------------------------------
802 --
803 -- Non-representations for non-presentable types
804 --
805 ------------------------------------------------------------------------------
806
807
808 -- | Deprecated version (misnamed)
809 {-# DEPRECATED mkNorepType "Use mkNoRepType instead" #-}
810 mkNorepType :: String -> DataType
811 mkNorepType str = DataType
812 { tycon = str
813 , datarep = NoRep
814 }
815
816 -- | Constructs a non-representation for a non-presentable type
817 mkNoRepType :: String -> DataType
818 mkNoRepType str = DataType
819 { tycon = str
820 , datarep = NoRep
821 }
822
823 -- | Test for a non-representable type
824 isNorepType :: DataType -> Bool
825 isNorepType dt = case datarep dt of
826 NoRep -> True
827 _ -> False
828
829
830
831 ------------------------------------------------------------------------------
832 --
833 -- Convenience for qualified type constructors
834 --
835 ------------------------------------------------------------------------------
836
837
838 -- | Gets the unqualified type constructor:
839 -- drop *.*.*... before name
840 --
841 tyconUQname :: String -> String
842 tyconUQname x = let x' = dropWhile (not . (==) '.') x
843 in if x' == [] then x else tyconUQname (tail x')
844
845
846 -- | Gets the module of a type constructor:
847 -- take *.*.*... before name
848 tyconModule :: String -> String
849 tyconModule x = let (a,b) = break ((==) '.') x
850 in if b == ""
851 then b
852 else a ++ tyconModule' (tail b)
853 where
854 tyconModule' y = let y' = tyconModule y
855 in if y' == "" then "" else ('.':y')
856
857
858
859
860 ------------------------------------------------------------------------------
861 ------------------------------------------------------------------------------
862 --
863 -- Instances of the Data class for Prelude-like types.
864 -- We define top-level definitions for representations.
865 --
866 ------------------------------------------------------------------------------
867
868
869 falseConstr :: Constr
870 falseConstr = mkConstr boolDataType "False" [] Prefix
871 trueConstr :: Constr
872 trueConstr = mkConstr boolDataType "True" [] Prefix
873
874 boolDataType :: DataType
875 boolDataType = mkDataType "Prelude.Bool" [falseConstr,trueConstr]
876
877 instance Data Bool where
878 toConstr False = falseConstr
879 toConstr True = trueConstr
880 gunfold _ z c = case constrIndex c of
881 1 -> z False
882 2 -> z True
883 _ -> error "Data.Data.gunfold(Bool)"
884 dataTypeOf _ = boolDataType
885
886
887 ------------------------------------------------------------------------------
888
889 charType :: DataType
890 charType = mkCharType "Prelude.Char"
891
892 instance Data Char where
893 toConstr x = mkCharConstr charType x
894 gunfold _ z c = case constrRep c of
895 (CharConstr x) -> z x
896 _ -> error "Data.Data.gunfold(Char)"
897 dataTypeOf _ = charType
898
899
900 ------------------------------------------------------------------------------
901
902 floatType :: DataType
903 floatType = mkFloatType "Prelude.Float"
904
905 instance Data Float where
906 toConstr = mkRealConstr floatType
907 gunfold _ z c = case constrRep c of
908 (FloatConstr x) -> z (realToFrac x)
909 _ -> error "Data.Data.gunfold(Float)"
910 dataTypeOf _ = floatType
911
912
913 ------------------------------------------------------------------------------
914
915 doubleType :: DataType
916 doubleType = mkFloatType "Prelude.Double"
917
918 instance Data Double where
919 toConstr = mkRealConstr doubleType
920 gunfold _ z c = case constrRep c of
921 (FloatConstr x) -> z (realToFrac x)
922 _ -> error "Data.Data.gunfold(Double)"
923 dataTypeOf _ = doubleType
924
925
926 ------------------------------------------------------------------------------
927
928 intType :: DataType
929 intType = mkIntType "Prelude.Int"
930
931 instance Data Int where
932 toConstr x = mkIntConstr intType (fromIntegral x)
933 gunfold _ z c = case constrRep c of
934 (IntConstr x) -> z (fromIntegral x)
935 _ -> error "Data.Data.gunfold(Int)"
936 dataTypeOf _ = intType
937
938
939 ------------------------------------------------------------------------------
940
941 integerType :: DataType
942 integerType = mkIntType "Prelude.Integer"
943
944 instance Data Integer where
945 toConstr = mkIntConstr integerType
946 gunfold _ z c = case constrRep c of
947 (IntConstr x) -> z x
948 _ -> error "Data.Data.gunfold(Integer)"
949 dataTypeOf _ = integerType
950
951
952 ------------------------------------------------------------------------------
953
954 int8Type :: DataType
955 int8Type = mkIntType "Data.Int.Int8"
956
957 instance Data Int8 where
958 toConstr x = mkIntConstr int8Type (fromIntegral x)
959 gunfold _ z c = case constrRep c of
960 (IntConstr x) -> z (fromIntegral x)
961 _ -> error "Data.Data.gunfold(Int8)"
962 dataTypeOf _ = int8Type
963
964
965 ------------------------------------------------------------------------------
966
967 int16Type :: DataType
968 int16Type = mkIntType "Data.Int.Int16"
969
970 instance Data Int16 where
971 toConstr x = mkIntConstr int16Type (fromIntegral x)
972 gunfold _ z c = case constrRep c of
973 (IntConstr x) -> z (fromIntegral x)
974 _ -> error "Data.Data.gunfold(Int16)"
975 dataTypeOf _ = int16Type
976
977
978 ------------------------------------------------------------------------------
979
980 int32Type :: DataType
981 int32Type = mkIntType "Data.Int.Int32"
982
983 instance Data Int32 where
984 toConstr x = mkIntConstr int32Type (fromIntegral x)
985 gunfold _ z c = case constrRep c of
986 (IntConstr x) -> z (fromIntegral x)
987 _ -> error "Data.Data.gunfold(Int32)"
988 dataTypeOf _ = int32Type
989
990
991 ------------------------------------------------------------------------------
992
993 int64Type :: DataType
994 int64Type = mkIntType "Data.Int.Int64"
995
996 instance Data Int64 where
997 toConstr x = mkIntConstr int64Type (fromIntegral x)
998 gunfold _ z c = case constrRep c of
999 (IntConstr x) -> z (fromIntegral x)
1000 _ -> error "Data.Data.gunfold(Int64)"
1001 dataTypeOf _ = int64Type
1002
1003
1004 ------------------------------------------------------------------------------
1005
1006 wordType :: DataType
1007 wordType = mkIntType "Data.Word.Word"
1008
1009 instance Data Word where
1010 toConstr x = mkIntConstr wordType (fromIntegral x)
1011 gunfold _ z c = case constrRep c of
1012 (IntConstr x) -> z (fromIntegral x)
1013 _ -> error "Data.Data.gunfold(Word)"
1014 dataTypeOf _ = wordType
1015
1016
1017 ------------------------------------------------------------------------------
1018
1019 word8Type :: DataType
1020 word8Type = mkIntType "Data.Word.Word8"
1021
1022 instance Data Word8 where
1023 toConstr x = mkIntConstr word8Type (fromIntegral x)
1024 gunfold _ z c = case constrRep c of
1025 (IntConstr x) -> z (fromIntegral x)
1026 _ -> error "Data.Data.gunfold(Word8)"
1027 dataTypeOf _ = word8Type
1028
1029
1030 ------------------------------------------------------------------------------
1031
1032 word16Type :: DataType
1033 word16Type = mkIntType "Data.Word.Word16"
1034
1035 instance Data Word16 where
1036 toConstr x = mkIntConstr word16Type (fromIntegral x)
1037 gunfold _ z c = case constrRep c of
1038 (IntConstr x) -> z (fromIntegral x)
1039 _ -> error "Data.Data.gunfold(Word16)"
1040 dataTypeOf _ = word16Type
1041
1042
1043 ------------------------------------------------------------------------------
1044
1045 word32Type :: DataType
1046 word32Type = mkIntType "Data.Word.Word32"
1047
1048 instance Data Word32 where
1049 toConstr x = mkIntConstr word32Type (fromIntegral x)
1050 gunfold _ z c = case constrRep c of
1051 (IntConstr x) -> z (fromIntegral x)
1052 _ -> error "Data.Data.gunfold(Word32)"
1053 dataTypeOf _ = word32Type
1054
1055
1056 ------------------------------------------------------------------------------
1057
1058 word64Type :: DataType
1059 word64Type = mkIntType "Data.Word.Word64"
1060
1061 instance Data Word64 where
1062 toConstr x = mkIntConstr word64Type (fromIntegral x)
1063 gunfold _ z c = case constrRep c of
1064 (IntConstr x) -> z (fromIntegral x)
1065 _ -> error "Data.Data.gunfold(Word64)"
1066 dataTypeOf _ = word64Type
1067
1068
1069 ------------------------------------------------------------------------------
1070
1071 ratioConstr :: Constr
1072 ratioConstr = mkConstr ratioDataType ":%" [] Infix
1073
1074 ratioDataType :: DataType
1075 ratioDataType = mkDataType "GHC.Real.Ratio" [ratioConstr]
1076
1077 instance (Data a, Integral a) => Data (Ratio a) where
1078 gfoldl k z (a :% b) = z (:%) `k` a `k` b
1079 toConstr _ = ratioConstr
1080 gunfold k z c | constrIndex c == 1 = k (k (z (:%)))
1081 gunfold _ _ _ = error "Data.Data.gunfold(Ratio)"
1082 dataTypeOf _ = ratioDataType
1083
1084
1085 ------------------------------------------------------------------------------
1086
1087 nilConstr :: Constr
1088 nilConstr = mkConstr listDataType "[]" [] Prefix
1089 consConstr :: Constr
1090 consConstr = mkConstr listDataType "(:)" [] Infix
1091
1092 listDataType :: DataType
1093 listDataType = mkDataType "Prelude.[]" [nilConstr,consConstr]
1094
1095 instance Data a => Data [a] where
1096 gfoldl _ z [] = z []
1097 gfoldl f z (x:xs) = z (:) `f` x `f` xs
1098 toConstr [] = nilConstr
1099 toConstr (_:_) = consConstr
1100 gunfold k z c = case constrIndex c of
1101 1 -> z []
1102 2 -> k (k (z (:)))
1103 _ -> error "Data.Data.gunfold(List)"
1104 dataTypeOf _ = listDataType
1105 dataCast1 f = gcast1 f
1106
1107 --
1108 -- The gmaps are given as an illustration.
1109 -- This shows that the gmaps for lists are different from list maps.
1110 --
1111 gmapT _ [] = []
1112 gmapT f (x:xs) = (f x:f xs)
1113 gmapQ _ [] = []
1114 gmapQ f (x:xs) = [f x,f xs]
1115 gmapM _ [] = return []
1116 gmapM f (x:xs) = f x >>= \x' -> f xs >>= \xs' -> return (x':xs')
1117
1118
1119 ------------------------------------------------------------------------------
1120
1121 nothingConstr :: Constr
1122 nothingConstr = mkConstr maybeDataType "Nothing" [] Prefix
1123 justConstr :: Constr
1124 justConstr = mkConstr maybeDataType "Just" [] Prefix
1125
1126 maybeDataType :: DataType
1127 maybeDataType = mkDataType "Prelude.Maybe" [nothingConstr,justConstr]
1128
1129 instance Data a => Data (Maybe a) where
1130 gfoldl _ z Nothing = z Nothing
1131 gfoldl f z (Just x) = z Just `f` x
1132 toConstr Nothing = nothingConstr
1133 toConstr (Just _) = justConstr
1134 gunfold k z c = case constrIndex c of
1135 1 -> z Nothing
1136 2 -> k (z Just)
1137 _ -> error "Data.Data.gunfold(Maybe)"
1138 dataTypeOf _ = maybeDataType
1139 dataCast1 f = gcast1 f
1140
1141
1142 ------------------------------------------------------------------------------
1143
1144 ltConstr :: Constr
1145 ltConstr = mkConstr orderingDataType "LT" [] Prefix
1146 eqConstr :: Constr
1147 eqConstr = mkConstr orderingDataType "EQ" [] Prefix
1148 gtConstr :: Constr
1149 gtConstr = mkConstr orderingDataType "GT" [] Prefix
1150
1151 orderingDataType :: DataType
1152 orderingDataType = mkDataType "Prelude.Ordering" [ltConstr,eqConstr,gtConstr]
1153
1154 instance Data Ordering where
1155 gfoldl _ z LT = z LT
1156 gfoldl _ z EQ = z EQ
1157 gfoldl _ z GT = z GT
1158 toConstr LT = ltConstr
1159 toConstr EQ = eqConstr
1160 toConstr GT = gtConstr
1161 gunfold _ z c = case constrIndex c of
1162 1 -> z LT
1163 2 -> z EQ
1164 3 -> z GT
1165 _ -> error "Data.Data.gunfold(Ordering)"
1166 dataTypeOf _ = orderingDataType
1167
1168
1169 ------------------------------------------------------------------------------
1170
1171 leftConstr :: Constr
1172 leftConstr = mkConstr eitherDataType "Left" [] Prefix
1173
1174 rightConstr :: Constr
1175 rightConstr = mkConstr eitherDataType "Right" [] Prefix
1176
1177 eitherDataType :: DataType
1178 eitherDataType = mkDataType "Prelude.Either" [leftConstr,rightConstr]
1179
1180 instance (Data a, Data b) => Data (Either a b) where
1181 gfoldl f z (Left a) = z Left `f` a
1182 gfoldl f z (Right a) = z Right `f` a
1183 toConstr (Left _) = leftConstr
1184 toConstr (Right _) = rightConstr
1185 gunfold k z c = case constrIndex c of
1186 1 -> k (z Left)
1187 2 -> k (z Right)
1188 _ -> error "Data.Data.gunfold(Either)"
1189 dataTypeOf _ = eitherDataType
1190 dataCast2 f = gcast2 f
1191
1192
1193 ------------------------------------------------------------------------------
1194
1195 tuple0Constr :: Constr
1196 tuple0Constr = mkConstr tuple0DataType "()" [] Prefix
1197
1198 tuple0DataType :: DataType
1199 tuple0DataType = mkDataType "Prelude.()" [tuple0Constr]
1200
1201 instance Data () where
1202 toConstr () = tuple0Constr
1203 gunfold _ z c | constrIndex c == 1 = z ()
1204 gunfold _ _ _ = error "Data.Data.gunfold(unit)"
1205 dataTypeOf _ = tuple0DataType
1206
1207
1208 ------------------------------------------------------------------------------
1209
1210 tuple2Constr :: Constr
1211 tuple2Constr = mkConstr tuple2DataType "(,)" [] Infix
1212
1213 tuple2DataType :: DataType
1214 tuple2DataType = mkDataType "Prelude.(,)" [tuple2Constr]
1215
1216 instance (Data a, Data b) => Data (a,b) where
1217 gfoldl f z (a,b) = z (,) `f` a `f` b
1218 toConstr (_,_) = tuple2Constr
1219 gunfold k z c | constrIndex c == 1 = k (k (z (,)))
1220 gunfold _ _ _ = error "Data.Data.gunfold(tup2)"
1221 dataTypeOf _ = tuple2DataType
1222 dataCast2 f = gcast2 f
1223
1224
1225 ------------------------------------------------------------------------------
1226
1227 tuple3Constr :: Constr
1228 tuple3Constr = mkConstr tuple3DataType "(,,)" [] Infix
1229
1230 tuple3DataType :: DataType
1231 tuple3DataType = mkDataType "Prelude.(,,)" [tuple3Constr]
1232
1233 instance (Data a, Data b, Data c) => Data (a,b,c) where
1234 gfoldl f z (a,b,c) = z (,,) `f` a `f` b `f` c
1235 toConstr (_,_,_) = tuple3Constr
1236 gunfold k z c | constrIndex c == 1 = k (k (k (z (,,))))
1237 gunfold _ _ _ = error "Data.Data.gunfold(tup3)"
1238 dataTypeOf _ = tuple3DataType
1239
1240
1241 ------------------------------------------------------------------------------
1242
1243 tuple4Constr :: Constr
1244 tuple4Constr = mkConstr tuple4DataType "(,,,)" [] Infix
1245
1246 tuple4DataType :: DataType
1247 tuple4DataType = mkDataType "Prelude.(,,,)" [tuple4Constr]
1248
1249 instance (Data a, Data b, Data c, Data d)
1250 => Data (a,b,c,d) where
1251 gfoldl f z (a,b,c,d) = z (,,,) `f` a `f` b `f` c `f` d
1252 toConstr (_,_,_,_) = tuple4Constr
1253 gunfold k z c = case constrIndex c of
1254 1 -> k (k (k (k (z (,,,)))))
1255 _ -> error "Data.Data.gunfold(tup4)"
1256 dataTypeOf _ = tuple4DataType
1257
1258
1259 ------------------------------------------------------------------------------
1260
1261 tuple5Constr :: Constr
1262 tuple5Constr = mkConstr tuple5DataType "(,,,,)" [] Infix
1263
1264 tuple5DataType :: DataType
1265 tuple5DataType = mkDataType "Prelude.(,,,,)" [tuple5Constr]
1266
1267 instance (Data a, Data b, Data c, Data d, Data e)
1268 => Data (a,b,c,d,e) where
1269 gfoldl f z (a,b,c,d,e) = z (,,,,) `f` a `f` b `f` c `f` d `f` e
1270 toConstr (_,_,_,_,_) = tuple5Constr
1271 gunfold k z c = case constrIndex c of
1272 1 -> k (k (k (k (k (z (,,,,))))))
1273 _ -> error "Data.Data.gunfold(tup5)"
1274 dataTypeOf _ = tuple5DataType
1275
1276
1277 ------------------------------------------------------------------------------
1278
1279 tuple6Constr :: Constr
1280 tuple6Constr = mkConstr tuple6DataType "(,,,,,)" [] Infix
1281
1282 tuple6DataType :: DataType
1283 tuple6DataType = mkDataType "Prelude.(,,,,,)" [tuple6Constr]
1284
1285 instance (Data a, Data b, Data c, Data d, Data e, Data f)
1286 => Data (a,b,c,d,e,f) where
1287 gfoldl f z (a,b,c,d,e,f') = z (,,,,,) `f` a `f` b `f` c `f` d `f` e `f` f'
1288 toConstr (_,_,_,_,_,_) = tuple6Constr
1289 gunfold k z c = case constrIndex c of
1290 1 -> k (k (k (k (k (k (z (,,,,,)))))))
1291 _ -> error "Data.Data.gunfold(tup6)"
1292 dataTypeOf _ = tuple6DataType
1293
1294
1295 ------------------------------------------------------------------------------
1296
1297 tuple7Constr :: Constr
1298 tuple7Constr = mkConstr tuple7DataType "(,,,,,,)" [] Infix
1299
1300 tuple7DataType :: DataType
1301 tuple7DataType = mkDataType "Prelude.(,,,,,,)" [tuple7Constr]
1302
1303 instance (Data a, Data b, Data c, Data d, Data e, Data f, Data g)
1304 => Data (a,b,c,d,e,f,g) where
1305 gfoldl f z (a,b,c,d,e,f',g) =
1306 z (,,,,,,) `f` a `f` b `f` c `f` d `f` e `f` f' `f` g
1307 toConstr (_,_,_,_,_,_,_) = tuple7Constr
1308 gunfold k z c = case constrIndex c of
1309 1 -> k (k (k (k (k (k (k (z (,,,,,,))))))))
1310 _ -> error "Data.Data.gunfold(tup7)"
1311 dataTypeOf _ = tuple7DataType
1312
1313
1314 ------------------------------------------------------------------------------
1315
1316 instance Typeable a => Data (Ptr a) where
1317 toConstr _ = error "Data.Data.toConstr(Ptr)"
1318 gunfold _ _ = error "Data.Data.gunfold(Ptr)"
1319 dataTypeOf _ = mkNoRepType "GHC.Ptr.Ptr"
1320
1321
1322 ------------------------------------------------------------------------------
1323
1324 instance Typeable a => Data (ForeignPtr a) where
1325 toConstr _ = error "Data.Data.toConstr(ForeignPtr)"
1326 gunfold _ _ = error "Data.Data.gunfold(ForeignPtr)"
1327 dataTypeOf _ = mkNoRepType "GHC.ForeignPtr.ForeignPtr"
1328
1329
1330 ------------------------------------------------------------------------------
1331 -- The Data instance for Array preserves data abstraction at the cost of
1332 -- inefficiency. We omit reflection services for the sake of data abstraction.
1333 instance (Typeable a, Data b, Ix a) => Data (Array a b)
1334 where
1335 gfoldl f z a = z (listArray (bounds a)) `f` (elems a)
1336 toConstr _ = error "Data.Data.toConstr(Array)"
1337 gunfold _ _ = error "Data.Data.gunfold(Array)"
1338 dataTypeOf _ = mkNoRepType "Data.Array.Array"
1339