Data/Data.hs

   1 -----------------------------------------------------------------------------
   2 -- |
   3 -- Module      :  Data.Data
   4 -- Copyright   :  (c) The University of Glasgow, CWI 2001--2004
   5 -- License     :  BSD-style (see the file libraries/base/LICENSE)
   6 --
   7 -- Maintainer  :  libraries@haskell.org
   8 -- Stability   :  experimental
   9 -- Portability :  non-portable (local universal quantification)
  10 --
  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.
  19 --
  20 -- For more information, please visit the new
  21 -- SYB wiki: <http://www.cs.uu.nl/wiki/bin/view/GenericProgramming/SYB>.
  22 --
  23 --
  24 -----------------------------------------------------------------------------
  25
  26 module Data.Data (
  27
  28         -- * Module Data.Typeable re-exported for convenience
  29         module Data.Typeable,
  30
  31         -- * The Data class for processing constructor applications
  32         Data(
  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
  40                 gmapT,
  41                 gmapQ,
  42                 gmapQl,
  43                 gmapQr,
  44                 gmapQi,
  45                 gmapM,
  46                 gmapMp,
  47                 gmapMo
  48             ),
  49
  50         -- * Datatype representations
  51         DataType,       -- abstract, instance of: Show
  52         -- ** Constructors
  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
  60         -- ** Observers
  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
  71
  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
  76         -- ** Constructors
  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
  84         -- ** Observers
  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
  95
  96         -- * Convenience functions: take type constructors apart
  97         tyconUQname,    -- :: String -> String
  98         tyconModule,    -- :: String -> String
  99
 100         -- * Generic operations defined in terms of 'gunfold'
 101         fromConstr,     -- :: Constr -> a
 102         fromConstrB,    -- :: ... -> Constr -> a
 103         fromConstrM     -- :: Monad m => ... -> Constr -> m a
 104
 105   ) where
 106
 107
 108 ------------------------------------------------------------------------------
 109
 110 import Prelude -- necessary to get dependencies right
 111
 112 import Data.Typeable
 113 import Data.Maybe
 114 import Control.Monad
 115
 116 -- Imports for the instances
 117 import Data.Typeable
 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
 129 #else
 130 # ifdef __HUGS__
 131 import Hugs.Prelude( Ratio(..) )
 132 # endif
 133 import Foreign.Ptr
 134 import Foreign.ForeignPtr
 135 import Data.Array
 136 #endif
 137
 138 #include "Typeable.h"
 139
 140
 141
 142 ------------------------------------------------------------------------------
 143 --
 144 --      The Data class
 145 --
 146 ------------------------------------------------------------------------------
 147
 148 {- |
 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.
 159
 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'.)
 169
 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.
 174
 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
 187 right unit.
 188
 189 With the @-XDeriveDataTypeable@ option, GHC can generate instances of the
 190 'Data' class automatically.  For example, given the declaration
 191
 192 > data T a b = C1 a b | C2 deriving (Typeable, Data)
 193
 194 GHC will generate an instance that is equivalent to
 195
 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
 199 >
 200 >     gunfold k z c = case constrIndex c of
 201 >                         1 -> k (k (z C1))
 202 >                         2 -> z C2
 203 >
 204 >     toConstr (C1 _ _) = con_C1
 205 >     toConstr C2       = con_C2
 206 >
 207 >     dataTypeOf _ = ty_T
 208 >
 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]
 212
 213 This is suitable for datatypes that are exported transparently.
 214
 215 -}
 216
 217 class Typeable a => Data a where
 218
 219   -- | Left-associative fold operation for constructor applications.
 220   --
 221   -- The type of 'gfoldl' is a headache, but operationally it is a simple
 222   -- generalisation of a list fold.
 223   --
 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
 234                 -- folding.
 235           -> a
 236                 -- ^ structure to be folded.
 237           -> c a
 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.
 241
 242   -- See the 'Data' instances in this file for an illustration of 'gfoldl'.
 243
 244   gfoldl _ z = z
 245
 246   -- | Unfolding constructor applications
 247   gunfold :: (forall b r. Data b => c (b -> r) -> c r)
 248           -> (forall r. r -> c r)
 249           -> Constr
 250           -> c a
 251
 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
 257
 258
 259   -- | The outer type constructor of the type
 260   dataTypeOf  :: a -> DataType
 261
 262
 263
 264 ------------------------------------------------------------------------------
 265 --
 266 -- Mediate types and type constructors
 267 --
 268 ------------------------------------------------------------------------------
 269
 270   -- | Mediate types and unary type constructors.
 271   -- In 'Data' instances of the form @T a@, 'dataCast1' should be defined
 272   -- as 'gcast1'.
 273   --
 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))
 278             -> Maybe (c a)
 279   dataCast1 _ = Nothing
 280
 281   -- | Mediate types and binary type constructors.
 282   -- In 'Data' instances of the form @T a b@, 'dataCast2' should be
 283   -- defined as 'gcast2'.
 284   --
 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))
 289             -> Maybe (c a)
 290   dataCast2 _ = Nothing
 291
 292
 293
 294 ------------------------------------------------------------------------------
 295 --
 296 --      Typical generic maps defined in terms of gfoldl
 297 --
 298 ------------------------------------------------------------------------------
 299
 300
 301   -- | A generic transformation that maps over the immediate subterms
 302   --
 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
 307
 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.
 311   --
 312   gmapT f x0 = unID (gfoldl k ID x0)
 313     where
 314       k (ID c) x = ID (c (f x))
 315
 316
 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
 320     where
 321       k c x = CONST $ (unCONST c) `o` f x
 322       z _   = CONST r
 323
 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
 327     where
 328       k (Qr c) x = Qr (\r -> c (f x `o` r))
 329
 330
 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
 336
 337
 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 }
 341     where
 342       k (Qi i' q) a = Qi (i'+1) (if i==i' then Just (f a) else q)
 343       z _           = Qi 0 Nothing
 344
 345
 346   -- | A generic monadic transformation that maps over the immediate subterms
 347   --
 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
 352
 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 >>=.
 356   --
 357   gmapM f = gfoldl k return
 358     where
 359       k c x = do c' <- c
 360                  x' <- f x
 361                  return (c' x')
 362
 363
 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
 366
 367 {-
 368
 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.
 372
 373 -}
 374
 375   gmapMp f x = unMp (gfoldl k z x) >>= \(x',b) ->
 376                 if b then return x' else mzero
 377     where
 378       z g = Mp (return (g,False))
 379       k (Mp c) y
 380         = Mp ( c >>= \(h, b) ->
 381                  (f y >>= \y' -> return (h y', True))
 382                  `mplus` return (h y, b)
 383              )
 384
 385   -- | Transformation of one immediate subterm with success
 386   gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
 387
 388 {-
 389
 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.
 395
 396 -}
 397
 398   gmapMo f x = unMp (gfoldl k z x) >>= \(x',b) ->
 399                 if b then return x' else mzero
 400     where
 401       z g = Mp (return (g,False))
 402       k (Mp c) y
 403         = Mp ( c >>= \(h,b) -> if b
 404                         then return (h y, b)
 405                         else (f y >>= \y' -> return (h y',True))
 406                              `mplus` return (h y, b)
 407              )
 408
 409
 410 -- | The identity type constructor needed for the definition of gmapT
 411 newtype ID x = ID { unID :: x }
 412
 413
 414 -- | The constant type constructor needed for the definition of gmapQl
 415 newtype CONST c a = CONST { unCONST :: c }
 416
 417
 418 -- | Type constructor for adding counters to queries
 419 data Qi q a = Qi Int (Maybe q)
 420
 421
 422 -- | The type constructor used in definition of gmapQr
 423 newtype Qr r a = Qr { unQr  :: r -> r }
 424
 425
 426 -- | The type constructor used in definition of gmapMp
 427 newtype Mp m x = Mp { unMp :: m (x, Bool) }
 428
 429
 430
 431 ------------------------------------------------------------------------------
 432 --
 433 --      Generic unfolding
 434 --
 435 ------------------------------------------------------------------------------
 436
 437
 438 -- | Build a term skeleton
 439 fromConstr :: Data a => Constr -> a
 440 fromConstr = fromConstrB (error "Data.Data.fromConstr")
 441
 442
 443 -- | Build a term and use a generic function for subterms
 444 fromConstrB :: Data a
 445             => (forall d. Data d => d)
 446             -> Constr
 447             -> a
 448 fromConstrB f = unID . gunfold k z
 449  where
 450   k c = ID (unID c f)
 451   z = ID
 452
 453
 454 -- | Monadic variation on 'fromConstrB'
 455 fromConstrM :: (Monad m, Data a)
 456             => (forall d. Data d => m d)
 457             -> Constr
 458             -> m a
 459 fromConstrM f = gunfold k z
 460  where
 461   k c = do { c' <- c; b <- f; return (c' b) }
 462   z = return
 463
 464
 465
 466 ------------------------------------------------------------------------------
 467 --
 468 --      Datatype and constructor representations
 469 --
 470 ------------------------------------------------------------------------------
 471
 472
 473 --
 474 -- | Representation of datatypes.
 475 -- A package of constructor representations with names of type and module.
 476 --
 477 data DataType = DataType
 478                         { tycon   :: String
 479                         , datarep :: DataRep
 480                         }
 481
 482               deriving Show
 483
 484
 485 -- | Representation of constructors
 486 data Constr = Constr
 487                         { conrep    :: ConstrRep
 488                         , constring :: String
 489                         , confields :: [String] -- for AlgRep only
 490                         , confixity :: Fixity   -- for AlgRep only
 491                         , datatype  :: DataType
 492                         }
 493
 494 instance Show Constr where
 495  show = constring
 496
 497
 498 -- | Equality of constructors
 499 instance Eq Constr where
 500   c == c' = constrRep c == constrRep c'
 501
 502
 503 -- | Public representation of datatypes
 504 data DataRep = AlgRep [Constr]
 505              | IntRep
 506              | FloatRep
 507              | CharRep
 508              | NoRep
 509
 510             deriving (Eq,Show)
 511 -- The list of constructors could be an array, a balanced tree, or others.
 512
 513
 514 -- | Public representation of constructors
 515 data ConstrRep = AlgConstr    ConIndex
 516                | IntConstr    Integer
 517                | FloatConstr  Rational
 518                | CharConstr   Char
 519
 520                deriving (Eq,Show)
 521
 522
 523 -- | Unique index for datatype constructors,
 524 -- counting from 1 in the order they are given in the program text.
 525 type ConIndex = Int
 526
 527
 528 -- | Fixity of constructors
 529 data Fixity = Prefix
 530             | Infix     -- Later: add associativity and precedence
 531
 532             deriving (Eq,Show)
 533
 534
 535 ------------------------------------------------------------------------------
 536 --
 537 --      Observers for datatype representations
 538 --
 539 ------------------------------------------------------------------------------
 540
 541
 542 -- | Gets the type constructor including the module
 543 dataTypeName :: DataType -> String
 544 dataTypeName = tycon
 545
 546
 547
 548 -- | Gets the public presentation of a datatype
 549 dataTypeRep :: DataType -> DataRep
 550 dataTypeRep = datarep
 551
 552
 553 -- | Gets the datatype of a constructor
 554 constrType :: Constr -> DataType
 555 constrType = datatype
 556
 557
 558 -- | Gets the public presentation of constructors
 559 constrRep :: Constr -> ConstrRep
 560 constrRep = conrep
 561
 562
 563 -- | Look up a constructor by its representation
 564 repConstr :: DataType -> ConstrRep -> Constr
 565 repConstr dt cr =
 566       case (dataTypeRep dt, cr) of
 567         (AlgRep cs, AlgConstr i)      -> cs !! (i-1)
 568         (IntRep,    IntConstr i)      -> mkIntConstr dt i
 569         (FloatRep,  FloatConstr f)    -> mkRealConstr dt f
 570         (CharRep,   CharConstr c)     -> mkCharConstr dt c
 571         _ -> error "repConstr"
 572
 573
 574
 575 ------------------------------------------------------------------------------
 576 --
 577 --      Representations of algebraic data types
 578 --
 579 ------------------------------------------------------------------------------
 580
 581
 582 -- | Constructs an algebraic datatype
 583 mkDataType :: String -> [Constr] -> DataType
 584 mkDataType str cs = DataType
 585                         { tycon   = str
 586                         , datarep = AlgRep cs
 587                         }
 588
 589
 590 -- | Constructs a constructor
 591 mkConstr :: DataType -> String -> [String] -> Fixity -> Constr
 592 mkConstr dt str fields fix =
 593         Constr
 594                 { conrep    = AlgConstr idx
 595                 , constring = str
 596                 , confields = fields
 597                 , confixity = fix
 598                 , datatype  = dt
 599                 }
 600   where
 601     idx = head [ i | (c,i) <- dataTypeConstrs dt `zip` [1..],
 602                      showConstr c == str ]
 603
 604
 605 -- | Gets the constructors of an algebraic datatype
 606 dataTypeConstrs :: DataType -> [Constr]
 607 dataTypeConstrs dt = case datarep dt of
 608                         (AlgRep cons) -> cons
 609                         _ -> error "dataTypeConstrs"
 610
 611
 612 -- | Gets the field labels of a constructor.  The list of labels
 613 -- is returned in the same order as they were given in the original
 614 -- constructor declaration.
 615 constrFields :: Constr -> [String]
 616 constrFields = confields
 617
 618
 619 -- | Gets the fixity of a constructor
 620 constrFixity :: Constr -> Fixity
 621 constrFixity = confixity
 622
 623
 624
 625 ------------------------------------------------------------------------------
 626 --
 627 --      From strings to constr's and vice versa: all data types
 628 --
 629 ------------------------------------------------------------------------------
 630
 631
 632 -- | Gets the string for a constructor
 633 showConstr :: Constr -> String
 634 showConstr = constring
 635
 636
 637 -- | Lookup a constructor via a string
 638 readConstr :: DataType -> String -> Maybe Constr
 639 readConstr dt str =
 640       case dataTypeRep dt of
 641         AlgRep cons -> idx cons
 642         IntRep      -> mkReadCon (\i -> (mkPrimCon dt str (IntConstr i)))
 643         FloatRep    -> mkReadCon (\f -> (mkPrimCon dt str (FloatConstr f)))
 644         CharRep     -> mkReadCon (\c -> (mkPrimCon dt str (CharConstr c)))
 645         NoRep       -> Nothing
 646   where
 647
 648     -- Read a value and build a constructor
 649     mkReadCon :: Read t => (t -> Constr) -> Maybe Constr
 650     mkReadCon f = case (reads str) of
 651                     [(t,"")] -> Just (f t)
 652                     _ -> Nothing
 653
 654     -- Traverse list of algebraic datatype constructors
 655     idx :: [Constr] -> Maybe Constr
 656     idx cons = let fit = filter ((==) str . showConstr) cons
 657                 in if fit == []
 658                      then Nothing
 659                      else Just (head fit)
 660
 661
 662 ------------------------------------------------------------------------------
 663 --
 664 --      Convenience funtions: algebraic data types
 665 --
 666 ------------------------------------------------------------------------------
 667
 668
 669 -- | Test for an algebraic type
 670 isAlgType :: DataType -> Bool
 671 isAlgType dt = case datarep dt of
 672                  (AlgRep _) -> True
 673                  _ -> False
 674
 675
 676 -- | Gets the constructor for an index (algebraic datatypes only)
 677 indexConstr :: DataType -> ConIndex -> Constr
 678 indexConstr dt idx = case datarep dt of
 679                         (AlgRep cs) -> cs !! (idx-1)
 680                         _           -> error "indexConstr"
 681
 682
 683 -- | Gets the index of a constructor (algebraic datatypes only)
 684 constrIndex :: Constr -> ConIndex
 685 constrIndex con = case constrRep con of
 686                     (AlgConstr idx) -> idx
 687                     _ -> error "constrIndex"
 688
 689
 690 -- | Gets the maximum constructor index of an algebraic datatype
 691 maxConstrIndex :: DataType -> ConIndex
 692 maxConstrIndex dt = case dataTypeRep dt of
 693                         AlgRep cs -> length cs
 694                         _            -> error "maxConstrIndex"
 695
 696
 697
 698 ------------------------------------------------------------------------------
 699 --
 700 --      Representation of primitive types
 701 --
 702 ------------------------------------------------------------------------------
 703
 704
 705 -- | Constructs the 'Int' type
 706 mkIntType :: String -> DataType
 707 mkIntType = mkPrimType IntRep
 708
 709
 710 -- | Constructs the 'Float' type
 711 mkFloatType :: String -> DataType
 712 mkFloatType = mkPrimType FloatRep
 713
 714
 715 -- | This function is now deprecated. Please use 'mkCharType' instead.
 716 {-# DEPRECATED mkStringType "Use mkCharType instead" #-}
 717 mkStringType :: String -> DataType
 718 mkStringType = mkCharType
 719
 720 -- | Constructs the 'Char' type
 721 mkCharType :: String -> DataType
 722 mkCharType = mkPrimType CharRep
 723
 724
 725 -- | Helper for 'mkIntType', 'mkFloatType', 'mkStringType'
 726 mkPrimType :: DataRep -> String -> DataType
 727 mkPrimType dr str = DataType
 728                         { tycon   = str
 729                         , datarep = dr
 730                         }
 731
 732
 733 -- Makes a constructor for primitive types
 734 mkPrimCon :: DataType -> String -> ConstrRep -> Constr
 735 mkPrimCon dt str cr = Constr
 736                         { datatype  = dt
 737                         , conrep    = cr
 738                         , constring = str
 739                         , confields = error "constrFields"
 740                         , confixity = error "constrFixity"
 741                         }
 742
 743 -- | This function is now deprecated. Please use 'mkIntegralConstr' instead.
 744 {-# DEPRECATED mkIntConstr "Use mkIntegralConstr instead" #-}
 745 mkIntConstr :: DataType -> Integer -> Constr
 746 mkIntConstr = mkIntegralConstr
 747
 748 mkIntegralConstr :: (Integral a) => DataType -> a -> Constr
 749 mkIntegralConstr dt i = case datarep dt of
 750                   IntRep -> mkPrimCon dt (show i) (IntConstr (toInteger  i))
 751                   _ -> error "mkIntegralConstr"
 752
 753 -- | This function is now deprecated. Please use 'mkRealConstr' instead.
 754 {-# DEPRECATED mkFloatConstr "Use mkRealConstr instead" #-}
 755 mkFloatConstr :: DataType -> Double -> Constr
 756 mkFloatConstr dt = mkRealConstr dt . toRational
 757
 758 mkRealConstr :: (Real a) => DataType -> a -> Constr
 759 mkRealConstr dt f = case datarep dt of
 760                     FloatRep -> mkPrimCon dt (show f) (FloatConstr (toRational f))
 761                     _ -> error "mkRealConstr"
 762
 763 -- | This function is now deprecated. Please use 'mkCharConstr' instead.
 764 {-# DEPRECATED mkStringConstr "Use mkCharConstr instead" #-}
 765 mkStringConstr :: DataType -> String -> Constr
 766 mkStringConstr dt str =
 767   case datarep dt of
 768     CharRep -> case str of
 769       [c] -> mkPrimCon dt (show c) (CharConstr c)
 770       _ -> error "mkStringConstr: input String must contain a single character"
 771     _ -> error "mkStringConstr"
 772
 773 -- | Makes a constructor for 'Char'.
 774 mkCharConstr :: DataType -> Char -> Constr
 775 mkCharConstr dt c = case datarep dt of
 776                    CharRep -> mkPrimCon dt (show c) (CharConstr c)
 777                    _ -> error "mkCharConstr"
 778
 779
 780 ------------------------------------------------------------------------------
 781 --
 782 --      Non-representations for non-presentable types
 783 --
 784 ------------------------------------------------------------------------------
 785
 786
 787 -- | Deprecated version (misnamed)
 788 {-# DEPRECATED mkNorepType "Use mkNoRepType instead" #-}
 789 mkNorepType :: String -> DataType
 790 mkNorepType str = DataType
 791                         { tycon   = str
 792                         , datarep = NoRep
 793                         }
 794
 795 -- | Constructs a non-representation for a non-presentable type
 796 mkNoRepType :: String -> DataType
 797 mkNoRepType str = DataType
 798                         { tycon   = str
 799                         , datarep = NoRep
 800                         }
 801
 802 -- | Test for a non-representable type
 803 isNorepType :: DataType -> Bool
 804 isNorepType dt = case datarep dt of
 805                    NoRep -> True
 806                    _ -> False
 807
 808
 809
 810 ------------------------------------------------------------------------------
 811 --
 812 --      Convenience for qualified type constructors
 813 --
 814 ------------------------------------------------------------------------------
 815
 816
 817 -- | Gets the unqualified type constructor:
 818 -- drop *.*.*... before name
 819 --
 820 tyconUQname :: String -> String
 821 tyconUQname x = let x' = dropWhile (not . (==) '.') x
 822                  in if x' == [] then x else tyconUQname (tail x')
 823
 824
 825 -- | Gets the module of a type constructor:
 826 -- take *.*.*... before name
 827 tyconModule :: String -> String
 828 tyconModule x = let (a,b) = break ((==) '.') x
 829                  in if b == ""
 830                       then b
 831                       else a ++ tyconModule' (tail b)
 832   where
 833     tyconModule' y = let y' = tyconModule y
 834                       in if y' == "" then "" else ('.':y')
 835
 836
 837
 838
 839 ------------------------------------------------------------------------------
 840 ------------------------------------------------------------------------------
 841 --
 842 --      Instances of the Data class for Prelude-like types.
 843 --      We define top-level definitions for representations.
 844 --
 845 ------------------------------------------------------------------------------
 846
 847
 848 falseConstr :: Constr
 849 falseConstr  = mkConstr boolDataType "False" [] Prefix
 850 trueConstr :: Constr
 851 trueConstr   = mkConstr boolDataType "True"  [] Prefix
 852
 853 boolDataType :: DataType
 854 boolDataType = mkDataType "Prelude.Bool" [falseConstr,trueConstr]
 855
 856 instance Data Bool where
 857   toConstr False = falseConstr
 858   toConstr True  = trueConstr
 859   gunfold _ z c  = case constrIndex c of
 860                      1 -> z False
 861                      2 -> z True
 862                      _ -> error "gunfold"
 863   dataTypeOf _ = boolDataType
 864
 865
 866 ------------------------------------------------------------------------------
 867
 868 charType :: DataType
 869 charType = mkCharType "Prelude.Char"
 870
 871 instance Data Char where
 872   toConstr x = mkCharConstr charType x
 873   gunfold _ z c = case constrRep c of
 874                     (CharConstr x) -> z x
 875                     _ -> error "gunfold"
 876   dataTypeOf _ = charType
 877
 878
 879 ------------------------------------------------------------------------------
 880
 881 floatType :: DataType
 882 floatType = mkFloatType "Prelude.Float"
 883
 884 instance Data Float where
 885   toConstr = mkRealConstr floatType
 886   gunfold _ z c = case constrRep c of
 887                     (FloatConstr x) -> z (realToFrac x)
 888                     _ -> error "gunfold"
 889   dataTypeOf _ = floatType
 890
 891
 892 ------------------------------------------------------------------------------
 893
 894 doubleType :: DataType
 895 doubleType = mkFloatType "Prelude.Double"
 896
 897 instance Data Double where
 898   toConstr = mkRealConstr doubleType
 899   gunfold _ z c = case constrRep c of
 900                     (FloatConstr x) -> z (realToFrac x)
 901                     _ -> error "gunfold"
 902   dataTypeOf _ = doubleType
 903
 904
 905 ------------------------------------------------------------------------------
 906
 907 intType :: DataType
 908 intType = mkIntType "Prelude.Int"
 909
 910 instance Data Int where
 911   toConstr x = mkIntConstr intType (fromIntegral x)
 912   gunfold _ z c = case constrRep c of
 913                     (IntConstr x) -> z (fromIntegral x)
 914                     _ -> error "gunfold"
 915   dataTypeOf _ = intType
 916
 917
 918 ------------------------------------------------------------------------------
 919
 920 integerType :: DataType
 921 integerType = mkIntType "Prelude.Integer"
 922
 923 instance Data Integer where
 924   toConstr = mkIntConstr integerType
 925   gunfold _ z c = case constrRep c of
 926                     (IntConstr x) -> z x
 927                     _ -> error "gunfold"
 928   dataTypeOf _ = integerType
 929
 930
 931 ------------------------------------------------------------------------------
 932
 933 int8Type :: DataType
 934 int8Type = mkIntType "Data.Int.Int8"
 935
 936 instance Data Int8 where
 937   toConstr x = mkIntConstr int8Type (fromIntegral x)
 938   gunfold _ z c = case constrRep c of
 939                     (IntConstr x) -> z (fromIntegral x)
 940                     _ -> error "gunfold"
 941   dataTypeOf _ = int8Type
 942
 943
 944 ------------------------------------------------------------------------------
 945
 946 int16Type :: DataType
 947 int16Type = mkIntType "Data.Int.Int16"
 948
 949 instance Data Int16 where
 950   toConstr x = mkIntConstr int16Type (fromIntegral x)
 951   gunfold _ z c = case constrRep c of
 952                     (IntConstr x) -> z (fromIntegral x)
 953                     _ -> error "gunfold"
 954   dataTypeOf _ = int16Type
 955
 956
 957 ------------------------------------------------------------------------------
 958
 959 int32Type :: DataType
 960 int32Type = mkIntType "Data.Int.Int32"
 961
 962 instance Data Int32 where
 963   toConstr x = mkIntConstr int32Type (fromIntegral x)
 964   gunfold _ z c = case constrRep c of
 965                     (IntConstr x) -> z (fromIntegral x)
 966                     _ -> error "gunfold"
 967   dataTypeOf _ = int32Type
 968
 969
 970 ------------------------------------------------------------------------------
 971
 972 int64Type :: DataType
 973 int64Type = mkIntType "Data.Int.Int64"
 974
 975 instance Data Int64 where
 976   toConstr x = mkIntConstr int64Type (fromIntegral x)
 977   gunfold _ z c = case constrRep c of
 978                     (IntConstr x) -> z (fromIntegral x)
 979                     _ -> error "gunfold"
 980   dataTypeOf _ = int64Type
 981
 982
 983 ------------------------------------------------------------------------------
 984
 985 wordType :: DataType
 986 wordType = mkIntType "Data.Word.Word"
 987
 988 instance Data Word where
 989   toConstr x = mkIntConstr wordType (fromIntegral x)
 990   gunfold _ z c = case constrRep c of
 991                     (IntConstr x) -> z (fromIntegral x)
 992                     _ -> error "gunfold"
 993   dataTypeOf _ = wordType
 994
 995
 996 ------------------------------------------------------------------------------
 997
 998 word8Type :: DataType
 999 word8Type = mkIntType "Data.Word.Word8"
1000
1001 instance Data Word8 where
1002   toConstr x = mkIntConstr word8Type (fromIntegral x)
1003   gunfold _ z c = case constrRep c of
1004                     (IntConstr x) -> z (fromIntegral x)
1005                     _ -> error "gunfold"
1006   dataTypeOf _ = word8Type
1007
1008
1009 ------------------------------------------------------------------------------
1010
1011 word16Type :: DataType
1012 word16Type = mkIntType "Data.Word.Word16"
1013
1014 instance Data Word16 where
1015   toConstr x = mkIntConstr word16Type (fromIntegral x)
1016   gunfold _ z c = case constrRep c of
1017                     (IntConstr x) -> z (fromIntegral x)
1018                     _ -> error "gunfold"
1019   dataTypeOf _ = word16Type
1020
1021
1022 ------------------------------------------------------------------------------
1023
1024 word32Type :: DataType
1025 word32Type = mkIntType "Data.Word.Word32"
1026
1027 instance Data Word32 where
1028   toConstr x = mkIntConstr word32Type (fromIntegral x)
1029   gunfold _ z c = case constrRep c of
1030                     (IntConstr x) -> z (fromIntegral x)
1031                     _ -> error "gunfold"
1032   dataTypeOf _ = word32Type
1033
1034
1035 ------------------------------------------------------------------------------
1036
1037 word64Type :: DataType
1038 word64Type = mkIntType "Data.Word.Word64"
1039
1040 instance Data Word64 where
1041   toConstr x = mkIntConstr word64Type (fromIntegral x)
1042   gunfold _ z c = case constrRep c of
1043                     (IntConstr x) -> z (fromIntegral x)
1044                     _ -> error "gunfold"
1045   dataTypeOf _ = word64Type
1046
1047
1048 ------------------------------------------------------------------------------
1049
1050 ratioConstr :: Constr
1051 ratioConstr = mkConstr ratioDataType ":%" [] Infix
1052
1053 ratioDataType :: DataType
1054 ratioDataType = mkDataType "GHC.Real.Ratio" [ratioConstr]
1055
1056 instance (Data a, Integral a) => Data (Ratio a) where
1057   gfoldl k z (a :% b) = z (:%) `k` a `k` b
1058   toConstr _ = ratioConstr
1059   gunfold k z c | constrIndex c == 1 = k (k (z (:%)))
1060   gunfold _ _ _ = error "gunfold"
1061   dataTypeOf _  = ratioDataType
1062
1063
1064 ------------------------------------------------------------------------------
1065
1066 nilConstr :: Constr
1067 nilConstr    = mkConstr listDataType "[]" [] Prefix
1068 consConstr :: Constr
1069 consConstr   = mkConstr listDataType "(:)" [] Infix
1070
1071 listDataType :: DataType
1072 listDataType = mkDataType "Prelude.[]" [nilConstr,consConstr]
1073
1074 instance Data a => Data [a] where
1075   gfoldl _ z []     = z []
1076   gfoldl f z (x:xs) = z (:) `f` x `f` xs
1077   toConstr []    = nilConstr
1078   toConstr (_:_) = consConstr
1079   gunfold k z c = case constrIndex c of
1080                     1 -> z []
1081                     2 -> k (k (z (:)))
1082                     _ -> error "gunfold"
1083   dataTypeOf _ = listDataType
1084   dataCast1 f  = gcast1 f
1085
1086 --
1087 -- The gmaps are given as an illustration.
1088 -- This shows that the gmaps for lists are different from list maps.
1089 --
1090   gmapT  _   []     = []
1091   gmapT  f   (x:xs) = (f x:f xs)
1092   gmapQ  _   []     = []
1093   gmapQ  f   (x:xs) = [f x,f xs]
1094   gmapM  _   []     = return []
1095   gmapM  f   (x:xs) = f x >>= \x' -> f xs >>= \xs' -> return (x':xs')
1096
1097
1098 ------------------------------------------------------------------------------
1099
1100 nothingConstr :: Constr
1101 nothingConstr = mkConstr maybeDataType "Nothing" [] Prefix
1102 justConstr :: Constr
1103 justConstr    = mkConstr maybeDataType "Just"    [] Prefix
1104
1105 maybeDataType :: DataType
1106 maybeDataType = mkDataType "Prelude.Maybe" [nothingConstr,justConstr]
1107
1108 instance Data a => Data (Maybe a) where
1109   gfoldl _ z Nothing  = z Nothing
1110   gfoldl f z (Just x) = z Just `f` x
1111   toConstr Nothing  = nothingConstr
1112   toConstr (Just _) = justConstr
1113   gunfold k z c = case constrIndex c of
1114                     1 -> z Nothing
1115                     2 -> k (z Just)
1116                     _ -> error "gunfold"
1117   dataTypeOf _ = maybeDataType
1118   dataCast1 f  = gcast1 f
1119
1120
1121 ------------------------------------------------------------------------------
1122
1123 ltConstr :: Constr
1124 ltConstr         = mkConstr orderingDataType "LT" [] Prefix
1125 eqConstr :: Constr
1126 eqConstr         = mkConstr orderingDataType "EQ" [] Prefix
1127 gtConstr :: Constr
1128 gtConstr         = mkConstr orderingDataType "GT" [] Prefix
1129
1130 orderingDataType :: DataType
1131 orderingDataType = mkDataType "Prelude.Ordering" [ltConstr,eqConstr,gtConstr]
1132
1133 instance Data Ordering where
1134   gfoldl _ z LT  = z LT
1135   gfoldl _ z EQ  = z EQ
1136   gfoldl _ z GT  = z GT
1137   toConstr LT  = ltConstr
1138   toConstr EQ  = eqConstr
1139   toConstr GT  = gtConstr
1140   gunfold _ z c = case constrIndex c of
1141                     1 -> z LT
1142                     2 -> z EQ
1143                     3 -> z GT
1144                     _ -> error "gunfold"
1145   dataTypeOf _ = orderingDataType
1146
1147
1148 ------------------------------------------------------------------------------
1149
1150 leftConstr :: Constr
1151 leftConstr     = mkConstr eitherDataType "Left"  [] Prefix
1152
1153 rightConstr :: Constr
1154 rightConstr    = mkConstr eitherDataType "Right" [] Prefix
1155
1156 eitherDataType :: DataType
1157 eitherDataType = mkDataType "Prelude.Either" [leftConstr,rightConstr]
1158
1159 instance (Data a, Data b) => Data (Either a b) where
1160   gfoldl f z (Left a)   = z Left  `f` a
1161   gfoldl f z (Right a)  = z Right `f` a
1162   toConstr (Left _)  = leftConstr
1163   toConstr (Right _) = rightConstr
1164   gunfold k z c = case constrIndex c of
1165                     1 -> k (z Left)
1166                     2 -> k (z Right)
1167                     _ -> error "gunfold"
1168   dataTypeOf _ = eitherDataType
1169   dataCast2 f  = gcast2 f
1170
1171
1172 ------------------------------------------------------------------------------
1173
1174 tuple0Constr :: Constr
1175 tuple0Constr = mkConstr tuple0DataType "()" [] Prefix
1176
1177 tuple0DataType :: DataType
1178 tuple0DataType = mkDataType "Prelude.()" [tuple0Constr]
1179
1180 instance Data () where
1181   toConstr ()   = tuple0Constr
1182   gunfold _ z c | constrIndex c == 1 = z ()
1183   gunfold _ _ _ = error "gunfold"
1184   dataTypeOf _  = tuple0DataType
1185
1186
1187 ------------------------------------------------------------------------------
1188
1189 tuple2Constr :: Constr
1190 tuple2Constr = mkConstr tuple2DataType "(,)" [] Infix
1191
1192 tuple2DataType :: DataType
1193 tuple2DataType = mkDataType "Prelude.(,)" [tuple2Constr]
1194
1195 instance (Data a, Data b) => Data (a,b) where
1196   gfoldl f z (a,b) = z (,) `f` a `f` b
1197   toConstr (_,_) = tuple2Constr
1198   gunfold k z c | constrIndex c == 1 = k (k (z (,)))
1199   gunfold _ _ _ = error "gunfold"
1200   dataTypeOf _  = tuple2DataType
1201   dataCast2 f   = gcast2 f
1202
1203
1204 ------------------------------------------------------------------------------
1205
1206 tuple3Constr :: Constr
1207 tuple3Constr = mkConstr tuple3DataType "(,,)" [] Infix
1208
1209 tuple3DataType :: DataType
1210 tuple3DataType = mkDataType "Prelude.(,,)" [tuple3Constr]
1211
1212 instance (Data a, Data b, Data c) => Data (a,b,c) where
1213   gfoldl f z (a,b,c) = z (,,) `f` a `f` b `f` c
1214   toConstr (_,_,_) = tuple3Constr
1215   gunfold k z c | constrIndex c == 1 = k (k (k (z (,,))))
1216   gunfold _ _ _ = error "gunfold"
1217   dataTypeOf _  = tuple3DataType
1218
1219
1220 ------------------------------------------------------------------------------
1221
1222 tuple4Constr :: Constr
1223 tuple4Constr = mkConstr tuple4DataType "(,,,)" [] Infix
1224
1225 tuple4DataType :: DataType
1226 tuple4DataType = mkDataType "Prelude.(,,,)" [tuple4Constr]
1227
1228 instance (Data a, Data b, Data c, Data d)
1229          => Data (a,b,c,d) where
1230   gfoldl f z (a,b,c,d) = z (,,,) `f` a `f` b `f` c `f` d
1231   toConstr (_,_,_,_) = tuple4Constr
1232   gunfold k z c = case constrIndex c of
1233                     1 -> k (k (k (k (z (,,,)))))
1234                     _ -> error "gunfold"
1235   dataTypeOf _ = tuple4DataType
1236
1237
1238 ------------------------------------------------------------------------------
1239
1240 tuple5Constr :: Constr
1241 tuple5Constr = mkConstr tuple5DataType "(,,,,)" [] Infix
1242
1243 tuple5DataType :: DataType
1244 tuple5DataType = mkDataType "Prelude.(,,,,)" [tuple5Constr]
1245
1246 instance (Data a, Data b, Data c, Data d, Data e)
1247          => Data (a,b,c,d,e) where
1248   gfoldl f z (a,b,c,d,e) = z (,,,,) `f` a `f` b `f` c `f` d `f` e
1249   toConstr (_,_,_,_,_) = tuple5Constr
1250   gunfold k z c = case constrIndex c of
1251                     1 -> k (k (k (k (k (z (,,,,))))))
1252                     _ -> error "gunfold"
1253   dataTypeOf _ = tuple5DataType
1254
1255
1256 ------------------------------------------------------------------------------
1257
1258 tuple6Constr :: Constr
1259 tuple6Constr = mkConstr tuple6DataType "(,,,,,)" [] Infix
1260
1261 tuple6DataType :: DataType
1262 tuple6DataType = mkDataType "Prelude.(,,,,,)" [tuple6Constr]
1263
1264 instance (Data a, Data b, Data c, Data d, Data e, Data f)
1265          => Data (a,b,c,d,e,f) where
1266   gfoldl f z (a,b,c,d,e,f') = z (,,,,,) `f` a `f` b `f` c `f` d `f` e `f` f'
1267   toConstr (_,_,_,_,_,_) = tuple6Constr
1268   gunfold k z c = case constrIndex c of
1269                     1 -> k (k (k (k (k (k (z (,,,,,)))))))
1270                     _ -> error "gunfold"
1271   dataTypeOf _ = tuple6DataType
1272
1273
1274 ------------------------------------------------------------------------------
1275
1276 tuple7Constr :: Constr
1277 tuple7Constr = mkConstr tuple7DataType "(,,,,,,)" [] Infix
1278
1279 tuple7DataType :: DataType
1280 tuple7DataType = mkDataType "Prelude.(,,,,,,)" [tuple7Constr]
1281
1282 instance (Data a, Data b, Data c, Data d, Data e, Data f, Data g)
1283          => Data (a,b,c,d,e,f,g) where
1284   gfoldl f z (a,b,c,d,e,f',g) =
1285     z (,,,,,,) `f` a `f` b `f` c `f` d `f` e `f` f' `f` g
1286   toConstr  (_,_,_,_,_,_,_) = tuple7Constr
1287   gunfold k z c = case constrIndex c of
1288                     1 -> k (k (k (k (k (k (k (z (,,,,,,))))))))
1289                     _ -> error "gunfold"
1290   dataTypeOf _ = tuple7DataType
1291
1292
1293 ------------------------------------------------------------------------------
1294
1295 instance Typeable a => Data (Ptr a) where
1296   toConstr _   = error "toConstr"
1297   gunfold _ _  = error "gunfold"
1298   dataTypeOf _ = mkNoRepType "GHC.Ptr.Ptr"
1299
1300
1301 ------------------------------------------------------------------------------
1302
1303 instance Typeable a => Data (ForeignPtr a) where
1304   toConstr _   = error "toConstr"
1305   gunfold _ _  = error "gunfold"
1306   dataTypeOf _ = mkNoRepType "GHC.ForeignPtr.ForeignPtr"
1307
1308
1309 ------------------------------------------------------------------------------
1310 -- The Data instance for Array preserves data abstraction at the cost of
1311 -- inefficiency. We omit reflection services for the sake of data abstraction.
1312 instance (Typeable a, Data b, Ix a) => Data (Array a b)
1313  where
1314   gfoldl f z a = z (listArray (bounds a)) `f` (elems a)
1315   toConstr _   = error "toConstr"
1316   gunfold _ _  = error "gunfold"
1317   dataTypeOf _ = mkNoRepType "Data.Array.Array"
1318