--
-- The default definition for 'gfoldl' is @'const' 'id'@, which is
-- suitable for abstract datatypes with no substructures.
- gfoldl :: (forall a b. Data a => c (a -> b) -> a -> c b)
+ gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-- ^ defines how nonempty constructor applications are
-- folded. It takes the folded tail of the constructor
-- application and its head, i.e., an immediate subterm,
-- The default definition is @'const' 'Nothing'@, which is appropriate
-- for non-unary type constructors.
dataCast1 :: Typeable1 t
- => (forall a. Data a => c (t a))
+ => (forall d. Data d => c (t d))
-> Maybe (c a)
dataCast1 _ = Nothing
-- The default definition is @'const' 'Nothing'@, which is appropriate
-- for non-binary type constructors.
dataCast2 :: Typeable2 t
- => (forall a b. (Data a, Data b) => c (t a b))
+ => (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c a)
dataCast2 _ = Nothing
-- to instantiate the type constructor c in the type of gfoldl,
-- and perform injections ID and projections unID accordingly.
--
- gmapT f x = unID (gfoldl k ID x)
+ gmapT f x0 = unID (gfoldl k ID x0)
where
k (ID c) x = ID (c (f x))
-- | A generic query with a left-associative binary operator
- gmapQl :: (r -> r' -> r) -> r -> (forall a. Data a => a -> r') -> a -> r
+ gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
gmapQl o r f = unCONST . gfoldl k z
where
k c x = CONST $ (unCONST c) `o` f x
z _ = CONST r
-- | A generic query with a right-associative binary operator
- gmapQr :: (r' -> r -> r) -> r -> (forall a. Data a => a -> r') -> a -> r
- gmapQr o r f x = unQr (gfoldl k (const (Qr id)) x) r
+ gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
+ gmapQr o r0 f x0 = unQr (gfoldl k (const (Qr id)) x0) r0
where
k (Qr c) x = Qr (\r -> c (f x `o` r))
-- | A generic query that processes the immediate subterms and returns a list
-- of results. The list is given in the same order as originally specified
-- in the declaratoin of the data constructors.
- gmapQ :: (forall a. Data a => a -> u) -> a -> [u]
+ gmapQ :: (forall d. Data d => d -> u) -> a -> [u]
gmapQ f = gmapQr (:) [] f
-- | A generic query that processes one child by index (zero-based)
- gmapQi :: Int -> (forall a. Data a => a -> u) -> a -> u
+ gmapQi :: Int -> (forall d. Data d => d -> u) -> a -> u
gmapQi i f x = case gfoldl k z x of { Qi _ q -> fromJust q }
where
k (Qi i' q) a = Qi (i'+1) (if i==i' then Just (f a) else q)
- z f = Qi 0 Nothing
+ z _ = Qi 0 Nothing
-- | A generic monadic transformation that maps over the immediate subterms
-- The default definition instantiates the type constructor @c@ in
-- the type of 'gfoldl' to the monad datatype constructor, defining
-- injection and projection using 'return' and '>>='.
- gmapM :: Monad m => (forall a. Data a => a -> m a) -> a -> m a
+ gmapM :: Monad m => (forall d. Data d => d -> m d) -> a -> m a
-- Use immediately the monad datatype constructor
-- to instantiate the type constructor c in the type of gfoldl,
-- | Transformation of at least one immediate subterm does not fail
- gmapMp :: MonadPlus m => (forall a. Data a => a -> m a) -> a -> m a
+ gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
{-
if b then return x' else mzero
where
z g = Mp (return (g,False))
- k (Mp c) x
- = Mp ( c >>= \(h,b) ->
- (f x >>= \x' -> return (h x',True))
- `mplus` return (h x,b)
+ k (Mp c) y
+ = Mp ( c >>= \(h, b) ->
+ (f y >>= \y' -> return (h y', True))
+ `mplus` return (h y, b)
)
-- | Transformation of one immediate subterm with success
- gmapMo :: MonadPlus m => (forall a. Data a => a -> m a) -> a -> m a
+ gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a
{-
if b then return x' else mzero
where
z g = Mp (return (g,False))
- k (Mp c) x
+ k (Mp c) y
= Mp ( c >>= \(h,b) -> if b
- then return (h x,b)
- else (f x >>= \x' -> return (h x',True))
- `mplus` return (h x,b)
+ then return (h y, b)
+ else (f y >>= \y' -> return (h y',True))
+ `mplus` return (h y, b)
)
-- | Build a term and use a generic function for subterms
fromConstrB :: Data a
- => (forall a. Data a => a)
+ => (forall d. Data d => d)
-> Constr
-> a
fromConstrB f = unID . gunfold k z
-- | Monadic variation on 'fromConstrB'
fromConstrM :: (Monad m, Data a)
- => (forall a. Data a => m a)
+ => (forall d. Data d => m d)
-> Constr
-> m a
fromConstrM f = gunfold k z
then b
else a ++ tyconModule' (tail b)
where
- tyconModule' x = let x' = tyconModule x
- in if x' == "" then "" else ('.':x')
+ tyconModule' y = let y' = tyconModule y
+ in if y' == "" then "" else ('.':y')
--
-----------------------------------------------------------------------------
+{-# OPTIONS_GHC -fno-warn-orphans #-}
module Data.Generics.Instances where
------------------------------------------------------------------------------
+falseConstr :: Constr
falseConstr = mkConstr boolDataType "False" [] Prefix
+trueConstr :: Constr
trueConstr = mkConstr boolDataType "True" [] Prefix
-boolDataType = mkDataType "Prelude.Bool" [falseConstr,trueConstr]
+boolDataType :: DataType
+boolDataType = mkDataType "Prelude.Bool" [falseConstr,trueConstr]
instance Data Bool where
toConstr False = falseConstr
toConstr True = trueConstr
- gunfold k z c = case constrIndex c of
+ gunfold _ z c = case constrIndex c of
1 -> z False
2 -> z True
_ -> error "gunfold"
------------------------------------------------------------------------------
-
+charType :: DataType
charType = mkStringType "Prelude.Char"
instance Data Char where
toConstr x = mkStringConstr charType [x]
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(StringConstr [x]) -> z x
_ -> error "gunfold"
dataTypeOf _ = charType
------------------------------------------------------------------------------
-
+floatType :: DataType
floatType = mkFloatType "Prelude.Float"
instance Data Float where
toConstr x = mkFloatConstr floatType (realToFrac x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(FloatConstr x) -> z (realToFrac x)
_ -> error "gunfold"
dataTypeOf _ = floatType
------------------------------------------------------------------------------
-
+doubleType :: DataType
doubleType = mkFloatType "Prelude.Double"
instance Data Double where
toConstr = mkFloatConstr floatType
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(FloatConstr x) -> z x
_ -> error "gunfold"
dataTypeOf _ = doubleType
------------------------------------------------------------------------------
-
+intType :: DataType
intType = mkIntType "Prelude.Int"
instance Data Int where
toConstr x = mkIntConstr intType (fromIntegral x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z (fromIntegral x)
_ -> error "gunfold"
dataTypeOf _ = intType
------------------------------------------------------------------------------
-
+integerType :: DataType
integerType = mkIntType "Prelude.Integer"
instance Data Integer where
toConstr = mkIntConstr integerType
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z x
_ -> error "gunfold"
dataTypeOf _ = integerType
------------------------------------------------------------------------------
-
+int8Type :: DataType
int8Type = mkIntType "Data.Int.Int8"
instance Data Int8 where
toConstr x = mkIntConstr int8Type (fromIntegral x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z (fromIntegral x)
_ -> error "gunfold"
dataTypeOf _ = int8Type
------------------------------------------------------------------------------
-
+int16Type :: DataType
int16Type = mkIntType "Data.Int.Int16"
instance Data Int16 where
toConstr x = mkIntConstr int16Type (fromIntegral x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z (fromIntegral x)
_ -> error "gunfold"
dataTypeOf _ = int16Type
------------------------------------------------------------------------------
-
+int32Type :: DataType
int32Type = mkIntType "Data.Int.Int32"
instance Data Int32 where
toConstr x = mkIntConstr int32Type (fromIntegral x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z (fromIntegral x)
_ -> error "gunfold"
dataTypeOf _ = int32Type
------------------------------------------------------------------------------
-
+int64Type :: DataType
int64Type = mkIntType "Data.Int.Int64"
instance Data Int64 where
toConstr x = mkIntConstr int64Type (fromIntegral x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z (fromIntegral x)
_ -> error "gunfold"
dataTypeOf _ = int64Type
------------------------------------------------------------------------------
-
+wordType :: DataType
wordType = mkIntType "Data.Word.Word"
instance Data Word where
toConstr x = mkIntConstr wordType (fromIntegral x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z (fromIntegral x)
_ -> error "gunfold"
dataTypeOf _ = wordType
------------------------------------------------------------------------------
-
+word8Type :: DataType
word8Type = mkIntType "Data.Word.Word8"
instance Data Word8 where
toConstr x = mkIntConstr word8Type (fromIntegral x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z (fromIntegral x)
_ -> error "gunfold"
dataTypeOf _ = word8Type
------------------------------------------------------------------------------
-
+word16Type :: DataType
word16Type = mkIntType "Data.Word.Word16"
instance Data Word16 where
toConstr x = mkIntConstr word16Type (fromIntegral x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z (fromIntegral x)
_ -> error "gunfold"
dataTypeOf _ = word16Type
------------------------------------------------------------------------------
-
+word32Type :: DataType
word32Type = mkIntType "Data.Word.Word32"
instance Data Word32 where
toConstr x = mkIntConstr word32Type (fromIntegral x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z (fromIntegral x)
_ -> error "gunfold"
dataTypeOf _ = word32Type
------------------------------------------------------------------------------
-
+word64Type :: DataType
word64Type = mkIntType "Data.Word.Word64"
instance Data Word64 where
toConstr x = mkIntConstr word64Type (fromIntegral x)
- gunfold k z c = case constrRep c of
+ gunfold _ z c = case constrRep c of
(IntConstr x) -> z (fromIntegral x)
_ -> error "gunfold"
dataTypeOf _ = word64Type
------------------------------------------------------------------------------
-
+ratioConstr :: Constr
ratioConstr = mkConstr ratioDataType ":%" [] Infix
+
+ratioDataType :: DataType
ratioDataType = mkDataType "GHC.Real.Ratio" [ratioConstr]
instance (Data a, Integral a) => Data (Ratio a) where
------------------------------------------------------------------------------
-
+nilConstr :: Constr
nilConstr = mkConstr listDataType "[]" [] Prefix
+consConstr :: Constr
consConstr = mkConstr listDataType "(:)" [] Infix
+
+listDataType :: DataType
listDataType = mkDataType "Prelude.[]" [nilConstr,consConstr]
instance Data a => Data [a] where
- gfoldl f z [] = z []
+ gfoldl _ z [] = z []
gfoldl f z (x:xs) = z (:) `f` x `f` xs
toConstr [] = nilConstr
toConstr (_:_) = consConstr
-- The gmaps are given as an illustration.
-- This shows that the gmaps for lists are different from list maps.
--
- gmapT f [] = []
+ gmapT _ [] = []
gmapT f (x:xs) = (f x:f xs)
- gmapQ f [] = []
+ gmapQ _ [] = []
gmapQ f (x:xs) = [f x,f xs]
- gmapM f [] = return []
+ gmapM _ [] = return []
gmapM f (x:xs) = f x >>= \x' -> f xs >>= \xs' -> return (x':xs')
------------------------------------------------------------------------------
-
+nothingConstr :: Constr
nothingConstr = mkConstr maybeDataType "Nothing" [] Prefix
+justConstr :: Constr
justConstr = mkConstr maybeDataType "Just" [] Prefix
+
+maybeDataType :: DataType
maybeDataType = mkDataType "Prelude.Maybe" [nothingConstr,justConstr]
instance Data a => Data (Maybe a) where
- gfoldl f z Nothing = z Nothing
+ gfoldl _ z Nothing = z Nothing
gfoldl f z (Just x) = z Just `f` x
toConstr Nothing = nothingConstr
toConstr (Just _) = justConstr
------------------------------------------------------------------------------
-
+ltConstr :: Constr
ltConstr = mkConstr orderingDataType "LT" [] Prefix
+eqConstr :: Constr
eqConstr = mkConstr orderingDataType "EQ" [] Prefix
+gtConstr :: Constr
gtConstr = mkConstr orderingDataType "GT" [] Prefix
+
+orderingDataType :: DataType
orderingDataType = mkDataType "Prelude.Ordering" [ltConstr,eqConstr,gtConstr]
instance Data Ordering where
- gfoldl f z LT = z LT
- gfoldl f z EQ = z EQ
- gfoldl f z GT = z GT
+ gfoldl _ z LT = z LT
+ gfoldl _ z EQ = z EQ
+ gfoldl _ z GT = z GT
toConstr LT = ltConstr
toConstr EQ = eqConstr
toConstr GT = gtConstr
- gunfold k z c = case constrIndex c of
+ gunfold _ z c = case constrIndex c of
1 -> z LT
2 -> z EQ
3 -> z GT
------------------------------------------------------------------------------
-
+leftConstr :: Constr
leftConstr = mkConstr eitherDataType "Left" [] Prefix
+
+rightConstr :: Constr
rightConstr = mkConstr eitherDataType "Right" [] Prefix
+
+eitherDataType :: DataType
eitherDataType = mkDataType "Prelude.Either" [leftConstr,rightConstr]
instance (Data a, Data b) => Data (Either a b) where
------------------------------------------------------------------------------
-
+tuple0Constr :: Constr
tuple0Constr = mkConstr tuple0DataType "()" [] Prefix
+
+tuple0DataType :: DataType
tuple0DataType = mkDataType "Prelude.()" [tuple0Constr]
instance Data () where
toConstr () = tuple0Constr
- gunfold k z c | constrIndex c == 1 = z ()
+ gunfold _ z c | constrIndex c == 1 = z ()
gunfold _ _ _ = error "gunfold"
dataTypeOf _ = tuple0DataType
------------------------------------------------------------------------------
-
+tuple2Constr :: Constr
tuple2Constr = mkConstr tuple2DataType "(,)" [] Infix
+
+tuple2DataType :: DataType
tuple2DataType = mkDataType "Prelude.(,)" [tuple2Constr]
instance (Data a, Data b) => Data (a,b) where
gfoldl f z (a,b) = z (,) `f` a `f` b
- toConstr (a,b) = tuple2Constr
+ toConstr (_,_) = tuple2Constr
gunfold k z c | constrIndex c == 1 = k (k (z (,)))
gunfold _ _ _ = error "gunfold"
dataTypeOf _ = tuple2DataType
------------------------------------------------------------------------------
-
+tuple3Constr :: Constr
tuple3Constr = mkConstr tuple3DataType "(,,)" [] Infix
+
+tuple3DataType :: DataType
tuple3DataType = mkDataType "Prelude.(,)" [tuple3Constr]
instance (Data a, Data b, Data c) => Data (a,b,c) where
gfoldl f z (a,b,c) = z (,,) `f` a `f` b `f` c
- toConstr (a,b,c) = tuple3Constr
+ toConstr (_,_,_) = tuple3Constr
gunfold k z c | constrIndex c == 1 = k (k (k (z (,,))))
gunfold _ _ _ = error "gunfold"
dataTypeOf _ = tuple3DataType
------------------------------------------------------------------------------
-
+tuple4Constr :: Constr
tuple4Constr = mkConstr tuple4DataType "(,,,)" [] Infix
+
+tuple4DataType :: DataType
tuple4DataType = mkDataType "Prelude.(,,,)" [tuple4Constr]
instance (Data a, Data b, Data c, Data d)
=> Data (a,b,c,d) where
gfoldl f z (a,b,c,d) = z (,,,) `f` a `f` b `f` c `f` d
- toConstr (a,b,c,d) = tuple4Constr
+ toConstr (_,_,_,_) = tuple4Constr
gunfold k z c = case constrIndex c of
1 -> k (k (k (k (z (,,,)))))
_ -> error "gunfold"
------------------------------------------------------------------------------
-
+tuple5Constr :: Constr
tuple5Constr = mkConstr tuple5DataType "(,,,,)" [] Infix
+
+tuple5DataType :: DataType
tuple5DataType = mkDataType "Prelude.(,,,,)" [tuple5Constr]
instance (Data a, Data b, Data c, Data d, Data e)
=> Data (a,b,c,d,e) where
gfoldl f z (a,b,c,d,e) = z (,,,,) `f` a `f` b `f` c `f` d `f` e
- toConstr (a,b,c,d,e) = tuple5Constr
+ toConstr (_,_,_,_,_) = tuple5Constr
gunfold k z c = case constrIndex c of
1 -> k (k (k (k (k (z (,,,,))))))
_ -> error "gunfold"
------------------------------------------------------------------------------
-
+tuple6Constr :: Constr
tuple6Constr = mkConstr tuple6DataType "(,,,,,)" [] Infix
+
+tuple6DataType :: DataType
tuple6DataType = mkDataType "Prelude.(,,,,,)" [tuple6Constr]
instance (Data a, Data b, Data c, Data d, Data e, Data f)
=> Data (a,b,c,d,e,f) where
gfoldl f z (a,b,c,d,e,f') = z (,,,,,) `f` a `f` b `f` c `f` d `f` e `f` f'
- toConstr (a,b,c,d,e,f) = tuple6Constr
+ toConstr (_,_,_,_,_,_) = tuple6Constr
gunfold k z c = case constrIndex c of
1 -> k (k (k (k (k (k (z (,,,,,)))))))
_ -> error "gunfold"
------------------------------------------------------------------------------
-
+tuple7Constr :: Constr
tuple7Constr = mkConstr tuple7DataType "(,,,,,,)" [] Infix
+
+tuple7DataType :: DataType
tuple7DataType = mkDataType "Prelude.(,,,,,,)" [tuple7Constr]
instance (Data a, Data b, Data c, Data d, Data e, Data f, Data g)
=> Data (a,b,c,d,e,f,g) where
gfoldl f z (a,b,c,d,e,f',g) =
z (,,,,,,) `f` a `f` b `f` c `f` d `f` e `f` f' `f` g
- toConstr (a,b,c,d,e,f,g) = tuple7Constr
+ toConstr (_,_,_,_,_,_,_) = tuple7Constr
gunfold k z c = case constrIndex c of
1 -> k (k (k (k (k (k (k (z (,,,,,,))))))))
_ -> error "gunfold"