{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}
module Language.Java.Syntax
( CompilationUnit(..)
, PackageDecl(..)
, ImportDecl(..)
, TypeDecl(..)
, ClassDecl(..)
, ClassBody(..)
, EnumBody(..)
, EnumConstant(..)
, InterfaceDecl(..)
, InterfaceBody(..)
, InterfaceKind(..)
, Decl(..)
, MemberDecl(..)
, VarDecl(..)
, VarDeclId(..)
, VarInit(..)
, FormalParam(..)
, MethodBody(..)
, ConstructorBody(..)
, ExplConstrInv(..)
, Modifier(..)
, Annotation(..)
, desugarAnnotation
, desugarAnnotation'
, ElementValue(..)
, Block(..)
, BlockStmt(..)
, Stmt(..)
, Catch(..)
, SwitchBlock(..)
, SwitchLabel(..)
, ForInit(..)
, ExceptionType
, Argument
, Exp(..)
, Lhs(..)
, ArrayIndex(..)
, FieldAccess(..)
, LambdaParams(..)
, LambdaExpression(..)
, ArrayInit(..)
, MethodInvocation(..)
, module Language.Java.Syntax.Exp
, module Language.Java.Syntax.Types
) where
import Data.Data
import GHC.Generics (Generic)
import Language.Java.Syntax.Types
import Language.Java.Syntax.Exp
data CompilationUnit = CompilationUnit (Maybe PackageDecl) [ImportDecl] [TypeDecl]
deriving (CompilationUnit -> CompilationUnit -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompilationUnit -> CompilationUnit -> Bool
$c/= :: CompilationUnit -> CompilationUnit -> Bool
== :: CompilationUnit -> CompilationUnit -> Bool
$c== :: CompilationUnit -> CompilationUnit -> Bool
Eq,Int -> CompilationUnit -> ShowS
[CompilationUnit] -> ShowS
CompilationUnit -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompilationUnit] -> ShowS
$cshowList :: [CompilationUnit] -> ShowS
show :: CompilationUnit -> String
$cshow :: CompilationUnit -> String
showsPrec :: Int -> CompilationUnit -> ShowS
$cshowsPrec :: Int -> CompilationUnit -> ShowS
Show,ReadPrec [CompilationUnit]
ReadPrec CompilationUnit
Int -> ReadS CompilationUnit
ReadS [CompilationUnit]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CompilationUnit]
$creadListPrec :: ReadPrec [CompilationUnit]
readPrec :: ReadPrec CompilationUnit
$creadPrec :: ReadPrec CompilationUnit
readList :: ReadS [CompilationUnit]
$creadList :: ReadS [CompilationUnit]
readsPrec :: Int -> ReadS CompilationUnit
$creadsPrec :: Int -> ReadS CompilationUnit
Read,Typeable,forall x. Rep CompilationUnit x -> CompilationUnit
forall x. CompilationUnit -> Rep CompilationUnit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CompilationUnit x -> CompilationUnit
$cfrom :: forall x. CompilationUnit -> Rep CompilationUnit x
Generic,Typeable CompilationUnit
CompilationUnit -> Constr
CompilationUnit -> DataType
(forall b. Data b => b -> b) -> CompilationUnit -> CompilationUnit
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) -> CompilationUnit -> u
forall u. (forall d. Data d => d -> u) -> CompilationUnit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompilationUnit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompilationUnit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompilationUnit -> m CompilationUnit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompilationUnit -> m CompilationUnit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompilationUnit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompilationUnit -> c CompilationUnit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompilationUnit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompilationUnit)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompilationUnit -> m CompilationUnit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompilationUnit -> m CompilationUnit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompilationUnit -> m CompilationUnit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompilationUnit -> m CompilationUnit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompilationUnit -> m CompilationUnit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompilationUnit -> m CompilationUnit
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CompilationUnit -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CompilationUnit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> CompilationUnit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CompilationUnit -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompilationUnit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompilationUnit -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompilationUnit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompilationUnit -> r
gmapT :: (forall b. Data b => b -> b) -> CompilationUnit -> CompilationUnit
$cgmapT :: (forall b. Data b => b -> b) -> CompilationUnit -> CompilationUnit
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompilationUnit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompilationUnit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompilationUnit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompilationUnit)
dataTypeOf :: CompilationUnit -> DataType
$cdataTypeOf :: CompilationUnit -> DataType
toConstr :: CompilationUnit -> Constr
$ctoConstr :: CompilationUnit -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompilationUnit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompilationUnit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompilationUnit -> c CompilationUnit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompilationUnit -> c CompilationUnit
Data)
newtype PackageDecl = PackageDecl Name
deriving (PackageDecl -> PackageDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackageDecl -> PackageDecl -> Bool
$c/= :: PackageDecl -> PackageDecl -> Bool
== :: PackageDecl -> PackageDecl -> Bool
$c== :: PackageDecl -> PackageDecl -> Bool
Eq,Int -> PackageDecl -> ShowS
[PackageDecl] -> ShowS
PackageDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackageDecl] -> ShowS
$cshowList :: [PackageDecl] -> ShowS
show :: PackageDecl -> String
$cshow :: PackageDecl -> String
showsPrec :: Int -> PackageDecl -> ShowS
$cshowsPrec :: Int -> PackageDecl -> ShowS
Show,ReadPrec [PackageDecl]
ReadPrec PackageDecl
Int -> ReadS PackageDecl
ReadS [PackageDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PackageDecl]
$creadListPrec :: ReadPrec [PackageDecl]
readPrec :: ReadPrec PackageDecl
$creadPrec :: ReadPrec PackageDecl
readList :: ReadS [PackageDecl]
$creadList :: ReadS [PackageDecl]
readsPrec :: Int -> ReadS PackageDecl
$creadsPrec :: Int -> ReadS PackageDecl
Read,Typeable,forall x. Rep PackageDecl x -> PackageDecl
forall x. PackageDecl -> Rep PackageDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PackageDecl x -> PackageDecl
$cfrom :: forall x. PackageDecl -> Rep PackageDecl x
Generic,Typeable PackageDecl
PackageDecl -> Constr
PackageDecl -> DataType
(forall b. Data b => b -> b) -> PackageDecl -> PackageDecl
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) -> PackageDecl -> u
forall u. (forall d. Data d => d -> u) -> PackageDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackageDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackageDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackageDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PackageDecl -> c PackageDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackageDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackageDecl)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PackageDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PackageDecl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> PackageDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PackageDecl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackageDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PackageDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackageDecl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PackageDecl -> r
gmapT :: (forall b. Data b => b -> b) -> PackageDecl -> PackageDecl
$cgmapT :: (forall b. Data b => b -> b) -> PackageDecl -> PackageDecl
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackageDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PackageDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackageDecl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PackageDecl)
dataTypeOf :: PackageDecl -> DataType
$cdataTypeOf :: PackageDecl -> DataType
toConstr :: PackageDecl -> Constr
$ctoConstr :: PackageDecl -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackageDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PackageDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PackageDecl -> c PackageDecl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PackageDecl -> c PackageDecl
Data)
data ImportDecl
= ImportDecl Bool Name Bool
deriving (ImportDecl -> ImportDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImportDecl -> ImportDecl -> Bool
$c/= :: ImportDecl -> ImportDecl -> Bool
== :: ImportDecl -> ImportDecl -> Bool
$c== :: ImportDecl -> ImportDecl -> Bool
Eq,Int -> ImportDecl -> ShowS
[ImportDecl] -> ShowS
ImportDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImportDecl] -> ShowS
$cshowList :: [ImportDecl] -> ShowS
show :: ImportDecl -> String
$cshow :: ImportDecl -> String
showsPrec :: Int -> ImportDecl -> ShowS
$cshowsPrec :: Int -> ImportDecl -> ShowS
Show,ReadPrec [ImportDecl]
ReadPrec ImportDecl
Int -> ReadS ImportDecl
ReadS [ImportDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ImportDecl]
$creadListPrec :: ReadPrec [ImportDecl]
readPrec :: ReadPrec ImportDecl
$creadPrec :: ReadPrec ImportDecl
readList :: ReadS [ImportDecl]
$creadList :: ReadS [ImportDecl]
readsPrec :: Int -> ReadS ImportDecl
$creadsPrec :: Int -> ReadS ImportDecl
Read,Typeable,forall x. Rep ImportDecl x -> ImportDecl
forall x. ImportDecl -> Rep ImportDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ImportDecl x -> ImportDecl
$cfrom :: forall x. ImportDecl -> Rep ImportDecl x
Generic,Typeable ImportDecl
ImportDecl -> Constr
ImportDecl -> DataType
(forall b. Data b => b -> b) -> ImportDecl -> ImportDecl
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) -> ImportDecl -> u
forall u. (forall d. Data d => d -> u) -> ImportDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportDecl -> c ImportDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportDecl)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImportDecl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImportDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImportDecl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImportDecl -> r
gmapT :: (forall b. Data b => b -> b) -> ImportDecl -> ImportDecl
$cgmapT :: (forall b. Data b => b -> b) -> ImportDecl -> ImportDecl
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportDecl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImportDecl)
dataTypeOf :: ImportDecl -> DataType
$cdataTypeOf :: ImportDecl -> DataType
toConstr :: ImportDecl -> Constr
$ctoConstr :: ImportDecl -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImportDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportDecl -> c ImportDecl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImportDecl -> c ImportDecl
Data)
data TypeDecl
= ClassTypeDecl ClassDecl
| InterfaceTypeDecl InterfaceDecl
deriving (TypeDecl -> TypeDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeDecl -> TypeDecl -> Bool
$c/= :: TypeDecl -> TypeDecl -> Bool
== :: TypeDecl -> TypeDecl -> Bool
$c== :: TypeDecl -> TypeDecl -> Bool
Eq,Int -> TypeDecl -> ShowS
[TypeDecl] -> ShowS
TypeDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeDecl] -> ShowS
$cshowList :: [TypeDecl] -> ShowS
show :: TypeDecl -> String
$cshow :: TypeDecl -> String
showsPrec :: Int -> TypeDecl -> ShowS
$cshowsPrec :: Int -> TypeDecl -> ShowS
Show,ReadPrec [TypeDecl]
ReadPrec TypeDecl
Int -> ReadS TypeDecl
ReadS [TypeDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TypeDecl]
$creadListPrec :: ReadPrec [TypeDecl]
readPrec :: ReadPrec TypeDecl
$creadPrec :: ReadPrec TypeDecl
readList :: ReadS [TypeDecl]
$creadList :: ReadS [TypeDecl]
readsPrec :: Int -> ReadS TypeDecl
$creadsPrec :: Int -> ReadS TypeDecl
Read,Typeable,forall x. Rep TypeDecl x -> TypeDecl
forall x. TypeDecl -> Rep TypeDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TypeDecl x -> TypeDecl
$cfrom :: forall x. TypeDecl -> Rep TypeDecl x
Generic,Typeable TypeDecl
TypeDecl -> Constr
TypeDecl -> DataType
(forall b. Data b => b -> b) -> TypeDecl -> TypeDecl
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) -> TypeDecl -> u
forall u. (forall d. Data d => d -> u) -> TypeDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDecl -> c TypeDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDecl)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeDecl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> TypeDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeDecl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeDecl -> r
gmapT :: (forall b. Data b => b -> b) -> TypeDecl -> TypeDecl
$cgmapT :: (forall b. Data b => b -> b) -> TypeDecl -> TypeDecl
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeDecl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeDecl)
dataTypeOf :: TypeDecl -> DataType
$cdataTypeOf :: TypeDecl -> DataType
toConstr :: TypeDecl -> Constr
$ctoConstr :: TypeDecl -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDecl -> c TypeDecl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeDecl -> c TypeDecl
Data)
data ClassDecl
= ClassDecl [Modifier] Ident [TypeParam] (Maybe RefType) [RefType] ClassBody
| EnumDecl [Modifier] Ident [RefType] EnumBody
deriving (ClassDecl -> ClassDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClassDecl -> ClassDecl -> Bool
$c/= :: ClassDecl -> ClassDecl -> Bool
== :: ClassDecl -> ClassDecl -> Bool
$c== :: ClassDecl -> ClassDecl -> Bool
Eq,Int -> ClassDecl -> ShowS
[ClassDecl] -> ShowS
ClassDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClassDecl] -> ShowS
$cshowList :: [ClassDecl] -> ShowS
show :: ClassDecl -> String
$cshow :: ClassDecl -> String
showsPrec :: Int -> ClassDecl -> ShowS
$cshowsPrec :: Int -> ClassDecl -> ShowS
Show,ReadPrec [ClassDecl]
ReadPrec ClassDecl
Int -> ReadS ClassDecl
ReadS [ClassDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ClassDecl]
$creadListPrec :: ReadPrec [ClassDecl]
readPrec :: ReadPrec ClassDecl
$creadPrec :: ReadPrec ClassDecl
readList :: ReadS [ClassDecl]
$creadList :: ReadS [ClassDecl]
readsPrec :: Int -> ReadS ClassDecl
$creadsPrec :: Int -> ReadS ClassDecl
Read,Typeable,forall x. Rep ClassDecl x -> ClassDecl
forall x. ClassDecl -> Rep ClassDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ClassDecl x -> ClassDecl
$cfrom :: forall x. ClassDecl -> Rep ClassDecl x
Generic,Typeable ClassDecl
ClassDecl -> Constr
ClassDecl -> DataType
(forall b. Data b => b -> b) -> ClassDecl -> ClassDecl
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) -> ClassDecl -> u
forall u. (forall d. Data d => d -> u) -> ClassDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDecl -> c ClassDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassDecl)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassDecl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ClassDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ClassDecl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassDecl -> r
gmapT :: (forall b. Data b => b -> b) -> ClassDecl -> ClassDecl
$cgmapT :: (forall b. Data b => b -> b) -> ClassDecl -> ClassDecl
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassDecl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassDecl)
dataTypeOf :: ClassDecl -> DataType
$cdataTypeOf :: ClassDecl -> DataType
toConstr :: ClassDecl -> Constr
$ctoConstr :: ClassDecl -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDecl -> c ClassDecl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassDecl -> c ClassDecl
Data)
newtype ClassBody = ClassBody [Decl]
deriving (ClassBody -> ClassBody -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ClassBody -> ClassBody -> Bool
$c/= :: ClassBody -> ClassBody -> Bool
== :: ClassBody -> ClassBody -> Bool
$c== :: ClassBody -> ClassBody -> Bool
Eq,Int -> ClassBody -> ShowS
[ClassBody] -> ShowS
ClassBody -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ClassBody] -> ShowS
$cshowList :: [ClassBody] -> ShowS
show :: ClassBody -> String
$cshow :: ClassBody -> String
showsPrec :: Int -> ClassBody -> ShowS
$cshowsPrec :: Int -> ClassBody -> ShowS
Show,ReadPrec [ClassBody]
ReadPrec ClassBody
Int -> ReadS ClassBody
ReadS [ClassBody]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ClassBody]
$creadListPrec :: ReadPrec [ClassBody]
readPrec :: ReadPrec ClassBody
$creadPrec :: ReadPrec ClassBody
readList :: ReadS [ClassBody]
$creadList :: ReadS [ClassBody]
readsPrec :: Int -> ReadS ClassBody
$creadsPrec :: Int -> ReadS ClassBody
Read,Typeable,forall x. Rep ClassBody x -> ClassBody
forall x. ClassBody -> Rep ClassBody x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ClassBody x -> ClassBody
$cfrom :: forall x. ClassBody -> Rep ClassBody x
Generic,Typeable ClassBody
ClassBody -> Constr
ClassBody -> DataType
(forall b. Data b => b -> b) -> ClassBody -> ClassBody
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) -> ClassBody -> u
forall u. (forall d. Data d => d -> u) -> ClassBody -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassBody -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassBody -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassBody -> m ClassBody
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassBody -> m ClassBody
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassBody
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassBody -> c ClassBody
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassBody)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassBody)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassBody -> m ClassBody
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassBody -> m ClassBody
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassBody -> m ClassBody
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ClassBody -> m ClassBody
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassBody -> m ClassBody
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ClassBody -> m ClassBody
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassBody -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ClassBody -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ClassBody -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ClassBody -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassBody -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ClassBody -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassBody -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ClassBody -> r
gmapT :: (forall b. Data b => b -> b) -> ClassBody -> ClassBody
$cgmapT :: (forall b. Data b => b -> b) -> ClassBody -> ClassBody
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassBody)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassBody)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassBody)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ClassBody)
dataTypeOf :: ClassBody -> DataType
$cdataTypeOf :: ClassBody -> DataType
toConstr :: ClassBody -> Constr
$ctoConstr :: ClassBody -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassBody
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ClassBody
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassBody -> c ClassBody
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ClassBody -> c ClassBody
Data)
data EnumBody = EnumBody [EnumConstant] [Decl]
deriving (EnumBody -> EnumBody -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnumBody -> EnumBody -> Bool
$c/= :: EnumBody -> EnumBody -> Bool
== :: EnumBody -> EnumBody -> Bool
$c== :: EnumBody -> EnumBody -> Bool
Eq,Int -> EnumBody -> ShowS
[EnumBody] -> ShowS
EnumBody -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnumBody] -> ShowS
$cshowList :: [EnumBody] -> ShowS
show :: EnumBody -> String
$cshow :: EnumBody -> String
showsPrec :: Int -> EnumBody -> ShowS
$cshowsPrec :: Int -> EnumBody -> ShowS
Show,ReadPrec [EnumBody]
ReadPrec EnumBody
Int -> ReadS EnumBody
ReadS [EnumBody]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EnumBody]
$creadListPrec :: ReadPrec [EnumBody]
readPrec :: ReadPrec EnumBody
$creadPrec :: ReadPrec EnumBody
readList :: ReadS [EnumBody]
$creadList :: ReadS [EnumBody]
readsPrec :: Int -> ReadS EnumBody
$creadsPrec :: Int -> ReadS EnumBody
Read,Typeable,forall x. Rep EnumBody x -> EnumBody
forall x. EnumBody -> Rep EnumBody x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep EnumBody x -> EnumBody
$cfrom :: forall x. EnumBody -> Rep EnumBody x
Generic,Typeable EnumBody
EnumBody -> Constr
EnumBody -> DataType
(forall b. Data b => b -> b) -> EnumBody -> EnumBody
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) -> EnumBody -> u
forall u. (forall d. Data d => d -> u) -> EnumBody -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumBody -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumBody -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumBody -> m EnumBody
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumBody -> m EnumBody
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumBody
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumBody -> c EnumBody
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumBody)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumBody)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumBody -> m EnumBody
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumBody -> m EnumBody
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumBody -> m EnumBody
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumBody -> m EnumBody
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumBody -> m EnumBody
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumBody -> m EnumBody
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnumBody -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnumBody -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> EnumBody -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnumBody -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumBody -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumBody -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumBody -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumBody -> r
gmapT :: (forall b. Data b => b -> b) -> EnumBody -> EnumBody
$cgmapT :: (forall b. Data b => b -> b) -> EnumBody -> EnumBody
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumBody)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumBody)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumBody)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumBody)
dataTypeOf :: EnumBody -> DataType
$cdataTypeOf :: EnumBody -> DataType
toConstr :: EnumBody -> Constr
$ctoConstr :: EnumBody -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumBody
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumBody
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumBody -> c EnumBody
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumBody -> c EnumBody
Data)
data EnumConstant = EnumConstant Ident [Argument] (Maybe ClassBody)
deriving (EnumConstant -> EnumConstant -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EnumConstant -> EnumConstant -> Bool
$c/= :: EnumConstant -> EnumConstant -> Bool
== :: EnumConstant -> EnumConstant -> Bool
$c== :: EnumConstant -> EnumConstant -> Bool
Eq,Int -> EnumConstant -> ShowS
[EnumConstant] -> ShowS
EnumConstant -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EnumConstant] -> ShowS
$cshowList :: [EnumConstant] -> ShowS
show :: EnumConstant -> String
$cshow :: EnumConstant -> String
showsPrec :: Int -> EnumConstant -> ShowS
$cshowsPrec :: Int -> EnumConstant -> ShowS
Show,ReadPrec [EnumConstant]
ReadPrec EnumConstant
Int -> ReadS EnumConstant
ReadS [EnumConstant]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [EnumConstant]
$creadListPrec :: ReadPrec [EnumConstant]
readPrec :: ReadPrec EnumConstant
$creadPrec :: ReadPrec EnumConstant
readList :: ReadS [EnumConstant]
$creadList :: ReadS [EnumConstant]
readsPrec :: Int -> ReadS EnumConstant
$creadsPrec :: Int -> ReadS EnumConstant
Read,Typeable,forall x. Rep EnumConstant x -> EnumConstant
forall x. EnumConstant -> Rep EnumConstant x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep EnumConstant x -> EnumConstant
$cfrom :: forall x. EnumConstant -> Rep EnumConstant x
Generic,Typeable EnumConstant
EnumConstant -> Constr
EnumConstant -> DataType
(forall b. Data b => b -> b) -> EnumConstant -> EnumConstant
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) -> EnumConstant -> u
forall u. (forall d. Data d => d -> u) -> EnumConstant -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumConstant -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumConstant -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumConstant
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumConstant -> c EnumConstant
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumConstant)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumConstant)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnumConstant -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnumConstant -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> EnumConstant -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnumConstant -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumConstant -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnumConstant -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumConstant -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnumConstant -> r
gmapT :: (forall b. Data b => b -> b) -> EnumConstant -> EnumConstant
$cgmapT :: (forall b. Data b => b -> b) -> EnumConstant -> EnumConstant
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumConstant)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnumConstant)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumConstant)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnumConstant)
dataTypeOf :: EnumConstant -> DataType
$cdataTypeOf :: EnumConstant -> DataType
toConstr :: EnumConstant -> Constr
$ctoConstr :: EnumConstant -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumConstant
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnumConstant
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumConstant -> c EnumConstant
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnumConstant -> c EnumConstant
Data)
data InterfaceDecl
= InterfaceDecl InterfaceKind [Modifier] Ident [TypeParam] [RefType] InterfaceBody
deriving (InterfaceDecl -> InterfaceDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InterfaceDecl -> InterfaceDecl -> Bool
$c/= :: InterfaceDecl -> InterfaceDecl -> Bool
== :: InterfaceDecl -> InterfaceDecl -> Bool
$c== :: InterfaceDecl -> InterfaceDecl -> Bool
Eq,Int -> InterfaceDecl -> ShowS
[InterfaceDecl] -> ShowS
InterfaceDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InterfaceDecl] -> ShowS
$cshowList :: [InterfaceDecl] -> ShowS
show :: InterfaceDecl -> String
$cshow :: InterfaceDecl -> String
showsPrec :: Int -> InterfaceDecl -> ShowS
$cshowsPrec :: Int -> InterfaceDecl -> ShowS
Show,ReadPrec [InterfaceDecl]
ReadPrec InterfaceDecl
Int -> ReadS InterfaceDecl
ReadS [InterfaceDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InterfaceDecl]
$creadListPrec :: ReadPrec [InterfaceDecl]
readPrec :: ReadPrec InterfaceDecl
$creadPrec :: ReadPrec InterfaceDecl
readList :: ReadS [InterfaceDecl]
$creadList :: ReadS [InterfaceDecl]
readsPrec :: Int -> ReadS InterfaceDecl
$creadsPrec :: Int -> ReadS InterfaceDecl
Read,Typeable,forall x. Rep InterfaceDecl x -> InterfaceDecl
forall x. InterfaceDecl -> Rep InterfaceDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InterfaceDecl x -> InterfaceDecl
$cfrom :: forall x. InterfaceDecl -> Rep InterfaceDecl x
Generic,Typeable InterfaceDecl
InterfaceDecl -> Constr
InterfaceDecl -> DataType
(forall b. Data b => b -> b) -> InterfaceDecl -> InterfaceDecl
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) -> InterfaceDecl -> u
forall u. (forall d. Data d => d -> u) -> InterfaceDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InterfaceDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InterfaceDecl -> c InterfaceDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InterfaceDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InterfaceDecl)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InterfaceDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InterfaceDecl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> InterfaceDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InterfaceDecl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceDecl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceDecl -> r
gmapT :: (forall b. Data b => b -> b) -> InterfaceDecl -> InterfaceDecl
$cgmapT :: (forall b. Data b => b -> b) -> InterfaceDecl -> InterfaceDecl
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InterfaceDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InterfaceDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InterfaceDecl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InterfaceDecl)
dataTypeOf :: InterfaceDecl -> DataType
$cdataTypeOf :: InterfaceDecl -> DataType
toConstr :: InterfaceDecl -> Constr
$ctoConstr :: InterfaceDecl -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InterfaceDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InterfaceDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InterfaceDecl -> c InterfaceDecl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InterfaceDecl -> c InterfaceDecl
Data)
data InterfaceKind = InterfaceNormal | InterfaceAnnotation
deriving (InterfaceKind -> InterfaceKind -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InterfaceKind -> InterfaceKind -> Bool
$c/= :: InterfaceKind -> InterfaceKind -> Bool
== :: InterfaceKind -> InterfaceKind -> Bool
$c== :: InterfaceKind -> InterfaceKind -> Bool
Eq,Int -> InterfaceKind -> ShowS
[InterfaceKind] -> ShowS
InterfaceKind -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InterfaceKind] -> ShowS
$cshowList :: [InterfaceKind] -> ShowS
show :: InterfaceKind -> String
$cshow :: InterfaceKind -> String
showsPrec :: Int -> InterfaceKind -> ShowS
$cshowsPrec :: Int -> InterfaceKind -> ShowS
Show,ReadPrec [InterfaceKind]
ReadPrec InterfaceKind
Int -> ReadS InterfaceKind
ReadS [InterfaceKind]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InterfaceKind]
$creadListPrec :: ReadPrec [InterfaceKind]
readPrec :: ReadPrec InterfaceKind
$creadPrec :: ReadPrec InterfaceKind
readList :: ReadS [InterfaceKind]
$creadList :: ReadS [InterfaceKind]
readsPrec :: Int -> ReadS InterfaceKind
$creadsPrec :: Int -> ReadS InterfaceKind
Read,Typeable,forall x. Rep InterfaceKind x -> InterfaceKind
forall x. InterfaceKind -> Rep InterfaceKind x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InterfaceKind x -> InterfaceKind
$cfrom :: forall x. InterfaceKind -> Rep InterfaceKind x
Generic,Typeable InterfaceKind
InterfaceKind -> Constr
InterfaceKind -> DataType
(forall b. Data b => b -> b) -> InterfaceKind -> InterfaceKind
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) -> InterfaceKind -> u
forall u. (forall d. Data d => d -> u) -> InterfaceKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InterfaceKind -> m InterfaceKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceKind -> m InterfaceKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InterfaceKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InterfaceKind -> c InterfaceKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InterfaceKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InterfaceKind)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceKind -> m InterfaceKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceKind -> m InterfaceKind
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceKind -> m InterfaceKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceKind -> m InterfaceKind
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InterfaceKind -> m InterfaceKind
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InterfaceKind -> m InterfaceKind
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InterfaceKind -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InterfaceKind -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> InterfaceKind -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InterfaceKind -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceKind -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceKind -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceKind -> r
gmapT :: (forall b. Data b => b -> b) -> InterfaceKind -> InterfaceKind
$cgmapT :: (forall b. Data b => b -> b) -> InterfaceKind -> InterfaceKind
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InterfaceKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InterfaceKind)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InterfaceKind)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InterfaceKind)
dataTypeOf :: InterfaceKind -> DataType
$cdataTypeOf :: InterfaceKind -> DataType
toConstr :: InterfaceKind -> Constr
$ctoConstr :: InterfaceKind -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InterfaceKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InterfaceKind
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InterfaceKind -> c InterfaceKind
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InterfaceKind -> c InterfaceKind
Data)
newtype InterfaceBody
= InterfaceBody [MemberDecl]
deriving (InterfaceBody -> InterfaceBody -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InterfaceBody -> InterfaceBody -> Bool
$c/= :: InterfaceBody -> InterfaceBody -> Bool
== :: InterfaceBody -> InterfaceBody -> Bool
$c== :: InterfaceBody -> InterfaceBody -> Bool
Eq,Int -> InterfaceBody -> ShowS
[InterfaceBody] -> ShowS
InterfaceBody -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InterfaceBody] -> ShowS
$cshowList :: [InterfaceBody] -> ShowS
show :: InterfaceBody -> String
$cshow :: InterfaceBody -> String
showsPrec :: Int -> InterfaceBody -> ShowS
$cshowsPrec :: Int -> InterfaceBody -> ShowS
Show,ReadPrec [InterfaceBody]
ReadPrec InterfaceBody
Int -> ReadS InterfaceBody
ReadS [InterfaceBody]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [InterfaceBody]
$creadListPrec :: ReadPrec [InterfaceBody]
readPrec :: ReadPrec InterfaceBody
$creadPrec :: ReadPrec InterfaceBody
readList :: ReadS [InterfaceBody]
$creadList :: ReadS [InterfaceBody]
readsPrec :: Int -> ReadS InterfaceBody
$creadsPrec :: Int -> ReadS InterfaceBody
Read,Typeable,forall x. Rep InterfaceBody x -> InterfaceBody
forall x. InterfaceBody -> Rep InterfaceBody x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep InterfaceBody x -> InterfaceBody
$cfrom :: forall x. InterfaceBody -> Rep InterfaceBody x
Generic,Typeable InterfaceBody
InterfaceBody -> Constr
InterfaceBody -> DataType
(forall b. Data b => b -> b) -> InterfaceBody -> InterfaceBody
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) -> InterfaceBody -> u
forall u. (forall d. Data d => d -> u) -> InterfaceBody -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceBody -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceBody -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InterfaceBody
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InterfaceBody -> c InterfaceBody
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InterfaceBody)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InterfaceBody)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InterfaceBody -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InterfaceBody -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> InterfaceBody -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InterfaceBody -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceBody -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceBody -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceBody -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InterfaceBody -> r
gmapT :: (forall b. Data b => b -> b) -> InterfaceBody -> InterfaceBody
$cgmapT :: (forall b. Data b => b -> b) -> InterfaceBody -> InterfaceBody
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InterfaceBody)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InterfaceBody)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InterfaceBody)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InterfaceBody)
dataTypeOf :: InterfaceBody -> DataType
$cdataTypeOf :: InterfaceBody -> DataType
toConstr :: InterfaceBody -> Constr
$ctoConstr :: InterfaceBody -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InterfaceBody
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InterfaceBody
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InterfaceBody -> c InterfaceBody
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InterfaceBody -> c InterfaceBody
Data)
data Decl
= MemberDecl MemberDecl
| InitDecl Bool Block
deriving (Decl -> Decl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Decl -> Decl -> Bool
$c/= :: Decl -> Decl -> Bool
== :: Decl -> Decl -> Bool
$c== :: Decl -> Decl -> Bool
Eq,Int -> Decl -> ShowS
[Decl] -> ShowS
Decl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Decl] -> ShowS
$cshowList :: [Decl] -> ShowS
show :: Decl -> String
$cshow :: Decl -> String
showsPrec :: Int -> Decl -> ShowS
$cshowsPrec :: Int -> Decl -> ShowS
Show,ReadPrec [Decl]
ReadPrec Decl
Int -> ReadS Decl
ReadS [Decl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Decl]
$creadListPrec :: ReadPrec [Decl]
readPrec :: ReadPrec Decl
$creadPrec :: ReadPrec Decl
readList :: ReadS [Decl]
$creadList :: ReadS [Decl]
readsPrec :: Int -> ReadS Decl
$creadsPrec :: Int -> ReadS Decl
Read,Typeable,forall x. Rep Decl x -> Decl
forall x. Decl -> Rep Decl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Decl x -> Decl
$cfrom :: forall x. Decl -> Rep Decl x
Generic,Typeable Decl
Decl -> Constr
Decl -> DataType
(forall b. Data b => b -> b) -> Decl -> Decl
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) -> Decl -> u
forall u. (forall d. Data d => d -> u) -> Decl -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Decl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Decl -> c Decl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Decl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Decl)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Decl -> m Decl
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Decl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Decl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Decl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Decl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r
gmapT :: (forall b. Data b => b -> b) -> Decl -> Decl
$cgmapT :: (forall b. Data b => b -> b) -> Decl -> Decl
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Decl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Decl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Decl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Decl)
dataTypeOf :: Decl -> DataType
$cdataTypeOf :: Decl -> DataType
toConstr :: Decl -> Constr
$ctoConstr :: Decl -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Decl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Decl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Decl -> c Decl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Decl -> c Decl
Data)
data MemberDecl
= FieldDecl [Modifier] Type [VarDecl]
| MethodDecl [Modifier] [TypeParam] (Maybe Type) Ident [FormalParam] [ExceptionType] (Maybe Exp) MethodBody
| ConstructorDecl [Modifier] [TypeParam] Ident [FormalParam] [ExceptionType] ConstructorBody
| MemberClassDecl ClassDecl
| MemberInterfaceDecl InterfaceDecl
deriving (MemberDecl -> MemberDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MemberDecl -> MemberDecl -> Bool
$c/= :: MemberDecl -> MemberDecl -> Bool
== :: MemberDecl -> MemberDecl -> Bool
$c== :: MemberDecl -> MemberDecl -> Bool
Eq,Int -> MemberDecl -> ShowS
[MemberDecl] -> ShowS
MemberDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MemberDecl] -> ShowS
$cshowList :: [MemberDecl] -> ShowS
show :: MemberDecl -> String
$cshow :: MemberDecl -> String
showsPrec :: Int -> MemberDecl -> ShowS
$cshowsPrec :: Int -> MemberDecl -> ShowS
Show,ReadPrec [MemberDecl]
ReadPrec MemberDecl
Int -> ReadS MemberDecl
ReadS [MemberDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MemberDecl]
$creadListPrec :: ReadPrec [MemberDecl]
readPrec :: ReadPrec MemberDecl
$creadPrec :: ReadPrec MemberDecl
readList :: ReadS [MemberDecl]
$creadList :: ReadS [MemberDecl]
readsPrec :: Int -> ReadS MemberDecl
$creadsPrec :: Int -> ReadS MemberDecl
Read,Typeable,forall x. Rep MemberDecl x -> MemberDecl
forall x. MemberDecl -> Rep MemberDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MemberDecl x -> MemberDecl
$cfrom :: forall x. MemberDecl -> Rep MemberDecl x
Generic,Typeable MemberDecl
MemberDecl -> Constr
MemberDecl -> DataType
(forall b. Data b => b -> b) -> MemberDecl -> MemberDecl
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) -> MemberDecl -> u
forall u. (forall d. Data d => d -> u) -> MemberDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MemberDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MemberDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemberDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemberDecl -> c MemberDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MemberDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MemberDecl)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MemberDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MemberDecl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MemberDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MemberDecl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MemberDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MemberDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MemberDecl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MemberDecl -> r
gmapT :: (forall b. Data b => b -> b) -> MemberDecl -> MemberDecl
$cgmapT :: (forall b. Data b => b -> b) -> MemberDecl -> MemberDecl
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MemberDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MemberDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MemberDecl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MemberDecl)
dataTypeOf :: MemberDecl -> DataType
$cdataTypeOf :: MemberDecl -> DataType
toConstr :: MemberDecl -> Constr
$ctoConstr :: MemberDecl -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemberDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemberDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemberDecl -> c MemberDecl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemberDecl -> c MemberDecl
Data)
data VarDecl
= VarDecl VarDeclId (Maybe VarInit)
deriving (VarDecl -> VarDecl -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VarDecl -> VarDecl -> Bool
$c/= :: VarDecl -> VarDecl -> Bool
== :: VarDecl -> VarDecl -> Bool
$c== :: VarDecl -> VarDecl -> Bool
Eq,Int -> VarDecl -> ShowS
[VarDecl] -> ShowS
VarDecl -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VarDecl] -> ShowS
$cshowList :: [VarDecl] -> ShowS
show :: VarDecl -> String
$cshow :: VarDecl -> String
showsPrec :: Int -> VarDecl -> ShowS
$cshowsPrec :: Int -> VarDecl -> ShowS
Show,ReadPrec [VarDecl]
ReadPrec VarDecl
Int -> ReadS VarDecl
ReadS [VarDecl]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VarDecl]
$creadListPrec :: ReadPrec [VarDecl]
readPrec :: ReadPrec VarDecl
$creadPrec :: ReadPrec VarDecl
readList :: ReadS [VarDecl]
$creadList :: ReadS [VarDecl]
readsPrec :: Int -> ReadS VarDecl
$creadsPrec :: Int -> ReadS VarDecl
Read,Typeable,forall x. Rep VarDecl x -> VarDecl
forall x. VarDecl -> Rep VarDecl x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VarDecl x -> VarDecl
$cfrom :: forall x. VarDecl -> Rep VarDecl x
Generic,Typeable VarDecl
VarDecl -> Constr
VarDecl -> DataType
(forall b. Data b => b -> b) -> VarDecl -> VarDecl
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) -> VarDecl -> u
forall u. (forall d. Data d => d -> u) -> VarDecl -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDecl -> m VarDecl
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecl -> m VarDecl
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarDecl
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecl -> c VarDecl
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarDecl)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarDecl)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecl -> m VarDecl
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecl -> m VarDecl
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecl -> m VarDecl
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDecl -> m VarDecl
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDecl -> m VarDecl
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDecl -> m VarDecl
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarDecl -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarDecl -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> VarDecl -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VarDecl -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDecl -> r
gmapT :: (forall b. Data b => b -> b) -> VarDecl -> VarDecl
$cgmapT :: (forall b. Data b => b -> b) -> VarDecl -> VarDecl
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarDecl)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarDecl)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarDecl)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarDecl)
dataTypeOf :: VarDecl -> DataType
$cdataTypeOf :: VarDecl -> DataType
toConstr :: VarDecl -> Constr
$ctoConstr :: VarDecl -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarDecl
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarDecl
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecl -> c VarDecl
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDecl -> c VarDecl
Data)
data VarDeclId
= VarId Ident
| VarDeclArray VarDeclId
deriving (VarDeclId -> VarDeclId -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VarDeclId -> VarDeclId -> Bool
$c/= :: VarDeclId -> VarDeclId -> Bool
== :: VarDeclId -> VarDeclId -> Bool
$c== :: VarDeclId -> VarDeclId -> Bool
Eq,Int -> VarDeclId -> ShowS
[VarDeclId] -> ShowS
VarDeclId -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VarDeclId] -> ShowS
$cshowList :: [VarDeclId] -> ShowS
show :: VarDeclId -> String
$cshow :: VarDeclId -> String
showsPrec :: Int -> VarDeclId -> ShowS
$cshowsPrec :: Int -> VarDeclId -> ShowS
Show,ReadPrec [VarDeclId]
ReadPrec VarDeclId
Int -> ReadS VarDeclId
ReadS [VarDeclId]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VarDeclId]
$creadListPrec :: ReadPrec [VarDeclId]
readPrec :: ReadPrec VarDeclId
$creadPrec :: ReadPrec VarDeclId
readList :: ReadS [VarDeclId]
$creadList :: ReadS [VarDeclId]
readsPrec :: Int -> ReadS VarDeclId
$creadsPrec :: Int -> ReadS VarDeclId
Read,Typeable,forall x. Rep VarDeclId x -> VarDeclId
forall x. VarDeclId -> Rep VarDeclId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VarDeclId x -> VarDeclId
$cfrom :: forall x. VarDeclId -> Rep VarDeclId x
Generic,Typeable VarDeclId
VarDeclId -> Constr
VarDeclId -> DataType
(forall b. Data b => b -> b) -> VarDeclId -> VarDeclId
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) -> VarDeclId -> u
forall u. (forall d. Data d => d -> u) -> VarDeclId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDeclId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDeclId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarDeclId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDeclId -> c VarDeclId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarDeclId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarDeclId)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarDeclId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarDeclId -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> VarDeclId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VarDeclId -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDeclId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarDeclId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDeclId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarDeclId -> r
gmapT :: (forall b. Data b => b -> b) -> VarDeclId -> VarDeclId
$cgmapT :: (forall b. Data b => b -> b) -> VarDeclId -> VarDeclId
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarDeclId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarDeclId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarDeclId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarDeclId)
dataTypeOf :: VarDeclId -> DataType
$cdataTypeOf :: VarDeclId -> DataType
toConstr :: VarDeclId -> Constr
$ctoConstr :: VarDeclId -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarDeclId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarDeclId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDeclId -> c VarDeclId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarDeclId -> c VarDeclId
Data)
data VarInit
= InitExp Exp
| InitArray ArrayInit
deriving (VarInit -> VarInit -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VarInit -> VarInit -> Bool
$c/= :: VarInit -> VarInit -> Bool
== :: VarInit -> VarInit -> Bool
$c== :: VarInit -> VarInit -> Bool
Eq,Int -> VarInit -> ShowS
[VarInit] -> ShowS
VarInit -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VarInit] -> ShowS
$cshowList :: [VarInit] -> ShowS
show :: VarInit -> String
$cshow :: VarInit -> String
showsPrec :: Int -> VarInit -> ShowS
$cshowsPrec :: Int -> VarInit -> ShowS
Show,ReadPrec [VarInit]
ReadPrec VarInit
Int -> ReadS VarInit
ReadS [VarInit]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VarInit]
$creadListPrec :: ReadPrec [VarInit]
readPrec :: ReadPrec VarInit
$creadPrec :: ReadPrec VarInit
readList :: ReadS [VarInit]
$creadList :: ReadS [VarInit]
readsPrec :: Int -> ReadS VarInit
$creadsPrec :: Int -> ReadS VarInit
Read,Typeable,forall x. Rep VarInit x -> VarInit
forall x. VarInit -> Rep VarInit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VarInit x -> VarInit
$cfrom :: forall x. VarInit -> Rep VarInit x
Generic,Typeable VarInit
VarInit -> Constr
VarInit -> DataType
(forall b. Data b => b -> b) -> VarInit -> VarInit
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) -> VarInit -> u
forall u. (forall d. Data d => d -> u) -> VarInit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarInit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarInit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarInit -> m VarInit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarInit -> m VarInit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarInit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarInit -> c VarInit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarInit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarInit)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarInit -> m VarInit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarInit -> m VarInit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarInit -> m VarInit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> VarInit -> m VarInit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarInit -> m VarInit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> VarInit -> m VarInit
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarInit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarInit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> VarInit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> VarInit -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarInit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> VarInit -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarInit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> VarInit -> r
gmapT :: (forall b. Data b => b -> b) -> VarInit -> VarInit
$cgmapT :: (forall b. Data b => b -> b) -> VarInit -> VarInit
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarInit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarInit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarInit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c VarInit)
dataTypeOf :: VarInit -> DataType
$cdataTypeOf :: VarInit -> DataType
toConstr :: VarInit -> Constr
$ctoConstr :: VarInit -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarInit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c VarInit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarInit -> c VarInit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> VarInit -> c VarInit
Data)
data FormalParam = FormalParam [Modifier] Type Bool VarDeclId
deriving (FormalParam -> FormalParam -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormalParam -> FormalParam -> Bool
$c/= :: FormalParam -> FormalParam -> Bool
== :: FormalParam -> FormalParam -> Bool
$c== :: FormalParam -> FormalParam -> Bool
Eq,Int -> FormalParam -> ShowS
[FormalParam] -> ShowS
FormalParam -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormalParam] -> ShowS
$cshowList :: [FormalParam] -> ShowS
show :: FormalParam -> String
$cshow :: FormalParam -> String
showsPrec :: Int -> FormalParam -> ShowS
$cshowsPrec :: Int -> FormalParam -> ShowS
Show,ReadPrec [FormalParam]
ReadPrec FormalParam
Int -> ReadS FormalParam
ReadS [FormalParam]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FormalParam]
$creadListPrec :: ReadPrec [FormalParam]
readPrec :: ReadPrec FormalParam
$creadPrec :: ReadPrec FormalParam
readList :: ReadS [FormalParam]
$creadList :: ReadS [FormalParam]
readsPrec :: Int -> ReadS FormalParam
$creadsPrec :: Int -> ReadS FormalParam
Read,Typeable,forall x. Rep FormalParam x -> FormalParam
forall x. FormalParam -> Rep FormalParam x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FormalParam x -> FormalParam
$cfrom :: forall x. FormalParam -> Rep FormalParam x
Generic,Typeable FormalParam
FormalParam -> Constr
FormalParam -> DataType
(forall b. Data b => b -> b) -> FormalParam -> FormalParam
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) -> FormalParam -> u
forall u. (forall d. Data d => d -> u) -> FormalParam -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormalParam -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormalParam -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FormalParam -> m FormalParam
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormalParam -> m FormalParam
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormalParam
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormalParam -> c FormalParam
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FormalParam)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FormalParam)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormalParam -> m FormalParam
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormalParam -> m FormalParam
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormalParam -> m FormalParam
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FormalParam -> m FormalParam
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FormalParam -> m FormalParam
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FormalParam -> m FormalParam
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FormalParam -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FormalParam -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> FormalParam -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FormalParam -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormalParam -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FormalParam -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormalParam -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FormalParam -> r
gmapT :: (forall b. Data b => b -> b) -> FormalParam -> FormalParam
$cgmapT :: (forall b. Data b => b -> b) -> FormalParam -> FormalParam
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FormalParam)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FormalParam)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FormalParam)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FormalParam)
dataTypeOf :: FormalParam -> DataType
$cdataTypeOf :: FormalParam -> DataType
toConstr :: FormalParam -> Constr
$ctoConstr :: FormalParam -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormalParam
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FormalParam
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormalParam -> c FormalParam
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FormalParam -> c FormalParam
Data)
newtype MethodBody = MethodBody (Maybe Block)
deriving (MethodBody -> MethodBody -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MethodBody -> MethodBody -> Bool
$c/= :: MethodBody -> MethodBody -> Bool
== :: MethodBody -> MethodBody -> Bool
$c== :: MethodBody -> MethodBody -> Bool
Eq,Int -> MethodBody -> ShowS
[MethodBody] -> ShowS
MethodBody -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MethodBody] -> ShowS
$cshowList :: [MethodBody] -> ShowS
show :: MethodBody -> String
$cshow :: MethodBody -> String
showsPrec :: Int -> MethodBody -> ShowS
$cshowsPrec :: Int -> MethodBody -> ShowS
Show,ReadPrec [MethodBody]
ReadPrec MethodBody
Int -> ReadS MethodBody
ReadS [MethodBody]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MethodBody]
$creadListPrec :: ReadPrec [MethodBody]
readPrec :: ReadPrec MethodBody
$creadPrec :: ReadPrec MethodBody
readList :: ReadS [MethodBody]
$creadList :: ReadS [MethodBody]
readsPrec :: Int -> ReadS MethodBody
$creadsPrec :: Int -> ReadS MethodBody
Read,Typeable,forall x. Rep MethodBody x -> MethodBody
forall x. MethodBody -> Rep MethodBody x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MethodBody x -> MethodBody
$cfrom :: forall x. MethodBody -> Rep MethodBody x
Generic,Typeable MethodBody
MethodBody -> Constr
MethodBody -> DataType
(forall b. Data b => b -> b) -> MethodBody -> MethodBody
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) -> MethodBody -> u
forall u. (forall d. Data d => d -> u) -> MethodBody -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodBody -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodBody -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MethodBody -> m MethodBody
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MethodBody -> m MethodBody
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodBody
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodBody -> c MethodBody
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodBody)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MethodBody)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MethodBody -> m MethodBody
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MethodBody -> m MethodBody
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MethodBody -> m MethodBody
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MethodBody -> m MethodBody
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MethodBody -> m MethodBody
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MethodBody -> m MethodBody
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MethodBody -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MethodBody -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MethodBody -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MethodBody -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodBody -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodBody -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodBody -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodBody -> r
gmapT :: (forall b. Data b => b -> b) -> MethodBody -> MethodBody
$cgmapT :: (forall b. Data b => b -> b) -> MethodBody -> MethodBody
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MethodBody)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MethodBody)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodBody)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodBody)
dataTypeOf :: MethodBody -> DataType
$cdataTypeOf :: MethodBody -> DataType
toConstr :: MethodBody -> Constr
$ctoConstr :: MethodBody -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodBody
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodBody
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodBody -> c MethodBody
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodBody -> c MethodBody
Data)
data ConstructorBody = ConstructorBody (Maybe ExplConstrInv) [BlockStmt]
deriving (ConstructorBody -> ConstructorBody -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstructorBody -> ConstructorBody -> Bool
$c/= :: ConstructorBody -> ConstructorBody -> Bool
== :: ConstructorBody -> ConstructorBody -> Bool
$c== :: ConstructorBody -> ConstructorBody -> Bool
Eq,Int -> ConstructorBody -> ShowS
[ConstructorBody] -> ShowS
ConstructorBody -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstructorBody] -> ShowS
$cshowList :: [ConstructorBody] -> ShowS
show :: ConstructorBody -> String
$cshow :: ConstructorBody -> String
showsPrec :: Int -> ConstructorBody -> ShowS
$cshowsPrec :: Int -> ConstructorBody -> ShowS
Show,ReadPrec [ConstructorBody]
ReadPrec ConstructorBody
Int -> ReadS ConstructorBody
ReadS [ConstructorBody]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ConstructorBody]
$creadListPrec :: ReadPrec [ConstructorBody]
readPrec :: ReadPrec ConstructorBody
$creadPrec :: ReadPrec ConstructorBody
readList :: ReadS [ConstructorBody]
$creadList :: ReadS [ConstructorBody]
readsPrec :: Int -> ReadS ConstructorBody
$creadsPrec :: Int -> ReadS ConstructorBody
Read,Typeable,forall x. Rep ConstructorBody x -> ConstructorBody
forall x. ConstructorBody -> Rep ConstructorBody x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ConstructorBody x -> ConstructorBody
$cfrom :: forall x. ConstructorBody -> Rep ConstructorBody x
Generic,Typeable ConstructorBody
ConstructorBody -> Constr
ConstructorBody -> DataType
(forall b. Data b => b -> b) -> ConstructorBody -> ConstructorBody
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) -> ConstructorBody -> u
forall u. (forall d. Data d => d -> u) -> ConstructorBody -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructorBody -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructorBody -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ConstructorBody -> m ConstructorBody
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstructorBody -> m ConstructorBody
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstructorBody
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstructorBody -> c ConstructorBody
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstructorBody)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstructorBody)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstructorBody -> m ConstructorBody
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstructorBody -> m ConstructorBody
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstructorBody -> m ConstructorBody
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstructorBody -> m ConstructorBody
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ConstructorBody -> m ConstructorBody
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ConstructorBody -> m ConstructorBody
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ConstructorBody -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ConstructorBody -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ConstructorBody -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ConstructorBody -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructorBody -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructorBody -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructorBody -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ConstructorBody -> r
gmapT :: (forall b. Data b => b -> b) -> ConstructorBody -> ConstructorBody
$cgmapT :: (forall b. Data b => b -> b) -> ConstructorBody -> ConstructorBody
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstructorBody)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ConstructorBody)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstructorBody)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ConstructorBody)
dataTypeOf :: ConstructorBody -> DataType
$cdataTypeOf :: ConstructorBody -> DataType
toConstr :: ConstructorBody -> Constr
$ctoConstr :: ConstructorBody -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstructorBody
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ConstructorBody
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstructorBody -> c ConstructorBody
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ConstructorBody -> c ConstructorBody
Data)
data ExplConstrInv
= ThisInvoke [RefType] [Argument]
| SuperInvoke [RefType] [Argument]
| PrimarySuperInvoke Exp [RefType] [Argument]
deriving (ExplConstrInv -> ExplConstrInv -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExplConstrInv -> ExplConstrInv -> Bool
$c/= :: ExplConstrInv -> ExplConstrInv -> Bool
== :: ExplConstrInv -> ExplConstrInv -> Bool
$c== :: ExplConstrInv -> ExplConstrInv -> Bool
Eq,Int -> ExplConstrInv -> ShowS
[ExplConstrInv] -> ShowS
ExplConstrInv -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExplConstrInv] -> ShowS
$cshowList :: [ExplConstrInv] -> ShowS
show :: ExplConstrInv -> String
$cshow :: ExplConstrInv -> String
showsPrec :: Int -> ExplConstrInv -> ShowS
$cshowsPrec :: Int -> ExplConstrInv -> ShowS
Show,ReadPrec [ExplConstrInv]
ReadPrec ExplConstrInv
Int -> ReadS ExplConstrInv
ReadS [ExplConstrInv]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExplConstrInv]
$creadListPrec :: ReadPrec [ExplConstrInv]
readPrec :: ReadPrec ExplConstrInv
$creadPrec :: ReadPrec ExplConstrInv
readList :: ReadS [ExplConstrInv]
$creadList :: ReadS [ExplConstrInv]
readsPrec :: Int -> ReadS ExplConstrInv
$creadsPrec :: Int -> ReadS ExplConstrInv
Read,Typeable,forall x. Rep ExplConstrInv x -> ExplConstrInv
forall x. ExplConstrInv -> Rep ExplConstrInv x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ExplConstrInv x -> ExplConstrInv
$cfrom :: forall x. ExplConstrInv -> Rep ExplConstrInv x
Generic,Typeable ExplConstrInv
ExplConstrInv -> Constr
ExplConstrInv -> DataType
(forall b. Data b => b -> b) -> ExplConstrInv -> ExplConstrInv
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) -> ExplConstrInv -> u
forall u. (forall d. Data d => d -> u) -> ExplConstrInv -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExplConstrInv -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExplConstrInv -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExplConstrInv
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExplConstrInv -> c ExplConstrInv
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExplConstrInv)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExplConstrInv)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExplConstrInv -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExplConstrInv -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ExplConstrInv -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExplConstrInv -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExplConstrInv -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExplConstrInv -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExplConstrInv -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExplConstrInv -> r
gmapT :: (forall b. Data b => b -> b) -> ExplConstrInv -> ExplConstrInv
$cgmapT :: (forall b. Data b => b -> b) -> ExplConstrInv -> ExplConstrInv
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExplConstrInv)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ExplConstrInv)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExplConstrInv)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExplConstrInv)
dataTypeOf :: ExplConstrInv -> DataType
$cdataTypeOf :: ExplConstrInv -> DataType
toConstr :: ExplConstrInv -> Constr
$ctoConstr :: ExplConstrInv -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExplConstrInv
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExplConstrInv
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExplConstrInv -> c ExplConstrInv
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExplConstrInv -> c ExplConstrInv
Data)
data Modifier
= Public
| Private
| Protected
| Abstract
| Final
| Static
| StrictFP
| Transient
| Volatile
| Native
| Annotation Annotation
| Synchronized_
deriving (Modifier -> Modifier -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Modifier -> Modifier -> Bool
$c/= :: Modifier -> Modifier -> Bool
== :: Modifier -> Modifier -> Bool
$c== :: Modifier -> Modifier -> Bool
Eq,ReadPrec [Modifier]
ReadPrec Modifier
Int -> ReadS Modifier
ReadS [Modifier]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Modifier]
$creadListPrec :: ReadPrec [Modifier]
readPrec :: ReadPrec Modifier
$creadPrec :: ReadPrec Modifier
readList :: ReadS [Modifier]
$creadList :: ReadS [Modifier]
readsPrec :: Int -> ReadS Modifier
$creadsPrec :: Int -> ReadS Modifier
Read,Typeable,forall x. Rep Modifier x -> Modifier
forall x. Modifier -> Rep Modifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Modifier x -> Modifier
$cfrom :: forall x. Modifier -> Rep Modifier x
Generic,Typeable Modifier
Modifier -> Constr
Modifier -> DataType
(forall b. Data b => b -> b) -> Modifier -> Modifier
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) -> Modifier -> u
forall u. (forall d. Data d => d -> u) -> Modifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Modifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Modifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Modifier -> m Modifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Modifier -> m Modifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Modifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Modifier -> c Modifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Modifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Modifier)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Modifier -> m Modifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Modifier -> m Modifier
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Modifier -> m Modifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Modifier -> m Modifier
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Modifier -> m Modifier
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Modifier -> m Modifier
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Modifier -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Modifier -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Modifier -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Modifier -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Modifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Modifier -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Modifier -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Modifier -> r
gmapT :: (forall b. Data b => b -> b) -> Modifier -> Modifier
$cgmapT :: (forall b. Data b => b -> b) -> Modifier -> Modifier
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Modifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Modifier)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Modifier)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Modifier)
dataTypeOf :: Modifier -> DataType
$cdataTypeOf :: Modifier -> DataType
toConstr :: Modifier -> Constr
$ctoConstr :: Modifier -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Modifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Modifier
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Modifier -> c Modifier
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Modifier -> c Modifier
Data)
instance Show Modifier where
show :: Modifier -> String
show Modifier
Public = String
"public"
show Modifier
Private = String
"private"
show Modifier
Protected = String
"protected"
show Modifier
Abstract = String
"abstract"
show Modifier
Final = String
"final"
show Modifier
Static = String
"static"
show Modifier
StrictFP = String
"strictfp"
show Modifier
Transient = String
"transient"
show Modifier
Volatile = String
"volatile"
show Modifier
Native = String
"native"
show (Annotation Annotation
a) = forall a. Show a => a -> String
show Annotation
a
show Modifier
Synchronized_ = String
"synchronized"
data Annotation = NormalAnnotation { Annotation -> Name
annName :: Name
, Annotation -> [(Ident, ElementValue)]
annKV :: [(Ident, ElementValue)] }
| SingleElementAnnotation { annName :: Name
, Annotation -> ElementValue
annValue:: ElementValue }
| MarkerAnnotation { annName :: Name }
deriving (Annotation -> Annotation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Annotation -> Annotation -> Bool
$c/= :: Annotation -> Annotation -> Bool
== :: Annotation -> Annotation -> Bool
$c== :: Annotation -> Annotation -> Bool
Eq,Int -> Annotation -> ShowS
[Annotation] -> ShowS
Annotation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Annotation] -> ShowS
$cshowList :: [Annotation] -> ShowS
show :: Annotation -> String
$cshow :: Annotation -> String
showsPrec :: Int -> Annotation -> ShowS
$cshowsPrec :: Int -> Annotation -> ShowS
Show,ReadPrec [Annotation]
ReadPrec Annotation
Int -> ReadS Annotation
ReadS [Annotation]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Annotation]
$creadListPrec :: ReadPrec [Annotation]
readPrec :: ReadPrec Annotation
$creadPrec :: ReadPrec Annotation
readList :: ReadS [Annotation]
$creadList :: ReadS [Annotation]
readsPrec :: Int -> ReadS Annotation
$creadsPrec :: Int -> ReadS Annotation
Read,Typeable,forall x. Rep Annotation x -> Annotation
forall x. Annotation -> Rep Annotation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Annotation x -> Annotation
$cfrom :: forall x. Annotation -> Rep Annotation x
Generic,Typeable Annotation
Annotation -> Constr
Annotation -> DataType
(forall b. Data b => b -> b) -> Annotation -> Annotation
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) -> Annotation -> u
forall u. (forall d. Data d => d -> u) -> Annotation -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Annotation -> m Annotation
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation -> m Annotation
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Annotation
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation -> c Annotation
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Annotation)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Annotation)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation -> m Annotation
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation -> m Annotation
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation -> m Annotation
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Annotation -> m Annotation
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Annotation -> m Annotation
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Annotation -> m Annotation
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Annotation -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Annotation -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Annotation -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Annotation -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Annotation -> r
gmapT :: (forall b. Data b => b -> b) -> Annotation -> Annotation
$cgmapT :: (forall b. Data b => b -> b) -> Annotation -> Annotation
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Annotation)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Annotation)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Annotation)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Annotation)
dataTypeOf :: Annotation -> DataType
$cdataTypeOf :: Annotation -> DataType
toConstr :: Annotation -> Constr
$ctoConstr :: Annotation -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Annotation
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Annotation
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation -> c Annotation
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Annotation -> c Annotation
Data)
desugarAnnotation :: Annotation -> (Name, [(Ident, ElementValue)])
desugarAnnotation (MarkerAnnotation Name
n) = (Name
n, [])
desugarAnnotation (SingleElementAnnotation Name
n ElementValue
e) = (Name
n, [(String -> Ident
Ident String
"value", ElementValue
e)])
desugarAnnotation (NormalAnnotation Name
n [(Ident, ElementValue)]
kv) = (Name
n, [(Ident, ElementValue)]
kv)
desugarAnnotation' :: Annotation -> Annotation
desugarAnnotation' = forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Name -> [(Ident, ElementValue)] -> Annotation
NormalAnnotation forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotation -> (Name, [(Ident, ElementValue)])
desugarAnnotation
data ElementValue = EVVal VarInit
| EVAnn Annotation
deriving (ElementValue -> ElementValue -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ElementValue -> ElementValue -> Bool
$c/= :: ElementValue -> ElementValue -> Bool
== :: ElementValue -> ElementValue -> Bool
$c== :: ElementValue -> ElementValue -> Bool
Eq,Int -> ElementValue -> ShowS
[ElementValue] -> ShowS
ElementValue -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ElementValue] -> ShowS
$cshowList :: [ElementValue] -> ShowS
show :: ElementValue -> String
$cshow :: ElementValue -> String
showsPrec :: Int -> ElementValue -> ShowS
$cshowsPrec :: Int -> ElementValue -> ShowS
Show,ReadPrec [ElementValue]
ReadPrec ElementValue
Int -> ReadS ElementValue
ReadS [ElementValue]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ElementValue]
$creadListPrec :: ReadPrec [ElementValue]
readPrec :: ReadPrec ElementValue
$creadPrec :: ReadPrec ElementValue
readList :: ReadS [ElementValue]
$creadList :: ReadS [ElementValue]
readsPrec :: Int -> ReadS ElementValue
$creadsPrec :: Int -> ReadS ElementValue
Read,Typeable,forall x. Rep ElementValue x -> ElementValue
forall x. ElementValue -> Rep ElementValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ElementValue x -> ElementValue
$cfrom :: forall x. ElementValue -> Rep ElementValue x
Generic,Typeable ElementValue
ElementValue -> Constr
ElementValue -> DataType
(forall b. Data b => b -> b) -> ElementValue -> ElementValue
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) -> ElementValue -> u
forall u. (forall d. Data d => d -> u) -> ElementValue -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ElementValue -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ElementValue -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ElementValue -> m ElementValue
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ElementValue -> m ElementValue
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ElementValue
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ElementValue -> c ElementValue
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ElementValue)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ElementValue)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ElementValue -> m ElementValue
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ElementValue -> m ElementValue
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ElementValue -> m ElementValue
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ElementValue -> m ElementValue
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ElementValue -> m ElementValue
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ElementValue -> m ElementValue
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ElementValue -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ElementValue -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ElementValue -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ElementValue -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ElementValue -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ElementValue -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ElementValue -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ElementValue -> r
gmapT :: (forall b. Data b => b -> b) -> ElementValue -> ElementValue
$cgmapT :: (forall b. Data b => b -> b) -> ElementValue -> ElementValue
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ElementValue)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ElementValue)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ElementValue)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ElementValue)
dataTypeOf :: ElementValue -> DataType
$cdataTypeOf :: ElementValue -> DataType
toConstr :: ElementValue -> Constr
$ctoConstr :: ElementValue -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ElementValue
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ElementValue
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ElementValue -> c ElementValue
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ElementValue -> c ElementValue
Data)
data Block = Block [BlockStmt]
deriving (Block -> Block -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Block -> Block -> Bool
$c/= :: Block -> Block -> Bool
== :: Block -> Block -> Bool
$c== :: Block -> Block -> Bool
Eq,Int -> Block -> ShowS
[Block] -> ShowS
Block -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Block] -> ShowS
$cshowList :: [Block] -> ShowS
show :: Block -> String
$cshow :: Block -> String
showsPrec :: Int -> Block -> ShowS
$cshowsPrec :: Int -> Block -> ShowS
Show,ReadPrec [Block]
ReadPrec Block
Int -> ReadS Block
ReadS [Block]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Block]
$creadListPrec :: ReadPrec [Block]
readPrec :: ReadPrec Block
$creadPrec :: ReadPrec Block
readList :: ReadS [Block]
$creadList :: ReadS [Block]
readsPrec :: Int -> ReadS Block
$creadsPrec :: Int -> ReadS Block
Read,Typeable,forall x. Rep Block x -> Block
forall x. Block -> Rep Block x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Block x -> Block
$cfrom :: forall x. Block -> Rep Block x
Generic,Typeable Block
Block -> Constr
Block -> DataType
(forall b. Data b => b -> b) -> Block -> Block
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) -> Block -> u
forall u. (forall d. Data d => d -> u) -> Block -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Block -> m Block
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Block -> m Block
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Block
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block -> c Block
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Block)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Block -> m Block
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Block -> m Block
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Block -> m Block
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Block -> m Block
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Block -> m Block
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Block -> m Block
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Block -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Block -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Block -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Block -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r
gmapT :: (forall b. Data b => b -> b) -> Block -> Block
$cgmapT :: (forall b. Data b => b -> b) -> Block -> Block
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Block)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Block)
dataTypeOf :: Block -> DataType
$cdataTypeOf :: Block -> DataType
toConstr :: Block -> Constr
$ctoConstr :: Block -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Block
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Block
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block -> c Block
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Block -> c Block
Data)
data BlockStmt
= BlockStmt Stmt
| LocalClass ClassDecl
| LocalVars [Modifier] Type [VarDecl]
deriving (BlockStmt -> BlockStmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BlockStmt -> BlockStmt -> Bool
$c/= :: BlockStmt -> BlockStmt -> Bool
== :: BlockStmt -> BlockStmt -> Bool
$c== :: BlockStmt -> BlockStmt -> Bool
Eq,Int -> BlockStmt -> ShowS
[BlockStmt] -> ShowS
BlockStmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BlockStmt] -> ShowS
$cshowList :: [BlockStmt] -> ShowS
show :: BlockStmt -> String
$cshow :: BlockStmt -> String
showsPrec :: Int -> BlockStmt -> ShowS
$cshowsPrec :: Int -> BlockStmt -> ShowS
Show,ReadPrec [BlockStmt]
ReadPrec BlockStmt
Int -> ReadS BlockStmt
ReadS [BlockStmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BlockStmt]
$creadListPrec :: ReadPrec [BlockStmt]
readPrec :: ReadPrec BlockStmt
$creadPrec :: ReadPrec BlockStmt
readList :: ReadS [BlockStmt]
$creadList :: ReadS [BlockStmt]
readsPrec :: Int -> ReadS BlockStmt
$creadsPrec :: Int -> ReadS BlockStmt
Read,Typeable,forall x. Rep BlockStmt x -> BlockStmt
forall x. BlockStmt -> Rep BlockStmt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BlockStmt x -> BlockStmt
$cfrom :: forall x. BlockStmt -> Rep BlockStmt x
Generic,Typeable BlockStmt
BlockStmt -> Constr
BlockStmt -> DataType
(forall b. Data b => b -> b) -> BlockStmt -> BlockStmt
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) -> BlockStmt -> u
forall u. (forall d. Data d => d -> u) -> BlockStmt -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlockStmt -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlockStmt -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlockStmt
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlockStmt -> c BlockStmt
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlockStmt)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockStmt)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BlockStmt -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BlockStmt -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> BlockStmt -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BlockStmt -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlockStmt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BlockStmt -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlockStmt -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BlockStmt -> r
gmapT :: (forall b. Data b => b -> b) -> BlockStmt -> BlockStmt
$cgmapT :: (forall b. Data b => b -> b) -> BlockStmt -> BlockStmt
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockStmt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockStmt)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlockStmt)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BlockStmt)
dataTypeOf :: BlockStmt -> DataType
$cdataTypeOf :: BlockStmt -> DataType
toConstr :: BlockStmt -> Constr
$ctoConstr :: BlockStmt -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlockStmt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BlockStmt
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlockStmt -> c BlockStmt
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BlockStmt -> c BlockStmt
Data)
data Stmt
= StmtBlock Block
| IfThen Exp Stmt
| IfThenElse Exp Stmt Stmt
| While Exp Stmt
| BasicFor (Maybe ForInit) (Maybe Exp) (Maybe [Exp]) Stmt
| EnhancedFor [Modifier] Type Ident Exp Stmt
| Empty
| ExpStmt Exp
| Assert Exp (Maybe Exp)
| Switch Exp [SwitchBlock]
| Do Stmt Exp
| Break (Maybe Ident)
| Continue (Maybe Ident)
| Return (Maybe Exp)
| Synchronized Exp Block
| Throw Exp
| Try Block [Catch] (Maybe Block)
| Labeled Ident Stmt
deriving (Stmt -> Stmt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Stmt -> Stmt -> Bool
$c/= :: Stmt -> Stmt -> Bool
== :: Stmt -> Stmt -> Bool
$c== :: Stmt -> Stmt -> Bool
Eq,Int -> Stmt -> ShowS
[Stmt] -> ShowS
Stmt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Stmt] -> ShowS
$cshowList :: [Stmt] -> ShowS
show :: Stmt -> String
$cshow :: Stmt -> String
showsPrec :: Int -> Stmt -> ShowS
$cshowsPrec :: Int -> Stmt -> ShowS
Show,ReadPrec [Stmt]
ReadPrec Stmt
Int -> ReadS Stmt
ReadS [Stmt]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Stmt]
$creadListPrec :: ReadPrec [Stmt]
readPrec :: ReadPrec Stmt
$creadPrec :: ReadPrec Stmt
readList :: ReadS [Stmt]
$creadList :: ReadS [Stmt]
readsPrec :: Int -> ReadS Stmt
$creadsPrec :: Int -> ReadS Stmt
Read,Typeable,forall x. Rep Stmt x -> Stmt
forall x. Stmt -> Rep Stmt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Stmt x -> Stmt
$cfrom :: forall x. Stmt -> Rep Stmt x
Generic,Typeable Stmt
Stmt -> Constr
Stmt -> DataType
(forall b. Data b => b -> b) -> Stmt -> Stmt
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) -> Stmt -> u
forall u. (forall d. Data d => d -> u) -> Stmt -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stmt
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt -> c Stmt
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stmt)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Stmt -> m Stmt
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stmt -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Stmt -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Stmt -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Stmt -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r
gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt
$cgmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stmt)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Stmt)
dataTypeOf :: Stmt -> DataType
$cdataTypeOf :: Stmt -> DataType
toConstr :: Stmt -> Constr
$ctoConstr :: Stmt -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stmt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Stmt
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt -> c Stmt
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Stmt -> c Stmt
Data)
data Catch = Catch FormalParam Block
deriving (Catch -> Catch -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Catch -> Catch -> Bool
$c/= :: Catch -> Catch -> Bool
== :: Catch -> Catch -> Bool
$c== :: Catch -> Catch -> Bool
Eq,Int -> Catch -> ShowS
[Catch] -> ShowS
Catch -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Catch] -> ShowS
$cshowList :: [Catch] -> ShowS
show :: Catch -> String
$cshow :: Catch -> String
showsPrec :: Int -> Catch -> ShowS
$cshowsPrec :: Int -> Catch -> ShowS
Show,ReadPrec [Catch]
ReadPrec Catch
Int -> ReadS Catch
ReadS [Catch]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Catch]
$creadListPrec :: ReadPrec [Catch]
readPrec :: ReadPrec Catch
$creadPrec :: ReadPrec Catch
readList :: ReadS [Catch]
$creadList :: ReadS [Catch]
readsPrec :: Int -> ReadS Catch
$creadsPrec :: Int -> ReadS Catch
Read,Typeable,forall x. Rep Catch x -> Catch
forall x. Catch -> Rep Catch x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Catch x -> Catch
$cfrom :: forall x. Catch -> Rep Catch x
Generic,Typeable Catch
Catch -> Constr
Catch -> DataType
(forall b. Data b => b -> b) -> Catch -> Catch
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) -> Catch -> u
forall u. (forall d. Data d => d -> u) -> Catch -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Catch -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Catch -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Catch -> m Catch
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Catch -> m Catch
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Catch
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Catch -> c Catch
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Catch)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Catch)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Catch -> m Catch
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Catch -> m Catch
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Catch -> m Catch
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Catch -> m Catch
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Catch -> m Catch
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Catch -> m Catch
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Catch -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Catch -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Catch -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Catch -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Catch -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Catch -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Catch -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Catch -> r
gmapT :: (forall b. Data b => b -> b) -> Catch -> Catch
$cgmapT :: (forall b. Data b => b -> b) -> Catch -> Catch
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Catch)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Catch)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Catch)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Catch)
dataTypeOf :: Catch -> DataType
$cdataTypeOf :: Catch -> DataType
toConstr :: Catch -> Constr
$ctoConstr :: Catch -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Catch
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Catch
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Catch -> c Catch
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Catch -> c Catch
Data)
data SwitchBlock
= SwitchBlock SwitchLabel [BlockStmt]
deriving (SwitchBlock -> SwitchBlock -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SwitchBlock -> SwitchBlock -> Bool
$c/= :: SwitchBlock -> SwitchBlock -> Bool
== :: SwitchBlock -> SwitchBlock -> Bool
$c== :: SwitchBlock -> SwitchBlock -> Bool
Eq,Int -> SwitchBlock -> ShowS
[SwitchBlock] -> ShowS
SwitchBlock -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SwitchBlock] -> ShowS
$cshowList :: [SwitchBlock] -> ShowS
show :: SwitchBlock -> String
$cshow :: SwitchBlock -> String
showsPrec :: Int -> SwitchBlock -> ShowS
$cshowsPrec :: Int -> SwitchBlock -> ShowS
Show,ReadPrec [SwitchBlock]
ReadPrec SwitchBlock
Int -> ReadS SwitchBlock
ReadS [SwitchBlock]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SwitchBlock]
$creadListPrec :: ReadPrec [SwitchBlock]
readPrec :: ReadPrec SwitchBlock
$creadPrec :: ReadPrec SwitchBlock
readList :: ReadS [SwitchBlock]
$creadList :: ReadS [SwitchBlock]
readsPrec :: Int -> ReadS SwitchBlock
$creadsPrec :: Int -> ReadS SwitchBlock
Read,Typeable,forall x. Rep SwitchBlock x -> SwitchBlock
forall x. SwitchBlock -> Rep SwitchBlock x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SwitchBlock x -> SwitchBlock
$cfrom :: forall x. SwitchBlock -> Rep SwitchBlock x
Generic,Typeable SwitchBlock
SwitchBlock -> Constr
SwitchBlock -> DataType
(forall b. Data b => b -> b) -> SwitchBlock -> SwitchBlock
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) -> SwitchBlock -> u
forall u. (forall d. Data d => d -> u) -> SwitchBlock -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchBlock -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchBlock -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SwitchBlock
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SwitchBlock -> c SwitchBlock
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SwitchBlock)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SwitchBlock)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SwitchBlock -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SwitchBlock -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SwitchBlock -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SwitchBlock -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchBlock -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchBlock -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchBlock -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchBlock -> r
gmapT :: (forall b. Data b => b -> b) -> SwitchBlock -> SwitchBlock
$cgmapT :: (forall b. Data b => b -> b) -> SwitchBlock -> SwitchBlock
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SwitchBlock)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SwitchBlock)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SwitchBlock)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SwitchBlock)
dataTypeOf :: SwitchBlock -> DataType
$cdataTypeOf :: SwitchBlock -> DataType
toConstr :: SwitchBlock -> Constr
$ctoConstr :: SwitchBlock -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SwitchBlock
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SwitchBlock
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SwitchBlock -> c SwitchBlock
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SwitchBlock -> c SwitchBlock
Data)
data SwitchLabel
= SwitchCase Exp
| Default
deriving (SwitchLabel -> SwitchLabel -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SwitchLabel -> SwitchLabel -> Bool
$c/= :: SwitchLabel -> SwitchLabel -> Bool
== :: SwitchLabel -> SwitchLabel -> Bool
$c== :: SwitchLabel -> SwitchLabel -> Bool
Eq,Int -> SwitchLabel -> ShowS
[SwitchLabel] -> ShowS
SwitchLabel -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SwitchLabel] -> ShowS
$cshowList :: [SwitchLabel] -> ShowS
show :: SwitchLabel -> String
$cshow :: SwitchLabel -> String
showsPrec :: Int -> SwitchLabel -> ShowS
$cshowsPrec :: Int -> SwitchLabel -> ShowS
Show,ReadPrec [SwitchLabel]
ReadPrec SwitchLabel
Int -> ReadS SwitchLabel
ReadS [SwitchLabel]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SwitchLabel]
$creadListPrec :: ReadPrec [SwitchLabel]
readPrec :: ReadPrec SwitchLabel
$creadPrec :: ReadPrec SwitchLabel
readList :: ReadS [SwitchLabel]
$creadList :: ReadS [SwitchLabel]
readsPrec :: Int -> ReadS SwitchLabel
$creadsPrec :: Int -> ReadS SwitchLabel
Read,Typeable,forall x. Rep SwitchLabel x -> SwitchLabel
forall x. SwitchLabel -> Rep SwitchLabel x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SwitchLabel x -> SwitchLabel
$cfrom :: forall x. SwitchLabel -> Rep SwitchLabel x
Generic,Typeable SwitchLabel
SwitchLabel -> Constr
SwitchLabel -> DataType
(forall b. Data b => b -> b) -> SwitchLabel -> SwitchLabel
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) -> SwitchLabel -> u
forall u. (forall d. Data d => d -> u) -> SwitchLabel -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchLabel -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchLabel -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SwitchLabel
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SwitchLabel -> c SwitchLabel
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SwitchLabel)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SwitchLabel)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SwitchLabel -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SwitchLabel -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SwitchLabel -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SwitchLabel -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchLabel -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchLabel -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchLabel -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SwitchLabel -> r
gmapT :: (forall b. Data b => b -> b) -> SwitchLabel -> SwitchLabel
$cgmapT :: (forall b. Data b => b -> b) -> SwitchLabel -> SwitchLabel
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SwitchLabel)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SwitchLabel)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SwitchLabel)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SwitchLabel)
dataTypeOf :: SwitchLabel -> DataType
$cdataTypeOf :: SwitchLabel -> DataType
toConstr :: SwitchLabel -> Constr
$ctoConstr :: SwitchLabel -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SwitchLabel
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SwitchLabel
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SwitchLabel -> c SwitchLabel
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SwitchLabel -> c SwitchLabel
Data)
data ForInit
= ForLocalVars [Modifier] Type [VarDecl]
| ForInitExps [Exp]
deriving (ForInit -> ForInit -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ForInit -> ForInit -> Bool
$c/= :: ForInit -> ForInit -> Bool
== :: ForInit -> ForInit -> Bool
$c== :: ForInit -> ForInit -> Bool
Eq,Int -> ForInit -> ShowS
[ForInit] -> ShowS
ForInit -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ForInit] -> ShowS
$cshowList :: [ForInit] -> ShowS
show :: ForInit -> String
$cshow :: ForInit -> String
showsPrec :: Int -> ForInit -> ShowS
$cshowsPrec :: Int -> ForInit -> ShowS
Show,ReadPrec [ForInit]
ReadPrec ForInit
Int -> ReadS ForInit
ReadS [ForInit]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ForInit]
$creadListPrec :: ReadPrec [ForInit]
readPrec :: ReadPrec ForInit
$creadPrec :: ReadPrec ForInit
readList :: ReadS [ForInit]
$creadList :: ReadS [ForInit]
readsPrec :: Int -> ReadS ForInit
$creadsPrec :: Int -> ReadS ForInit
Read,Typeable,forall x. Rep ForInit x -> ForInit
forall x. ForInit -> Rep ForInit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ForInit x -> ForInit
$cfrom :: forall x. ForInit -> Rep ForInit x
Generic,Typeable ForInit
ForInit -> Constr
ForInit -> DataType
(forall b. Data b => b -> b) -> ForInit -> ForInit
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) -> ForInit -> u
forall u. (forall d. Data d => d -> u) -> ForInit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForInit -> m ForInit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInit -> m ForInit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForInit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInit -> c ForInit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForInit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForInit)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInit -> m ForInit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInit -> m ForInit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInit -> m ForInit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForInit -> m ForInit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForInit -> m ForInit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForInit -> m ForInit
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForInit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForInit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForInit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ForInit -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForInit -> r
gmapT :: (forall b. Data b => b -> b) -> ForInit -> ForInit
$cgmapT :: (forall b. Data b => b -> b) -> ForInit -> ForInit
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForInit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForInit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForInit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForInit)
dataTypeOf :: ForInit -> DataType
$cdataTypeOf :: ForInit -> DataType
toConstr :: ForInit -> Constr
$ctoConstr :: ForInit -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForInit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForInit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInit -> c ForInit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForInit -> c ForInit
Data)
type ExceptionType = RefType
type Argument = Exp
data Exp
= Lit Literal
| ClassLit (Maybe Type)
| This
| ThisClass Name
| InstanceCreation [TypeArgument] TypeDeclSpecifier [Argument] (Maybe ClassBody)
| QualInstanceCreation Exp [TypeArgument] Ident [Argument] (Maybe ClassBody)
| ArrayCreate Type [Exp] Int
| ArrayCreateInit Type Int ArrayInit
| FieldAccess FieldAccess
| MethodInv MethodInvocation
| ArrayAccess ArrayIndex
| ExpName Name
| PostIncrement Exp
| PostDecrement Exp
| PreIncrement Exp
| PreDecrement Exp
| PrePlus Exp
| PreMinus Exp
| PreBitCompl Exp
| PreNot Exp
| Cast Type Exp
| BinOp Exp Op Exp
| InstanceOf Exp RefType
| Cond Exp Exp Exp
| Assign Lhs AssignOp Exp
| Lambda LambdaParams LambdaExpression
| MethodRef Name Ident
deriving (Exp -> Exp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Exp -> Exp -> Bool
$c/= :: Exp -> Exp -> Bool
== :: Exp -> Exp -> Bool
$c== :: Exp -> Exp -> Bool
Eq,Int -> Exp -> ShowS
[Exp] -> ShowS
Exp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Exp] -> ShowS
$cshowList :: [Exp] -> ShowS
show :: Exp -> String
$cshow :: Exp -> String
showsPrec :: Int -> Exp -> ShowS
$cshowsPrec :: Int -> Exp -> ShowS
Show,ReadPrec [Exp]
ReadPrec Exp
Int -> ReadS Exp
ReadS [Exp]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Exp]
$creadListPrec :: ReadPrec [Exp]
readPrec :: ReadPrec Exp
$creadPrec :: ReadPrec Exp
readList :: ReadS [Exp]
$creadList :: ReadS [Exp]
readsPrec :: Int -> ReadS Exp
$creadsPrec :: Int -> ReadS Exp
Read,Typeable,forall x. Rep Exp x -> Exp
forall x. Exp -> Rep Exp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Exp x -> Exp
$cfrom :: forall x. Exp -> Rep Exp x
Generic,Typeable Exp
Exp -> Constr
Exp -> DataType
(forall b. Data b => b -> b) -> Exp -> Exp
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) -> Exp -> u
forall u. (forall d. Data d => d -> u) -> Exp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Exp -> m Exp
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Exp -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Exp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Exp -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r
gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp
$cgmapT :: (forall b. Data b => b -> b) -> Exp -> Exp
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Exp)
dataTypeOf :: Exp -> DataType
$cdataTypeOf :: Exp -> DataType
toConstr :: Exp -> Constr
$ctoConstr :: Exp -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Exp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Exp -> c Exp
Data)
data Lhs
= NameLhs Name
| FieldLhs FieldAccess
| ArrayLhs ArrayIndex
deriving (Lhs -> Lhs -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Lhs -> Lhs -> Bool
$c/= :: Lhs -> Lhs -> Bool
== :: Lhs -> Lhs -> Bool
$c== :: Lhs -> Lhs -> Bool
Eq,Int -> Lhs -> ShowS
[Lhs] -> ShowS
Lhs -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Lhs] -> ShowS
$cshowList :: [Lhs] -> ShowS
show :: Lhs -> String
$cshow :: Lhs -> String
showsPrec :: Int -> Lhs -> ShowS
$cshowsPrec :: Int -> Lhs -> ShowS
Show,ReadPrec [Lhs]
ReadPrec Lhs
Int -> ReadS Lhs
ReadS [Lhs]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Lhs]
$creadListPrec :: ReadPrec [Lhs]
readPrec :: ReadPrec Lhs
$creadPrec :: ReadPrec Lhs
readList :: ReadS [Lhs]
$creadList :: ReadS [Lhs]
readsPrec :: Int -> ReadS Lhs
$creadsPrec :: Int -> ReadS Lhs
Read,Typeable,forall x. Rep Lhs x -> Lhs
forall x. Lhs -> Rep Lhs x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Lhs x -> Lhs
$cfrom :: forall x. Lhs -> Rep Lhs x
Generic,Typeable Lhs
Lhs -> Constr
Lhs -> DataType
(forall b. Data b => b -> b) -> Lhs -> Lhs
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) -> Lhs -> u
forall u. (forall d. Data d => d -> u) -> Lhs -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lhs -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lhs -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Lhs -> m Lhs
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lhs -> m Lhs
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lhs
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lhs -> c Lhs
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Lhs)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lhs)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lhs -> m Lhs
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lhs -> m Lhs
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lhs -> m Lhs
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lhs -> m Lhs
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Lhs -> m Lhs
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Lhs -> m Lhs
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Lhs -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Lhs -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Lhs -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Lhs -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lhs -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lhs -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lhs -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lhs -> r
gmapT :: (forall b. Data b => b -> b) -> Lhs -> Lhs
$cgmapT :: (forall b. Data b => b -> b) -> Lhs -> Lhs
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lhs)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lhs)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Lhs)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Lhs)
dataTypeOf :: Lhs -> DataType
$cdataTypeOf :: Lhs -> DataType
toConstr :: Lhs -> Constr
$ctoConstr :: Lhs -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lhs
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lhs
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lhs -> c Lhs
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lhs -> c Lhs
Data)
data ArrayIndex = ArrayIndex Exp [Exp]
deriving (ArrayIndex -> ArrayIndex -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrayIndex -> ArrayIndex -> Bool
$c/= :: ArrayIndex -> ArrayIndex -> Bool
== :: ArrayIndex -> ArrayIndex -> Bool
$c== :: ArrayIndex -> ArrayIndex -> Bool
Eq,Int -> ArrayIndex -> ShowS
[ArrayIndex] -> ShowS
ArrayIndex -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrayIndex] -> ShowS
$cshowList :: [ArrayIndex] -> ShowS
show :: ArrayIndex -> String
$cshow :: ArrayIndex -> String
showsPrec :: Int -> ArrayIndex -> ShowS
$cshowsPrec :: Int -> ArrayIndex -> ShowS
Show,ReadPrec [ArrayIndex]
ReadPrec ArrayIndex
Int -> ReadS ArrayIndex
ReadS [ArrayIndex]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ArrayIndex]
$creadListPrec :: ReadPrec [ArrayIndex]
readPrec :: ReadPrec ArrayIndex
$creadPrec :: ReadPrec ArrayIndex
readList :: ReadS [ArrayIndex]
$creadList :: ReadS [ArrayIndex]
readsPrec :: Int -> ReadS ArrayIndex
$creadsPrec :: Int -> ReadS ArrayIndex
Read,Typeable,forall x. Rep ArrayIndex x -> ArrayIndex
forall x. ArrayIndex -> Rep ArrayIndex x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ArrayIndex x -> ArrayIndex
$cfrom :: forall x. ArrayIndex -> Rep ArrayIndex x
Generic,Typeable ArrayIndex
ArrayIndex -> Constr
ArrayIndex -> DataType
(forall b. Data b => b -> b) -> ArrayIndex -> ArrayIndex
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) -> ArrayIndex -> u
forall u. (forall d. Data d => d -> u) -> ArrayIndex -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayIndex -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayIndex -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArrayIndex
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArrayIndex -> c ArrayIndex
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArrayIndex)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayIndex)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArrayIndex -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArrayIndex -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ArrayIndex -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ArrayIndex -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayIndex -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayIndex -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayIndex -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayIndex -> r
gmapT :: (forall b. Data b => b -> b) -> ArrayIndex -> ArrayIndex
$cgmapT :: (forall b. Data b => b -> b) -> ArrayIndex -> ArrayIndex
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayIndex)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayIndex)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArrayIndex)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArrayIndex)
dataTypeOf :: ArrayIndex -> DataType
$cdataTypeOf :: ArrayIndex -> DataType
toConstr :: ArrayIndex -> Constr
$ctoConstr :: ArrayIndex -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArrayIndex
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArrayIndex
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArrayIndex -> c ArrayIndex
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArrayIndex -> c ArrayIndex
Data)
data FieldAccess
= PrimaryFieldAccess Exp Ident
| SuperFieldAccess Ident
| ClassFieldAccess Name Ident
deriving (FieldAccess -> FieldAccess -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldAccess -> FieldAccess -> Bool
$c/= :: FieldAccess -> FieldAccess -> Bool
== :: FieldAccess -> FieldAccess -> Bool
$c== :: FieldAccess -> FieldAccess -> Bool
Eq,Int -> FieldAccess -> ShowS
[FieldAccess] -> ShowS
FieldAccess -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FieldAccess] -> ShowS
$cshowList :: [FieldAccess] -> ShowS
show :: FieldAccess -> String
$cshow :: FieldAccess -> String
showsPrec :: Int -> FieldAccess -> ShowS
$cshowsPrec :: Int -> FieldAccess -> ShowS
Show,ReadPrec [FieldAccess]
ReadPrec FieldAccess
Int -> ReadS FieldAccess
ReadS [FieldAccess]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FieldAccess]
$creadListPrec :: ReadPrec [FieldAccess]
readPrec :: ReadPrec FieldAccess
$creadPrec :: ReadPrec FieldAccess
readList :: ReadS [FieldAccess]
$creadList :: ReadS [FieldAccess]
readsPrec :: Int -> ReadS FieldAccess
$creadsPrec :: Int -> ReadS FieldAccess
Read,Typeable,forall x. Rep FieldAccess x -> FieldAccess
forall x. FieldAccess -> Rep FieldAccess x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FieldAccess x -> FieldAccess
$cfrom :: forall x. FieldAccess -> Rep FieldAccess x
Generic,Typeable FieldAccess
FieldAccess -> Constr
FieldAccess -> DataType
(forall b. Data b => b -> b) -> FieldAccess -> FieldAccess
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) -> FieldAccess -> u
forall u. (forall d. Data d => d -> u) -> FieldAccess -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldAccess -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldAccess -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldAccess
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldAccess -> c FieldAccess
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldAccess)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FieldAccess)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldAccess -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FieldAccess -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> FieldAccess -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FieldAccess -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldAccess -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FieldAccess -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldAccess -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FieldAccess -> r
gmapT :: (forall b. Data b => b -> b) -> FieldAccess -> FieldAccess
$cgmapT :: (forall b. Data b => b -> b) -> FieldAccess -> FieldAccess
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FieldAccess)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FieldAccess)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldAccess)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FieldAccess)
dataTypeOf :: FieldAccess -> DataType
$cdataTypeOf :: FieldAccess -> DataType
toConstr :: FieldAccess -> Constr
$ctoConstr :: FieldAccess -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldAccess
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FieldAccess
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldAccess -> c FieldAccess
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FieldAccess -> c FieldAccess
Data)
data LambdaParams
= LambdaSingleParam Ident
| LambdaFormalParams [FormalParam]
| LambdaInferredParams [Ident]
deriving (LambdaParams -> LambdaParams -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LambdaParams -> LambdaParams -> Bool
$c/= :: LambdaParams -> LambdaParams -> Bool
== :: LambdaParams -> LambdaParams -> Bool
$c== :: LambdaParams -> LambdaParams -> Bool
Eq,Int -> LambdaParams -> ShowS
[LambdaParams] -> ShowS
LambdaParams -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LambdaParams] -> ShowS
$cshowList :: [LambdaParams] -> ShowS
show :: LambdaParams -> String
$cshow :: LambdaParams -> String
showsPrec :: Int -> LambdaParams -> ShowS
$cshowsPrec :: Int -> LambdaParams -> ShowS
Show,ReadPrec [LambdaParams]
ReadPrec LambdaParams
Int -> ReadS LambdaParams
ReadS [LambdaParams]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LambdaParams]
$creadListPrec :: ReadPrec [LambdaParams]
readPrec :: ReadPrec LambdaParams
$creadPrec :: ReadPrec LambdaParams
readList :: ReadS [LambdaParams]
$creadList :: ReadS [LambdaParams]
readsPrec :: Int -> ReadS LambdaParams
$creadsPrec :: Int -> ReadS LambdaParams
Read,Typeable,forall x. Rep LambdaParams x -> LambdaParams
forall x. LambdaParams -> Rep LambdaParams x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LambdaParams x -> LambdaParams
$cfrom :: forall x. LambdaParams -> Rep LambdaParams x
Generic,Typeable LambdaParams
LambdaParams -> Constr
LambdaParams -> DataType
(forall b. Data b => b -> b) -> LambdaParams -> LambdaParams
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) -> LambdaParams -> u
forall u. (forall d. Data d => d -> u) -> LambdaParams -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaParams -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaParams -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LambdaParams
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LambdaParams -> c LambdaParams
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LambdaParams)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LambdaParams)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LambdaParams -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LambdaParams -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> LambdaParams -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LambdaParams -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaParams -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaParams -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaParams -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaParams -> r
gmapT :: (forall b. Data b => b -> b) -> LambdaParams -> LambdaParams
$cgmapT :: (forall b. Data b => b -> b) -> LambdaParams -> LambdaParams
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LambdaParams)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LambdaParams)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LambdaParams)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LambdaParams)
dataTypeOf :: LambdaParams -> DataType
$cdataTypeOf :: LambdaParams -> DataType
toConstr :: LambdaParams -> Constr
$ctoConstr :: LambdaParams -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LambdaParams
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LambdaParams
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LambdaParams -> c LambdaParams
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LambdaParams -> c LambdaParams
Data)
data LambdaExpression
= LambdaExpression Exp
| LambdaBlock Block
deriving (LambdaExpression -> LambdaExpression -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LambdaExpression -> LambdaExpression -> Bool
$c/= :: LambdaExpression -> LambdaExpression -> Bool
== :: LambdaExpression -> LambdaExpression -> Bool
$c== :: LambdaExpression -> LambdaExpression -> Bool
Eq,Int -> LambdaExpression -> ShowS
[LambdaExpression] -> ShowS
LambdaExpression -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LambdaExpression] -> ShowS
$cshowList :: [LambdaExpression] -> ShowS
show :: LambdaExpression -> String
$cshow :: LambdaExpression -> String
showsPrec :: Int -> LambdaExpression -> ShowS
$cshowsPrec :: Int -> LambdaExpression -> ShowS
Show,ReadPrec [LambdaExpression]
ReadPrec LambdaExpression
Int -> ReadS LambdaExpression
ReadS [LambdaExpression]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LambdaExpression]
$creadListPrec :: ReadPrec [LambdaExpression]
readPrec :: ReadPrec LambdaExpression
$creadPrec :: ReadPrec LambdaExpression
readList :: ReadS [LambdaExpression]
$creadList :: ReadS [LambdaExpression]
readsPrec :: Int -> ReadS LambdaExpression
$creadsPrec :: Int -> ReadS LambdaExpression
Read,Typeable,forall x. Rep LambdaExpression x -> LambdaExpression
forall x. LambdaExpression -> Rep LambdaExpression x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LambdaExpression x -> LambdaExpression
$cfrom :: forall x. LambdaExpression -> Rep LambdaExpression x
Generic,Typeable LambdaExpression
LambdaExpression -> Constr
LambdaExpression -> DataType
(forall b. Data b => b -> b)
-> LambdaExpression -> LambdaExpression
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) -> LambdaExpression -> u
forall u. (forall d. Data d => d -> u) -> LambdaExpression -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaExpression -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaExpression -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LambdaExpression -> m LambdaExpression
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LambdaExpression -> m LambdaExpression
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LambdaExpression
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LambdaExpression -> c LambdaExpression
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LambdaExpression)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LambdaExpression)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LambdaExpression -> m LambdaExpression
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LambdaExpression -> m LambdaExpression
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LambdaExpression -> m LambdaExpression
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> LambdaExpression -> m LambdaExpression
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LambdaExpression -> m LambdaExpression
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> LambdaExpression -> m LambdaExpression
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LambdaExpression -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> LambdaExpression -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> LambdaExpression -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LambdaExpression -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaExpression -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaExpression -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaExpression -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LambdaExpression -> r
gmapT :: (forall b. Data b => b -> b)
-> LambdaExpression -> LambdaExpression
$cgmapT :: (forall b. Data b => b -> b)
-> LambdaExpression -> LambdaExpression
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LambdaExpression)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LambdaExpression)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LambdaExpression)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LambdaExpression)
dataTypeOf :: LambdaExpression -> DataType
$cdataTypeOf :: LambdaExpression -> DataType
toConstr :: LambdaExpression -> Constr
$ctoConstr :: LambdaExpression -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LambdaExpression
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LambdaExpression
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LambdaExpression -> c LambdaExpression
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LambdaExpression -> c LambdaExpression
Data)
data MethodInvocation
= MethodCall Name [Argument]
| PrimaryMethodCall Exp [RefType] Ident [Argument]
| SuperMethodCall [RefType] Ident [Argument]
| ClassMethodCall Name [RefType] Ident [Argument]
| TypeMethodCall Name [RefType] Ident [Argument]
deriving (MethodInvocation -> MethodInvocation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MethodInvocation -> MethodInvocation -> Bool
$c/= :: MethodInvocation -> MethodInvocation -> Bool
== :: MethodInvocation -> MethodInvocation -> Bool
$c== :: MethodInvocation -> MethodInvocation -> Bool
Eq,Int -> MethodInvocation -> ShowS
[MethodInvocation] -> ShowS
MethodInvocation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MethodInvocation] -> ShowS
$cshowList :: [MethodInvocation] -> ShowS
show :: MethodInvocation -> String
$cshow :: MethodInvocation -> String
showsPrec :: Int -> MethodInvocation -> ShowS
$cshowsPrec :: Int -> MethodInvocation -> ShowS
Show,ReadPrec [MethodInvocation]
ReadPrec MethodInvocation
Int -> ReadS MethodInvocation
ReadS [MethodInvocation]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [MethodInvocation]
$creadListPrec :: ReadPrec [MethodInvocation]
readPrec :: ReadPrec MethodInvocation
$creadPrec :: ReadPrec MethodInvocation
readList :: ReadS [MethodInvocation]
$creadList :: ReadS [MethodInvocation]
readsPrec :: Int -> ReadS MethodInvocation
$creadsPrec :: Int -> ReadS MethodInvocation
Read,Typeable,forall x. Rep MethodInvocation x -> MethodInvocation
forall x. MethodInvocation -> Rep MethodInvocation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MethodInvocation x -> MethodInvocation
$cfrom :: forall x. MethodInvocation -> Rep MethodInvocation x
Generic,Typeable MethodInvocation
MethodInvocation -> Constr
MethodInvocation -> DataType
(forall b. Data b => b -> b)
-> MethodInvocation -> MethodInvocation
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) -> MethodInvocation -> u
forall u. (forall d. Data d => d -> u) -> MethodInvocation -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodInvocation -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodInvocation -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MethodInvocation -> m MethodInvocation
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MethodInvocation -> m MethodInvocation
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodInvocation
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodInvocation -> c MethodInvocation
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodInvocation)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MethodInvocation)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MethodInvocation -> m MethodInvocation
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MethodInvocation -> m MethodInvocation
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MethodInvocation -> m MethodInvocation
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MethodInvocation -> m MethodInvocation
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MethodInvocation -> m MethodInvocation
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MethodInvocation -> m MethodInvocation
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MethodInvocation -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> MethodInvocation -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MethodInvocation -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MethodInvocation -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodInvocation -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MethodInvocation -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodInvocation -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MethodInvocation -> r
gmapT :: (forall b. Data b => b -> b)
-> MethodInvocation -> MethodInvocation
$cgmapT :: (forall b. Data b => b -> b)
-> MethodInvocation -> MethodInvocation
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MethodInvocation)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MethodInvocation)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodInvocation)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MethodInvocation)
dataTypeOf :: MethodInvocation -> DataType
$cdataTypeOf :: MethodInvocation -> DataType
toConstr :: MethodInvocation -> Constr
$ctoConstr :: MethodInvocation -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodInvocation
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MethodInvocation
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodInvocation -> c MethodInvocation
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MethodInvocation -> c MethodInvocation
Data)
data ArrayInit
= ArrayInit [VarInit]
deriving (ArrayInit -> ArrayInit -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrayInit -> ArrayInit -> Bool
$c/= :: ArrayInit -> ArrayInit -> Bool
== :: ArrayInit -> ArrayInit -> Bool
$c== :: ArrayInit -> ArrayInit -> Bool
Eq,Int -> ArrayInit -> ShowS
[ArrayInit] -> ShowS
ArrayInit -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrayInit] -> ShowS
$cshowList :: [ArrayInit] -> ShowS
show :: ArrayInit -> String
$cshow :: ArrayInit -> String
showsPrec :: Int -> ArrayInit -> ShowS
$cshowsPrec :: Int -> ArrayInit -> ShowS
Show,ReadPrec [ArrayInit]
ReadPrec ArrayInit
Int -> ReadS ArrayInit
ReadS [ArrayInit]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ArrayInit]
$creadListPrec :: ReadPrec [ArrayInit]
readPrec :: ReadPrec ArrayInit
$creadPrec :: ReadPrec ArrayInit
readList :: ReadS [ArrayInit]
$creadList :: ReadS [ArrayInit]
readsPrec :: Int -> ReadS ArrayInit
$creadsPrec :: Int -> ReadS ArrayInit
Read,Typeable,forall x. Rep ArrayInit x -> ArrayInit
forall x. ArrayInit -> Rep ArrayInit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ArrayInit x -> ArrayInit
$cfrom :: forall x. ArrayInit -> Rep ArrayInit x
Generic,Typeable ArrayInit
ArrayInit -> Constr
ArrayInit -> DataType
(forall b. Data b => b -> b) -> ArrayInit -> ArrayInit
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) -> ArrayInit -> u
forall u. (forall d. Data d => d -> u) -> ArrayInit -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayInit -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayInit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArrayInit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArrayInit -> c ArrayInit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArrayInit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayInit)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArrayInit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArrayInit -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ArrayInit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ArrayInit -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayInit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayInit -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayInit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayInit -> r
gmapT :: (forall b. Data b => b -> b) -> ArrayInit -> ArrayInit
$cgmapT :: (forall b. Data b => b -> b) -> ArrayInit -> ArrayInit
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayInit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayInit)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArrayInit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArrayInit)
dataTypeOf :: ArrayInit -> DataType
$cdataTypeOf :: ArrayInit -> DataType
toConstr :: ArrayInit -> Constr
$ctoConstr :: ArrayInit -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArrayInit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArrayInit
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArrayInit -> c ArrayInit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArrayInit -> c ArrayInit
Data)