{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
module Language.Java.Syntax.Types where

import Data.Data
import GHC.Generics (Generic)

-- | There are two kinds of types in the Java programming language: primitive types and reference types.
data Type
    = PrimType PrimType
    | RefType RefType
  deriving (Type -> Type -> Bool
(Type -> Type -> Bool) -> (Type -> Type -> Bool) -> Eq Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Type -> Type -> Bool
$c/= :: Type -> Type -> Bool
== :: Type -> Type -> Bool
$c== :: Type -> Type -> Bool
Eq,Int -> Type -> ShowS
[Type] -> ShowS
Type -> String
(Int -> Type -> ShowS)
-> (Type -> String) -> ([Type] -> ShowS) -> Show Type
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Type] -> ShowS
$cshowList :: [Type] -> ShowS
show :: Type -> String
$cshow :: Type -> String
showsPrec :: Int -> Type -> ShowS
$cshowsPrec :: Int -> Type -> ShowS
Show,ReadPrec [Type]
ReadPrec Type
Int -> ReadS Type
ReadS [Type]
(Int -> ReadS Type)
-> ReadS [Type] -> ReadPrec Type -> ReadPrec [Type] -> Read Type
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Type]
$creadListPrec :: ReadPrec [Type]
readPrec :: ReadPrec Type
$creadPrec :: ReadPrec Type
readList :: ReadS [Type]
$creadList :: ReadS [Type]
readsPrec :: Int -> ReadS Type
$creadsPrec :: Int -> ReadS Type
Read,Typeable,(forall x. Type -> Rep Type x)
-> (forall x. Rep Type x -> Type) -> Generic Type
forall x. Rep Type x -> Type
forall x. Type -> Rep Type x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Type x -> Type
$cfrom :: forall x. Type -> Rep Type x
Generic,Typeable Type
Constr
DataType
Typeable Type
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Type -> c Type)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Type)
-> (Type -> Constr)
-> (Type -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Type))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type))
-> ((forall b. Data b => b -> b) -> Type -> Type)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r)
-> (forall u. (forall d. Data d => d -> u) -> Type -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Type -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Type -> m Type)
-> Data Type
Type -> Constr
Type -> DataType
(forall b. Data b => b -> b) -> Type -> Type
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Type -> u
forall u. (forall d. Data d => d -> u) -> Type -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cRefType :: Constr
$cPrimType :: Constr
$tType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapMp :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapM :: (forall d. Data d => d -> m d) -> Type -> m Type
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Type -> m Type
gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Type -> u
gmapQ :: (forall d. Data d => d -> u) -> Type -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Type -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r
gmapT :: (forall b. Data b => b -> b) -> Type -> Type
$cgmapT :: (forall b. Data b => b -> b) -> Type -> Type
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Type)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Type)
dataTypeOf :: Type -> DataType
$cdataTypeOf :: Type -> DataType
toConstr :: Type -> Constr
$ctoConstr :: Type -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Type
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Type -> c Type
$cp1Data :: Typeable Type
Data)

-- | There are three kinds of reference types: class types, interface types, and array types.
--   Reference types may be parameterized with type arguments.
--   Type variables cannot be syntactically distinguished from class type identifiers,
--   and are thus represented uniformly as single ident class types.
data RefType
    = ClassRefType ClassType
    {- | TypeVariable Ident -}
    | ArrayType Type
  deriving (RefType -> RefType -> Bool
(RefType -> RefType -> Bool)
-> (RefType -> RefType -> Bool) -> Eq RefType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RefType -> RefType -> Bool
$c/= :: RefType -> RefType -> Bool
== :: RefType -> RefType -> Bool
$c== :: RefType -> RefType -> Bool
Eq,Int -> RefType -> ShowS
[RefType] -> ShowS
RefType -> String
(Int -> RefType -> ShowS)
-> (RefType -> String) -> ([RefType] -> ShowS) -> Show RefType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RefType] -> ShowS
$cshowList :: [RefType] -> ShowS
show :: RefType -> String
$cshow :: RefType -> String
showsPrec :: Int -> RefType -> ShowS
$cshowsPrec :: Int -> RefType -> ShowS
Show,ReadPrec [RefType]
ReadPrec RefType
Int -> ReadS RefType
ReadS [RefType]
(Int -> ReadS RefType)
-> ReadS [RefType]
-> ReadPrec RefType
-> ReadPrec [RefType]
-> Read RefType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RefType]
$creadListPrec :: ReadPrec [RefType]
readPrec :: ReadPrec RefType
$creadPrec :: ReadPrec RefType
readList :: ReadS [RefType]
$creadList :: ReadS [RefType]
readsPrec :: Int -> ReadS RefType
$creadsPrec :: Int -> ReadS RefType
Read,Typeable,(forall x. RefType -> Rep RefType x)
-> (forall x. Rep RefType x -> RefType) -> Generic RefType
forall x. Rep RefType x -> RefType
forall x. RefType -> Rep RefType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RefType x -> RefType
$cfrom :: forall x. RefType -> Rep RefType x
Generic,Typeable RefType
Constr
DataType
Typeable RefType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> RefType -> c RefType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RefType)
-> (RefType -> Constr)
-> (RefType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RefType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RefType))
-> ((forall b. Data b => b -> b) -> RefType -> RefType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RefType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RefType -> r)
-> (forall u. (forall d. Data d => d -> u) -> RefType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> RefType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> RefType -> m RefType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RefType -> m RefType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> RefType -> m RefType)
-> Data RefType
RefType -> Constr
RefType -> DataType
(forall b. Data b => b -> b) -> RefType -> RefType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RefType -> c RefType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RefType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> RefType -> u
forall u. (forall d. Data d => d -> u) -> RefType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RefType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RefType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RefType -> m RefType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RefType -> m RefType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RefType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RefType -> c RefType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RefType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RefType)
$cArrayType :: Constr
$cClassRefType :: Constr
$tRefType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> RefType -> m RefType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RefType -> m RefType
gmapMp :: (forall d. Data d => d -> m d) -> RefType -> m RefType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> RefType -> m RefType
gmapM :: (forall d. Data d => d -> m d) -> RefType -> m RefType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> RefType -> m RefType
gmapQi :: Int -> (forall d. Data d => d -> u) -> RefType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> RefType -> u
gmapQ :: (forall d. Data d => d -> u) -> RefType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RefType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RefType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RefType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RefType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RefType -> r
gmapT :: (forall b. Data b => b -> b) -> RefType -> RefType
$cgmapT :: (forall b. Data b => b -> b) -> RefType -> RefType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RefType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RefType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c RefType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RefType)
dataTypeOf :: RefType -> DataType
$cdataTypeOf :: RefType -> DataType
toConstr :: RefType -> Constr
$ctoConstr :: RefType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RefType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RefType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RefType -> c RefType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RefType -> c RefType
$cp1Data :: Typeable RefType
Data)

-- | A class or interface type consists of a type declaration specifier,
--   optionally followed by type arguments (in which case it is a parameterized type).
data ClassType
    = ClassType [(Ident, [TypeArgument])]
  deriving (ClassType -> ClassType -> Bool
(ClassType -> ClassType -> Bool)
-> (ClassType -> ClassType -> Bool) -> Eq ClassType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClassType -> ClassType -> Bool
$c/= :: ClassType -> ClassType -> Bool
== :: ClassType -> ClassType -> Bool
$c== :: ClassType -> ClassType -> Bool
Eq,Int -> ClassType -> ShowS
[ClassType] -> ShowS
ClassType -> String
(Int -> ClassType -> ShowS)
-> (ClassType -> String)
-> ([ClassType] -> ShowS)
-> Show ClassType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClassType] -> ShowS
$cshowList :: [ClassType] -> ShowS
show :: ClassType -> String
$cshow :: ClassType -> String
showsPrec :: Int -> ClassType -> ShowS
$cshowsPrec :: Int -> ClassType -> ShowS
Show,ReadPrec [ClassType]
ReadPrec ClassType
Int -> ReadS ClassType
ReadS [ClassType]
(Int -> ReadS ClassType)
-> ReadS [ClassType]
-> ReadPrec ClassType
-> ReadPrec [ClassType]
-> Read ClassType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ClassType]
$creadListPrec :: ReadPrec [ClassType]
readPrec :: ReadPrec ClassType
$creadPrec :: ReadPrec ClassType
readList :: ReadS [ClassType]
$creadList :: ReadS [ClassType]
readsPrec :: Int -> ReadS ClassType
$creadsPrec :: Int -> ReadS ClassType
Read,Typeable,(forall x. ClassType -> Rep ClassType x)
-> (forall x. Rep ClassType x -> ClassType) -> Generic ClassType
forall x. Rep ClassType x -> ClassType
forall x. ClassType -> Rep ClassType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ClassType x -> ClassType
$cfrom :: forall x. ClassType -> Rep ClassType x
Generic,Typeable ClassType
Constr
DataType
Typeable ClassType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ClassType -> c ClassType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ClassType)
-> (ClassType -> Constr)
-> (ClassType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ClassType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassType))
-> ((forall b. Data b => b -> b) -> ClassType -> ClassType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ClassType -> r)
-> (forall u. (forall d. Data d => d -> u) -> ClassType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ClassType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ClassType -> m ClassType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassType -> m ClassType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ClassType -> m ClassType)
-> Data ClassType
ClassType -> Constr
ClassType -> DataType
(forall b. Data b => b -> b) -> ClassType -> ClassType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassType -> c ClassType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ClassType -> u
forall u. (forall d. Data d => d -> u) -> ClassType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassType -> m ClassType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassType -> m ClassType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassType -> c ClassType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassType)
$cClassType :: Constr
$tClassType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ClassType -> m ClassType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassType -> m ClassType
gmapMp :: (forall d. Data d => d -> m d) -> ClassType -> m ClassType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassType -> m ClassType
gmapM :: (forall d. Data d => d -> m d) -> ClassType -> m ClassType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassType -> m ClassType
gmapQi :: Int -> (forall d. Data d => d -> u) -> ClassType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassType -> u
gmapQ :: (forall d. Data d => d -> u) -> ClassType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ClassType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassType -> r
gmapT :: (forall b. Data b => b -> b) -> ClassType -> ClassType
$cgmapT :: (forall b. Data b => b -> b) -> ClassType -> ClassType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ClassType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassType)
dataTypeOf :: ClassType -> DataType
$cdataTypeOf :: ClassType -> DataType
toConstr :: ClassType -> Constr
$ctoConstr :: ClassType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassType -> c ClassType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassType -> c ClassType
$cp1Data :: Typeable ClassType
Data)

-- | Type arguments may be either reference types or wildcards.
data TypeArgument
    = Wildcard (Maybe WildcardBound)
    | ActualType RefType
  deriving (TypeArgument -> TypeArgument -> Bool
(TypeArgument -> TypeArgument -> Bool)
-> (TypeArgument -> TypeArgument -> Bool) -> Eq TypeArgument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeArgument -> TypeArgument -> Bool
$c/= :: TypeArgument -> TypeArgument -> Bool
== :: TypeArgument -> TypeArgument -> Bool
$c== :: TypeArgument -> TypeArgument -> Bool
Eq,Int -> TypeArgument -> ShowS
[TypeArgument] -> ShowS
TypeArgument -> String
(Int -> TypeArgument -> ShowS)
-> (TypeArgument -> String)
-> ([TypeArgument] -> ShowS)
-> Show TypeArgument
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeArgument] -> ShowS
$cshowList :: [TypeArgument] -> ShowS
show :: TypeArgument -> String
$cshow :: TypeArgument -> String
showsPrec :: Int -> TypeArgument -> ShowS
$cshowsPrec :: Int -> TypeArgument -> ShowS
Show,ReadPrec [TypeArgument]
ReadPrec TypeArgument
Int -> ReadS TypeArgument
ReadS [TypeArgument]
(Int -> ReadS TypeArgument)
-> ReadS [TypeArgument]
-> ReadPrec TypeArgument
-> ReadPrec [TypeArgument]
-> Read TypeArgument
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TypeArgument]
$creadListPrec :: ReadPrec [TypeArgument]
readPrec :: ReadPrec TypeArgument
$creadPrec :: ReadPrec TypeArgument
readList :: ReadS [TypeArgument]
$creadList :: ReadS [TypeArgument]
readsPrec :: Int -> ReadS TypeArgument
$creadsPrec :: Int -> ReadS TypeArgument
Read,Typeable,(forall x. TypeArgument -> Rep TypeArgument x)
-> (forall x. Rep TypeArgument x -> TypeArgument)
-> Generic TypeArgument
forall x. Rep TypeArgument x -> TypeArgument
forall x. TypeArgument -> Rep TypeArgument x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TypeArgument x -> TypeArgument
$cfrom :: forall x. TypeArgument -> Rep TypeArgument x
Generic,Typeable TypeArgument
Constr
DataType
Typeable TypeArgument
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeArgument -> c TypeArgument)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeArgument)
-> (TypeArgument -> Constr)
-> (TypeArgument -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeArgument))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypeArgument))
-> ((forall b. Data b => b -> b) -> TypeArgument -> TypeArgument)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeArgument -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeArgument -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeArgument -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypeArgument -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument)
-> Data TypeArgument
TypeArgument -> Constr
TypeArgument -> DataType
(forall b. Data b => b -> b) -> TypeArgument -> TypeArgument
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeArgument -> c TypeArgument
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeArgument
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TypeArgument -> u
forall u. (forall d. Data d => d -> u) -> TypeArgument -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeArgument -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeArgument -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeArgument
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeArgument -> c TypeArgument
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeArgument)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeArgument)
$cActualType :: Constr
$cWildcard :: Constr
$tTypeArgument :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument
gmapMp :: (forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument
gmapM :: (forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeArgument -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeArgument -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeArgument -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeArgument -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeArgument -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeArgument -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeArgument -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeArgument -> r
gmapT :: (forall b. Data b => b -> b) -> TypeArgument -> TypeArgument
$cgmapT :: (forall b. Data b => b -> b) -> TypeArgument -> TypeArgument
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeArgument)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeArgument)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeArgument)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeArgument)
dataTypeOf :: TypeArgument -> DataType
$cdataTypeOf :: TypeArgument -> DataType
toConstr :: TypeArgument -> Constr
$ctoConstr :: TypeArgument -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeArgument
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeArgument
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeArgument -> c TypeArgument
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeArgument -> c TypeArgument
$cp1Data :: Typeable TypeArgument
Data)

data TypeDeclSpecifier
    = TypeDeclSpecifier ClassType
    | TypeDeclSpecifierWithDiamond ClassType Ident Diamond
    | TypeDeclSpecifierUnqualifiedWithDiamond Ident Diamond
  deriving (TypeDeclSpecifier -> TypeDeclSpecifier -> Bool
(TypeDeclSpecifier -> TypeDeclSpecifier -> Bool)
-> (TypeDeclSpecifier -> TypeDeclSpecifier -> Bool)
-> Eq TypeDeclSpecifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeDeclSpecifier -> TypeDeclSpecifier -> Bool
$c/= :: TypeDeclSpecifier -> TypeDeclSpecifier -> Bool
== :: TypeDeclSpecifier -> TypeDeclSpecifier -> Bool
$c== :: TypeDeclSpecifier -> TypeDeclSpecifier -> Bool
Eq,Int -> TypeDeclSpecifier -> ShowS
[TypeDeclSpecifier] -> ShowS
TypeDeclSpecifier -> String
(Int -> TypeDeclSpecifier -> ShowS)
-> (TypeDeclSpecifier -> String)
-> ([TypeDeclSpecifier] -> ShowS)
-> Show TypeDeclSpecifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeDeclSpecifier] -> ShowS
$cshowList :: [TypeDeclSpecifier] -> ShowS
show :: TypeDeclSpecifier -> String
$cshow :: TypeDeclSpecifier -> String
showsPrec :: Int -> TypeDeclSpecifier -> ShowS
$cshowsPrec :: Int -> TypeDeclSpecifier -> ShowS
Show,ReadPrec [TypeDeclSpecifier]
ReadPrec TypeDeclSpecifier
Int -> ReadS TypeDeclSpecifier
ReadS [TypeDeclSpecifier]
(Int -> ReadS TypeDeclSpecifier)
-> ReadS [TypeDeclSpecifier]
-> ReadPrec TypeDeclSpecifier
-> ReadPrec [TypeDeclSpecifier]
-> Read TypeDeclSpecifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TypeDeclSpecifier]
$creadListPrec :: ReadPrec [TypeDeclSpecifier]
readPrec :: ReadPrec TypeDeclSpecifier
$creadPrec :: ReadPrec TypeDeclSpecifier
readList :: ReadS [TypeDeclSpecifier]
$creadList :: ReadS [TypeDeclSpecifier]
readsPrec :: Int -> ReadS TypeDeclSpecifier
$creadsPrec :: Int -> ReadS TypeDeclSpecifier
Read,Typeable,(forall x. TypeDeclSpecifier -> Rep TypeDeclSpecifier x)
-> (forall x. Rep TypeDeclSpecifier x -> TypeDeclSpecifier)
-> Generic TypeDeclSpecifier
forall x. Rep TypeDeclSpecifier x -> TypeDeclSpecifier
forall x. TypeDeclSpecifier -> Rep TypeDeclSpecifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TypeDeclSpecifier x -> TypeDeclSpecifier
$cfrom :: forall x. TypeDeclSpecifier -> Rep TypeDeclSpecifier x
Generic,Typeable TypeDeclSpecifier
Constr
DataType
Typeable TypeDeclSpecifier
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> TypeDeclSpecifier
    -> c TypeDeclSpecifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeDeclSpecifier)
-> (TypeDeclSpecifier -> Constr)
-> (TypeDeclSpecifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeDeclSpecifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c TypeDeclSpecifier))
-> ((forall b. Data b => b -> b)
    -> TypeDeclSpecifier -> TypeDeclSpecifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeDeclSpecifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeDeclSpecifier -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TypeDeclSpecifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypeDeclSpecifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TypeDeclSpecifier -> m TypeDeclSpecifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TypeDeclSpecifier -> m TypeDeclSpecifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TypeDeclSpecifier -> m TypeDeclSpecifier)
-> Data TypeDeclSpecifier
TypeDeclSpecifier -> Constr
TypeDeclSpecifier -> DataType
(forall b. Data b => b -> b)
-> TypeDeclSpecifier -> TypeDeclSpecifier
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDeclSpecifier -> c TypeDeclSpecifier
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDeclSpecifier
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> TypeDeclSpecifier -> u
forall u. (forall d. Data d => d -> u) -> TypeDeclSpecifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDeclSpecifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDeclSpecifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TypeDeclSpecifier -> m TypeDeclSpecifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeDeclSpecifier -> m TypeDeclSpecifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDeclSpecifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDeclSpecifier -> c TypeDeclSpecifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeDeclSpecifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeDeclSpecifier)
$cTypeDeclSpecifierUnqualifiedWithDiamond :: Constr
$cTypeDeclSpecifierWithDiamond :: Constr
$cTypeDeclSpecifier :: Constr
$tTypeDeclSpecifier :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> TypeDeclSpecifier -> m TypeDeclSpecifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeDeclSpecifier -> m TypeDeclSpecifier
gmapMp :: (forall d. Data d => d -> m d)
-> TypeDeclSpecifier -> m TypeDeclSpecifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TypeDeclSpecifier -> m TypeDeclSpecifier
gmapM :: (forall d. Data d => d -> m d)
-> TypeDeclSpecifier -> m TypeDeclSpecifier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TypeDeclSpecifier -> m TypeDeclSpecifier
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeDeclSpecifier -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TypeDeclSpecifier -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeDeclSpecifier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeDeclSpecifier -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDeclSpecifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDeclSpecifier -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDeclSpecifier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDeclSpecifier -> r
gmapT :: (forall b. Data b => b -> b)
-> TypeDeclSpecifier -> TypeDeclSpecifier
$cgmapT :: (forall b. Data b => b -> b)
-> TypeDeclSpecifier -> TypeDeclSpecifier
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeDeclSpecifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c TypeDeclSpecifier)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeDeclSpecifier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeDeclSpecifier)
dataTypeOf :: TypeDeclSpecifier -> DataType
$cdataTypeOf :: TypeDeclSpecifier -> DataType
toConstr :: TypeDeclSpecifier -> Constr
$ctoConstr :: TypeDeclSpecifier -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDeclSpecifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDeclSpecifier
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDeclSpecifier -> c TypeDeclSpecifier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDeclSpecifier -> c TypeDeclSpecifier
$cp1Data :: Typeable TypeDeclSpecifier
Data)

data Diamond = Diamond
  deriving (Diamond -> Diamond -> Bool
(Diamond -> Diamond -> Bool)
-> (Diamond -> Diamond -> Bool) -> Eq Diamond
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Diamond -> Diamond -> Bool
$c/= :: Diamond -> Diamond -> Bool
== :: Diamond -> Diamond -> Bool
$c== :: Diamond -> Diamond -> Bool
Eq,Int -> Diamond -> ShowS
[Diamond] -> ShowS
Diamond -> String
(Int -> Diamond -> ShowS)
-> (Diamond -> String) -> ([Diamond] -> ShowS) -> Show Diamond
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Diamond] -> ShowS
$cshowList :: [Diamond] -> ShowS
show :: Diamond -> String
$cshow :: Diamond -> String
showsPrec :: Int -> Diamond -> ShowS
$cshowsPrec :: Int -> Diamond -> ShowS
Show,ReadPrec [Diamond]
ReadPrec Diamond
Int -> ReadS Diamond
ReadS [Diamond]
(Int -> ReadS Diamond)
-> ReadS [Diamond]
-> ReadPrec Diamond
-> ReadPrec [Diamond]
-> Read Diamond
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Diamond]
$creadListPrec :: ReadPrec [Diamond]
readPrec :: ReadPrec Diamond
$creadPrec :: ReadPrec Diamond
readList :: ReadS [Diamond]
$creadList :: ReadS [Diamond]
readsPrec :: Int -> ReadS Diamond
$creadsPrec :: Int -> ReadS Diamond
Read,Typeable,(forall x. Diamond -> Rep Diamond x)
-> (forall x. Rep Diamond x -> Diamond) -> Generic Diamond
forall x. Rep Diamond x -> Diamond
forall x. Diamond -> Rep Diamond x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Diamond x -> Diamond
$cfrom :: forall x. Diamond -> Rep Diamond x
Generic,Typeable Diamond
Constr
DataType
Typeable Diamond
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Diamond -> c Diamond)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Diamond)
-> (Diamond -> Constr)
-> (Diamond -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Diamond))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diamond))
-> ((forall b. Data b => b -> b) -> Diamond -> Diamond)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Diamond -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Diamond -> r)
-> (forall u. (forall d. Data d => d -> u) -> Diamond -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Diamond -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Diamond -> m Diamond)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Diamond -> m Diamond)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Diamond -> m Diamond)
-> Data Diamond
Diamond -> Constr
Diamond -> DataType
(forall b. Data b => b -> b) -> Diamond -> Diamond
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Diamond -> c Diamond
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Diamond
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Diamond -> u
forall u. (forall d. Data d => d -> u) -> Diamond -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Diamond -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Diamond -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Diamond -> m Diamond
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diamond -> m Diamond
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Diamond
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Diamond -> c Diamond
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Diamond)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diamond)
$cDiamond :: Constr
$tDiamond :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Diamond -> m Diamond
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diamond -> m Diamond
gmapMp :: (forall d. Data d => d -> m d) -> Diamond -> m Diamond
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Diamond -> m Diamond
gmapM :: (forall d. Data d => d -> m d) -> Diamond -> m Diamond
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Diamond -> m Diamond
gmapQi :: Int -> (forall d. Data d => d -> u) -> Diamond -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Diamond -> u
gmapQ :: (forall d. Data d => d -> u) -> Diamond -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Diamond -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Diamond -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Diamond -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Diamond -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Diamond -> r
gmapT :: (forall b. Data b => b -> b) -> Diamond -> Diamond
$cgmapT :: (forall b. Data b => b -> b) -> Diamond -> Diamond
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diamond)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Diamond)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Diamond)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Diamond)
dataTypeOf :: Diamond -> DataType
$cdataTypeOf :: Diamond -> DataType
toConstr :: Diamond -> Constr
$ctoConstr :: Diamond -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Diamond
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Diamond
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Diamond -> c Diamond
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Diamond -> c Diamond
$cp1Data :: Typeable Diamond
Data)

-- | Wildcards may be given explicit bounds, either upper (@extends@) or lower (@super@) bounds.
data WildcardBound
    = ExtendsBound RefType
    | SuperBound RefType
  deriving (WildcardBound -> WildcardBound -> Bool
(WildcardBound -> WildcardBound -> Bool)
-> (WildcardBound -> WildcardBound -> Bool) -> Eq WildcardBound
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WildcardBound -> WildcardBound -> Bool
$c/= :: WildcardBound -> WildcardBound -> Bool
== :: WildcardBound -> WildcardBound -> Bool
$c== :: WildcardBound -> WildcardBound -> Bool
Eq,Int -> WildcardBound -> ShowS
[WildcardBound] -> ShowS
WildcardBound -> String
(Int -> WildcardBound -> ShowS)
-> (WildcardBound -> String)
-> ([WildcardBound] -> ShowS)
-> Show WildcardBound
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WildcardBound] -> ShowS
$cshowList :: [WildcardBound] -> ShowS
show :: WildcardBound -> String
$cshow :: WildcardBound -> String
showsPrec :: Int -> WildcardBound -> ShowS
$cshowsPrec :: Int -> WildcardBound -> ShowS
Show,ReadPrec [WildcardBound]
ReadPrec WildcardBound
Int -> ReadS WildcardBound
ReadS [WildcardBound]
(Int -> ReadS WildcardBound)
-> ReadS [WildcardBound]
-> ReadPrec WildcardBound
-> ReadPrec [WildcardBound]
-> Read WildcardBound
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [WildcardBound]
$creadListPrec :: ReadPrec [WildcardBound]
readPrec :: ReadPrec WildcardBound
$creadPrec :: ReadPrec WildcardBound
readList :: ReadS [WildcardBound]
$creadList :: ReadS [WildcardBound]
readsPrec :: Int -> ReadS WildcardBound
$creadsPrec :: Int -> ReadS WildcardBound
Read,Typeable,(forall x. WildcardBound -> Rep WildcardBound x)
-> (forall x. Rep WildcardBound x -> WildcardBound)
-> Generic WildcardBound
forall x. Rep WildcardBound x -> WildcardBound
forall x. WildcardBound -> Rep WildcardBound x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep WildcardBound x -> WildcardBound
$cfrom :: forall x. WildcardBound -> Rep WildcardBound x
Generic,Typeable WildcardBound
Constr
DataType
Typeable WildcardBound
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WildcardBound -> c WildcardBound)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WildcardBound)
-> (WildcardBound -> Constr)
-> (WildcardBound -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WildcardBound))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c WildcardBound))
-> ((forall b. Data b => b -> b) -> WildcardBound -> WildcardBound)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WildcardBound -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WildcardBound -> r)
-> (forall u. (forall d. Data d => d -> u) -> WildcardBound -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> WildcardBound -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound)
-> Data WildcardBound
WildcardBound -> Constr
WildcardBound -> DataType
(forall b. Data b => b -> b) -> WildcardBound -> WildcardBound
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WildcardBound -> c WildcardBound
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WildcardBound
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> WildcardBound -> u
forall u. (forall d. Data d => d -> u) -> WildcardBound -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WildcardBound -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WildcardBound -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WildcardBound
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WildcardBound -> c WildcardBound
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WildcardBound)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c WildcardBound)
$cSuperBound :: Constr
$cExtendsBound :: Constr
$tWildcardBound :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound
gmapMp :: (forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound
gmapM :: (forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound
gmapQi :: Int -> (forall d. Data d => d -> u) -> WildcardBound -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WildcardBound -> u
gmapQ :: (forall d. Data d => d -> u) -> WildcardBound -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WildcardBound -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WildcardBound -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WildcardBound -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WildcardBound -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WildcardBound -> r
gmapT :: (forall b. Data b => b -> b) -> WildcardBound -> WildcardBound
$cgmapT :: (forall b. Data b => b -> b) -> WildcardBound -> WildcardBound
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c WildcardBound)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c WildcardBound)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c WildcardBound)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WildcardBound)
dataTypeOf :: WildcardBound -> DataType
$cdataTypeOf :: WildcardBound -> DataType
toConstr :: WildcardBound -> Constr
$ctoConstr :: WildcardBound -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WildcardBound
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WildcardBound
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WildcardBound -> c WildcardBound
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WildcardBound -> c WildcardBound
$cp1Data :: Typeable WildcardBound
Data)

-- | A primitive type is predefined by the Java programming language and named by its reserved keyword.
data PrimType
    = BooleanT
    | ByteT
    | ShortT
    | IntT
    | LongT
    | CharT
    | FloatT
    | DoubleT
  deriving (PrimType -> PrimType -> Bool
(PrimType -> PrimType -> Bool)
-> (PrimType -> PrimType -> Bool) -> Eq PrimType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrimType -> PrimType -> Bool
$c/= :: PrimType -> PrimType -> Bool
== :: PrimType -> PrimType -> Bool
$c== :: PrimType -> PrimType -> Bool
Eq,Int -> PrimType -> ShowS
[PrimType] -> ShowS
PrimType -> String
(Int -> PrimType -> ShowS)
-> (PrimType -> String) -> ([PrimType] -> ShowS) -> Show PrimType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrimType] -> ShowS
$cshowList :: [PrimType] -> ShowS
show :: PrimType -> String
$cshow :: PrimType -> String
showsPrec :: Int -> PrimType -> ShowS
$cshowsPrec :: Int -> PrimType -> ShowS
Show,ReadPrec [PrimType]
ReadPrec PrimType
Int -> ReadS PrimType
ReadS [PrimType]
(Int -> ReadS PrimType)
-> ReadS [PrimType]
-> ReadPrec PrimType
-> ReadPrec [PrimType]
-> Read PrimType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PrimType]
$creadListPrec :: ReadPrec [PrimType]
readPrec :: ReadPrec PrimType
$creadPrec :: ReadPrec PrimType
readList :: ReadS [PrimType]
$creadList :: ReadS [PrimType]
readsPrec :: Int -> ReadS PrimType
$creadsPrec :: Int -> ReadS PrimType
Read,Typeable,(forall x. PrimType -> Rep PrimType x)
-> (forall x. Rep PrimType x -> PrimType) -> Generic PrimType
forall x. Rep PrimType x -> PrimType
forall x. PrimType -> Rep PrimType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PrimType x -> PrimType
$cfrom :: forall x. PrimType -> Rep PrimType x
Generic,Typeable PrimType
Constr
DataType
Typeable PrimType
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PrimType -> c PrimType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrimType)
-> (PrimType -> Constr)
-> (PrimType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrimType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimType))
-> ((forall b. Data b => b -> b) -> PrimType -> PrimType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrimType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrimType -> r)
-> (forall u. (forall d. Data d => d -> u) -> PrimType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PrimType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PrimType -> m PrimType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrimType -> m PrimType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrimType -> m PrimType)
-> Data PrimType
PrimType -> Constr
PrimType -> DataType
(forall b. Data b => b -> b) -> PrimType -> PrimType
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimType -> c PrimType
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimType
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PrimType -> u
forall u. (forall d. Data d => d -> u) -> PrimType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimType -> c PrimType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimType)
$cDoubleT :: Constr
$cFloatT :: Constr
$cCharT :: Constr
$cLongT :: Constr
$cIntT :: Constr
$cShortT :: Constr
$cByteT :: Constr
$cBooleanT :: Constr
$tPrimType :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PrimType -> m PrimType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
gmapMp :: (forall d. Data d => d -> m d) -> PrimType -> m PrimType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
gmapM :: (forall d. Data d => d -> m d) -> PrimType -> m PrimType
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrimType -> m PrimType
gmapQi :: Int -> (forall d. Data d => d -> u) -> PrimType -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrimType -> u
gmapQ :: (forall d. Data d => d -> u) -> PrimType -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrimType -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrimType -> r
gmapT :: (forall b. Data b => b -> b) -> PrimType -> PrimType
$cgmapT :: (forall b. Data b => b -> b) -> PrimType -> PrimType
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimType)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PrimType)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrimType)
dataTypeOf :: PrimType -> DataType
$cdataTypeOf :: PrimType -> DataType
toConstr :: PrimType -> Constr
$ctoConstr :: PrimType -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrimType
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimType -> c PrimType
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrimType -> c PrimType
$cp1Data :: Typeable PrimType
Data)


-- | A class is generic if it declares one or more type variables. These type variables are known
--   as the type parameters of the class.
data TypeParam = TypeParam Ident [RefType]
  deriving (TypeParam -> TypeParam -> Bool
(TypeParam -> TypeParam -> Bool)
-> (TypeParam -> TypeParam -> Bool) -> Eq TypeParam
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeParam -> TypeParam -> Bool
$c/= :: TypeParam -> TypeParam -> Bool
== :: TypeParam -> TypeParam -> Bool
$c== :: TypeParam -> TypeParam -> Bool
Eq,Int -> TypeParam -> ShowS
[TypeParam] -> ShowS
TypeParam -> String
(Int -> TypeParam -> ShowS)
-> (TypeParam -> String)
-> ([TypeParam] -> ShowS)
-> Show TypeParam
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeParam] -> ShowS
$cshowList :: [TypeParam] -> ShowS
show :: TypeParam -> String
$cshow :: TypeParam -> String
showsPrec :: Int -> TypeParam -> ShowS
$cshowsPrec :: Int -> TypeParam -> ShowS
Show,ReadPrec [TypeParam]
ReadPrec TypeParam
Int -> ReadS TypeParam
ReadS [TypeParam]
(Int -> ReadS TypeParam)
-> ReadS [TypeParam]
-> ReadPrec TypeParam
-> ReadPrec [TypeParam]
-> Read TypeParam
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TypeParam]
$creadListPrec :: ReadPrec [TypeParam]
readPrec :: ReadPrec TypeParam
$creadPrec :: ReadPrec TypeParam
readList :: ReadS [TypeParam]
$creadList :: ReadS [TypeParam]
readsPrec :: Int -> ReadS TypeParam
$creadsPrec :: Int -> ReadS TypeParam
Read,Typeable,(forall x. TypeParam -> Rep TypeParam x)
-> (forall x. Rep TypeParam x -> TypeParam) -> Generic TypeParam
forall x. Rep TypeParam x -> TypeParam
forall x. TypeParam -> Rep TypeParam x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TypeParam x -> TypeParam
$cfrom :: forall x. TypeParam -> Rep TypeParam x
Generic,Typeable TypeParam
Constr
DataType
Typeable TypeParam
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeParam -> c TypeParam)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeParam)
-> (TypeParam -> Constr)
-> (TypeParam -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeParam))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeParam))
-> ((forall b. Data b => b -> b) -> TypeParam -> TypeParam)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeParam -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeParam -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeParam -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TypeParam -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeParam -> m TypeParam)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeParam -> m TypeParam)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeParam -> m TypeParam)
-> Data TypeParam
TypeParam -> Constr
TypeParam -> DataType
(forall b. Data b => b -> b) -> TypeParam -> TypeParam
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeParam -> c TypeParam
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeParam
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TypeParam -> u
forall u. (forall d. Data d => d -> u) -> TypeParam -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeParam -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeParam -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeParam -> m TypeParam
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeParam -> m TypeParam
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeParam
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeParam -> c TypeParam
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeParam)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeParam)
$cTypeParam :: Constr
$tTypeParam :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TypeParam -> m TypeParam
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeParam -> m TypeParam
gmapMp :: (forall d. Data d => d -> m d) -> TypeParam -> m TypeParam
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeParam -> m TypeParam
gmapM :: (forall d. Data d => d -> m d) -> TypeParam -> m TypeParam
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeParam -> m TypeParam
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeParam -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeParam -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeParam -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeParam -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeParam -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeParam -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeParam -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeParam -> r
gmapT :: (forall b. Data b => b -> b) -> TypeParam -> TypeParam
$cgmapT :: (forall b. Data b => b -> b) -> TypeParam -> TypeParam
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeParam)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeParam)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeParam)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeParam)
dataTypeOf :: TypeParam -> DataType
$cdataTypeOf :: TypeParam -> DataType
toConstr :: TypeParam -> Constr
$ctoConstr :: TypeParam -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeParam
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeParam
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeParam -> c TypeParam
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeParam -> c TypeParam
$cp1Data :: Typeable TypeParam
Data)

-----------------------------------------------------------------------
-- Names and identifiers

-- | A single identifier.
data Ident = Ident String
    deriving (Ident -> Ident -> Bool
(Ident -> Ident -> Bool) -> (Ident -> Ident -> Bool) -> Eq Ident
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ident -> Ident -> Bool
$c/= :: Ident -> Ident -> Bool
== :: Ident -> Ident -> Bool
$c== :: Ident -> Ident -> Bool
Eq,Eq Ident
Eq Ident
-> (Ident -> Ident -> Ordering)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Bool)
-> (Ident -> Ident -> Ident)
-> (Ident -> Ident -> Ident)
-> Ord Ident
Ident -> Ident -> Bool
Ident -> Ident -> Ordering
Ident -> Ident -> Ident
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Ident -> Ident -> Ident
$cmin :: Ident -> Ident -> Ident
max :: Ident -> Ident -> Ident
$cmax :: Ident -> Ident -> Ident
>= :: Ident -> Ident -> Bool
$c>= :: Ident -> Ident -> Bool
> :: Ident -> Ident -> Bool
$c> :: Ident -> Ident -> Bool
<= :: Ident -> Ident -> Bool
$c<= :: Ident -> Ident -> Bool
< :: Ident -> Ident -> Bool
$c< :: Ident -> Ident -> Bool
compare :: Ident -> Ident -> Ordering
$ccompare :: Ident -> Ident -> Ordering
$cp1Ord :: Eq Ident
Ord,Int -> Ident -> ShowS
[Ident] -> ShowS
Ident -> String
(Int -> Ident -> ShowS)
-> (Ident -> String) -> ([Ident] -> ShowS) -> Show Ident
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ident] -> ShowS
$cshowList :: [Ident] -> ShowS
show :: Ident -> String
$cshow :: Ident -> String
showsPrec :: Int -> Ident -> ShowS
$cshowsPrec :: Int -> Ident -> ShowS
Show,ReadPrec [Ident]
ReadPrec Ident
Int -> ReadS Ident
ReadS [Ident]
(Int -> ReadS Ident)
-> ReadS [Ident]
-> ReadPrec Ident
-> ReadPrec [Ident]
-> Read Ident
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Ident]
$creadListPrec :: ReadPrec [Ident]
readPrec :: ReadPrec Ident
$creadPrec :: ReadPrec Ident
readList :: ReadS [Ident]
$creadList :: ReadS [Ident]
readsPrec :: Int -> ReadS Ident
$creadsPrec :: Int -> ReadS Ident
Read,Typeable,(forall x. Ident -> Rep Ident x)
-> (forall x. Rep Ident x -> Ident) -> Generic Ident
forall x. Rep Ident x -> Ident
forall x. Ident -> Rep Ident x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Ident x -> Ident
$cfrom :: forall x. Ident -> Rep Ident x
Generic,Typeable Ident
Constr
DataType
Typeable Ident
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Ident -> c Ident)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Ident)
-> (Ident -> Constr)
-> (Ident -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Ident))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ident))
-> ((forall b. Data b => b -> b) -> Ident -> Ident)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r)
-> (forall u. (forall d. Data d => d -> u) -> Ident -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Ident -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Ident -> m Ident)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ident -> m Ident)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ident -> m Ident)
-> Data Ident
Ident -> Constr
Ident -> DataType
(forall b. Data b => b -> b) -> Ident -> Ident
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ident -> c Ident
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ident
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Ident -> u
forall u. (forall d. Data d => d -> u) -> Ident -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ident
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ident -> c Ident
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ident)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ident)
$cIdent :: Constr
$tIdent :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Ident -> m Ident
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
gmapMp :: (forall d. Data d => d -> m d) -> Ident -> m Ident
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
gmapM :: (forall d. Data d => d -> m d) -> Ident -> m Ident
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ident -> m Ident
gmapQi :: Int -> (forall d. Data d => d -> u) -> Ident -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Ident -> u
gmapQ :: (forall d. Data d => d -> u) -> Ident -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Ident -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r
gmapT :: (forall b. Data b => b -> b) -> Ident -> Ident
$cgmapT :: (forall b. Data b => b -> b) -> Ident -> Ident
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ident)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ident)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Ident)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ident)
dataTypeOf :: Ident -> DataType
$cdataTypeOf :: Ident -> DataType
toConstr :: Ident -> Constr
$ctoConstr :: Ident -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ident
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ident
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ident -> c Ident
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ident -> c Ident
$cp1Data :: Typeable Ident
Data)

-- | A name, i.e. a period-separated list of identifiers.
data Name = Name [Ident]
    deriving (Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq,Eq Name
Eq Name
-> (Name -> Name -> Ordering)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Name)
-> (Name -> Name -> Name)
-> Ord Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmax :: Name -> Name -> Name
>= :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c< :: Name -> Name -> Bool
compare :: Name -> Name -> Ordering
$ccompare :: Name -> Name -> Ordering
$cp1Ord :: Eq Name
Ord,Int -> Name -> ShowS
[Name] -> ShowS
Name -> String
(Int -> Name -> ShowS)
-> (Name -> String) -> ([Name] -> ShowS) -> Show Name
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Name] -> ShowS
$cshowList :: [Name] -> ShowS
show :: Name -> String
$cshow :: Name -> String
showsPrec :: Int -> Name -> ShowS
$cshowsPrec :: Int -> Name -> ShowS
Show,ReadPrec [Name]
ReadPrec Name
Int -> ReadS Name
ReadS [Name]
(Int -> ReadS Name)
-> ReadS [Name] -> ReadPrec Name -> ReadPrec [Name] -> Read Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Name]
$creadListPrec :: ReadPrec [Name]
readPrec :: ReadPrec Name
$creadPrec :: ReadPrec Name
readList :: ReadS [Name]
$creadList :: ReadS [Name]
readsPrec :: Int -> ReadS Name
$creadsPrec :: Int -> ReadS Name
Read,Typeable,(forall x. Name -> Rep Name x)
-> (forall x. Rep Name x -> Name) -> Generic Name
forall x. Rep Name x -> Name
forall x. Name -> Rep Name x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Name x -> Name
$cfrom :: forall x. Name -> Rep Name x
Generic,Typeable Name
Constr
DataType
Typeable Name
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name -> c Name)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Name)
-> (Name -> Constr)
-> (Name -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Name))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name))
-> ((forall b. Data b => b -> b) -> Name -> Name)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall u. (forall d. Data d => d -> u) -> Name -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Name -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> Data Name
Name -> Constr
Name -> DataType
(forall b. Data b => b -> b) -> Name -> Name
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
forall u. (forall d. Data d => d -> u) -> Name -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cName :: Constr
$tName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMp :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapM :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQ :: (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataTypeOf :: Name -> DataType
$cdataTypeOf :: Name -> DataType
toConstr :: Name -> Constr
$ctoConstr :: Name -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cp1Data :: Typeable Name
Data)