language-java-0.2.8: Manipulating Java source: abstract syntax, lexer, parser, and pretty-printer

Safe HaskellSafe
LanguageHaskell98

Language.Java.Syntax

Synopsis

Documentation

data CompilationUnit #

A compilation unit is the top level syntactic goal symbol of a Java program.

Instances

Eq CompilationUnit # 
Data CompilationUnit # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CompilationUnit -> c CompilationUnit #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompilationUnit #

toConstr :: CompilationUnit -> Constr #

dataTypeOf :: CompilationUnit -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CompilationUnit) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompilationUnit) #

gmapT :: (forall b. Data b => b -> b) -> CompilationUnit -> CompilationUnit #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompilationUnit -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompilationUnit -> r #

gmapQ :: (forall d. Data d => d -> u) -> CompilationUnit -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CompilationUnit -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompilationUnit -> m CompilationUnit #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompilationUnit -> m CompilationUnit #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompilationUnit -> m CompilationUnit #

Ord CompilationUnit # 
Show CompilationUnit # 
Generic CompilationUnit # 
Pretty CompilationUnit # 
type Rep CompilationUnit # 

data PackageDecl #

A package declaration appears within a compilation unit to indicate the package to which the compilation unit belongs.

Constructors

PackageDecl Name 

Instances

Eq PackageDecl # 
Data PackageDecl # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PackageDecl -> c PackageDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PackageDecl #

toConstr :: PackageDecl -> Constr #

dataTypeOf :: PackageDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PackageDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PackageDecl) #

gmapT :: (forall b. Data b => b -> b) -> PackageDecl -> PackageDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PackageDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PackageDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> PackageDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PackageDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageDecl -> m PackageDecl #

Ord PackageDecl # 
Show PackageDecl # 
Generic PackageDecl # 

Associated Types

type Rep PackageDecl :: * -> * #

Pretty PackageDecl # 
type Rep PackageDecl # 
type Rep PackageDecl = D1 (MetaData "PackageDecl" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "PackageDecl" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)))

data ImportDecl #

An import declaration allows a static member or a named type to be referred to by a single unqualified identifier. The first argument signals whether the declaration only imports static members. The last argument signals whether the declaration brings all names in the named type or package, or only brings a single name into scope.

Constructors

ImportDecl Bool Name Bool 

Instances

Eq ImportDecl # 
Data ImportDecl # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportDecl -> c ImportDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportDecl #

toConstr :: ImportDecl -> Constr #

dataTypeOf :: ImportDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ImportDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportDecl) #

gmapT :: (forall b. Data b => b -> b) -> ImportDecl -> ImportDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImportDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl -> m ImportDecl #

Ord ImportDecl # 
Show ImportDecl # 
Generic ImportDecl # 

Associated Types

type Rep ImportDecl :: * -> * #

Pretty ImportDecl # 
type Rep ImportDecl # 

data TypeDecl #

A type declaration declares a class type or an interface type.

Instances

Eq TypeDecl # 
Data TypeDecl # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeDecl -> c TypeDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeDecl #

toConstr :: TypeDecl -> Constr #

dataTypeOf :: TypeDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TypeDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeDecl) #

gmapT :: (forall b. Data b => b -> b) -> TypeDecl -> TypeDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> TypeDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeDecl -> m TypeDecl #

Ord TypeDecl # 
Show TypeDecl # 
Generic TypeDecl # 

Associated Types

type Rep TypeDecl :: * -> * #

Methods

from :: TypeDecl -> Rep TypeDecl x #

to :: Rep TypeDecl x -> TypeDecl #

Pretty TypeDecl # 

Methods

pretty :: TypeDecl -> Doc #

prettyPrec :: Int -> TypeDecl -> Doc #

type Rep TypeDecl # 
type Rep TypeDecl = D1 (MetaData "TypeDecl" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "ClassTypeDecl" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ClassDecl))) (C1 (MetaCons "InterfaceTypeDecl" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 InterfaceDecl))))

data ClassDecl #

A class declaration specifies a new named reference type.

Instances

Eq ClassDecl # 
Data ClassDecl # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClassDecl -> c ClassDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ClassDecl #

toConstr :: ClassDecl -> Constr #

dataTypeOf :: ClassDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ClassDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassDecl) #

gmapT :: (forall b. Data b => b -> b) -> ClassDecl -> ClassDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClassDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClassDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> ClassDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ClassDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassDecl -> m ClassDecl #

Ord ClassDecl # 
Show ClassDecl # 
Generic ClassDecl # 

Associated Types

type Rep ClassDecl :: * -> * #

Pretty ClassDecl # 
type Rep ClassDecl # 

data ClassBody #

A class body may contain declarations of members of the class, that is, fields, classes, interfaces and methods. A class body may also contain instance initializers, static initializers, and declarations of constructors for the class.

Constructors

ClassBody [Decl] 

Instances

Eq ClassBody # 
Data ClassBody # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClassBody -> c ClassBody #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ClassBody #

toConstr :: ClassBody -> Constr #

dataTypeOf :: ClassBody -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ClassBody) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassBody) #

gmapT :: (forall b. Data b => b -> b) -> ClassBody -> ClassBody #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClassBody -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClassBody -> r #

gmapQ :: (forall d. Data d => d -> u) -> ClassBody -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ClassBody -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClassBody -> m ClassBody #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassBody -> m ClassBody #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassBody -> m ClassBody #

Ord ClassBody # 
Show ClassBody # 
Generic ClassBody # 

Associated Types

type Rep ClassBody :: * -> * #

Pretty ClassBody # 
type Rep ClassBody # 
type Rep ClassBody = D1 (MetaData "ClassBody" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "ClassBody" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl])))

data EnumBody #

The body of an enum type may contain enum constants.

Constructors

EnumBody [EnumConstant] [Decl] 

Instances

Eq EnumBody # 
Data EnumBody # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EnumBody -> c EnumBody #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EnumBody #

toConstr :: EnumBody -> Constr #

dataTypeOf :: EnumBody -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c EnumBody) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumBody) #

gmapT :: (forall b. Data b => b -> b) -> EnumBody -> EnumBody #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EnumBody -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EnumBody -> r #

gmapQ :: (forall d. Data d => d -> u) -> EnumBody -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> EnumBody -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EnumBody -> m EnumBody #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EnumBody -> m EnumBody #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EnumBody -> m EnumBody #

Ord EnumBody # 
Show EnumBody # 
Generic EnumBody # 

Associated Types

type Rep EnumBody :: * -> * #

Methods

from :: EnumBody -> Rep EnumBody x #

to :: Rep EnumBody x -> EnumBody #

Pretty EnumBody # 

Methods

pretty :: EnumBody -> Doc #

prettyPrec :: Int -> EnumBody -> Doc #

type Rep EnumBody # 
type Rep EnumBody = D1 (MetaData "EnumBody" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "EnumBody" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [EnumConstant])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Decl]))))

data EnumConstant #

An enum constant defines an instance of the enum type.

Instances

Eq EnumConstant # 
Data EnumConstant # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EnumConstant -> c EnumConstant #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EnumConstant #

toConstr :: EnumConstant -> Constr #

dataTypeOf :: EnumConstant -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c EnumConstant) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnumConstant) #

gmapT :: (forall b. Data b => b -> b) -> EnumConstant -> EnumConstant #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EnumConstant -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EnumConstant -> r #

gmapQ :: (forall d. Data d => d -> u) -> EnumConstant -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> EnumConstant -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EnumConstant -> m EnumConstant #

Ord EnumConstant # 
Show EnumConstant # 
Generic EnumConstant # 

Associated Types

type Rep EnumConstant :: * -> * #

Pretty EnumConstant # 
type Rep EnumConstant # 

data InterfaceDecl #

An interface declaration introduces a new reference type whose members are classes, interfaces, constants and abstract methods. This type has no implementation, but otherwise unrelated classes can implement it by providing implementations for its abstract methods.

Instances

Eq InterfaceDecl # 
Data InterfaceDecl # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InterfaceDecl -> c InterfaceDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InterfaceDecl #

toConstr :: InterfaceDecl -> Constr #

dataTypeOf :: InterfaceDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c InterfaceDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InterfaceDecl) #

gmapT :: (forall b. Data b => b -> b) -> InterfaceDecl -> InterfaceDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InterfaceDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InterfaceDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> InterfaceDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InterfaceDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InterfaceDecl -> m InterfaceDecl #

Ord InterfaceDecl # 
Show InterfaceDecl # 
Generic InterfaceDecl # 

Associated Types

type Rep InterfaceDecl :: * -> * #

Pretty InterfaceDecl # 
type Rep InterfaceDecl # 

data InterfaceBody #

The body of an interface may declare members of the interface.

Constructors

InterfaceBody [MemberDecl] 

Instances

Eq InterfaceBody # 
Data InterfaceBody # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InterfaceBody -> c InterfaceBody #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InterfaceBody #

toConstr :: InterfaceBody -> Constr #

dataTypeOf :: InterfaceBody -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c InterfaceBody) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InterfaceBody) #

gmapT :: (forall b. Data b => b -> b) -> InterfaceBody -> InterfaceBody #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InterfaceBody -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InterfaceBody -> r #

gmapQ :: (forall d. Data d => d -> u) -> InterfaceBody -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InterfaceBody -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InterfaceBody -> m InterfaceBody #

Ord InterfaceBody # 
Show InterfaceBody # 
Generic InterfaceBody # 

Associated Types

type Rep InterfaceBody :: * -> * #

Pretty InterfaceBody # 
type Rep InterfaceBody # 
type Rep InterfaceBody = D1 (MetaData "InterfaceBody" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "InterfaceBody" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [MemberDecl])))

data Decl #

A declaration is either a member declaration, or a declaration of an initializer, which may be static.

Instances

Eq Decl # 

Methods

(==) :: Decl -> Decl -> Bool #

(/=) :: Decl -> Decl -> Bool #

Data Decl # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Decl -> c Decl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Decl #

toConstr :: Decl -> Constr #

dataTypeOf :: Decl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Decl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Decl) #

gmapT :: (forall b. Data b => b -> b) -> Decl -> Decl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl -> r #

gmapQ :: (forall d. Data d => d -> u) -> Decl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Decl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Decl -> m Decl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl -> m Decl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl -> m Decl #

Ord Decl # 

Methods

compare :: Decl -> Decl -> Ordering #

(<) :: Decl -> Decl -> Bool #

(<=) :: Decl -> Decl -> Bool #

(>) :: Decl -> Decl -> Bool #

(>=) :: Decl -> Decl -> Bool #

max :: Decl -> Decl -> Decl #

min :: Decl -> Decl -> Decl #

Show Decl # 

Methods

showsPrec :: Int -> Decl -> ShowS #

show :: Decl -> String #

showList :: [Decl] -> ShowS #

Generic Decl # 

Associated Types

type Rep Decl :: * -> * #

Methods

from :: Decl -> Rep Decl x #

to :: Rep Decl x -> Decl #

Pretty Decl # 

Methods

pretty :: Decl -> Doc #

prettyPrec :: Int -> Decl -> Doc #

type Rep Decl # 

data MemberDecl #

A class or interface member can be an inner class or interface, a field or constant, or a method or constructor. An interface may only have as members constants (not fields), abstract methods, and no constructors.

Constructors

FieldDecl [Modifier] Type [VarDecl]

The variables of a class type are introduced by field declarations.

MethodDecl [Modifier] [TypeParam] (Maybe Type) Ident [FormalParam] [ExceptionType] MethodBody

A method declares executable code that can be invoked, passing a fixed number of values as arguments.

ConstructorDecl [Modifier] [TypeParam] Ident [FormalParam] [ExceptionType] ConstructorBody

A constructor is used in the creation of an object that is an instance of a class.

MemberClassDecl ClassDecl

A member class is a class whose declaration is directly enclosed in another class or interface declaration.

MemberInterfaceDecl InterfaceDecl

A member interface is an interface whose declaration is directly enclosed in another class or interface declaration.

Instances

Eq MemberDecl # 
Data MemberDecl # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MemberDecl -> c MemberDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MemberDecl #

toConstr :: MemberDecl -> Constr #

dataTypeOf :: MemberDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MemberDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MemberDecl) #

gmapT :: (forall b. Data b => b -> b) -> MemberDecl -> MemberDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MemberDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MemberDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> MemberDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MemberDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MemberDecl -> m MemberDecl #

Ord MemberDecl # 
Show MemberDecl # 
Generic MemberDecl # 

Associated Types

type Rep MemberDecl :: * -> * #

Pretty MemberDecl # 
type Rep MemberDecl # 
type Rep MemberDecl = D1 (MetaData "MemberDecl" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) ((:+:) (C1 (MetaCons "FieldDecl" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Modifier])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [VarDecl]))))) (C1 (MetaCons "MethodDecl" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Modifier])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TypeParam])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Type))))) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FormalParam]))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ExceptionType])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 MethodBody))))))) ((:+:) (C1 (MetaCons "ConstructorDecl" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Modifier])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TypeParam])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FormalParam])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [ExceptionType])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ConstructorBody)))))) ((:+:) (C1 (MetaCons "MemberClassDecl" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ClassDecl))) (C1 (MetaCons "MemberInterfaceDecl" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 InterfaceDecl))))))

data VarDecl #

A declaration of a variable, which may be explicitly initialized.

Constructors

VarDecl VarDeclId (Maybe VarInit) 

Instances

Eq VarDecl # 

Methods

(==) :: VarDecl -> VarDecl -> Bool #

(/=) :: VarDecl -> VarDecl -> Bool #

Data VarDecl # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VarDecl -> c VarDecl #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VarDecl #

toConstr :: VarDecl -> Constr #

dataTypeOf :: VarDecl -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c VarDecl) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarDecl) #

gmapT :: (forall b. Data b => b -> b) -> VarDecl -> VarDecl #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarDecl -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarDecl -> r #

gmapQ :: (forall d. Data d => d -> u) -> VarDecl -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> VarDecl -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VarDecl -> m VarDecl #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VarDecl -> m VarDecl #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VarDecl -> m VarDecl #

Ord VarDecl # 
Show VarDecl # 
Generic VarDecl # 

Associated Types

type Rep VarDecl :: * -> * #

Methods

from :: VarDecl -> Rep VarDecl x #

to :: Rep VarDecl x -> VarDecl #

Pretty VarDecl # 

Methods

pretty :: VarDecl -> Doc #

prettyPrec :: Int -> VarDecl -> Doc #

type Rep VarDecl # 
type Rep VarDecl = D1 (MetaData "VarDecl" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "VarDecl" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VarDeclId)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe VarInit)))))

data VarDeclId #

The name of a variable in a declaration, which may be an array.

Constructors

VarId Ident 
VarDeclArray VarDeclId

Multi-dimensional arrays are represented by nested applications of VarDeclArray.

Instances

Eq VarDeclId # 
Data VarDeclId # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VarDeclId -> c VarDeclId #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VarDeclId #

toConstr :: VarDeclId -> Constr #

dataTypeOf :: VarDeclId -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c VarDeclId) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarDeclId) #

gmapT :: (forall b. Data b => b -> b) -> VarDeclId -> VarDeclId #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarDeclId -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarDeclId -> r #

gmapQ :: (forall d. Data d => d -> u) -> VarDeclId -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> VarDeclId -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VarDeclId -> m VarDeclId #

Ord VarDeclId # 
Show VarDeclId # 
Generic VarDeclId # 

Associated Types

type Rep VarDeclId :: * -> * #

Pretty VarDeclId # 
type Rep VarDeclId # 
type Rep VarDeclId = D1 (MetaData "VarDeclId" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "VarId" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident))) (C1 (MetaCons "VarDeclArray" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VarDeclId))))

data VarInit #

Explicit initializer for a variable declaration.

Instances

Eq VarInit # 

Methods

(==) :: VarInit -> VarInit -> Bool #

(/=) :: VarInit -> VarInit -> Bool #

Data VarInit # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VarInit -> c VarInit #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c VarInit #

toConstr :: VarInit -> Constr #

dataTypeOf :: VarInit -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c VarInit) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c VarInit) #

gmapT :: (forall b. Data b => b -> b) -> VarInit -> VarInit #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarInit -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarInit -> r #

gmapQ :: (forall d. Data d => d -> u) -> VarInit -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> VarInit -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> VarInit -> m VarInit #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VarInit -> m VarInit #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VarInit -> m VarInit #

Ord VarInit # 
Show VarInit # 
Generic VarInit # 

Associated Types

type Rep VarInit :: * -> * #

Methods

from :: VarInit -> Rep VarInit x #

to :: Rep VarInit x -> VarInit #

Pretty VarInit # 

Methods

pretty :: VarInit -> Doc #

prettyPrec :: Int -> VarInit -> Doc #

type Rep VarInit # 
type Rep VarInit = D1 (MetaData "VarInit" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "InitExp" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "InitArray" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ArrayInit))))

data FormalParam #

A formal parameter in method declaration. The last parameter for a given declaration may be marked as variable arity, indicated by the boolean argument.

Instances

Eq FormalParam # 
Data FormalParam # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FormalParam -> c FormalParam #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FormalParam #

toConstr :: FormalParam -> Constr #

dataTypeOf :: FormalParam -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FormalParam) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FormalParam) #

gmapT :: (forall b. Data b => b -> b) -> FormalParam -> FormalParam #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FormalParam -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FormalParam -> r #

gmapQ :: (forall d. Data d => d -> u) -> FormalParam -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FormalParam -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FormalParam -> m FormalParam #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FormalParam -> m FormalParam #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FormalParam -> m FormalParam #

Ord FormalParam # 
Show FormalParam # 
Generic FormalParam # 

Associated Types

type Rep FormalParam :: * -> * #

Pretty FormalParam # 
type Rep FormalParam # 

data MethodBody #

A method body is either a block of code that implements the method or simply a semicolon, indicating the lack of an implementation (modelled by Nothing).

Constructors

MethodBody (Maybe Block) 

Instances

Eq MethodBody # 
Data MethodBody # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MethodBody -> c MethodBody #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MethodBody #

toConstr :: MethodBody -> Constr #

dataTypeOf :: MethodBody -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MethodBody) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MethodBody) #

gmapT :: (forall b. Data b => b -> b) -> MethodBody -> MethodBody #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MethodBody -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MethodBody -> r #

gmapQ :: (forall d. Data d => d -> u) -> MethodBody -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MethodBody -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MethodBody -> m MethodBody #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MethodBody -> m MethodBody #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MethodBody -> m MethodBody #

Ord MethodBody # 
Show MethodBody # 
Generic MethodBody # 

Associated Types

type Rep MethodBody :: * -> * #

Pretty MethodBody # 
type Rep MethodBody # 
type Rep MethodBody = D1 (MetaData "MethodBody" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "MethodBody" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Block))))

data ConstructorBody #

The first statement of a constructor body may be an explicit invocation of another constructor of the same class or of the direct superclass.

Instances

Eq ConstructorBody # 
Data ConstructorBody # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConstructorBody -> c ConstructorBody #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConstructorBody #

toConstr :: ConstructorBody -> Constr #

dataTypeOf :: ConstructorBody -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ConstructorBody) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstructorBody) #

gmapT :: (forall b. Data b => b -> b) -> ConstructorBody -> ConstructorBody #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConstructorBody -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConstructorBody -> r #

gmapQ :: (forall d. Data d => d -> u) -> ConstructorBody -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstructorBody -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConstructorBody -> m ConstructorBody #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstructorBody -> m ConstructorBody #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstructorBody -> m ConstructorBody #

Ord ConstructorBody # 
Show ConstructorBody # 
Generic ConstructorBody # 
Pretty ConstructorBody # 
type Rep ConstructorBody # 
type Rep ConstructorBody = D1 (MetaData "ConstructorBody" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "ConstructorBody" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ExplConstrInv))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [BlockStmt]))))

data ExplConstrInv #

An explicit constructor invocation invokes another constructor of the same class, or a constructor of the direct superclass, which may be qualified to explicitly specify the newly created object's immediately enclosing instance.

Instances

Eq ExplConstrInv # 
Data ExplConstrInv # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExplConstrInv -> c ExplConstrInv #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ExplConstrInv #

toConstr :: ExplConstrInv -> Constr #

dataTypeOf :: ExplConstrInv -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ExplConstrInv) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExplConstrInv) #

gmapT :: (forall b. Data b => b -> b) -> ExplConstrInv -> ExplConstrInv #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExplConstrInv -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExplConstrInv -> r #

gmapQ :: (forall d. Data d => d -> u) -> ExplConstrInv -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExplConstrInv -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExplConstrInv -> m ExplConstrInv #

Ord ExplConstrInv # 
Show ExplConstrInv # 
Generic ExplConstrInv # 

Associated Types

type Rep ExplConstrInv :: * -> * #

Pretty ExplConstrInv # 
type Rep ExplConstrInv # 

data Modifier #

A modifier specifying properties of a given declaration. In general only a few of these modifiers are allowed for each declaration type, for instance a member type declaration may only specify one of public, private or protected.

Instances

Eq Modifier # 
Data Modifier # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Modifier -> c Modifier #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Modifier #

toConstr :: Modifier -> Constr #

dataTypeOf :: Modifier -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Modifier) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Modifier) #

gmapT :: (forall b. Data b => b -> b) -> Modifier -> Modifier #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Modifier -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Modifier -> r #

gmapQ :: (forall d. Data d => d -> u) -> Modifier -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Modifier -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Modifier -> m Modifier #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Modifier -> m Modifier #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Modifier -> m Modifier #

Ord Modifier # 
Show Modifier # 
Generic Modifier # 

Associated Types

type Rep Modifier :: * -> * #

Methods

from :: Modifier -> Rep Modifier x #

to :: Rep Modifier x -> Modifier #

Pretty Modifier # 

Methods

pretty :: Modifier -> Doc #

prettyPrec :: Int -> Modifier -> Doc #

type Rep Modifier # 
type Rep Modifier = D1 (MetaData "Modifier" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "Public" PrefixI False) U1) ((:+:) (C1 (MetaCons "Private" PrefixI False) U1) (C1 (MetaCons "Protected" PrefixI False) U1))) ((:+:) (C1 (MetaCons "Abstract" PrefixI False) U1) ((:+:) (C1 (MetaCons "Final" PrefixI False) U1) (C1 (MetaCons "Static" PrefixI False) U1)))) ((:+:) ((:+:) (C1 (MetaCons "StrictFP" PrefixI False) U1) ((:+:) (C1 (MetaCons "Transient" PrefixI False) U1) (C1 (MetaCons "Volatile" PrefixI False) U1))) ((:+:) (C1 (MetaCons "Native" PrefixI False) U1) ((:+:) (C1 (MetaCons "Annotation" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Annotation))) (C1 (MetaCons "Synchronised" PrefixI False) U1)))))

data Annotation #

Annotations have three different forms: no-parameter, single-parameter or key-value pairs

Instances

Eq Annotation # 
Data Annotation # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Annotation -> c Annotation #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Annotation #

toConstr :: Annotation -> Constr #

dataTypeOf :: Annotation -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Annotation) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Annotation) #

gmapT :: (forall b. Data b => b -> b) -> Annotation -> Annotation #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Annotation -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Annotation -> r #

gmapQ :: (forall d. Data d => d -> u) -> Annotation -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Annotation -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Annotation -> m Annotation #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Annotation -> m Annotation #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Annotation -> m Annotation #

Ord Annotation # 
Show Annotation # 
Generic Annotation # 

Associated Types

type Rep Annotation :: * -> * #

Pretty Annotation # 
type Rep Annotation # 

data ElementValue #

Annotations may contain annotations or (loosely) expressions

Constructors

EVVal VarInit 
EVAnn Annotation 

Instances

Eq ElementValue # 
Data ElementValue # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ElementValue -> c ElementValue #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ElementValue #

toConstr :: ElementValue -> Constr #

dataTypeOf :: ElementValue -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ElementValue) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ElementValue) #

gmapT :: (forall b. Data b => b -> b) -> ElementValue -> ElementValue #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ElementValue -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ElementValue -> r #

gmapQ :: (forall d. Data d => d -> u) -> ElementValue -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ElementValue -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ElementValue -> m ElementValue #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ElementValue -> m ElementValue #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ElementValue -> m ElementValue #

Ord ElementValue # 
Show ElementValue # 
Generic ElementValue # 

Associated Types

type Rep ElementValue :: * -> * #

Pretty ElementValue # 
type Rep ElementValue # 
type Rep ElementValue = D1 (MetaData "ElementValue" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "EVVal" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 VarInit))) (C1 (MetaCons "EVAnn" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Annotation))))

data Block #

A block is a sequence of statements, local class declarations and local variable declaration statements within braces.

Constructors

Block [BlockStmt] 

Instances

Eq Block # 

Methods

(==) :: Block -> Block -> Bool #

(/=) :: Block -> Block -> Bool #

Data Block # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Block -> c Block #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Block #

toConstr :: Block -> Constr #

dataTypeOf :: Block -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Block) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Block) #

gmapT :: (forall b. Data b => b -> b) -> Block -> Block #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block -> r #

gmapQ :: (forall d. Data d => d -> u) -> Block -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Block -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Block -> m Block #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Block -> m Block #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Block -> m Block #

Ord Block # 

Methods

compare :: Block -> Block -> Ordering #

(<) :: Block -> Block -> Bool #

(<=) :: Block -> Block -> Bool #

(>) :: Block -> Block -> Bool #

(>=) :: Block -> Block -> Bool #

max :: Block -> Block -> Block #

min :: Block -> Block -> Block #

Show Block # 

Methods

showsPrec :: Int -> Block -> ShowS #

show :: Block -> String #

showList :: [Block] -> ShowS #

Generic Block # 

Associated Types

type Rep Block :: * -> * #

Methods

from :: Block -> Rep Block x #

to :: Rep Block x -> Block #

Pretty Block # 

Methods

pretty :: Block -> Doc #

prettyPrec :: Int -> Block -> Doc #

type Rep Block # 
type Rep Block = D1 (MetaData "Block" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "Block" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [BlockStmt])))

data BlockStmt #

A block statement is either a normal statement, a local class declaration or a local variable declaration.

Instances

Eq BlockStmt # 
Data BlockStmt # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BlockStmt -> c BlockStmt #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BlockStmt #

toConstr :: BlockStmt -> Constr #

dataTypeOf :: BlockStmt -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c BlockStmt) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BlockStmt) #

gmapT :: (forall b. Data b => b -> b) -> BlockStmt -> BlockStmt #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BlockStmt -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BlockStmt -> r #

gmapQ :: (forall d. Data d => d -> u) -> BlockStmt -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BlockStmt -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BlockStmt -> m BlockStmt #

Ord BlockStmt # 
Show BlockStmt # 
Generic BlockStmt # 

Associated Types

type Rep BlockStmt :: * -> * #

Pretty BlockStmt # 
type Rep BlockStmt # 

data Stmt #

A Java statement.

Constructors

StmtBlock Block

A statement can be a nested block.

IfThen Exp Stmt

The if-then statement allows conditional execution of a statement.

IfThenElse Exp Stmt Stmt

The if-then-else statement allows conditional choice of two statements, executing one or the other but not both.

While Exp Stmt

The while statement executes an expression and a statement repeatedly until the value of the expression is false.

BasicFor (Maybe ForInit) (Maybe Exp) (Maybe [Exp]) Stmt

The basic for statement executes some initialization code, then executes an expression, a statement, and some update code repeatedly until the value of the expression is false.

EnhancedFor [Modifier] Type Ident Exp Stmt

The enhanced for statement iterates over an array or a value of a class that implements the iterator interface.

Empty

An empty statement does nothing.

ExpStmt Exp

Certain kinds of expressions may be used as statements by following them with semicolons: assignments, pre- or post-inc- or decrementation, method invocation or class instance creation expressions.

Assert Exp (Maybe Exp)

An assertion is a statement containing a boolean expression, where an error is reported if the expression evaluates to false.

Switch Exp [SwitchBlock]

The switch statement transfers control to one of several statements depending on the value of an expression.

Do Stmt Exp

The do statement executes a statement and an expression repeatedly until the value of the expression is false.

Break (Maybe Ident)

A break statement transfers control out of an enclosing statement.

Continue (Maybe Ident)

A continue statement may occur only in a while, do, or for statement. Control passes to the loop-continuation point of that statement.

Return (Maybe Exp) 
Synchronized Exp Block

A synchronized statement acquires a mutual-exclusion lock on behalf of the executing thread, executes a block, then releases the lock. While the executing thread owns the lock, no other thread may acquire the lock.

Throw Exp

A throw statement causes an exception to be thrown.

Try Block [Catch] (Maybe Block)

A try statement executes a block. If a value is thrown and the try statement has one or more catch clauses that can catch it, then control will be transferred to the first such catch clause. If the try statement has a finally clause, then another block of code is executed, no matter whether the try block completes normally or abruptly, and no matter whether a catch clause is first given control.

Labeled Ident Stmt

Statements may have label prefixes.

Instances

Eq Stmt # 

Methods

(==) :: Stmt -> Stmt -> Bool #

(/=) :: Stmt -> Stmt -> Bool #

Data Stmt # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stmt -> c Stmt #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Stmt #

toConstr :: Stmt -> Constr #

dataTypeOf :: Stmt -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Stmt) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt) #

gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r #

gmapQ :: (forall d. Data d => d -> u) -> Stmt -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt #

Ord Stmt # 

Methods

compare :: Stmt -> Stmt -> Ordering #

(<) :: Stmt -> Stmt -> Bool #

(<=) :: Stmt -> Stmt -> Bool #

(>) :: Stmt -> Stmt -> Bool #

(>=) :: Stmt -> Stmt -> Bool #

max :: Stmt -> Stmt -> Stmt #

min :: Stmt -> Stmt -> Stmt #

Show Stmt # 

Methods

showsPrec :: Int -> Stmt -> ShowS #

show :: Stmt -> String #

showList :: [Stmt] -> ShowS #

Generic Stmt # 

Associated Types

type Rep Stmt :: * -> * #

Methods

from :: Stmt -> Rep Stmt x #

to :: Rep Stmt x -> Stmt #

Pretty Stmt # 

Methods

pretty :: Stmt -> Doc #

prettyPrec :: Int -> Stmt -> Doc #

type Rep Stmt # 
type Rep Stmt = D1 (MetaData "Stmt" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "StmtBlock" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Block))) (C1 (MetaCons "IfThen" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Stmt))))) ((:+:) (C1 (MetaCons "IfThenElse" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Stmt)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Stmt))))) (C1 (MetaCons "While" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Stmt)))))) ((:+:) ((:+:) (C1 (MetaCons "BasicFor" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ForInit))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Exp)))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe [Exp]))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Stmt))))) (C1 (MetaCons "EnhancedFor" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Modifier])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Stmt))))))) ((:+:) (C1 (MetaCons "Empty" PrefixI False) U1) ((:+:) (C1 (MetaCons "ExpStmt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "Assert" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Exp))))))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "Switch" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [SwitchBlock])))) (C1 (MetaCons "Do" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Stmt)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))))) ((:+:) (C1 (MetaCons "Break" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Ident)))) (C1 (MetaCons "Continue" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Ident)))))) ((:+:) ((:+:) (C1 (MetaCons "Return" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Exp)))) (C1 (MetaCons "Synchronized" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Block))))) ((:+:) (C1 (MetaCons "Throw" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) ((:+:) (C1 (MetaCons "Try" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Block)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Catch])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Block)))))) (C1 (MetaCons "Labeled" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Stmt)))))))))

data Catch #

If a value is thrown and the try statement has one or more catch clauses that can catch it, then control will be transferred to the first such catch clause.

Constructors

Catch FormalParam Block 

Instances

Eq Catch # 

Methods

(==) :: Catch -> Catch -> Bool #

(/=) :: Catch -> Catch -> Bool #

Data Catch # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Catch -> c Catch #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Catch #

toConstr :: Catch -> Constr #

dataTypeOf :: Catch -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Catch) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Catch) #

gmapT :: (forall b. Data b => b -> b) -> Catch -> Catch #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Catch -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Catch -> r #

gmapQ :: (forall d. Data d => d -> u) -> Catch -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Catch -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Catch -> m Catch #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Catch -> m Catch #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Catch -> m Catch #

Ord Catch # 

Methods

compare :: Catch -> Catch -> Ordering #

(<) :: Catch -> Catch -> Bool #

(<=) :: Catch -> Catch -> Bool #

(>) :: Catch -> Catch -> Bool #

(>=) :: Catch -> Catch -> Bool #

max :: Catch -> Catch -> Catch #

min :: Catch -> Catch -> Catch #

Show Catch # 

Methods

showsPrec :: Int -> Catch -> ShowS #

show :: Catch -> String #

showList :: [Catch] -> ShowS #

Generic Catch # 

Associated Types

type Rep Catch :: * -> * #

Methods

from :: Catch -> Rep Catch x #

to :: Rep Catch x -> Catch #

Pretty Catch # 

Methods

pretty :: Catch -> Doc #

prettyPrec :: Int -> Catch -> Doc #

type Rep Catch # 

data SwitchBlock #

A block of code labelled with a case or default within a switch statement.

Instances

Eq SwitchBlock # 
Data SwitchBlock # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SwitchBlock -> c SwitchBlock #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SwitchBlock #

toConstr :: SwitchBlock -> Constr #

dataTypeOf :: SwitchBlock -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SwitchBlock) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SwitchBlock) #

gmapT :: (forall b. Data b => b -> b) -> SwitchBlock -> SwitchBlock #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SwitchBlock -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SwitchBlock -> r #

gmapQ :: (forall d. Data d => d -> u) -> SwitchBlock -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SwitchBlock -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SwitchBlock -> m SwitchBlock #

Ord SwitchBlock # 
Show SwitchBlock # 
Generic SwitchBlock # 

Associated Types

type Rep SwitchBlock :: * -> * #

Pretty SwitchBlock # 
type Rep SwitchBlock # 
type Rep SwitchBlock = D1 (MetaData "SwitchBlock" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "SwitchBlock" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 SwitchLabel)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [BlockStmt]))))

data SwitchLabel #

A label within a switch statement.

Constructors

SwitchCase Exp

The expression contained in the case must be a Lit or an enum constant.

Default 

Instances

Eq SwitchLabel # 
Data SwitchLabel # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SwitchLabel -> c SwitchLabel #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SwitchLabel #

toConstr :: SwitchLabel -> Constr #

dataTypeOf :: SwitchLabel -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SwitchLabel) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SwitchLabel) #

gmapT :: (forall b. Data b => b -> b) -> SwitchLabel -> SwitchLabel #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SwitchLabel -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SwitchLabel -> r #

gmapQ :: (forall d. Data d => d -> u) -> SwitchLabel -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SwitchLabel -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SwitchLabel -> m SwitchLabel #

Ord SwitchLabel # 
Show SwitchLabel # 
Generic SwitchLabel # 

Associated Types

type Rep SwitchLabel :: * -> * #

Pretty SwitchLabel # 
type Rep SwitchLabel # 
type Rep SwitchLabel = D1 (MetaData "SwitchLabel" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "SwitchCase" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "Default" PrefixI False) U1))

data ForInit #

Initialization code for a basic for statement.

Instances

Eq ForInit # 

Methods

(==) :: ForInit -> ForInit -> Bool #

(/=) :: ForInit -> ForInit -> Bool #

Data ForInit # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForInit -> c ForInit #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForInit #

toConstr :: ForInit -> Constr #

dataTypeOf :: ForInit -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ForInit) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForInit) #

gmapT :: (forall b. Data b => b -> b) -> ForInit -> ForInit #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForInit -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForInit -> r #

gmapQ :: (forall d. Data d => d -> u) -> ForInit -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForInit -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForInit -> m ForInit #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForInit -> m ForInit #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForInit -> m ForInit #

Ord ForInit # 
Show ForInit # 
Generic ForInit # 

Associated Types

type Rep ForInit :: * -> * #

Methods

from :: ForInit -> Rep ForInit x #

to :: Rep ForInit x -> ForInit #

Pretty ForInit # 

Methods

pretty :: ForInit -> Doc #

prettyPrec :: Int -> ForInit -> Doc #

type Rep ForInit # 

type ExceptionType = RefType #

An exception type has to be a class type or a type variable.

type Argument = Exp #

Arguments to methods and constructors are expressions.

data Exp #

A Java expression.

Constructors

Lit Literal

A literal denotes a fixed, unchanging value.

ClassLit (Maybe Type)

A class literal, which is an expression consisting of the name of a class, interface, array, or primitive type, or the pseudo-type void (modelled by Nothing), followed by a . and the token class.

This

The keyword this denotes a value that is a reference to the object for which the instance method was invoked, or to the object being constructed.

ThisClass Name

Any lexically enclosing instance can be referred to by explicitly qualifying the keyword this.

InstanceCreation [TypeArgument] ClassType [Argument] (Maybe ClassBody)

A class instance creation expression is used to create new objects that are instances of classes. | The first argument is a list of non-wildcard type arguments to a generic constructor. What follows is the type to be instantiated, the list of arguments passed to the constructor, and optionally a class body that makes the constructor result in an object of an anonymous class.

QualInstanceCreation Exp [TypeArgument] Ident [Argument] (Maybe ClassBody)

A qualified class instance creation expression enables the creation of instances of inner member classes and their anonymous subclasses.

ArrayCreate Type [Exp] Int

An array instance creation expression is used to create new arrays. The last argument denotes the number of dimensions that have no explicit length given. These dimensions must be given last.

ArrayCreateInit Type Int ArrayInit

An array instance creation expression may come with an explicit initializer. Such expressions may not be given explicit lengths for any of its dimensions.

FieldAccess FieldAccess

A field access expression.

MethodInv MethodInvocation

A method invocation expression.

ArrayAccess ArrayIndex

An array access expression refers to a variable that is a component of an array.

ExpName Name

An expression name, e.g. a variable.

PostIncrement Exp

Post-incrementation expression, i.e. an expression followed by ++.

PostDecrement Exp

Post-decrementation expression, i.e. an expression followed by --.

PreIncrement Exp

Pre-incrementation expression, i.e. an expression preceded by ++.

PreDecrement Exp

Pre-decrementation expression, i.e. an expression preceded by --.

PrePlus Exp

Unary plus, the promotion of the value of the expression to a primitive numeric type.

PreMinus Exp

Unary minus, the promotion of the negation of the value of the expression to a primitive numeric type.

PreBitCompl Exp

Unary bitwise complementation: note that, in all cases, ~x equals (-x)-1.

PreNot Exp

Logical complementation of boolean values.

Cast Type Exp

A cast expression converts, at run time, a value of one numeric type to a similar value of another numeric type; or confirms, at compile time, that the type of an expression is boolean; or checks, at run time, that a reference value refers to an object whose class is compatible with a specified reference type.

BinOp Exp Op Exp

The application of a binary operator to two operand expressions.

InstanceOf Exp RefType

Testing whether the result of an expression is an instance of some reference type.

Cond Exp Exp Exp

The conditional operator ? : uses the boolean value of one expression to decide which of two other expressions should be evaluated.

Assign Lhs AssignOp Exp

Assignment of the result of an expression to a variable.

Lambda LambdaParams LambdaExpression

Lambda expression

MethodRef Ident Ident

Method reference

Instances

Eq Exp # 

Methods

(==) :: Exp -> Exp -> Bool #

(/=) :: Exp -> Exp -> Bool #

Data Exp # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp -> c Exp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exp #

toConstr :: Exp -> Constr #

dataTypeOf :: Exp -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Exp) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp) #

gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r #

gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp -> m Exp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp #

Ord Exp # 

Methods

compare :: Exp -> Exp -> Ordering #

(<) :: Exp -> Exp -> Bool #

(<=) :: Exp -> Exp -> Bool #

(>) :: Exp -> Exp -> Bool #

(>=) :: Exp -> Exp -> Bool #

max :: Exp -> Exp -> Exp #

min :: Exp -> Exp -> Exp #

Show Exp # 

Methods

showsPrec :: Int -> Exp -> ShowS #

show :: Exp -> String #

showList :: [Exp] -> ShowS #

Generic Exp # 

Associated Types

type Rep Exp :: * -> * #

Methods

from :: Exp -> Rep Exp x #

to :: Rep Exp x -> Exp #

Pretty Exp # 

Methods

pretty :: Exp -> Doc #

prettyPrec :: Int -> Exp -> Doc #

type Rep Exp # 
type Rep Exp = D1 (MetaData "Exp" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "Lit" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Literal))) ((:+:) (C1 (MetaCons "ClassLit" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe Type)))) (C1 (MetaCons "This" PrefixI False) U1))) ((:+:) (C1 (MetaCons "ThisClass" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) ((:+:) (C1 (MetaCons "InstanceCreation" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TypeArgument])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ClassType))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Argument])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ClassBody)))))) (C1 (MetaCons "QualInstanceCreation" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [TypeArgument]))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Argument])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe ClassBody)))))))))) ((:+:) ((:+:) (C1 (MetaCons "ArrayCreate" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp])) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int))))) ((:+:) (C1 (MetaCons "ArrayCreateInit" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ArrayInit))))) (C1 (MetaCons "FieldAccess" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 FieldAccess))))) ((:+:) ((:+:) (C1 (MetaCons "MethodInv" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 MethodInvocation))) (C1 (MetaCons "ArrayAccess" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ArrayIndex)))) ((:+:) (C1 (MetaCons "ExpName" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name))) (C1 (MetaCons "PostIncrement" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "PostDecrement" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) ((:+:) (C1 (MetaCons "PreIncrement" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "PreDecrement" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))))) ((:+:) ((:+:) (C1 (MetaCons "PrePlus" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "PreMinus" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))) ((:+:) (C1 (MetaCons "PreBitCompl" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "PreNot" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))))) ((:+:) ((:+:) (C1 (MetaCons "Cast" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))) ((:+:) (C1 (MetaCons "BinOp" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Op)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))))) (C1 (MetaCons "InstanceOf" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RefType)))))) ((:+:) ((:+:) (C1 (MetaCons "Cond" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))))) (C1 (MetaCons "Assign" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Lhs)) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 AssignOp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)))))) ((:+:) (C1 (MetaCons "Lambda" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 LambdaParams)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 LambdaExpression)))) (C1 (MetaCons "MethodRef" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)))))))))

data Literal #

A literal denotes a fixed, unchanging value.

Instances

Eq Literal # 

Methods

(==) :: Literal -> Literal -> Bool #

(/=) :: Literal -> Literal -> Bool #

Data Literal # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Literal -> c Literal #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Literal #

toConstr :: Literal -> Constr #

dataTypeOf :: Literal -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Literal) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal) #

gmapT :: (forall b. Data b => b -> b) -> Literal -> Literal #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Literal -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Literal -> r #

gmapQ :: (forall d. Data d => d -> u) -> Literal -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Literal -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Literal -> m Literal #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal -> m Literal #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal -> m Literal #

Ord Literal # 
Show Literal # 
Generic Literal # 

Associated Types

type Rep Literal :: * -> * #

Methods

from :: Literal -> Rep Literal x #

to :: Rep Literal x -> Literal #

Pretty Literal # 

Methods

pretty :: Literal -> Doc #

prettyPrec :: Int -> Literal -> Doc #

type Rep Literal # 

data Op #

A binary infix operator.

Instances

Eq Op # 

Methods

(==) :: Op -> Op -> Bool #

(/=) :: Op -> Op -> Bool #

Data Op # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Op -> c Op #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Op #

toConstr :: Op -> Constr #

dataTypeOf :: Op -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Op) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Op) #

gmapT :: (forall b. Data b => b -> b) -> Op -> Op #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op -> r #

gmapQ :: (forall d. Data d => d -> u) -> Op -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Op -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Op -> m Op #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Op -> m Op #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Op -> m Op #

Ord Op # 

Methods

compare :: Op -> Op -> Ordering #

(<) :: Op -> Op -> Bool #

(<=) :: Op -> Op -> Bool #

(>) :: Op -> Op -> Bool #

(>=) :: Op -> Op -> Bool #

max :: Op -> Op -> Op #

min :: Op -> Op -> Op #

Show Op # 

Methods

showsPrec :: Int -> Op -> ShowS #

show :: Op -> String #

showList :: [Op] -> ShowS #

Generic Op # 

Associated Types

type Rep Op :: * -> * #

Methods

from :: Op -> Rep Op x #

to :: Rep Op x -> Op #

Pretty Op # 

Methods

pretty :: Op -> Doc #

prettyPrec :: Int -> Op -> Doc #

type Rep Op # 
type Rep Op = D1 (MetaData "Op" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "Mult" PrefixI False) U1) (C1 (MetaCons "Div" PrefixI False) U1)) ((:+:) (C1 (MetaCons "Rem" PrefixI False) U1) (C1 (MetaCons "Add" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "Sub" PrefixI False) U1) (C1 (MetaCons "LShift" PrefixI False) U1)) ((:+:) (C1 (MetaCons "RShift" PrefixI False) U1) ((:+:) (C1 (MetaCons "RRShift" PrefixI False) U1) (C1 (MetaCons "LThan" PrefixI False) U1))))) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "GThan" PrefixI False) U1) (C1 (MetaCons "LThanE" PrefixI False) U1)) ((:+:) (C1 (MetaCons "GThanE" PrefixI False) U1) ((:+:) (C1 (MetaCons "Equal" PrefixI False) U1) (C1 (MetaCons "NotEq" PrefixI False) U1)))) ((:+:) ((:+:) (C1 (MetaCons "And" PrefixI False) U1) (C1 (MetaCons "Or" PrefixI False) U1)) ((:+:) (C1 (MetaCons "Xor" PrefixI False) U1) ((:+:) (C1 (MetaCons "CAnd" PrefixI False) U1) (C1 (MetaCons "COr" PrefixI False) U1))))))

data AssignOp #

An assignment operator.

Instances

Eq AssignOp # 
Data AssignOp # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AssignOp -> c AssignOp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AssignOp #

toConstr :: AssignOp -> Constr #

dataTypeOf :: AssignOp -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c AssignOp) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AssignOp) #

gmapT :: (forall b. Data b => b -> b) -> AssignOp -> AssignOp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AssignOp -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AssignOp -> r #

gmapQ :: (forall d. Data d => d -> u) -> AssignOp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AssignOp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AssignOp -> m AssignOp #

Ord AssignOp # 
Show AssignOp # 
Generic AssignOp # 

Associated Types

type Rep AssignOp :: * -> * #

Methods

from :: AssignOp -> Rep AssignOp x #

to :: Rep AssignOp x -> AssignOp #

Pretty AssignOp # 

Methods

pretty :: AssignOp -> Doc #

prettyPrec :: Int -> AssignOp -> Doc #

type Rep AssignOp # 
type Rep AssignOp = D1 (MetaData "AssignOp" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "EqualA" PrefixI False) U1) ((:+:) (C1 (MetaCons "MultA" PrefixI False) U1) (C1 (MetaCons "DivA" PrefixI False) U1))) ((:+:) (C1 (MetaCons "RemA" PrefixI False) U1) ((:+:) (C1 (MetaCons "AddA" PrefixI False) U1) (C1 (MetaCons "SubA" PrefixI False) U1)))) ((:+:) ((:+:) (C1 (MetaCons "LShiftA" PrefixI False) U1) ((:+:) (C1 (MetaCons "RShiftA" PrefixI False) U1) (C1 (MetaCons "RRShiftA" PrefixI False) U1))) ((:+:) (C1 (MetaCons "AndA" PrefixI False) U1) ((:+:) (C1 (MetaCons "XorA" PrefixI False) U1) (C1 (MetaCons "OrA" PrefixI False) U1)))))

data Lhs #

The left-hand side of an assignment expression. This operand may be a named variable, such as a local variable or a field of the current object or class, or it may be a computed variable, as can result from a field access or an array access.

Constructors

NameLhs Name

Assign to a variable

FieldLhs FieldAccess

Assign through a field access

ArrayLhs ArrayIndex

Assign to an array

Instances

Eq Lhs # 

Methods

(==) :: Lhs -> Lhs -> Bool #

(/=) :: Lhs -> Lhs -> Bool #

Data Lhs # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lhs -> c Lhs #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lhs #

toConstr :: Lhs -> Constr #

dataTypeOf :: Lhs -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Lhs) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lhs) #

gmapT :: (forall b. Data b => b -> b) -> Lhs -> Lhs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lhs -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lhs -> r #

gmapQ :: (forall d. Data d => d -> u) -> Lhs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Lhs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lhs -> m Lhs #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lhs -> m Lhs #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lhs -> m Lhs #

Ord Lhs # 

Methods

compare :: Lhs -> Lhs -> Ordering #

(<) :: Lhs -> Lhs -> Bool #

(<=) :: Lhs -> Lhs -> Bool #

(>) :: Lhs -> Lhs -> Bool #

(>=) :: Lhs -> Lhs -> Bool #

max :: Lhs -> Lhs -> Lhs #

min :: Lhs -> Lhs -> Lhs #

Show Lhs # 

Methods

showsPrec :: Int -> Lhs -> ShowS #

show :: Lhs -> String #

showList :: [Lhs] -> ShowS #

Generic Lhs # 

Associated Types

type Rep Lhs :: * -> * #

Methods

from :: Lhs -> Rep Lhs x #

to :: Rep Lhs x -> Lhs #

Pretty Lhs # 

Methods

pretty :: Lhs -> Doc #

prettyPrec :: Int -> Lhs -> Doc #

type Rep Lhs # 

data ArrayIndex #

Array access

Constructors

ArrayIndex Exp [Exp]

Index into an array

Instances

Eq ArrayIndex # 
Data ArrayIndex # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArrayIndex -> c ArrayIndex #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArrayIndex #

toConstr :: ArrayIndex -> Constr #

dataTypeOf :: ArrayIndex -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ArrayIndex) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayIndex) #

gmapT :: (forall b. Data b => b -> b) -> ArrayIndex -> ArrayIndex #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArrayIndex -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArrayIndex -> r #

gmapQ :: (forall d. Data d => d -> u) -> ArrayIndex -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ArrayIndex -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArrayIndex -> m ArrayIndex #

Ord ArrayIndex # 
Show ArrayIndex # 
Generic ArrayIndex # 

Associated Types

type Rep ArrayIndex :: * -> * #

Pretty ArrayIndex # 
type Rep ArrayIndex # 
type Rep ArrayIndex = D1 (MetaData "ArrayIndex" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "ArrayIndex" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Exp]))))

data FieldAccess #

A field access expression may access a field of an object or array, a reference to which is the value of either an expression or the special keyword super.

Constructors

PrimaryFieldAccess Exp Ident

Accessing a field of an object or array computed from an expression.

SuperFieldAccess Ident

Accessing a field of the superclass.

ClassFieldAccess Name Ident

Accessing a (static) field of a named class.

Instances

Eq FieldAccess # 
Data FieldAccess # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldAccess -> c FieldAccess #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FieldAccess #

toConstr :: FieldAccess -> Constr #

dataTypeOf :: FieldAccess -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FieldAccess) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldAccess) #

gmapT :: (forall b. Data b => b -> b) -> FieldAccess -> FieldAccess #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldAccess -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldAccess -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldAccess -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldAccess -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldAccess -> m FieldAccess #

Ord FieldAccess # 
Show FieldAccess # 
Generic FieldAccess # 

Associated Types

type Rep FieldAccess :: * -> * #

Pretty FieldAccess # 
type Rep FieldAccess # 

data LambdaParams #

Instances

Eq LambdaParams # 
Data LambdaParams # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LambdaParams -> c LambdaParams #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LambdaParams #

toConstr :: LambdaParams -> Constr #

dataTypeOf :: LambdaParams -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LambdaParams) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LambdaParams) #

gmapT :: (forall b. Data b => b -> b) -> LambdaParams -> LambdaParams #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LambdaParams -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LambdaParams -> r #

gmapQ :: (forall d. Data d => d -> u) -> LambdaParams -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LambdaParams -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LambdaParams -> m LambdaParams #

Ord LambdaParams # 
Show LambdaParams # 
Generic LambdaParams # 

Associated Types

type Rep LambdaParams :: * -> * #

type Rep LambdaParams # 
type Rep LambdaParams = D1 (MetaData "LambdaParams" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "LambdaSingleParam" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident))) ((:+:) (C1 (MetaCons "LambdaFormalParams" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [FormalParam]))) (C1 (MetaCons "LambdaInferredParams" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Ident])))))

data LambdaExpression #

Lambda expression, starting from java 8

Instances

Eq LambdaExpression # 
Data LambdaExpression # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LambdaExpression -> c LambdaExpression #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LambdaExpression #

toConstr :: LambdaExpression -> Constr #

dataTypeOf :: LambdaExpression -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LambdaExpression) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LambdaExpression) #

gmapT :: (forall b. Data b => b -> b) -> LambdaExpression -> LambdaExpression #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LambdaExpression -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LambdaExpression -> r #

gmapQ :: (forall d. Data d => d -> u) -> LambdaExpression -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LambdaExpression -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LambdaExpression -> m LambdaExpression #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LambdaExpression -> m LambdaExpression #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LambdaExpression -> m LambdaExpression #

Ord LambdaExpression # 
Show LambdaExpression # 
Generic LambdaExpression # 
type Rep LambdaExpression # 
type Rep LambdaExpression = D1 (MetaData "LambdaExpression" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "LambdaExpression" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp))) (C1 (MetaCons "LambdaBlock" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Block))))

data MethodInvocation #

A method invocation expression is used to invoke a class or instance method.

Constructors

MethodCall Name [Argument]

Invoking a specific named method.

PrimaryMethodCall Exp [RefType] Ident [Argument]

Invoking a method of a class computed from a primary expression, giving arguments for any generic type parameters.

SuperMethodCall [RefType] Ident [Argument]

Invoking a method of the super class, giving arguments for any generic type parameters.

ClassMethodCall Name [RefType] Ident [Argument]

Invoking a method of the superclass of a named class, giving arguments for any generic type parameters.

TypeMethodCall Name [RefType] Ident [Argument]

Invoking a method of a named type, giving arguments for any generic type parameters.

Instances

Eq MethodInvocation # 
Data MethodInvocation # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MethodInvocation -> c MethodInvocation #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MethodInvocation #

toConstr :: MethodInvocation -> Constr #

dataTypeOf :: MethodInvocation -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MethodInvocation) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MethodInvocation) #

gmapT :: (forall b. Data b => b -> b) -> MethodInvocation -> MethodInvocation #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MethodInvocation -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MethodInvocation -> r #

gmapQ :: (forall d. Data d => d -> u) -> MethodInvocation -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MethodInvocation -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MethodInvocation -> m MethodInvocation #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MethodInvocation -> m MethodInvocation #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MethodInvocation -> m MethodInvocation #

Ord MethodInvocation # 
Show MethodInvocation # 
Generic MethodInvocation # 
Pretty MethodInvocation # 
type Rep MethodInvocation # 
type Rep MethodInvocation = D1 (MetaData "MethodInvocation" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) ((:+:) (C1 (MetaCons "MethodCall" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Argument])))) (C1 (MetaCons "PrimaryMethodCall" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Exp)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RefType]))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Argument])))))) ((:+:) (C1 (MetaCons "SuperMethodCall" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RefType])) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Argument]))))) ((:+:) (C1 (MetaCons "ClassMethodCall" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RefType]))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Argument]))))) (C1 (MetaCons "TypeMethodCall" PrefixI False) ((:*:) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Name)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RefType]))) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Argument]))))))))

data ArrayInit #

An array initializer may be specified in a declaration, or as part of an array creation expression, creating an array and providing some initial values

Constructors

ArrayInit [VarInit] 

Instances

Eq ArrayInit # 
Data ArrayInit # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArrayInit -> c ArrayInit #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArrayInit #

toConstr :: ArrayInit -> Constr #

dataTypeOf :: ArrayInit -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ArrayInit) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayInit) #

gmapT :: (forall b. Data b => b -> b) -> ArrayInit -> ArrayInit #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArrayInit -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArrayInit -> r #

gmapQ :: (forall d. Data d => d -> u) -> ArrayInit -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ArrayInit -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArrayInit -> m ArrayInit #

Ord ArrayInit # 
Show ArrayInit # 
Generic ArrayInit # 

Associated Types

type Rep ArrayInit :: * -> * #

Pretty ArrayInit # 
type Rep ArrayInit # 
type Rep ArrayInit = D1 (MetaData "ArrayInit" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "ArrayInit" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [VarInit])))

data Type #

There are two kinds of types in the Java programming language: primitive types and reference types.

Instances

Eq Type # 

Methods

(==) :: Type -> Type -> Bool #

(/=) :: Type -> Type -> Bool #

Data Type # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type #

toConstr :: Type -> Constr #

dataTypeOf :: Type -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Type) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) #

gmapT :: (forall b. Data b => b -> b) -> Type -> Type #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r #

gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type #

Ord Type # 

Methods

compare :: Type -> Type -> Ordering #

(<) :: Type -> Type -> Bool #

(<=) :: Type -> Type -> Bool #

(>) :: Type -> Type -> Bool #

(>=) :: Type -> Type -> Bool #

max :: Type -> Type -> Type #

min :: Type -> Type -> Type #

Show Type # 

Methods

showsPrec :: Int -> Type -> ShowS #

show :: Type -> String #

showList :: [Type] -> ShowS #

Generic Type # 

Associated Types

type Rep Type :: * -> * #

Methods

from :: Type -> Rep Type x #

to :: Rep Type x -> Type #

Pretty Type # 

Methods

pretty :: Type -> Doc #

prettyPrec :: Int -> Type -> Doc #

type Rep Type # 
type Rep Type = D1 (MetaData "Type" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "PrimType" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 PrimType))) (C1 (MetaCons "RefType" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RefType))))

data RefType #

There are three kinds of reference types: class types, interface types, and array types. Reference types may be parameterized with type arguments. Type variables cannot be syntactically distinguished from class type identifiers, and are thus represented uniformly as single ident class types.

Constructors

ClassRefType ClassType 
ArrayType Type

TypeVariable Ident

Instances

Eq RefType # 

Methods

(==) :: RefType -> RefType -> Bool #

(/=) :: RefType -> RefType -> Bool #

Data RefType # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RefType -> c RefType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RefType #

toConstr :: RefType -> Constr #

dataTypeOf :: RefType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c RefType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RefType) #

gmapT :: (forall b. Data b => b -> b) -> RefType -> RefType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RefType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RefType -> r #

gmapQ :: (forall d. Data d => d -> u) -> RefType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RefType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RefType -> m RefType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RefType -> m RefType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RefType -> m RefType #

Ord RefType # 
Show RefType # 
Generic RefType # 

Associated Types

type Rep RefType :: * -> * #

Methods

from :: RefType -> Rep RefType x #

to :: Rep RefType x -> RefType #

Pretty RefType # 

Methods

pretty :: RefType -> Doc #

prettyPrec :: Int -> RefType -> Doc #

type Rep RefType # 
type Rep RefType = D1 (MetaData "RefType" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "ClassRefType" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 ClassType))) (C1 (MetaCons "ArrayType" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Type))))

data ClassType #

A class or interface type consists of a type declaration specifier, optionally followed by type arguments (in which case it is a parameterized type).

Constructors

ClassType [(Ident, [TypeArgument])] 

Instances

Eq ClassType # 
Data ClassType # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClassType -> c ClassType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ClassType #

toConstr :: ClassType -> Constr #

dataTypeOf :: ClassType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ClassType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ClassType) #

gmapT :: (forall b. Data b => b -> b) -> ClassType -> ClassType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClassType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClassType -> r #

gmapQ :: (forall d. Data d => d -> u) -> ClassType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ClassType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClassType -> m ClassType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassType -> m ClassType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassType -> m ClassType #

Ord ClassType # 
Show ClassType # 
Generic ClassType # 

Associated Types

type Rep ClassType :: * -> * #

Pretty ClassType # 
type Rep ClassType # 
type Rep ClassType = D1 (MetaData "ClassType" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "ClassType" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [(Ident, [TypeArgument])])))

data TypeArgument #

Type arguments may be either reference types or wildcards.

Instances

Eq TypeArgument # 
Data TypeArgument # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeArgument -> c TypeArgument #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeArgument #

toConstr :: TypeArgument -> Constr #

dataTypeOf :: TypeArgument -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TypeArgument) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeArgument) #

gmapT :: (forall b. Data b => b -> b) -> TypeArgument -> TypeArgument #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeArgument -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeArgument -> r #

gmapQ :: (forall d. Data d => d -> u) -> TypeArgument -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeArgument -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeArgument -> m TypeArgument #

Ord TypeArgument # 
Show TypeArgument # 
Generic TypeArgument # 

Associated Types

type Rep TypeArgument :: * -> * #

Pretty TypeArgument # 
type Rep TypeArgument # 
type Rep TypeArgument = D1 (MetaData "TypeArgument" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "Wildcard" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe WildcardBound)))) (C1 (MetaCons "ActualType" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RefType))))

data WildcardBound #

Wildcards may be given explicit bounds, either upper (extends) or lower (super) bounds.

Instances

Eq WildcardBound # 
Data WildcardBound # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WildcardBound -> c WildcardBound #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WildcardBound #

toConstr :: WildcardBound -> Constr #

dataTypeOf :: WildcardBound -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c WildcardBound) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WildcardBound) #

gmapT :: (forall b. Data b => b -> b) -> WildcardBound -> WildcardBound #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WildcardBound -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WildcardBound -> r #

gmapQ :: (forall d. Data d => d -> u) -> WildcardBound -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WildcardBound -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WildcardBound -> m WildcardBound #

Ord WildcardBound # 
Show WildcardBound # 
Generic WildcardBound # 

Associated Types

type Rep WildcardBound :: * -> * #

Pretty WildcardBound # 
type Rep WildcardBound # 
type Rep WildcardBound = D1 (MetaData "WildcardBound" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) (C1 (MetaCons "ExtendsBound" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RefType))) (C1 (MetaCons "SuperBound" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 RefType))))

data PrimType #

A primitive type is predefined by the Java programming language and named by its reserved keyword.

Instances

Eq PrimType # 
Data PrimType # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrimType -> c PrimType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrimType #

toConstr :: PrimType -> Constr #

dataTypeOf :: PrimType -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PrimType) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimType) #

gmapT :: (forall b. Data b => b -> b) -> PrimType -> PrimType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrimType -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrimType -> r #

gmapQ :: (forall d. Data d => d -> u) -> PrimType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PrimType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrimType -> m PrimType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrimType -> m PrimType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrimType -> m PrimType #

Ord PrimType # 
Show PrimType # 
Generic PrimType # 

Associated Types

type Rep PrimType :: * -> * #

Methods

from :: PrimType -> Rep PrimType x #

to :: Rep PrimType x -> PrimType #

Pretty PrimType # 

Methods

pretty :: PrimType -> Doc #

prettyPrec :: Int -> PrimType -> Doc #

type Rep PrimType # 
type Rep PrimType = D1 (MetaData "PrimType" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "BooleanT" PrefixI False) U1) (C1 (MetaCons "ByteT" PrefixI False) U1)) ((:+:) (C1 (MetaCons "ShortT" PrefixI False) U1) (C1 (MetaCons "IntT" PrefixI False) U1))) ((:+:) ((:+:) (C1 (MetaCons "LongT" PrefixI False) U1) (C1 (MetaCons "CharT" PrefixI False) U1)) ((:+:) (C1 (MetaCons "FloatT" PrefixI False) U1) (C1 (MetaCons "DoubleT" PrefixI False) U1))))

data TypeParam #

A class is generic if it declares one or more type variables. These type variables are known as the type parameters of the class.

Constructors

TypeParam Ident [RefType] 

Instances

Eq TypeParam # 
Data TypeParam # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeParam -> c TypeParam #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeParam #

toConstr :: TypeParam -> Constr #

dataTypeOf :: TypeParam -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TypeParam) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeParam) #

gmapT :: (forall b. Data b => b -> b) -> TypeParam -> TypeParam #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeParam -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeParam -> r #

gmapQ :: (forall d. Data d => d -> u) -> TypeParam -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeParam -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeParam -> m TypeParam #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeParam -> m TypeParam #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeParam -> m TypeParam #

Ord TypeParam # 
Show TypeParam # 
Generic TypeParam # 

Associated Types

type Rep TypeParam :: * -> * #

Pretty TypeParam # 
type Rep TypeParam # 
type Rep TypeParam = D1 (MetaData "TypeParam" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "TypeParam" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Ident)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [RefType]))))

data Ident #

A single identifier.

Constructors

Ident String 

Instances

Eq Ident # 

Methods

(==) :: Ident -> Ident -> Bool #

(/=) :: Ident -> Ident -> Bool #

Data Ident # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ident -> c Ident #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ident #

toConstr :: Ident -> Constr #

dataTypeOf :: Ident -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Ident) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ident) #

gmapT :: (forall b. Data b => b -> b) -> Ident -> Ident #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ident -> r #

gmapQ :: (forall d. Data d => d -> u) -> Ident -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ident -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ident -> m Ident #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ident -> m Ident #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ident -> m Ident #

Ord Ident # 

Methods

compare :: Ident -> Ident -> Ordering #

(<) :: Ident -> Ident -> Bool #

(<=) :: Ident -> Ident -> Bool #

(>) :: Ident -> Ident -> Bool #

(>=) :: Ident -> Ident -> Bool #

max :: Ident -> Ident -> Ident #

min :: Ident -> Ident -> Ident #

Show Ident # 

Methods

showsPrec :: Int -> Ident -> ShowS #

show :: Ident -> String #

showList :: [Ident] -> ShowS #

Generic Ident # 

Associated Types

type Rep Ident :: * -> * #

Methods

from :: Ident -> Rep Ident x #

to :: Rep Ident x -> Ident #

Pretty Ident # 

Methods

pretty :: Ident -> Doc #

prettyPrec :: Int -> Ident -> Doc #

type Rep Ident # 
type Rep Ident = D1 (MetaData "Ident" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "Ident" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String)))

data Name #

A name, i.e. a period-separated list of identifiers.

Constructors

Name [Ident] 

Instances

Eq Name # 

Methods

(==) :: Name -> Name -> Bool #

(/=) :: Name -> Name -> Bool #

Data Name # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name #

toConstr :: Name -> Constr #

dataTypeOf :: Name -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Name) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) #

gmapT :: (forall b. Data b => b -> b) -> Name -> Name #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r #

gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #

Ord Name # 

Methods

compare :: Name -> Name -> Ordering #

(<) :: Name -> Name -> Bool #

(<=) :: Name -> Name -> Bool #

(>) :: Name -> Name -> Bool #

(>=) :: Name -> Name -> Bool #

max :: Name -> Name -> Name #

min :: Name -> Name -> Name #

Show Name # 

Methods

showsPrec :: Int -> Name -> ShowS #

show :: Name -> String #

showList :: [Name] -> ShowS #

Generic Name # 

Associated Types

type Rep Name :: * -> * #

Methods

from :: Name -> Rep Name x #

to :: Rep Name x -> Name #

Pretty Name # 

Methods

pretty :: Name -> Doc #

prettyPrec :: Int -> Name -> Doc #

type Rep Name # 
type Rep Name = D1 (MetaData "Name" "Language.Java.Syntax" "language-java-0.2.8-6oOQ1UYyZwx6BdUybbDSep" False) (C1 (MetaCons "Name" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [Ident])))