1 -----------------------------------------------------------------------------
4 -- Copyright : (c) The University of Glasgow, CWI 2001--2004
5 -- License : BSD-style (see the file libraries/base/LICENSE)
7 -- Maintainer : libraries@haskell.org
8 -- Stability : experimental
9 -- Portability : non-portable (local universal quantification)
11 -- \"Scrap your boilerplate\" --- Generic programming in Haskell.
12 -- See <http://www.cs.vu.nl/boilerplate/>. This module provides
13 -- the 'Data' class with its primitives for generic programming, along
14 -- with instances for many datatypes. It corresponds to a merge between
15 -- the previous "Data.Generics.Basics" and almost all of
16 -- "Data.Generics.Instances". The instances that are not present
17 -- in this module were moved to the @Data.Generics.Instances@ module
18 -- in the @syb@ package.
20 -- For more information, please visit the new
21 -- SYB wiki: <http://www.cs.uu.nl/wiki/bin/view/GenericProgramming/SYB>.
24 -----------------------------------------------------------------------------
28 -- * Module Data.Typeable re-exported for convenience
31 -- * The Data class for processing constructor applications
33 gfoldl, -- :: ... -> a -> c a
34 gunfold, -- :: ... -> Constr -> c a
35 toConstr, -- :: a -> Constr
36 dataTypeOf, -- :: a -> DataType
37 dataCast1, -- mediate types and unary type constructors
38 dataCast2, -- mediate types and binary type constructors
39 -- Generic maps defined in terms of gfoldl
50 -- * Datatype representations
51 DataType, -- abstract, instance of: Show
53 mkDataType, -- :: String -> [Constr] -> DataType
54 mkIntType, -- :: String -> DataType
55 mkFloatType, -- :: String -> DataType
56 mkStringType, -- :: String -> DataType
57 mkCharType, -- :: String -> DataType
58 mkNoRepType, -- :: String -> DataType
59 mkNorepType, -- :: String -> DataType
61 dataTypeName, -- :: DataType -> String
62 DataRep(..), -- instance of: Eq, Show
63 dataTypeRep, -- :: DataType -> DataRep
64 -- ** Convenience functions
65 repConstr, -- :: DataType -> ConstrRep -> Constr
66 isAlgType, -- :: DataType -> Bool
67 dataTypeConstrs,-- :: DataType -> [Constr]
68 indexConstr, -- :: DataType -> ConIndex -> Constr
69 maxConstrIndex, -- :: DataType -> ConIndex
70 isNorepType, -- :: DataType -> Bool
72 -- * Data constructor representations
73 Constr, -- abstract, instance of: Eq, Show
74 ConIndex, -- alias for Int, start at 1
75 Fixity(..), -- instance of: Eq, Show
77 mkConstr, -- :: DataType -> String -> Fixity -> Constr
78 mkIntConstr, -- :: DataType -> Integer -> Constr
79 mkFloatConstr, -- :: DataType -> Double -> Constr
80 mkIntegralConstr,-- :: (Integral a) => DataType -> a -> Constr
81 mkRealConstr, -- :: (Real a) => DataType -> a -> Constr
82 mkStringConstr, -- :: DataType -> String -> Constr
83 mkCharConstr, -- :: DataType -> Char -> Constr
85 constrType, -- :: Constr -> DataType
86 ConstrRep(..), -- instance of: Eq, Show
87 constrRep, -- :: Constr -> ConstrRep
88 constrFields, -- :: Constr -> [String]
89 constrFixity, -- :: Constr -> Fixity
90 -- ** Convenience function: algebraic data types
91 constrIndex, -- :: Constr -> ConIndex
92 -- ** From strings to constructors and vice versa: all data types
93 showConstr, -- :: Constr -> String
94 readConstr, -- :: DataType -> String -> Maybe Constr
96 -- * Convenience functions: take type constructors apart
97 tyconUQname, -- :: String -> String
98 tyconModule, -- :: String -> String
100 -- * Generic operations defined in terms of 'gunfold'
101 fromConstr, -- :: Constr -> a
102 fromConstrB, -- :: ... -> Constr -> a
103 fromConstrM -- :: Monad m => ... -> Constr -> m a
108 ------------------------------------------------------------------------------
110 import Prelude -- necessary to get dependencies right
116 -- Imports for the instances
118 import Data.Int -- So we can give Data instance for Int8, ...
119 import Data.Word -- So we can give Data instance for Word8, ...
120 #ifdef __GLASGOW_HASKELL__
121 import GHC.Real( Ratio(..) ) -- So we can give Data instance for Ratio
122 --import GHC.IOBase -- So we can give Data instance for IO, Handle
123 import GHC.Ptr -- So we can give Data instance for Ptr
124 import GHC.ForeignPtr -- So we can give Data instance for ForeignPtr
125 --import GHC.Stable -- So we can give Data instance for StablePtr
126 --import GHC.ST -- So we can give Data instance for ST
127 --import GHC.Conc -- So we can give Data instance for MVar & Co.
128 import GHC.Arr -- So we can give Data instance for Array
131 import Hugs.Prelude( Ratio(..) )
134 import Foreign.ForeignPtr
138 #include "Typeable.h"
142 ------------------------------------------------------------------------------
146 ------------------------------------------------------------------------------
149 The 'Data' class comprehends a fundamental primitive 'gfoldl' for
150 folding over constructor applications, say terms. This primitive can
151 be instantiated in several ways to map over the immediate subterms
152 of a term; see the @gmap@ combinators later in this class. Indeed, a
153 generic programmer does not necessarily need to use the ingenious gfoldl
154 primitive but rather the intuitive @gmap@ combinators. The 'gfoldl'
155 primitive is completed by means to query top-level constructors, to
156 turn constructor representations into proper terms, and to list all
157 possible datatype constructors. This completion allows us to serve
158 generic programming scenarios like read, show, equality, term generation.
160 The combinators 'gmapT', 'gmapQ', 'gmapM', etc are all provided with
161 default definitions in terms of 'gfoldl', leaving open the opportunity
162 to provide datatype-specific definitions.
163 (The inclusion of the @gmap@ combinators as members of class 'Data'
164 allows the programmer or the compiler to derive specialised, and maybe
165 more efficient code per datatype. /Note/: 'gfoldl' is more higher-order
166 than the @gmap@ combinators. This is subject to ongoing benchmarking
167 experiments. It might turn out that the @gmap@ combinators will be
168 moved out of the class 'Data'.)
170 Conceptually, the definition of the @gmap@ combinators in terms of the
171 primitive 'gfoldl' requires the identification of the 'gfoldl' function
172 arguments. Technically, we also need to identify the type constructor
173 @c@ for the construction of the result type from the folded term type.
175 In the definition of @gmapQ@/x/ combinators, we use phantom type
176 constructors for the @c@ in the type of 'gfoldl' because the result type
177 of a query does not involve the (polymorphic) type of the term argument.
178 In the definition of 'gmapQl' we simply use the plain constant type
179 constructor because 'gfoldl' is left-associative anyway and so it is
180 readily suited to fold a left-associative binary operation over the
181 immediate subterms. In the definition of gmapQr, extra effort is
182 needed. We use a higher-order accumulation trick to mediate between
183 left-associative constructor application vs. right-associative binary
184 operation (e.g., @(:)@). When the query is meant to compute a value
185 of type @r@, then the result type withing generic folding is @r -> r@.
186 So the result of folding is a function to which we finally pass the
189 With the @-XDeriveDataTypeable@ option, GHC can generate instances of the
190 'Data' class automatically. For example, given the declaration
192 > data T a b = C1 a b | C2 deriving (Typeable, Data)
194 GHC will generate an instance that is equivalent to
196 > instance (Data a, Data b) => Data (T a b) where
197 > gfoldl k z (C1 a b) = z C1 `k` a `k` b
198 > gfoldl k z C2 = z C2
200 > gunfold k z c = case constrIndex c of
204 > toConstr (C1 _ _) = con_C1
205 > toConstr C2 = con_C2
207 > dataTypeOf _ = ty_T
209 > con_C1 = mkConstr ty_T "C1" [] Prefix
210 > con_C2 = mkConstr ty_T "C2" [] Prefix
211 > ty_T = mkDataType "Module.T" [con_C1, con_C2]
213 This is suitable for datatypes that are exported transparently.
217 class Typeable a => Data a where
219 -- | Left-associative fold operation for constructor applications.
221 -- The type of 'gfoldl' is a headache, but operationally it is a simple
222 -- generalisation of a list fold.
224 -- The default definition for 'gfoldl' is @'const' 'id'@, which is
225 -- suitable for abstract datatypes with no substructures.
226 gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
227 -- ^ defines how nonempty constructor applications are
228 -- folded. It takes the folded tail of the constructor
229 -- application and its head, i.e., an immediate subterm,
230 -- and combines them in some way.
231 -> (forall g. g -> c g)
232 -- ^ defines how the empty constructor application is
233 -- folded, like the neutral \/ start element for list
236 -- ^ structure to be folded.
238 -- ^ result, with a type defined in terms of @a@, but
239 -- variability is achieved by means of type constructor
240 -- @c@ for the construction of the actual result type.
242 -- See the 'Data' instances in this file for an illustration of 'gfoldl'.
246 -- | Unfolding constructor applications
247 gunfold :: (forall b r. Data b => c (b -> r) -> c r)
248 -> (forall r. r -> c r)
252 -- | Obtaining the constructor from a given datum.
253 -- For proper terms, this is meant to be the top-level constructor.
254 -- Primitive datatypes are here viewed as potentially infinite sets of
255 -- values (i.e., constructors).
256 toConstr :: a -> Constr
259 -- | The outer type constructor of the type
260 dataTypeOf :: a -> DataType
264 ------------------------------------------------------------------------------
266 -- Mediate types and type constructors
268 ------------------------------------------------------------------------------
270 -- | Mediate types and unary type constructors.
271 -- In 'Data' instances of the form @T a@, 'dataCast1' should be defined
274 -- The default definition is @'const' 'Nothing'@, which is appropriate
275 -- for non-unary type constructors.
276 dataCast1 :: Typeable1 t
277 => (forall d. Data d => c (t d))
279 dataCast1 _ = Nothing
281 -- | Mediate types and binary type constructors.
282 -- In 'Data' instances of the form @T a b@, 'dataCast2' should be
283 -- defined as 'gcast2'.
285 -- The default definition is @'const' 'Nothing'@, which is appropriate
286 -- for non-binary type constructors.
287 dataCast2 :: Typeable2 t
288 => (forall d e. (Data d, Data e) => c (t d e))
290 dataCast2 _ = Nothing
294 ------------------------------------------------------------------------------
296 -- Typical generic maps defined in terms of gfoldl
298 ------------------------------------------------------------------------------
301 -- | A generic transformation that maps over the immediate subterms
303 -- The default definition instantiates the type constructor @c@ in the
304 -- type of 'gfoldl' to an identity datatype constructor, using the
305 -- isomorphism pair as injection and projection.
306 gmapT :: (forall b. Data b => b -> b) -> a -> a
308 -- Use an identity datatype constructor ID (see below)
309 -- to instantiate the type constructor c in the type of gfoldl,
310 -- and perform injections ID and projections unID accordingly.
312 gmapT f x0 = unID (gfoldl k ID x0)
314 k (ID c) x = ID (c (f x))
317 -- | A generic query with a left-associative binary operator
318 gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
319 gmapQl o r f = unCONST . gfoldl k z
321 k c x = CONST $ (unCONST c) `o` f x
324 -- | A generic query with a right-associative binary operator
325 gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
326 gmapQr o r0 f x0 = unQr (gfoldl k (const (Qr id)) x0) r0
328 k (Qr c) x = Qr (\r -> c (f x `o` r))
331 -- | A generic query that processes the immediate subterms and returns a list
332 -- of results. The list is given in the same order as originally specified
333 -- in the declaratoin of the data constructors.
334 gmapQ :: (forall d. Data d => d -> u) -> a -> [u]
335 gmapQ f = gmapQr (:) [] f
338 -- | A generic query that processes one child by index (zero-based)
339 gmapQi :: Int -> (forall d. Data d => d -> u) -> a -> u
340 gmapQi i f x = case gfoldl k z x of { Qi _ q -> fromJust q }
342 k (Qi i' q) a = Qi (i'+1) (if i==i' then Just (f a) else q)
346 -- | A generic monadic transformation that maps over the immediate subterms
348 -- The default definition instantiates the type constructor @c@ in
349 -- the type of 'gfoldl' to the monad datatype constructor, defining
350 -- injection and projection using 'return' and '>>='.
351 gmapM :: Monad m => (forall d. Data d => d -> m d) -> a -> m a
353 -- Use immediately the monad datatype constructor
354 -- to instantiate the type constructor c in the type of gfoldl,
355 -- so injection and projection is done by return and >>=.
357 gmapM f = gfoldl k return
364 -- | Transformation of at least one immediate subterm does not fail
365 gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
369 The type constructor that we use here simply keeps track of the fact
370 if we already succeeded for an immediate subterm; see Mp below. To
371 this end, we couple the monadic computation with a Boolean.
375 gmapMp f x = unMp (gfoldl k z x) >>= \(x',b) ->
376 if b then return x' else mzero
378 z g = Mp (return (g,False))
380 = Mp ( c >>= \(h, b) ->
381 (f y >>= \y' -> return (h y', True))
382 `mplus` return (h y, b)
385 -- | Transformation of one immediate subterm with success
386 gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
390 We use the same pairing trick as for gmapMp,
391 i.e., we use an extra Bool component to keep track of the
392 fact whether an immediate subterm was processed successfully.
393 However, we cut of mapping over subterms once a first subterm
394 was transformed successfully.
398 gmapMo f x = unMp (gfoldl k z x) >>= \(x',b) ->
399 if b then return x' else mzero
401 z g = Mp (return (g,False))
403 = Mp ( c >>= \(h,b) -> if b
405 else (f y >>= \y' -> return (h y',True))
406 `mplus` return (h y, b)
410 -- | The identity type constructor needed for the definition of gmapT
411 newtype ID x = ID { unID :: x }
414 -- | The constant type constructor needed for the definition of gmapQl
415 newtype CONST c a = CONST { unCONST :: c }
418 -- | Type constructor for adding counters to queries
419 data Qi q a = Qi Int (Maybe q)
422 -- | The type constructor used in definition of gmapQr
423 newtype Qr r a = Qr { unQr :: r -> r }
426 -- | The type constructor used in definition of gmapMp
427 newtype Mp m x = Mp { unMp :: m (x, Bool) }
431 ------------------------------------------------------------------------------
435 ------------------------------------------------------------------------------
438 -- | Build a term skeleton
439 fromConstr :: Data a => Constr -> a
440 fromConstr = fromConstrB (error "Data.Data.fromConstr")
443 -- | Build a term and use a generic function for subterms
444 fromConstrB :: Data a
445 => (forall d. Data d => d)
448 fromConstrB f = unID . gunfold k z
454 -- | Monadic variation on 'fromConstrB'
455 fromConstrM :: (Monad m, Data a)
456 => (forall d. Data d => m d)
459 fromConstrM f = gunfold k z
461 k c = do { c' <- c; b <- f; return (c' b) }
466 ------------------------------------------------------------------------------
468 -- Datatype and constructor representations
470 ------------------------------------------------------------------------------
474 -- | Representation of datatypes.
475 -- A package of constructor representations with names of type and module.
477 data DataType = DataType
485 -- | Representation of constructors
487 { conrep :: ConstrRep
488 , constring :: String
489 , confields :: [String] -- for AlgRep only
490 , confixity :: Fixity -- for AlgRep only
491 , datatype :: DataType
494 instance Show Constr where
498 -- | Equality of constructors
499 instance Eq Constr where
500 c == c' = constrRep c == constrRep c'
503 -- | Public representation of datatypes
504 {-# DEPRECATED StringRep "Use CharRep instead" #-}
505 data DataRep = AlgRep [Constr]
508 | StringRep -- ^ Deprecated. Please use 'CharRep' instead.
513 -- The list of constructors could be an array, a balanced tree, or others.
516 -- | Public representation of constructors
517 {-# DEPRECATED StringConstr "Use CharConstr instead" #-}
518 data ConstrRep = AlgConstr ConIndex
520 | FloatConstr Rational
521 | StringConstr String -- ^ Deprecated. Please use 'CharConstr' instead.
527 -- | Unique index for datatype constructors,
528 -- counting from 1 in the order they are given in the program text.
532 -- | Fixity of constructors
534 | Infix -- Later: add associativity and precedence
539 ------------------------------------------------------------------------------
541 -- Observers for datatype representations
543 ------------------------------------------------------------------------------
546 -- | Gets the type constructor including the module
547 dataTypeName :: DataType -> String
552 -- | Gets the public presentation of a datatype
553 dataTypeRep :: DataType -> DataRep
554 dataTypeRep = datarep
557 -- | Gets the datatype of a constructor
558 constrType :: Constr -> DataType
559 constrType = datatype
562 -- | Gets the public presentation of constructors
563 constrRep :: Constr -> ConstrRep
567 -- | Look up a constructor by its representation
568 repConstr :: DataType -> ConstrRep -> Constr
570 case (dataTypeRep dt, cr) of
571 (AlgRep cs, AlgConstr i) -> cs !! (i-1)
572 (IntRep, IntConstr i) -> mkIntConstr dt i
573 (FloatRep, FloatConstr f) -> mkRealConstr dt f
574 (StringRep, StringConstr str) -> mkStringConstr dt str
575 (CharRep, CharConstr c) -> mkCharConstr dt c
576 _ -> error "repConstr"
580 ------------------------------------------------------------------------------
582 -- Representations of algebraic data types
584 ------------------------------------------------------------------------------
587 -- | Constructs an algebraic datatype
588 mkDataType :: String -> [Constr] -> DataType
589 mkDataType str cs = DataType
591 , datarep = AlgRep cs
595 -- | Constructs a constructor
596 mkConstr :: DataType -> String -> [String] -> Fixity -> Constr
597 mkConstr dt str fields fix =
599 { conrep = AlgConstr idx
606 idx = head [ i | (c,i) <- dataTypeConstrs dt `zip` [1..],
607 showConstr c == str ]
610 -- | Gets the constructors of an algebraic datatype
611 dataTypeConstrs :: DataType -> [Constr]
612 dataTypeConstrs dt = case datarep dt of
613 (AlgRep cons) -> cons
614 _ -> error "dataTypeConstrs"
617 -- | Gets the field labels of a constructor. The list of labels
618 -- is returned in the same order as they were given in the original
619 -- constructor declaration.
620 constrFields :: Constr -> [String]
621 constrFields = confields
624 -- | Gets the fixity of a constructor
625 constrFixity :: Constr -> Fixity
626 constrFixity = confixity
630 ------------------------------------------------------------------------------
632 -- From strings to constr's and vice versa: all data types
634 ------------------------------------------------------------------------------
637 -- | Gets the string for a constructor
638 showConstr :: Constr -> String
639 showConstr = constring
642 -- | Lookup a constructor via a string
643 readConstr :: DataType -> String -> Maybe Constr
645 case dataTypeRep dt of
646 AlgRep cons -> idx cons
647 IntRep -> mkReadCon (\i -> (mkPrimCon dt str (IntConstr i)))
648 FloatRep -> mkReadCon (\f -> (mkPrimCon dt str (FloatConstr f)))
649 StringRep -> Just (mkStringConstr dt str)
650 CharRep -> mkReadCon (\c -> (mkPrimCon dt str (CharConstr c)))
654 -- Read a value and build a constructor
655 mkReadCon :: Read t => (t -> Constr) -> Maybe Constr
656 mkReadCon f = case (reads str) of
657 [(t,"")] -> Just (f t)
660 -- Traverse list of algebraic datatype constructors
661 idx :: [Constr] -> Maybe Constr
662 idx cons = let fit = filter ((==) str . showConstr) cons
668 ------------------------------------------------------------------------------
670 -- Convenience funtions: algebraic data types
672 ------------------------------------------------------------------------------
675 -- | Test for an algebraic type
676 isAlgType :: DataType -> Bool
677 isAlgType dt = case datarep dt of
682 -- | Gets the constructor for an index (algebraic datatypes only)
683 indexConstr :: DataType -> ConIndex -> Constr
684 indexConstr dt idx = case datarep dt of
685 (AlgRep cs) -> cs !! (idx-1)
686 _ -> error "indexConstr"
689 -- | Gets the index of a constructor (algebraic datatypes only)
690 constrIndex :: Constr -> ConIndex
691 constrIndex con = case constrRep con of
692 (AlgConstr idx) -> idx
693 _ -> error "constrIndex"
696 -- | Gets the maximum constructor index of an algebraic datatype
697 maxConstrIndex :: DataType -> ConIndex
698 maxConstrIndex dt = case dataTypeRep dt of
699 AlgRep cs -> length cs
700 _ -> error "maxConstrIndex"
704 ------------------------------------------------------------------------------
706 -- Representation of primitive types
708 ------------------------------------------------------------------------------
711 -- | Constructs the 'Int' type
712 mkIntType :: String -> DataType
713 mkIntType = mkPrimType IntRep
716 -- | Constructs the 'Float' type
717 mkFloatType :: String -> DataType
718 mkFloatType = mkPrimType FloatRep
721 -- | This function is now deprecated. Please use 'mkCharType' instead.
722 {-# DEPRECATED mkStringType "Use mkCharType instead" #-}
723 mkStringType :: String -> DataType
724 mkStringType = mkPrimType StringRep
726 -- | Constructs the 'Char' type
727 mkCharType :: String -> DataType
728 mkCharType = mkPrimType CharRep
731 -- | Helper for 'mkIntType', 'mkFloatType', 'mkStringType'
732 mkPrimType :: DataRep -> String -> DataType
733 mkPrimType dr str = DataType
739 -- Makes a constructor for primitive types
740 mkPrimCon :: DataType -> String -> ConstrRep -> Constr
741 mkPrimCon dt str cr = Constr
745 , confields = error "constrFields"
746 , confixity = error "constrFixity"
749 -- | This function is now deprecated. Please use 'mkIntegralConstr' instead.
750 {-# DEPRECATED mkIntConstr "Use mkIntegralConstr instead" #-}
751 mkIntConstr :: DataType -> Integer -> Constr
752 mkIntConstr = mkIntegralConstr
754 mkIntegralConstr :: (Integral a) => DataType -> a -> Constr
755 mkIntegralConstr dt i = case datarep dt of
756 IntRep -> mkPrimCon dt (show i) (IntConstr (toInteger i))
757 _ -> error "mkIntegralConstr"
759 -- | This function is now deprecated. Please use 'mkRealConstr' instead.
760 {-# DEPRECATED mkFloatConstr "Use mkRealConstr instead" #-}
761 mkFloatConstr :: DataType -> Double -> Constr
762 mkFloatConstr dt = mkRealConstr dt . toRational
764 mkRealConstr :: (Real a) => DataType -> a -> Constr
765 mkRealConstr dt f = case datarep dt of
766 FloatRep -> mkPrimCon dt (show f) (FloatConstr (toRational f))
767 _ -> error "mkRealConstr"
769 -- | This function is now deprecated. Please use 'mkCharConstr' instead.
770 {-# DEPRECATED mkStringConstr "Use mkCharConstr instead" #-}
771 mkStringConstr :: DataType -> String -> Constr
772 mkStringConstr dt str = case datarep dt of
773 StringRep -> mkPrimCon dt str (StringConstr str)
774 _ -> error "mkStringConstr"
776 -- | Makes a constructor for 'Char'.
777 mkCharConstr :: DataType -> Char -> Constr
778 mkCharConstr dt c = case datarep dt of
779 CharRep -> mkPrimCon dt (show c) (CharConstr c)
780 _ -> error "mkCharConstr"
783 ------------------------------------------------------------------------------
785 -- Non-representations for non-presentable types
787 ------------------------------------------------------------------------------
790 -- | Deprecated version (misnamed)
791 {-# DEPRECATED mkNorepType "Use mkNoRepType instead" #-}
792 mkNorepType :: String -> DataType
793 mkNorepType str = DataType
798 -- | Constructs a non-representation for a non-presentable type
799 mkNoRepType :: String -> DataType
800 mkNoRepType str = DataType
805 -- | Test for a non-representable type
806 isNorepType :: DataType -> Bool
807 isNorepType dt = case datarep dt of
813 ------------------------------------------------------------------------------
815 -- Convenience for qualified type constructors
817 ------------------------------------------------------------------------------
820 -- | Gets the unqualified type constructor:
821 -- drop *.*.*... before name
823 tyconUQname :: String -> String
824 tyconUQname x = let x' = dropWhile (not . (==) '.') x
825 in if x' == [] then x else tyconUQname (tail x')
828 -- | Gets the module of a type constructor:
829 -- take *.*.*... before name
830 tyconModule :: String -> String
831 tyconModule x = let (a,b) = break ((==) '.') x
834 else a ++ tyconModule' (tail b)
836 tyconModule' y = let y' = tyconModule y
837 in if y' == "" then "" else ('.':y')
842 ------------------------------------------------------------------------------
843 ------------------------------------------------------------------------------
845 -- Instances of the Data class for Prelude-like types.
846 -- We define top-level definitions for representations.
848 ------------------------------------------------------------------------------
851 falseConstr :: Constr
852 falseConstr = mkConstr boolDataType "False" [] Prefix
854 trueConstr = mkConstr boolDataType "True" [] Prefix
856 boolDataType :: DataType
857 boolDataType = mkDataType "Prelude.Bool" [falseConstr,trueConstr]
859 instance Data Bool where
860 toConstr False = falseConstr
861 toConstr True = trueConstr
862 gunfold _ z c = case constrIndex c of
866 dataTypeOf _ = boolDataType
869 ------------------------------------------------------------------------------
872 charType = mkCharType "Prelude.Char"
874 instance Data Char where
875 toConstr x = mkCharConstr charType x
876 gunfold _ z c = case constrRep c of
877 (CharConstr x) -> z x
879 dataTypeOf _ = charType
882 ------------------------------------------------------------------------------
884 floatType :: DataType
885 floatType = mkFloatType "Prelude.Float"
887 instance Data Float where
888 toConstr = mkRealConstr floatType
889 gunfold _ z c = case constrRep c of
890 (FloatConstr x) -> z (realToFrac x)
892 dataTypeOf _ = floatType
895 ------------------------------------------------------------------------------
897 doubleType :: DataType
898 doubleType = mkFloatType "Prelude.Double"
900 instance Data Double where
901 toConstr = mkRealConstr doubleType
902 gunfold _ z c = case constrRep c of
903 (FloatConstr x) -> z (realToFrac x)
905 dataTypeOf _ = doubleType
908 ------------------------------------------------------------------------------
911 intType = mkIntType "Prelude.Int"
913 instance Data Int where
914 toConstr x = mkIntConstr intType (fromIntegral x)
915 gunfold _ z c = case constrRep c of
916 (IntConstr x) -> z (fromIntegral x)
918 dataTypeOf _ = intType
921 ------------------------------------------------------------------------------
923 integerType :: DataType
924 integerType = mkIntType "Prelude.Integer"
926 instance Data Integer where
927 toConstr = mkIntConstr integerType
928 gunfold _ z c = case constrRep c of
931 dataTypeOf _ = integerType
934 ------------------------------------------------------------------------------
937 int8Type = mkIntType "Data.Int.Int8"
939 instance Data Int8 where
940 toConstr x = mkIntConstr int8Type (fromIntegral x)
941 gunfold _ z c = case constrRep c of
942 (IntConstr x) -> z (fromIntegral x)
944 dataTypeOf _ = int8Type
947 ------------------------------------------------------------------------------
949 int16Type :: DataType
950 int16Type = mkIntType "Data.Int.Int16"
952 instance Data Int16 where
953 toConstr x = mkIntConstr int16Type (fromIntegral x)
954 gunfold _ z c = case constrRep c of
955 (IntConstr x) -> z (fromIntegral x)
957 dataTypeOf _ = int16Type
960 ------------------------------------------------------------------------------
962 int32Type :: DataType
963 int32Type = mkIntType "Data.Int.Int32"
965 instance Data Int32 where
966 toConstr x = mkIntConstr int32Type (fromIntegral x)
967 gunfold _ z c = case constrRep c of
968 (IntConstr x) -> z (fromIntegral x)
970 dataTypeOf _ = int32Type
973 ------------------------------------------------------------------------------
975 int64Type :: DataType
976 int64Type = mkIntType "Data.Int.Int64"
978 instance Data Int64 where
979 toConstr x = mkIntConstr int64Type (fromIntegral x)
980 gunfold _ z c = case constrRep c of
981 (IntConstr x) -> z (fromIntegral x)
983 dataTypeOf _ = int64Type
986 ------------------------------------------------------------------------------
989 wordType = mkIntType "Data.Word.Word"
991 instance Data Word where
992 toConstr x = mkIntConstr wordType (fromIntegral x)
993 gunfold _ z c = case constrRep c of
994 (IntConstr x) -> z (fromIntegral x)
996 dataTypeOf _ = wordType
999 ------------------------------------------------------------------------------
1001 word8Type :: DataType
1002 word8Type = mkIntType "Data.Word.Word8"
1004 instance Data Word8 where
1005 toConstr x = mkIntConstr word8Type (fromIntegral x)
1006 gunfold _ z c = case constrRep c of
1007 (IntConstr x) -> z (fromIntegral x)
1008 _ -> error "gunfold"
1009 dataTypeOf _ = word8Type
1012 ------------------------------------------------------------------------------
1014 word16Type :: DataType
1015 word16Type = mkIntType "Data.Word.Word16"
1017 instance Data Word16 where
1018 toConstr x = mkIntConstr word16Type (fromIntegral x)
1019 gunfold _ z c = case constrRep c of
1020 (IntConstr x) -> z (fromIntegral x)
1021 _ -> error "gunfold"
1022 dataTypeOf _ = word16Type
1025 ------------------------------------------------------------------------------
1027 word32Type :: DataType
1028 word32Type = mkIntType "Data.Word.Word32"
1030 instance Data Word32 where
1031 toConstr x = mkIntConstr word32Type (fromIntegral x)
1032 gunfold _ z c = case constrRep c of
1033 (IntConstr x) -> z (fromIntegral x)
1034 _ -> error "gunfold"
1035 dataTypeOf _ = word32Type
1038 ------------------------------------------------------------------------------
1040 word64Type :: DataType
1041 word64Type = mkIntType "Data.Word.Word64"
1043 instance Data Word64 where
1044 toConstr x = mkIntConstr word64Type (fromIntegral x)
1045 gunfold _ z c = case constrRep c of
1046 (IntConstr x) -> z (fromIntegral x)
1047 _ -> error "gunfold"
1048 dataTypeOf _ = word64Type
1051 ------------------------------------------------------------------------------
1053 ratioConstr :: Constr
1054 ratioConstr = mkConstr ratioDataType ":%" [] Infix
1056 ratioDataType :: DataType
1057 ratioDataType = mkDataType "GHC.Real.Ratio" [ratioConstr]
1059 instance (Data a, Integral a) => Data (Ratio a) where
1060 gfoldl k z (a :% b) = z (:%) `k` a `k` b
1061 toConstr _ = ratioConstr
1062 gunfold k z c | constrIndex c == 1 = k (k (z (:%)))
1063 gunfold _ _ _ = error "gunfold"
1064 dataTypeOf _ = ratioDataType
1067 ------------------------------------------------------------------------------
1070 nilConstr = mkConstr listDataType "[]" [] Prefix
1071 consConstr :: Constr
1072 consConstr = mkConstr listDataType "(:)" [] Infix
1074 listDataType :: DataType
1075 listDataType = mkDataType "Prelude.[]" [nilConstr,consConstr]
1077 instance Data a => Data [a] where
1078 gfoldl _ z [] = z []
1079 gfoldl f z (x:xs) = z (:) `f` x `f` xs
1080 toConstr [] = nilConstr
1081 toConstr (_:_) = consConstr
1082 gunfold k z c = case constrIndex c of
1085 _ -> error "gunfold"
1086 dataTypeOf _ = listDataType
1087 dataCast1 f = gcast1 f
1090 -- The gmaps are given as an illustration.
1091 -- This shows that the gmaps for lists are different from list maps.
1094 gmapT f (x:xs) = (f x:f xs)
1096 gmapQ f (x:xs) = [f x,f xs]
1097 gmapM _ [] = return []
1098 gmapM f (x:xs) = f x >>= \x' -> f xs >>= \xs' -> return (x':xs')
1101 ------------------------------------------------------------------------------
1103 nothingConstr :: Constr
1104 nothingConstr = mkConstr maybeDataType "Nothing" [] Prefix
1105 justConstr :: Constr
1106 justConstr = mkConstr maybeDataType "Just" [] Prefix
1108 maybeDataType :: DataType
1109 maybeDataType = mkDataType "Prelude.Maybe" [nothingConstr,justConstr]
1111 instance Data a => Data (Maybe a) where
1112 gfoldl _ z Nothing = z Nothing
1113 gfoldl f z (Just x) = z Just `f` x
1114 toConstr Nothing = nothingConstr
1115 toConstr (Just _) = justConstr
1116 gunfold k z c = case constrIndex c of
1119 _ -> error "gunfold"
1120 dataTypeOf _ = maybeDataType
1121 dataCast1 f = gcast1 f
1124 ------------------------------------------------------------------------------
1127 ltConstr = mkConstr orderingDataType "LT" [] Prefix
1129 eqConstr = mkConstr orderingDataType "EQ" [] Prefix
1131 gtConstr = mkConstr orderingDataType "GT" [] Prefix
1133 orderingDataType :: DataType
1134 orderingDataType = mkDataType "Prelude.Ordering" [ltConstr,eqConstr,gtConstr]
1136 instance Data Ordering where
1137 gfoldl _ z LT = z LT
1138 gfoldl _ z EQ = z EQ
1139 gfoldl _ z GT = z GT
1140 toConstr LT = ltConstr
1141 toConstr EQ = eqConstr
1142 toConstr GT = gtConstr
1143 gunfold _ z c = case constrIndex c of
1147 _ -> error "gunfold"
1148 dataTypeOf _ = orderingDataType
1151 ------------------------------------------------------------------------------
1153 leftConstr :: Constr
1154 leftConstr = mkConstr eitherDataType "Left" [] Prefix
1156 rightConstr :: Constr
1157 rightConstr = mkConstr eitherDataType "Right" [] Prefix
1159 eitherDataType :: DataType
1160 eitherDataType = mkDataType "Prelude.Either" [leftConstr,rightConstr]
1162 instance (Data a, Data b) => Data (Either a b) where
1163 gfoldl f z (Left a) = z Left `f` a
1164 gfoldl f z (Right a) = z Right `f` a
1165 toConstr (Left _) = leftConstr
1166 toConstr (Right _) = rightConstr
1167 gunfold k z c = case constrIndex c of
1170 _ -> error "gunfold"
1171 dataTypeOf _ = eitherDataType
1172 dataCast2 f = gcast2 f
1175 ------------------------------------------------------------------------------
1177 tuple0Constr :: Constr
1178 tuple0Constr = mkConstr tuple0DataType "()" [] Prefix
1180 tuple0DataType :: DataType
1181 tuple0DataType = mkDataType "Prelude.()" [tuple0Constr]
1183 instance Data () where
1184 toConstr () = tuple0Constr
1185 gunfold _ z c | constrIndex c == 1 = z ()
1186 gunfold _ _ _ = error "gunfold"
1187 dataTypeOf _ = tuple0DataType
1190 ------------------------------------------------------------------------------
1192 tuple2Constr :: Constr
1193 tuple2Constr = mkConstr tuple2DataType "(,)" [] Infix
1195 tuple2DataType :: DataType
1196 tuple2DataType = mkDataType "Prelude.(,)" [tuple2Constr]
1198 instance (Data a, Data b) => Data (a,b) where
1199 gfoldl f z (a,b) = z (,) `f` a `f` b
1200 toConstr (_,_) = tuple2Constr
1201 gunfold k z c | constrIndex c == 1 = k (k (z (,)))
1202 gunfold _ _ _ = error "gunfold"
1203 dataTypeOf _ = tuple2DataType
1204 dataCast2 f = gcast2 f
1207 ------------------------------------------------------------------------------
1209 tuple3Constr :: Constr
1210 tuple3Constr = mkConstr tuple3DataType "(,,)" [] Infix
1212 tuple3DataType :: DataType
1213 tuple3DataType = mkDataType "Prelude.(,,)" [tuple3Constr]
1215 instance (Data a, Data b, Data c) => Data (a,b,c) where
1216 gfoldl f z (a,b,c) = z (,,) `f` a `f` b `f` c
1217 toConstr (_,_,_) = tuple3Constr
1218 gunfold k z c | constrIndex c == 1 = k (k (k (z (,,))))
1219 gunfold _ _ _ = error "gunfold"
1220 dataTypeOf _ = tuple3DataType
1223 ------------------------------------------------------------------------------
1225 tuple4Constr :: Constr
1226 tuple4Constr = mkConstr tuple4DataType "(,,,)" [] Infix
1228 tuple4DataType :: DataType
1229 tuple4DataType = mkDataType "Prelude.(,,,)" [tuple4Constr]
1231 instance (Data a, Data b, Data c, Data d)
1232 => Data (a,b,c,d) where
1233 gfoldl f z (a,b,c,d) = z (,,,) `f` a `f` b `f` c `f` d
1234 toConstr (_,_,_,_) = tuple4Constr
1235 gunfold k z c = case constrIndex c of
1236 1 -> k (k (k (k (z (,,,)))))
1237 _ -> error "gunfold"
1238 dataTypeOf _ = tuple4DataType
1241 ------------------------------------------------------------------------------
1243 tuple5Constr :: Constr
1244 tuple5Constr = mkConstr tuple5DataType "(,,,,)" [] Infix
1246 tuple5DataType :: DataType
1247 tuple5DataType = mkDataType "Prelude.(,,,,)" [tuple5Constr]
1249 instance (Data a, Data b, Data c, Data d, Data e)
1250 => Data (a,b,c,d,e) where
1251 gfoldl f z (a,b,c,d,e) = z (,,,,) `f` a `f` b `f` c `f` d `f` e
1252 toConstr (_,_,_,_,_) = tuple5Constr
1253 gunfold k z c = case constrIndex c of
1254 1 -> k (k (k (k (k (z (,,,,))))))
1255 _ -> error "gunfold"
1256 dataTypeOf _ = tuple5DataType
1259 ------------------------------------------------------------------------------
1261 tuple6Constr :: Constr
1262 tuple6Constr = mkConstr tuple6DataType "(,,,,,)" [] Infix
1264 tuple6DataType :: DataType
1265 tuple6DataType = mkDataType "Prelude.(,,,,,)" [tuple6Constr]
1267 instance (Data a, Data b, Data c, Data d, Data e, Data f)
1268 => Data (a,b,c,d,e,f) where
1269 gfoldl f z (a,b,c,d,e,f') = z (,,,,,) `f` a `f` b `f` c `f` d `f` e `f` f'
1270 toConstr (_,_,_,_,_,_) = tuple6Constr
1271 gunfold k z c = case constrIndex c of
1272 1 -> k (k (k (k (k (k (z (,,,,,)))))))
1273 _ -> error "gunfold"
1274 dataTypeOf _ = tuple6DataType
1277 ------------------------------------------------------------------------------
1279 tuple7Constr :: Constr
1280 tuple7Constr = mkConstr tuple7DataType "(,,,,,,)" [] Infix
1282 tuple7DataType :: DataType
1283 tuple7DataType = mkDataType "Prelude.(,,,,,,)" [tuple7Constr]
1285 instance (Data a, Data b, Data c, Data d, Data e, Data f, Data g)
1286 => Data (a,b,c,d,e,f,g) where
1287 gfoldl f z (a,b,c,d,e,f',g) =
1288 z (,,,,,,) `f` a `f` b `f` c `f` d `f` e `f` f' `f` g
1289 toConstr (_,_,_,_,_,_,_) = tuple7Constr
1290 gunfold k z c = case constrIndex c of
1291 1 -> k (k (k (k (k (k (k (z (,,,,,,))))))))
1292 _ -> error "gunfold"
1293 dataTypeOf _ = tuple7DataType
1296 ------------------------------------------------------------------------------
1298 instance Typeable a => Data (Ptr a) where
1299 toConstr _ = error "toConstr"
1300 gunfold _ _ = error "gunfold"
1301 dataTypeOf _ = mkNoRepType "GHC.Ptr.Ptr"
1304 ------------------------------------------------------------------------------
1306 instance Typeable a => Data (ForeignPtr a) where
1307 toConstr _ = error "toConstr"
1308 gunfold _ _ = error "gunfold"
1309 dataTypeOf _ = mkNoRepType "GHC.ForeignPtr.ForeignPtr"
1312 ------------------------------------------------------------------------------
1313 -- The Data instance for Array preserves data abstraction at the cost of
1314 -- inefficiency. We omit reflection services for the sake of data abstraction.
1315 instance (Typeable a, Data b, Ix a) => Data (Array a b)
1317 gfoldl f z a = z (listArray (bounds a)) `f` (elems a)
1318 toConstr _ = error "toConstr"
1319 gunfold _ _ = error "gunfold"
1320 dataTypeOf _ = mkNoRepType "Data.Array.Array"