-- | A C# syntax module based on the ANTLR grammar dated 02/07/2024 and available at:
-- |   https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/grammar

module Hydra.Ext.Csharp.Syntax where

import qualified Hydra.Core as Core
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

newtype Identifier = 
  Identifier {
    Identifier -> String
unIdentifier :: String}
  deriving (Identifier -> Identifier -> Bool
(Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool) -> Eq Identifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Identifier -> Identifier -> Bool
== :: Identifier -> Identifier -> Bool
$c/= :: Identifier -> Identifier -> Bool
/= :: Identifier -> Identifier -> Bool
Eq, Eq Identifier
Eq Identifier =>
(Identifier -> Identifier -> Ordering)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Bool)
-> (Identifier -> Identifier -> Identifier)
-> (Identifier -> Identifier -> Identifier)
-> Ord Identifier
Identifier -> Identifier -> Bool
Identifier -> Identifier -> Ordering
Identifier -> Identifier -> Identifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Identifier -> Identifier -> Ordering
compare :: Identifier -> Identifier -> Ordering
$c< :: Identifier -> Identifier -> Bool
< :: Identifier -> Identifier -> Bool
$c<= :: Identifier -> Identifier -> Bool
<= :: Identifier -> Identifier -> Bool
$c> :: Identifier -> Identifier -> Bool
> :: Identifier -> Identifier -> Bool
$c>= :: Identifier -> Identifier -> Bool
>= :: Identifier -> Identifier -> Bool
$cmax :: Identifier -> Identifier -> Identifier
max :: Identifier -> Identifier -> Identifier
$cmin :: Identifier -> Identifier -> Identifier
min :: Identifier -> Identifier -> Identifier
Ord, ReadPrec [Identifier]
ReadPrec Identifier
Int -> ReadS Identifier
ReadS [Identifier]
(Int -> ReadS Identifier)
-> ReadS [Identifier]
-> ReadPrec Identifier
-> ReadPrec [Identifier]
-> Read Identifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Identifier
readsPrec :: Int -> ReadS Identifier
$creadList :: ReadS [Identifier]
readList :: ReadS [Identifier]
$creadPrec :: ReadPrec Identifier
readPrec :: ReadPrec Identifier
$creadListPrec :: ReadPrec [Identifier]
readListPrec :: ReadPrec [Identifier]
Read, Int -> Identifier -> String -> String
[Identifier] -> String -> String
Identifier -> String
(Int -> Identifier -> String -> String)
-> (Identifier -> String)
-> ([Identifier] -> String -> String)
-> Show Identifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Identifier -> String -> String
showsPrec :: Int -> Identifier -> String -> String
$cshow :: Identifier -> String
show :: Identifier -> String
$cshowList :: [Identifier] -> String -> String
showList :: [Identifier] -> String -> String
Show)

_Identifier :: Name
_Identifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Identifier")

newtype Keyword = 
  Keyword {
    Keyword -> String
unKeyword :: String}
  deriving (Keyword -> Keyword -> Bool
(Keyword -> Keyword -> Bool)
-> (Keyword -> Keyword -> Bool) -> Eq Keyword
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Keyword -> Keyword -> Bool
== :: Keyword -> Keyword -> Bool
$c/= :: Keyword -> Keyword -> Bool
/= :: Keyword -> Keyword -> Bool
Eq, Eq Keyword
Eq Keyword =>
(Keyword -> Keyword -> Ordering)
-> (Keyword -> Keyword -> Bool)
-> (Keyword -> Keyword -> Bool)
-> (Keyword -> Keyword -> Bool)
-> (Keyword -> Keyword -> Bool)
-> (Keyword -> Keyword -> Keyword)
-> (Keyword -> Keyword -> Keyword)
-> Ord Keyword
Keyword -> Keyword -> Bool
Keyword -> Keyword -> Ordering
Keyword -> Keyword -> Keyword
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Keyword -> Keyword -> Ordering
compare :: Keyword -> Keyword -> Ordering
$c< :: Keyword -> Keyword -> Bool
< :: Keyword -> Keyword -> Bool
$c<= :: Keyword -> Keyword -> Bool
<= :: Keyword -> Keyword -> Bool
$c> :: Keyword -> Keyword -> Bool
> :: Keyword -> Keyword -> Bool
$c>= :: Keyword -> Keyword -> Bool
>= :: Keyword -> Keyword -> Bool
$cmax :: Keyword -> Keyword -> Keyword
max :: Keyword -> Keyword -> Keyword
$cmin :: Keyword -> Keyword -> Keyword
min :: Keyword -> Keyword -> Keyword
Ord, ReadPrec [Keyword]
ReadPrec Keyword
Int -> ReadS Keyword
ReadS [Keyword]
(Int -> ReadS Keyword)
-> ReadS [Keyword]
-> ReadPrec Keyword
-> ReadPrec [Keyword]
-> Read Keyword
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Keyword
readsPrec :: Int -> ReadS Keyword
$creadList :: ReadS [Keyword]
readList :: ReadS [Keyword]
$creadPrec :: ReadPrec Keyword
readPrec :: ReadPrec Keyword
$creadListPrec :: ReadPrec [Keyword]
readListPrec :: ReadPrec [Keyword]
Read, Int -> Keyword -> String -> String
[Keyword] -> String -> String
Keyword -> String
(Int -> Keyword -> String -> String)
-> (Keyword -> String)
-> ([Keyword] -> String -> String)
-> Show Keyword
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Keyword -> String -> String
showsPrec :: Int -> Keyword -> String -> String
$cshow :: Keyword -> String
show :: Keyword -> String
$cshowList :: [Keyword] -> String -> String
showList :: [Keyword] -> String -> String
Show)

_Keyword :: Name
_Keyword = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Keyword")

data Literal = 
  LiteralBoolean Bool |
  LiteralInteger IntegerLiteral |
  LiteralReal Double |
  LiteralCharacter String |
  LiteralString String |
  LiteralNull 
  deriving (Literal -> Literal -> Bool
(Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool) -> Eq Literal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Literal -> Literal -> Bool
== :: Literal -> Literal -> Bool
$c/= :: Literal -> Literal -> Bool
/= :: Literal -> Literal -> Bool
Eq, Eq Literal
Eq Literal =>
(Literal -> Literal -> Ordering)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Bool)
-> (Literal -> Literal -> Literal)
-> (Literal -> Literal -> Literal)
-> Ord Literal
Literal -> Literal -> Bool
Literal -> Literal -> Ordering
Literal -> Literal -> Literal
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Literal -> Literal -> Ordering
compare :: Literal -> Literal -> Ordering
$c< :: Literal -> Literal -> Bool
< :: Literal -> Literal -> Bool
$c<= :: Literal -> Literal -> Bool
<= :: Literal -> Literal -> Bool
$c> :: Literal -> Literal -> Bool
> :: Literal -> Literal -> Bool
$c>= :: Literal -> Literal -> Bool
>= :: Literal -> Literal -> Bool
$cmax :: Literal -> Literal -> Literal
max :: Literal -> Literal -> Literal
$cmin :: Literal -> Literal -> Literal
min :: Literal -> Literal -> Literal
Ord, ReadPrec [Literal]
ReadPrec Literal
Int -> ReadS Literal
ReadS [Literal]
(Int -> ReadS Literal)
-> ReadS [Literal]
-> ReadPrec Literal
-> ReadPrec [Literal]
-> Read Literal
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Literal
readsPrec :: Int -> ReadS Literal
$creadList :: ReadS [Literal]
readList :: ReadS [Literal]
$creadPrec :: ReadPrec Literal
readPrec :: ReadPrec Literal
$creadListPrec :: ReadPrec [Literal]
readListPrec :: ReadPrec [Literal]
Read, Int -> Literal -> String -> String
[Literal] -> String -> String
Literal -> String
(Int -> Literal -> String -> String)
-> (Literal -> String)
-> ([Literal] -> String -> String)
-> Show Literal
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Literal -> String -> String
showsPrec :: Int -> Literal -> String -> String
$cshow :: Literal -> String
show :: Literal -> String
$cshowList :: [Literal] -> String -> String
showList :: [Literal] -> String -> String
Show)

_Literal :: Name
_Literal = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Literal")

_Literal_boolean :: Name
_Literal_boolean = (String -> Name
Core.Name String
"boolean")

_Literal_integer :: Name
_Literal_integer = (String -> Name
Core.Name String
"integer")

_Literal_real :: Name
_Literal_real = (String -> Name
Core.Name String
"real")

_Literal_character :: Name
_Literal_character = (String -> Name
Core.Name String
"character")

_Literal_string :: Name
_Literal_string = (String -> Name
Core.Name String
"string")

_Literal_null :: Name
_Literal_null = (String -> Name
Core.Name String
"null")

data IntegerLiteral = 
  IntegerLiteralDecimal String |
  IntegerLiteralHexadecimal String |
  IntegerLiteralBinary Integer
  deriving (IntegerLiteral -> IntegerLiteral -> Bool
(IntegerLiteral -> IntegerLiteral -> Bool)
-> (IntegerLiteral -> IntegerLiteral -> Bool) -> Eq IntegerLiteral
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IntegerLiteral -> IntegerLiteral -> Bool
== :: IntegerLiteral -> IntegerLiteral -> Bool
$c/= :: IntegerLiteral -> IntegerLiteral -> Bool
/= :: IntegerLiteral -> IntegerLiteral -> Bool
Eq, Eq IntegerLiteral
Eq IntegerLiteral =>
(IntegerLiteral -> IntegerLiteral -> Ordering)
-> (IntegerLiteral -> IntegerLiteral -> Bool)
-> (IntegerLiteral -> IntegerLiteral -> Bool)
-> (IntegerLiteral -> IntegerLiteral -> Bool)
-> (IntegerLiteral -> IntegerLiteral -> Bool)
-> (IntegerLiteral -> IntegerLiteral -> IntegerLiteral)
-> (IntegerLiteral -> IntegerLiteral -> IntegerLiteral)
-> Ord IntegerLiteral
IntegerLiteral -> IntegerLiteral -> Bool
IntegerLiteral -> IntegerLiteral -> Ordering
IntegerLiteral -> IntegerLiteral -> IntegerLiteral
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IntegerLiteral -> IntegerLiteral -> Ordering
compare :: IntegerLiteral -> IntegerLiteral -> Ordering
$c< :: IntegerLiteral -> IntegerLiteral -> Bool
< :: IntegerLiteral -> IntegerLiteral -> Bool
$c<= :: IntegerLiteral -> IntegerLiteral -> Bool
<= :: IntegerLiteral -> IntegerLiteral -> Bool
$c> :: IntegerLiteral -> IntegerLiteral -> Bool
> :: IntegerLiteral -> IntegerLiteral -> Bool
$c>= :: IntegerLiteral -> IntegerLiteral -> Bool
>= :: IntegerLiteral -> IntegerLiteral -> Bool
$cmax :: IntegerLiteral -> IntegerLiteral -> IntegerLiteral
max :: IntegerLiteral -> IntegerLiteral -> IntegerLiteral
$cmin :: IntegerLiteral -> IntegerLiteral -> IntegerLiteral
min :: IntegerLiteral -> IntegerLiteral -> IntegerLiteral
Ord, ReadPrec [IntegerLiteral]
ReadPrec IntegerLiteral
Int -> ReadS IntegerLiteral
ReadS [IntegerLiteral]
(Int -> ReadS IntegerLiteral)
-> ReadS [IntegerLiteral]
-> ReadPrec IntegerLiteral
-> ReadPrec [IntegerLiteral]
-> Read IntegerLiteral
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IntegerLiteral
readsPrec :: Int -> ReadS IntegerLiteral
$creadList :: ReadS [IntegerLiteral]
readList :: ReadS [IntegerLiteral]
$creadPrec :: ReadPrec IntegerLiteral
readPrec :: ReadPrec IntegerLiteral
$creadListPrec :: ReadPrec [IntegerLiteral]
readListPrec :: ReadPrec [IntegerLiteral]
Read, Int -> IntegerLiteral -> String -> String
[IntegerLiteral] -> String -> String
IntegerLiteral -> String
(Int -> IntegerLiteral -> String -> String)
-> (IntegerLiteral -> String)
-> ([IntegerLiteral] -> String -> String)
-> Show IntegerLiteral
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IntegerLiteral -> String -> String
showsPrec :: Int -> IntegerLiteral -> String -> String
$cshow :: IntegerLiteral -> String
show :: IntegerLiteral -> String
$cshowList :: [IntegerLiteral] -> String -> String
showList :: [IntegerLiteral] -> String -> String
Show)

_IntegerLiteral :: Name
_IntegerLiteral = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IntegerLiteral")

_IntegerLiteral_decimal :: Name
_IntegerLiteral_decimal = (String -> Name
Core.Name String
"decimal")

_IntegerLiteral_hexadecimal :: Name
_IntegerLiteral_hexadecimal = (String -> Name
Core.Name String
"hexadecimal")

_IntegerLiteral_binary :: Name
_IntegerLiteral_binary = (String -> Name
Core.Name String
"binary")

newtype NamespaceName = 
  NamespaceName {
    NamespaceName -> NamespaceOrTypeName
unNamespaceName :: NamespaceOrTypeName}
  deriving (NamespaceName -> NamespaceName -> Bool
(NamespaceName -> NamespaceName -> Bool)
-> (NamespaceName -> NamespaceName -> Bool) -> Eq NamespaceName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceName -> NamespaceName -> Bool
== :: NamespaceName -> NamespaceName -> Bool
$c/= :: NamespaceName -> NamespaceName -> Bool
/= :: NamespaceName -> NamespaceName -> Bool
Eq, Eq NamespaceName
Eq NamespaceName =>
(NamespaceName -> NamespaceName -> Ordering)
-> (NamespaceName -> NamespaceName -> Bool)
-> (NamespaceName -> NamespaceName -> Bool)
-> (NamespaceName -> NamespaceName -> Bool)
-> (NamespaceName -> NamespaceName -> Bool)
-> (NamespaceName -> NamespaceName -> NamespaceName)
-> (NamespaceName -> NamespaceName -> NamespaceName)
-> Ord NamespaceName
NamespaceName -> NamespaceName -> Bool
NamespaceName -> NamespaceName -> Ordering
NamespaceName -> NamespaceName -> NamespaceName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceName -> NamespaceName -> Ordering
compare :: NamespaceName -> NamespaceName -> Ordering
$c< :: NamespaceName -> NamespaceName -> Bool
< :: NamespaceName -> NamespaceName -> Bool
$c<= :: NamespaceName -> NamespaceName -> Bool
<= :: NamespaceName -> NamespaceName -> Bool
$c> :: NamespaceName -> NamespaceName -> Bool
> :: NamespaceName -> NamespaceName -> Bool
$c>= :: NamespaceName -> NamespaceName -> Bool
>= :: NamespaceName -> NamespaceName -> Bool
$cmax :: NamespaceName -> NamespaceName -> NamespaceName
max :: NamespaceName -> NamespaceName -> NamespaceName
$cmin :: NamespaceName -> NamespaceName -> NamespaceName
min :: NamespaceName -> NamespaceName -> NamespaceName
Ord, ReadPrec [NamespaceName]
ReadPrec NamespaceName
Int -> ReadS NamespaceName
ReadS [NamespaceName]
(Int -> ReadS NamespaceName)
-> ReadS [NamespaceName]
-> ReadPrec NamespaceName
-> ReadPrec [NamespaceName]
-> Read NamespaceName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamespaceName
readsPrec :: Int -> ReadS NamespaceName
$creadList :: ReadS [NamespaceName]
readList :: ReadS [NamespaceName]
$creadPrec :: ReadPrec NamespaceName
readPrec :: ReadPrec NamespaceName
$creadListPrec :: ReadPrec [NamespaceName]
readListPrec :: ReadPrec [NamespaceName]
Read, Int -> NamespaceName -> String -> String
[NamespaceName] -> String -> String
NamespaceName -> String
(Int -> NamespaceName -> String -> String)
-> (NamespaceName -> String)
-> ([NamespaceName] -> String -> String)
-> Show NamespaceName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NamespaceName -> String -> String
showsPrec :: Int -> NamespaceName -> String -> String
$cshow :: NamespaceName -> String
show :: NamespaceName -> String
$cshowList :: [NamespaceName] -> String -> String
showList :: [NamespaceName] -> String -> String
Show)

_NamespaceName :: Name
_NamespaceName = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NamespaceName")

newtype TypeName = 
  TypeName {
    TypeName -> NamespaceOrTypeName
unTypeName :: NamespaceOrTypeName}
  deriving (TypeName -> TypeName -> Bool
(TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> Bool) -> Eq TypeName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeName -> TypeName -> Bool
== :: TypeName -> TypeName -> Bool
$c/= :: TypeName -> TypeName -> Bool
/= :: TypeName -> TypeName -> Bool
Eq, Eq TypeName
Eq TypeName =>
(TypeName -> TypeName -> Ordering)
-> (TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> Bool)
-> (TypeName -> TypeName -> TypeName)
-> (TypeName -> TypeName -> TypeName)
-> Ord TypeName
TypeName -> TypeName -> Bool
TypeName -> TypeName -> Ordering
TypeName -> TypeName -> TypeName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TypeName -> TypeName -> Ordering
compare :: TypeName -> TypeName -> Ordering
$c< :: TypeName -> TypeName -> Bool
< :: TypeName -> TypeName -> Bool
$c<= :: TypeName -> TypeName -> Bool
<= :: TypeName -> TypeName -> Bool
$c> :: TypeName -> TypeName -> Bool
> :: TypeName -> TypeName -> Bool
$c>= :: TypeName -> TypeName -> Bool
>= :: TypeName -> TypeName -> Bool
$cmax :: TypeName -> TypeName -> TypeName
max :: TypeName -> TypeName -> TypeName
$cmin :: TypeName -> TypeName -> TypeName
min :: TypeName -> TypeName -> TypeName
Ord, ReadPrec [TypeName]
ReadPrec TypeName
Int -> ReadS TypeName
ReadS [TypeName]
(Int -> ReadS TypeName)
-> ReadS [TypeName]
-> ReadPrec TypeName
-> ReadPrec [TypeName]
-> Read TypeName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeName
readsPrec :: Int -> ReadS TypeName
$creadList :: ReadS [TypeName]
readList :: ReadS [TypeName]
$creadPrec :: ReadPrec TypeName
readPrec :: ReadPrec TypeName
$creadListPrec :: ReadPrec [TypeName]
readListPrec :: ReadPrec [TypeName]
Read, Int -> TypeName -> String -> String
[TypeName] -> String -> String
TypeName -> String
(Int -> TypeName -> String -> String)
-> (TypeName -> String)
-> ([TypeName] -> String -> String)
-> Show TypeName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TypeName -> String -> String
showsPrec :: Int -> TypeName -> String -> String
$cshow :: TypeName -> String
show :: TypeName -> String
$cshowList :: [TypeName] -> String -> String
showList :: [TypeName] -> String -> String
Show)

_TypeName :: Name
_TypeName = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TypeName")

data NamespaceOrTypeName = 
  NamespaceOrTypeNameIdentifier IdentifierNamespaceOrTypeName |
  NamespaceOrTypeNameQualified QualifiedNamespaceOrTypeName |
  NamespaceOrTypeNameAlias QualifiedAliasMember
  deriving (NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
(NamespaceOrTypeName -> NamespaceOrTypeName -> Bool)
-> (NamespaceOrTypeName -> NamespaceOrTypeName -> Bool)
-> Eq NamespaceOrTypeName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
== :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
$c/= :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
/= :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
Eq, Eq NamespaceOrTypeName
Eq NamespaceOrTypeName =>
(NamespaceOrTypeName -> NamespaceOrTypeName -> Ordering)
-> (NamespaceOrTypeName -> NamespaceOrTypeName -> Bool)
-> (NamespaceOrTypeName -> NamespaceOrTypeName -> Bool)
-> (NamespaceOrTypeName -> NamespaceOrTypeName -> Bool)
-> (NamespaceOrTypeName -> NamespaceOrTypeName -> Bool)
-> (NamespaceOrTypeName
    -> NamespaceOrTypeName -> NamespaceOrTypeName)
-> (NamespaceOrTypeName
    -> NamespaceOrTypeName -> NamespaceOrTypeName)
-> Ord NamespaceOrTypeName
NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
NamespaceOrTypeName -> NamespaceOrTypeName -> Ordering
NamespaceOrTypeName -> NamespaceOrTypeName -> NamespaceOrTypeName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceOrTypeName -> NamespaceOrTypeName -> Ordering
compare :: NamespaceOrTypeName -> NamespaceOrTypeName -> Ordering
$c< :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
< :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
$c<= :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
<= :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
$c> :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
> :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
$c>= :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
>= :: NamespaceOrTypeName -> NamespaceOrTypeName -> Bool
$cmax :: NamespaceOrTypeName -> NamespaceOrTypeName -> NamespaceOrTypeName
max :: NamespaceOrTypeName -> NamespaceOrTypeName -> NamespaceOrTypeName
$cmin :: NamespaceOrTypeName -> NamespaceOrTypeName -> NamespaceOrTypeName
min :: NamespaceOrTypeName -> NamespaceOrTypeName -> NamespaceOrTypeName
Ord, ReadPrec [NamespaceOrTypeName]
ReadPrec NamespaceOrTypeName
Int -> ReadS NamespaceOrTypeName
ReadS [NamespaceOrTypeName]
(Int -> ReadS NamespaceOrTypeName)
-> ReadS [NamespaceOrTypeName]
-> ReadPrec NamespaceOrTypeName
-> ReadPrec [NamespaceOrTypeName]
-> Read NamespaceOrTypeName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamespaceOrTypeName
readsPrec :: Int -> ReadS NamespaceOrTypeName
$creadList :: ReadS [NamespaceOrTypeName]
readList :: ReadS [NamespaceOrTypeName]
$creadPrec :: ReadPrec NamespaceOrTypeName
readPrec :: ReadPrec NamespaceOrTypeName
$creadListPrec :: ReadPrec [NamespaceOrTypeName]
readListPrec :: ReadPrec [NamespaceOrTypeName]
Read, Int -> NamespaceOrTypeName -> String -> String
[NamespaceOrTypeName] -> String -> String
NamespaceOrTypeName -> String
(Int -> NamespaceOrTypeName -> String -> String)
-> (NamespaceOrTypeName -> String)
-> ([NamespaceOrTypeName] -> String -> String)
-> Show NamespaceOrTypeName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NamespaceOrTypeName -> String -> String
showsPrec :: Int -> NamespaceOrTypeName -> String -> String
$cshow :: NamespaceOrTypeName -> String
show :: NamespaceOrTypeName -> String
$cshowList :: [NamespaceOrTypeName] -> String -> String
showList :: [NamespaceOrTypeName] -> String -> String
Show)

_NamespaceOrTypeName :: Name
_NamespaceOrTypeName = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NamespaceOrTypeName")

_NamespaceOrTypeName_identifier :: Name
_NamespaceOrTypeName_identifier = (String -> Name
Core.Name String
"identifier")

_NamespaceOrTypeName_qualified :: Name
_NamespaceOrTypeName_qualified = (String -> Name
Core.Name String
"qualified")

_NamespaceOrTypeName_alias :: Name
_NamespaceOrTypeName_alias = (String -> Name
Core.Name String
"alias")

data IdentifierNamespaceOrTypeName = 
  IdentifierNamespaceOrTypeName {
    IdentifierNamespaceOrTypeName -> Identifier
identifierNamespaceOrTypeNameIdentifier :: Identifier,
    IdentifierNamespaceOrTypeName -> Maybe TypeArgumentList
identifierNamespaceOrTypeNameArguments :: (Maybe TypeArgumentList)}
  deriving (IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
(IdentifierNamespaceOrTypeName
 -> IdentifierNamespaceOrTypeName -> Bool)
-> (IdentifierNamespaceOrTypeName
    -> IdentifierNamespaceOrTypeName -> Bool)
-> Eq IdentifierNamespaceOrTypeName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
== :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
$c/= :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
/= :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
Eq, Eq IdentifierNamespaceOrTypeName
Eq IdentifierNamespaceOrTypeName =>
(IdentifierNamespaceOrTypeName
 -> IdentifierNamespaceOrTypeName -> Ordering)
-> (IdentifierNamespaceOrTypeName
    -> IdentifierNamespaceOrTypeName -> Bool)
-> (IdentifierNamespaceOrTypeName
    -> IdentifierNamespaceOrTypeName -> Bool)
-> (IdentifierNamespaceOrTypeName
    -> IdentifierNamespaceOrTypeName -> Bool)
-> (IdentifierNamespaceOrTypeName
    -> IdentifierNamespaceOrTypeName -> Bool)
-> (IdentifierNamespaceOrTypeName
    -> IdentifierNamespaceOrTypeName -> IdentifierNamespaceOrTypeName)
-> (IdentifierNamespaceOrTypeName
    -> IdentifierNamespaceOrTypeName -> IdentifierNamespaceOrTypeName)
-> Ord IdentifierNamespaceOrTypeName
IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Ordering
IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> IdentifierNamespaceOrTypeName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Ordering
compare :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Ordering
$c< :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
< :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
$c<= :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
<= :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
$c> :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
> :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
$c>= :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
>= :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> Bool
$cmax :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> IdentifierNamespaceOrTypeName
max :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> IdentifierNamespaceOrTypeName
$cmin :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> IdentifierNamespaceOrTypeName
min :: IdentifierNamespaceOrTypeName
-> IdentifierNamespaceOrTypeName -> IdentifierNamespaceOrTypeName
Ord, ReadPrec [IdentifierNamespaceOrTypeName]
ReadPrec IdentifierNamespaceOrTypeName
Int -> ReadS IdentifierNamespaceOrTypeName
ReadS [IdentifierNamespaceOrTypeName]
(Int -> ReadS IdentifierNamespaceOrTypeName)
-> ReadS [IdentifierNamespaceOrTypeName]
-> ReadPrec IdentifierNamespaceOrTypeName
-> ReadPrec [IdentifierNamespaceOrTypeName]
-> Read IdentifierNamespaceOrTypeName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IdentifierNamespaceOrTypeName
readsPrec :: Int -> ReadS IdentifierNamespaceOrTypeName
$creadList :: ReadS [IdentifierNamespaceOrTypeName]
readList :: ReadS [IdentifierNamespaceOrTypeName]
$creadPrec :: ReadPrec IdentifierNamespaceOrTypeName
readPrec :: ReadPrec IdentifierNamespaceOrTypeName
$creadListPrec :: ReadPrec [IdentifierNamespaceOrTypeName]
readListPrec :: ReadPrec [IdentifierNamespaceOrTypeName]
Read, Int -> IdentifierNamespaceOrTypeName -> String -> String
[IdentifierNamespaceOrTypeName] -> String -> String
IdentifierNamespaceOrTypeName -> String
(Int -> IdentifierNamespaceOrTypeName -> String -> String)
-> (IdentifierNamespaceOrTypeName -> String)
-> ([IdentifierNamespaceOrTypeName] -> String -> String)
-> Show IdentifierNamespaceOrTypeName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IdentifierNamespaceOrTypeName -> String -> String
showsPrec :: Int -> IdentifierNamespaceOrTypeName -> String -> String
$cshow :: IdentifierNamespaceOrTypeName -> String
show :: IdentifierNamespaceOrTypeName -> String
$cshowList :: [IdentifierNamespaceOrTypeName] -> String -> String
showList :: [IdentifierNamespaceOrTypeName] -> String -> String
Show)

_IdentifierNamespaceOrTypeName :: Name
_IdentifierNamespaceOrTypeName = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IdentifierNamespaceOrTypeName")

_IdentifierNamespaceOrTypeName_identifier :: Name
_IdentifierNamespaceOrTypeName_identifier = (String -> Name
Core.Name String
"identifier")

_IdentifierNamespaceOrTypeName_arguments :: Name
_IdentifierNamespaceOrTypeName_arguments = (String -> Name
Core.Name String
"arguments")

data QualifiedNamespaceOrTypeName = 
  QualifiedNamespaceOrTypeName {
    QualifiedNamespaceOrTypeName -> NamespaceOrTypeName
qualifiedNamespaceOrTypeNameNamespaceOrType :: NamespaceOrTypeName,
    QualifiedNamespaceOrTypeName -> Identifier
qualifiedNamespaceOrTypeNameIdentifier :: Identifier,
    QualifiedNamespaceOrTypeName -> Maybe TypeArgumentList
qualifiedNamespaceOrTypeNameArguments :: (Maybe TypeArgumentList)}
  deriving (QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
(QualifiedNamespaceOrTypeName
 -> QualifiedNamespaceOrTypeName -> Bool)
-> (QualifiedNamespaceOrTypeName
    -> QualifiedNamespaceOrTypeName -> Bool)
-> Eq QualifiedNamespaceOrTypeName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
== :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
$c/= :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
/= :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
Eq, Eq QualifiedNamespaceOrTypeName
Eq QualifiedNamespaceOrTypeName =>
(QualifiedNamespaceOrTypeName
 -> QualifiedNamespaceOrTypeName -> Ordering)
-> (QualifiedNamespaceOrTypeName
    -> QualifiedNamespaceOrTypeName -> Bool)
-> (QualifiedNamespaceOrTypeName
    -> QualifiedNamespaceOrTypeName -> Bool)
-> (QualifiedNamespaceOrTypeName
    -> QualifiedNamespaceOrTypeName -> Bool)
-> (QualifiedNamespaceOrTypeName
    -> QualifiedNamespaceOrTypeName -> Bool)
-> (QualifiedNamespaceOrTypeName
    -> QualifiedNamespaceOrTypeName -> QualifiedNamespaceOrTypeName)
-> (QualifiedNamespaceOrTypeName
    -> QualifiedNamespaceOrTypeName -> QualifiedNamespaceOrTypeName)
-> Ord QualifiedNamespaceOrTypeName
QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Ordering
QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> QualifiedNamespaceOrTypeName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Ordering
compare :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Ordering
$c< :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
< :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
$c<= :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
<= :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
$c> :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
> :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
$c>= :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
>= :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> Bool
$cmax :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> QualifiedNamespaceOrTypeName
max :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> QualifiedNamespaceOrTypeName
$cmin :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> QualifiedNamespaceOrTypeName
min :: QualifiedNamespaceOrTypeName
-> QualifiedNamespaceOrTypeName -> QualifiedNamespaceOrTypeName
Ord, ReadPrec [QualifiedNamespaceOrTypeName]
ReadPrec QualifiedNamespaceOrTypeName
Int -> ReadS QualifiedNamespaceOrTypeName
ReadS [QualifiedNamespaceOrTypeName]
(Int -> ReadS QualifiedNamespaceOrTypeName)
-> ReadS [QualifiedNamespaceOrTypeName]
-> ReadPrec QualifiedNamespaceOrTypeName
-> ReadPrec [QualifiedNamespaceOrTypeName]
-> Read QualifiedNamespaceOrTypeName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS QualifiedNamespaceOrTypeName
readsPrec :: Int -> ReadS QualifiedNamespaceOrTypeName
$creadList :: ReadS [QualifiedNamespaceOrTypeName]
readList :: ReadS [QualifiedNamespaceOrTypeName]
$creadPrec :: ReadPrec QualifiedNamespaceOrTypeName
readPrec :: ReadPrec QualifiedNamespaceOrTypeName
$creadListPrec :: ReadPrec [QualifiedNamespaceOrTypeName]
readListPrec :: ReadPrec [QualifiedNamespaceOrTypeName]
Read, Int -> QualifiedNamespaceOrTypeName -> String -> String
[QualifiedNamespaceOrTypeName] -> String -> String
QualifiedNamespaceOrTypeName -> String
(Int -> QualifiedNamespaceOrTypeName -> String -> String)
-> (QualifiedNamespaceOrTypeName -> String)
-> ([QualifiedNamespaceOrTypeName] -> String -> String)
-> Show QualifiedNamespaceOrTypeName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> QualifiedNamespaceOrTypeName -> String -> String
showsPrec :: Int -> QualifiedNamespaceOrTypeName -> String -> String
$cshow :: QualifiedNamespaceOrTypeName -> String
show :: QualifiedNamespaceOrTypeName -> String
$cshowList :: [QualifiedNamespaceOrTypeName] -> String -> String
showList :: [QualifiedNamespaceOrTypeName] -> String -> String
Show)

_QualifiedNamespaceOrTypeName :: Name
_QualifiedNamespaceOrTypeName = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.QualifiedNamespaceOrTypeName")

_QualifiedNamespaceOrTypeName_namespaceOrType :: Name
_QualifiedNamespaceOrTypeName_namespaceOrType = (String -> Name
Core.Name String
"namespaceOrType")

_QualifiedNamespaceOrTypeName_identifier :: Name
_QualifiedNamespaceOrTypeName_identifier = (String -> Name
Core.Name String
"identifier")

_QualifiedNamespaceOrTypeName_arguments :: Name
_QualifiedNamespaceOrTypeName_arguments = (String -> Name
Core.Name String
"arguments")

data Type = 
  TypeReference ReferenceType |
  TypeValue ValueType |
  TypeParam TypeParameter |
  TypePointer PointerType
  deriving (Type -> Type -> Bool
(Type -> Type -> Bool) -> (Type -> Type -> Bool) -> Eq Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type -> Type -> Bool
== :: Type -> Type -> Bool
$c/= :: Type -> Type -> Bool
/= :: Type -> Type -> Bool
Eq, Eq Type
Eq Type =>
(Type -> Type -> Ordering)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Type)
-> (Type -> Type -> Type)
-> Ord Type
Type -> Type -> Bool
Type -> Type -> Ordering
Type -> Type -> Type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type -> Type -> Ordering
compare :: Type -> Type -> Ordering
$c< :: Type -> Type -> Bool
< :: Type -> Type -> Bool
$c<= :: Type -> Type -> Bool
<= :: Type -> Type -> Bool
$c> :: Type -> Type -> Bool
> :: Type -> Type -> Bool
$c>= :: Type -> Type -> Bool
>= :: Type -> Type -> Bool
$cmax :: Type -> Type -> Type
max :: Type -> Type -> Type
$cmin :: Type -> Type -> Type
min :: Type -> Type -> Type
Ord, ReadPrec [Type]
ReadPrec Type
Int -> ReadS Type
ReadS [Type]
(Int -> ReadS Type)
-> ReadS [Type] -> ReadPrec Type -> ReadPrec [Type] -> Read Type
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type
readsPrec :: Int -> ReadS Type
$creadList :: ReadS [Type]
readList :: ReadS [Type]
$creadPrec :: ReadPrec Type
readPrec :: ReadPrec Type
$creadListPrec :: ReadPrec [Type]
readListPrec :: ReadPrec [Type]
Read, Int -> Type -> String -> String
[Type] -> String -> String
Type -> String
(Int -> Type -> String -> String)
-> (Type -> String) -> ([Type] -> String -> String) -> Show Type
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type -> String -> String
showsPrec :: Int -> Type -> String -> String
$cshow :: Type -> String
show :: Type -> String
$cshowList :: [Type] -> String -> String
showList :: [Type] -> String -> String
Show)

_Type :: Name
_Type = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Type")

_Type_reference :: Name
_Type_reference = (String -> Name
Core.Name String
"reference")

_Type_value :: Name
_Type_value = (String -> Name
Core.Name String
"value")

_Type_param :: Name
_Type_param = (String -> Name
Core.Name String
"param")

_Type_pointer :: Name
_Type_pointer = (String -> Name
Core.Name String
"pointer")

data ReferenceType = 
  ReferenceTypeClass ClassType |
  ReferenceTypeInterface InterfaceType |
  ReferenceTypeArray ArrayType |
  ReferenceTypeDelegate DelegateType |
  ReferenceTypeDynamic 
  deriving (ReferenceType -> ReferenceType -> Bool
(ReferenceType -> ReferenceType -> Bool)
-> (ReferenceType -> ReferenceType -> Bool) -> Eq ReferenceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReferenceType -> ReferenceType -> Bool
== :: ReferenceType -> ReferenceType -> Bool
$c/= :: ReferenceType -> ReferenceType -> Bool
/= :: ReferenceType -> ReferenceType -> Bool
Eq, Eq ReferenceType
Eq ReferenceType =>
(ReferenceType -> ReferenceType -> Ordering)
-> (ReferenceType -> ReferenceType -> Bool)
-> (ReferenceType -> ReferenceType -> Bool)
-> (ReferenceType -> ReferenceType -> Bool)
-> (ReferenceType -> ReferenceType -> Bool)
-> (ReferenceType -> ReferenceType -> ReferenceType)
-> (ReferenceType -> ReferenceType -> ReferenceType)
-> Ord ReferenceType
ReferenceType -> ReferenceType -> Bool
ReferenceType -> ReferenceType -> Ordering
ReferenceType -> ReferenceType -> ReferenceType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ReferenceType -> ReferenceType -> Ordering
compare :: ReferenceType -> ReferenceType -> Ordering
$c< :: ReferenceType -> ReferenceType -> Bool
< :: ReferenceType -> ReferenceType -> Bool
$c<= :: ReferenceType -> ReferenceType -> Bool
<= :: ReferenceType -> ReferenceType -> Bool
$c> :: ReferenceType -> ReferenceType -> Bool
> :: ReferenceType -> ReferenceType -> Bool
$c>= :: ReferenceType -> ReferenceType -> Bool
>= :: ReferenceType -> ReferenceType -> Bool
$cmax :: ReferenceType -> ReferenceType -> ReferenceType
max :: ReferenceType -> ReferenceType -> ReferenceType
$cmin :: ReferenceType -> ReferenceType -> ReferenceType
min :: ReferenceType -> ReferenceType -> ReferenceType
Ord, ReadPrec [ReferenceType]
ReadPrec ReferenceType
Int -> ReadS ReferenceType
ReadS [ReferenceType]
(Int -> ReadS ReferenceType)
-> ReadS [ReferenceType]
-> ReadPrec ReferenceType
-> ReadPrec [ReferenceType]
-> Read ReferenceType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ReferenceType
readsPrec :: Int -> ReadS ReferenceType
$creadList :: ReadS [ReferenceType]
readList :: ReadS [ReferenceType]
$creadPrec :: ReadPrec ReferenceType
readPrec :: ReadPrec ReferenceType
$creadListPrec :: ReadPrec [ReferenceType]
readListPrec :: ReadPrec [ReferenceType]
Read, Int -> ReferenceType -> String -> String
[ReferenceType] -> String -> String
ReferenceType -> String
(Int -> ReferenceType -> String -> String)
-> (ReferenceType -> String)
-> ([ReferenceType] -> String -> String)
-> Show ReferenceType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ReferenceType -> String -> String
showsPrec :: Int -> ReferenceType -> String -> String
$cshow :: ReferenceType -> String
show :: ReferenceType -> String
$cshowList :: [ReferenceType] -> String -> String
showList :: [ReferenceType] -> String -> String
Show)

_ReferenceType :: Name
_ReferenceType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ReferenceType")

_ReferenceType_class :: Name
_ReferenceType_class = (String -> Name
Core.Name String
"class")

_ReferenceType_interface :: Name
_ReferenceType_interface = (String -> Name
Core.Name String
"interface")

_ReferenceType_array :: Name
_ReferenceType_array = (String -> Name
Core.Name String
"array")

_ReferenceType_delegate :: Name
_ReferenceType_delegate = (String -> Name
Core.Name String
"delegate")

_ReferenceType_dynamic :: Name
_ReferenceType_dynamic = (String -> Name
Core.Name String
"dynamic")

data ClassType = 
  ClassTypeTypeName TypeName |
  ClassTypeObject  |
  ClassTypeString 
  deriving (ClassType -> ClassType -> Bool
(ClassType -> ClassType -> Bool)
-> (ClassType -> ClassType -> Bool) -> Eq ClassType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClassType -> ClassType -> Bool
== :: ClassType -> ClassType -> Bool
$c/= :: ClassType -> ClassType -> Bool
/= :: ClassType -> ClassType -> Bool
Eq, Eq ClassType
Eq ClassType =>
(ClassType -> ClassType -> Ordering)
-> (ClassType -> ClassType -> Bool)
-> (ClassType -> ClassType -> Bool)
-> (ClassType -> ClassType -> Bool)
-> (ClassType -> ClassType -> Bool)
-> (ClassType -> ClassType -> ClassType)
-> (ClassType -> ClassType -> ClassType)
-> Ord ClassType
ClassType -> ClassType -> Bool
ClassType -> ClassType -> Ordering
ClassType -> ClassType -> ClassType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ClassType -> ClassType -> Ordering
compare :: ClassType -> ClassType -> Ordering
$c< :: ClassType -> ClassType -> Bool
< :: ClassType -> ClassType -> Bool
$c<= :: ClassType -> ClassType -> Bool
<= :: ClassType -> ClassType -> Bool
$c> :: ClassType -> ClassType -> Bool
> :: ClassType -> ClassType -> Bool
$c>= :: ClassType -> ClassType -> Bool
>= :: ClassType -> ClassType -> Bool
$cmax :: ClassType -> ClassType -> ClassType
max :: ClassType -> ClassType -> ClassType
$cmin :: ClassType -> ClassType -> ClassType
min :: ClassType -> ClassType -> ClassType
Ord, ReadPrec [ClassType]
ReadPrec ClassType
Int -> ReadS ClassType
ReadS [ClassType]
(Int -> ReadS ClassType)
-> ReadS [ClassType]
-> ReadPrec ClassType
-> ReadPrec [ClassType]
-> Read ClassType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ClassType
readsPrec :: Int -> ReadS ClassType
$creadList :: ReadS [ClassType]
readList :: ReadS [ClassType]
$creadPrec :: ReadPrec ClassType
readPrec :: ReadPrec ClassType
$creadListPrec :: ReadPrec [ClassType]
readListPrec :: ReadPrec [ClassType]
Read, Int -> ClassType -> String -> String
[ClassType] -> String -> String
ClassType -> String
(Int -> ClassType -> String -> String)
-> (ClassType -> String)
-> ([ClassType] -> String -> String)
-> Show ClassType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ClassType -> String -> String
showsPrec :: Int -> ClassType -> String -> String
$cshow :: ClassType -> String
show :: ClassType -> String
$cshowList :: [ClassType] -> String -> String
showList :: [ClassType] -> String -> String
Show)

_ClassType :: Name
_ClassType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ClassType")

_ClassType_typeName :: Name
_ClassType_typeName = (String -> Name
Core.Name String
"typeName")

_ClassType_object :: Name
_ClassType_object = (String -> Name
Core.Name String
"object")

_ClassType_string :: Name
_ClassType_string = (String -> Name
Core.Name String
"string")

newtype InterfaceType = 
  InterfaceType {
    InterfaceType -> TypeName
unInterfaceType :: TypeName}
  deriving (InterfaceType -> InterfaceType -> Bool
(InterfaceType -> InterfaceType -> Bool)
-> (InterfaceType -> InterfaceType -> Bool) -> Eq InterfaceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterfaceType -> InterfaceType -> Bool
== :: InterfaceType -> InterfaceType -> Bool
$c/= :: InterfaceType -> InterfaceType -> Bool
/= :: InterfaceType -> InterfaceType -> Bool
Eq, Eq InterfaceType
Eq InterfaceType =>
(InterfaceType -> InterfaceType -> Ordering)
-> (InterfaceType -> InterfaceType -> Bool)
-> (InterfaceType -> InterfaceType -> Bool)
-> (InterfaceType -> InterfaceType -> Bool)
-> (InterfaceType -> InterfaceType -> Bool)
-> (InterfaceType -> InterfaceType -> InterfaceType)
-> (InterfaceType -> InterfaceType -> InterfaceType)
-> Ord InterfaceType
InterfaceType -> InterfaceType -> Bool
InterfaceType -> InterfaceType -> Ordering
InterfaceType -> InterfaceType -> InterfaceType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterfaceType -> InterfaceType -> Ordering
compare :: InterfaceType -> InterfaceType -> Ordering
$c< :: InterfaceType -> InterfaceType -> Bool
< :: InterfaceType -> InterfaceType -> Bool
$c<= :: InterfaceType -> InterfaceType -> Bool
<= :: InterfaceType -> InterfaceType -> Bool
$c> :: InterfaceType -> InterfaceType -> Bool
> :: InterfaceType -> InterfaceType -> Bool
$c>= :: InterfaceType -> InterfaceType -> Bool
>= :: InterfaceType -> InterfaceType -> Bool
$cmax :: InterfaceType -> InterfaceType -> InterfaceType
max :: InterfaceType -> InterfaceType -> InterfaceType
$cmin :: InterfaceType -> InterfaceType -> InterfaceType
min :: InterfaceType -> InterfaceType -> InterfaceType
Ord, ReadPrec [InterfaceType]
ReadPrec InterfaceType
Int -> ReadS InterfaceType
ReadS [InterfaceType]
(Int -> ReadS InterfaceType)
-> ReadS [InterfaceType]
-> ReadPrec InterfaceType
-> ReadPrec [InterfaceType]
-> Read InterfaceType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterfaceType
readsPrec :: Int -> ReadS InterfaceType
$creadList :: ReadS [InterfaceType]
readList :: ReadS [InterfaceType]
$creadPrec :: ReadPrec InterfaceType
readPrec :: ReadPrec InterfaceType
$creadListPrec :: ReadPrec [InterfaceType]
readListPrec :: ReadPrec [InterfaceType]
Read, Int -> InterfaceType -> String -> String
[InterfaceType] -> String -> String
InterfaceType -> String
(Int -> InterfaceType -> String -> String)
-> (InterfaceType -> String)
-> ([InterfaceType] -> String -> String)
-> Show InterfaceType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterfaceType -> String -> String
showsPrec :: Int -> InterfaceType -> String -> String
$cshow :: InterfaceType -> String
show :: InterfaceType -> String
$cshowList :: [InterfaceType] -> String -> String
showList :: [InterfaceType] -> String -> String
Show)

_InterfaceType :: Name
_InterfaceType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterfaceType")

data ArrayType = 
  ArrayType {
    ArrayType -> NonArrayType
arrayTypeType :: NonArrayType,
    ArrayType -> [RankSpecifier]
arrayTypeRank :: [RankSpecifier]}
  deriving (ArrayType -> ArrayType -> Bool
(ArrayType -> ArrayType -> Bool)
-> (ArrayType -> ArrayType -> Bool) -> Eq ArrayType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArrayType -> ArrayType -> Bool
== :: ArrayType -> ArrayType -> Bool
$c/= :: ArrayType -> ArrayType -> Bool
/= :: ArrayType -> ArrayType -> Bool
Eq, Eq ArrayType
Eq ArrayType =>
(ArrayType -> ArrayType -> Ordering)
-> (ArrayType -> ArrayType -> Bool)
-> (ArrayType -> ArrayType -> Bool)
-> (ArrayType -> ArrayType -> Bool)
-> (ArrayType -> ArrayType -> Bool)
-> (ArrayType -> ArrayType -> ArrayType)
-> (ArrayType -> ArrayType -> ArrayType)
-> Ord ArrayType
ArrayType -> ArrayType -> Bool
ArrayType -> ArrayType -> Ordering
ArrayType -> ArrayType -> ArrayType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ArrayType -> ArrayType -> Ordering
compare :: ArrayType -> ArrayType -> Ordering
$c< :: ArrayType -> ArrayType -> Bool
< :: ArrayType -> ArrayType -> Bool
$c<= :: ArrayType -> ArrayType -> Bool
<= :: ArrayType -> ArrayType -> Bool
$c> :: ArrayType -> ArrayType -> Bool
> :: ArrayType -> ArrayType -> Bool
$c>= :: ArrayType -> ArrayType -> Bool
>= :: ArrayType -> ArrayType -> Bool
$cmax :: ArrayType -> ArrayType -> ArrayType
max :: ArrayType -> ArrayType -> ArrayType
$cmin :: ArrayType -> ArrayType -> ArrayType
min :: ArrayType -> ArrayType -> ArrayType
Ord, ReadPrec [ArrayType]
ReadPrec ArrayType
Int -> ReadS ArrayType
ReadS [ArrayType]
(Int -> ReadS ArrayType)
-> ReadS [ArrayType]
-> ReadPrec ArrayType
-> ReadPrec [ArrayType]
-> Read ArrayType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ArrayType
readsPrec :: Int -> ReadS ArrayType
$creadList :: ReadS [ArrayType]
readList :: ReadS [ArrayType]
$creadPrec :: ReadPrec ArrayType
readPrec :: ReadPrec ArrayType
$creadListPrec :: ReadPrec [ArrayType]
readListPrec :: ReadPrec [ArrayType]
Read, Int -> ArrayType -> String -> String
[ArrayType] -> String -> String
ArrayType -> String
(Int -> ArrayType -> String -> String)
-> (ArrayType -> String)
-> ([ArrayType] -> String -> String)
-> Show ArrayType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ArrayType -> String -> String
showsPrec :: Int -> ArrayType -> String -> String
$cshow :: ArrayType -> String
show :: ArrayType -> String
$cshowList :: [ArrayType] -> String -> String
showList :: [ArrayType] -> String -> String
Show)

_ArrayType :: Name
_ArrayType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ArrayType")

_ArrayType_type :: Name
_ArrayType_type = (String -> Name
Core.Name String
"type")

_ArrayType_rank :: Name
_ArrayType_rank = (String -> Name
Core.Name String
"rank")

data NonArrayType = 
  NonArrayTypeValue ValueType |
  NonArrayTypeClass ClassType |
  NonArrayTypeInterface InterfaceType |
  NonArrayTypeDelegate DelegateType |
  NonArrayTypeDynamic  |
  NonArrayTypeParameter TypeParameter |
  NonArrayTypePointer PointerType
  deriving (NonArrayType -> NonArrayType -> Bool
(NonArrayType -> NonArrayType -> Bool)
-> (NonArrayType -> NonArrayType -> Bool) -> Eq NonArrayType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NonArrayType -> NonArrayType -> Bool
== :: NonArrayType -> NonArrayType -> Bool
$c/= :: NonArrayType -> NonArrayType -> Bool
/= :: NonArrayType -> NonArrayType -> Bool
Eq, Eq NonArrayType
Eq NonArrayType =>
(NonArrayType -> NonArrayType -> Ordering)
-> (NonArrayType -> NonArrayType -> Bool)
-> (NonArrayType -> NonArrayType -> Bool)
-> (NonArrayType -> NonArrayType -> Bool)
-> (NonArrayType -> NonArrayType -> Bool)
-> (NonArrayType -> NonArrayType -> NonArrayType)
-> (NonArrayType -> NonArrayType -> NonArrayType)
-> Ord NonArrayType
NonArrayType -> NonArrayType -> Bool
NonArrayType -> NonArrayType -> Ordering
NonArrayType -> NonArrayType -> NonArrayType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NonArrayType -> NonArrayType -> Ordering
compare :: NonArrayType -> NonArrayType -> Ordering
$c< :: NonArrayType -> NonArrayType -> Bool
< :: NonArrayType -> NonArrayType -> Bool
$c<= :: NonArrayType -> NonArrayType -> Bool
<= :: NonArrayType -> NonArrayType -> Bool
$c> :: NonArrayType -> NonArrayType -> Bool
> :: NonArrayType -> NonArrayType -> Bool
$c>= :: NonArrayType -> NonArrayType -> Bool
>= :: NonArrayType -> NonArrayType -> Bool
$cmax :: NonArrayType -> NonArrayType -> NonArrayType
max :: NonArrayType -> NonArrayType -> NonArrayType
$cmin :: NonArrayType -> NonArrayType -> NonArrayType
min :: NonArrayType -> NonArrayType -> NonArrayType
Ord, ReadPrec [NonArrayType]
ReadPrec NonArrayType
Int -> ReadS NonArrayType
ReadS [NonArrayType]
(Int -> ReadS NonArrayType)
-> ReadS [NonArrayType]
-> ReadPrec NonArrayType
-> ReadPrec [NonArrayType]
-> Read NonArrayType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NonArrayType
readsPrec :: Int -> ReadS NonArrayType
$creadList :: ReadS [NonArrayType]
readList :: ReadS [NonArrayType]
$creadPrec :: ReadPrec NonArrayType
readPrec :: ReadPrec NonArrayType
$creadListPrec :: ReadPrec [NonArrayType]
readListPrec :: ReadPrec [NonArrayType]
Read, Int -> NonArrayType -> String -> String
[NonArrayType] -> String -> String
NonArrayType -> String
(Int -> NonArrayType -> String -> String)
-> (NonArrayType -> String)
-> ([NonArrayType] -> String -> String)
-> Show NonArrayType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NonArrayType -> String -> String
showsPrec :: Int -> NonArrayType -> String -> String
$cshow :: NonArrayType -> String
show :: NonArrayType -> String
$cshowList :: [NonArrayType] -> String -> String
showList :: [NonArrayType] -> String -> String
Show)

_NonArrayType :: Name
_NonArrayType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NonArrayType")

_NonArrayType_value :: Name
_NonArrayType_value = (String -> Name
Core.Name String
"value")

_NonArrayType_class :: Name
_NonArrayType_class = (String -> Name
Core.Name String
"class")

_NonArrayType_interface :: Name
_NonArrayType_interface = (String -> Name
Core.Name String
"interface")

_NonArrayType_delegate :: Name
_NonArrayType_delegate = (String -> Name
Core.Name String
"delegate")

_NonArrayType_dynamic :: Name
_NonArrayType_dynamic = (String -> Name
Core.Name String
"dynamic")

_NonArrayType_parameter :: Name
_NonArrayType_parameter = (String -> Name
Core.Name String
"parameter")

_NonArrayType_pointer :: Name
_NonArrayType_pointer = (String -> Name
Core.Name String
"pointer")

newtype RankSpecifier = 
  RankSpecifier {
    RankSpecifier -> Int
unRankSpecifier :: Int}
  deriving (RankSpecifier -> RankSpecifier -> Bool
(RankSpecifier -> RankSpecifier -> Bool)
-> (RankSpecifier -> RankSpecifier -> Bool) -> Eq RankSpecifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RankSpecifier -> RankSpecifier -> Bool
== :: RankSpecifier -> RankSpecifier -> Bool
$c/= :: RankSpecifier -> RankSpecifier -> Bool
/= :: RankSpecifier -> RankSpecifier -> Bool
Eq, Eq RankSpecifier
Eq RankSpecifier =>
(RankSpecifier -> RankSpecifier -> Ordering)
-> (RankSpecifier -> RankSpecifier -> Bool)
-> (RankSpecifier -> RankSpecifier -> Bool)
-> (RankSpecifier -> RankSpecifier -> Bool)
-> (RankSpecifier -> RankSpecifier -> Bool)
-> (RankSpecifier -> RankSpecifier -> RankSpecifier)
-> (RankSpecifier -> RankSpecifier -> RankSpecifier)
-> Ord RankSpecifier
RankSpecifier -> RankSpecifier -> Bool
RankSpecifier -> RankSpecifier -> Ordering
RankSpecifier -> RankSpecifier -> RankSpecifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RankSpecifier -> RankSpecifier -> Ordering
compare :: RankSpecifier -> RankSpecifier -> Ordering
$c< :: RankSpecifier -> RankSpecifier -> Bool
< :: RankSpecifier -> RankSpecifier -> Bool
$c<= :: RankSpecifier -> RankSpecifier -> Bool
<= :: RankSpecifier -> RankSpecifier -> Bool
$c> :: RankSpecifier -> RankSpecifier -> Bool
> :: RankSpecifier -> RankSpecifier -> Bool
$c>= :: RankSpecifier -> RankSpecifier -> Bool
>= :: RankSpecifier -> RankSpecifier -> Bool
$cmax :: RankSpecifier -> RankSpecifier -> RankSpecifier
max :: RankSpecifier -> RankSpecifier -> RankSpecifier
$cmin :: RankSpecifier -> RankSpecifier -> RankSpecifier
min :: RankSpecifier -> RankSpecifier -> RankSpecifier
Ord, ReadPrec [RankSpecifier]
ReadPrec RankSpecifier
Int -> ReadS RankSpecifier
ReadS [RankSpecifier]
(Int -> ReadS RankSpecifier)
-> ReadS [RankSpecifier]
-> ReadPrec RankSpecifier
-> ReadPrec [RankSpecifier]
-> Read RankSpecifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RankSpecifier
readsPrec :: Int -> ReadS RankSpecifier
$creadList :: ReadS [RankSpecifier]
readList :: ReadS [RankSpecifier]
$creadPrec :: ReadPrec RankSpecifier
readPrec :: ReadPrec RankSpecifier
$creadListPrec :: ReadPrec [RankSpecifier]
readListPrec :: ReadPrec [RankSpecifier]
Read, Int -> RankSpecifier -> String -> String
[RankSpecifier] -> String -> String
RankSpecifier -> String
(Int -> RankSpecifier -> String -> String)
-> (RankSpecifier -> String)
-> ([RankSpecifier] -> String -> String)
-> Show RankSpecifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RankSpecifier -> String -> String
showsPrec :: Int -> RankSpecifier -> String -> String
$cshow :: RankSpecifier -> String
show :: RankSpecifier -> String
$cshowList :: [RankSpecifier] -> String -> String
showList :: [RankSpecifier] -> String -> String
Show)

_RankSpecifier :: Name
_RankSpecifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RankSpecifier")

newtype DelegateType = 
  DelegateType {
    DelegateType -> TypeName
unDelegateType :: TypeName}
  deriving (DelegateType -> DelegateType -> Bool
(DelegateType -> DelegateType -> Bool)
-> (DelegateType -> DelegateType -> Bool) -> Eq DelegateType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DelegateType -> DelegateType -> Bool
== :: DelegateType -> DelegateType -> Bool
$c/= :: DelegateType -> DelegateType -> Bool
/= :: DelegateType -> DelegateType -> Bool
Eq, Eq DelegateType
Eq DelegateType =>
(DelegateType -> DelegateType -> Ordering)
-> (DelegateType -> DelegateType -> Bool)
-> (DelegateType -> DelegateType -> Bool)
-> (DelegateType -> DelegateType -> Bool)
-> (DelegateType -> DelegateType -> Bool)
-> (DelegateType -> DelegateType -> DelegateType)
-> (DelegateType -> DelegateType -> DelegateType)
-> Ord DelegateType
DelegateType -> DelegateType -> Bool
DelegateType -> DelegateType -> Ordering
DelegateType -> DelegateType -> DelegateType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DelegateType -> DelegateType -> Ordering
compare :: DelegateType -> DelegateType -> Ordering
$c< :: DelegateType -> DelegateType -> Bool
< :: DelegateType -> DelegateType -> Bool
$c<= :: DelegateType -> DelegateType -> Bool
<= :: DelegateType -> DelegateType -> Bool
$c> :: DelegateType -> DelegateType -> Bool
> :: DelegateType -> DelegateType -> Bool
$c>= :: DelegateType -> DelegateType -> Bool
>= :: DelegateType -> DelegateType -> Bool
$cmax :: DelegateType -> DelegateType -> DelegateType
max :: DelegateType -> DelegateType -> DelegateType
$cmin :: DelegateType -> DelegateType -> DelegateType
min :: DelegateType -> DelegateType -> DelegateType
Ord, ReadPrec [DelegateType]
ReadPrec DelegateType
Int -> ReadS DelegateType
ReadS [DelegateType]
(Int -> ReadS DelegateType)
-> ReadS [DelegateType]
-> ReadPrec DelegateType
-> ReadPrec [DelegateType]
-> Read DelegateType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DelegateType
readsPrec :: Int -> ReadS DelegateType
$creadList :: ReadS [DelegateType]
readList :: ReadS [DelegateType]
$creadPrec :: ReadPrec DelegateType
readPrec :: ReadPrec DelegateType
$creadListPrec :: ReadPrec [DelegateType]
readListPrec :: ReadPrec [DelegateType]
Read, Int -> DelegateType -> String -> String
[DelegateType] -> String -> String
DelegateType -> String
(Int -> DelegateType -> String -> String)
-> (DelegateType -> String)
-> ([DelegateType] -> String -> String)
-> Show DelegateType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DelegateType -> String -> String
showsPrec :: Int -> DelegateType -> String -> String
$cshow :: DelegateType -> String
show :: DelegateType -> String
$cshowList :: [DelegateType] -> String -> String
showList :: [DelegateType] -> String -> String
Show)

_DelegateType :: Name
_DelegateType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DelegateType")

data ValueType = 
  ValueTypeNonNullable StructOrEnumType |
  ValueTypeNullable StructOrEnumType
  deriving (ValueType -> ValueType -> Bool
(ValueType -> ValueType -> Bool)
-> (ValueType -> ValueType -> Bool) -> Eq ValueType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ValueType -> ValueType -> Bool
== :: ValueType -> ValueType -> Bool
$c/= :: ValueType -> ValueType -> Bool
/= :: ValueType -> ValueType -> Bool
Eq, Eq ValueType
Eq ValueType =>
(ValueType -> ValueType -> Ordering)
-> (ValueType -> ValueType -> Bool)
-> (ValueType -> ValueType -> Bool)
-> (ValueType -> ValueType -> Bool)
-> (ValueType -> ValueType -> Bool)
-> (ValueType -> ValueType -> ValueType)
-> (ValueType -> ValueType -> ValueType)
-> Ord ValueType
ValueType -> ValueType -> Bool
ValueType -> ValueType -> Ordering
ValueType -> ValueType -> ValueType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ValueType -> ValueType -> Ordering
compare :: ValueType -> ValueType -> Ordering
$c< :: ValueType -> ValueType -> Bool
< :: ValueType -> ValueType -> Bool
$c<= :: ValueType -> ValueType -> Bool
<= :: ValueType -> ValueType -> Bool
$c> :: ValueType -> ValueType -> Bool
> :: ValueType -> ValueType -> Bool
$c>= :: ValueType -> ValueType -> Bool
>= :: ValueType -> ValueType -> Bool
$cmax :: ValueType -> ValueType -> ValueType
max :: ValueType -> ValueType -> ValueType
$cmin :: ValueType -> ValueType -> ValueType
min :: ValueType -> ValueType -> ValueType
Ord, ReadPrec [ValueType]
ReadPrec ValueType
Int -> ReadS ValueType
ReadS [ValueType]
(Int -> ReadS ValueType)
-> ReadS [ValueType]
-> ReadPrec ValueType
-> ReadPrec [ValueType]
-> Read ValueType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ValueType
readsPrec :: Int -> ReadS ValueType
$creadList :: ReadS [ValueType]
readList :: ReadS [ValueType]
$creadPrec :: ReadPrec ValueType
readPrec :: ReadPrec ValueType
$creadListPrec :: ReadPrec [ValueType]
readListPrec :: ReadPrec [ValueType]
Read, Int -> ValueType -> String -> String
[ValueType] -> String -> String
ValueType -> String
(Int -> ValueType -> String -> String)
-> (ValueType -> String)
-> ([ValueType] -> String -> String)
-> Show ValueType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ValueType -> String -> String
showsPrec :: Int -> ValueType -> String -> String
$cshow :: ValueType -> String
show :: ValueType -> String
$cshowList :: [ValueType] -> String -> String
showList :: [ValueType] -> String -> String
Show)

_ValueType :: Name
_ValueType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ValueType")

_ValueType_nonNullable :: Name
_ValueType_nonNullable = (String -> Name
Core.Name String
"nonNullable")

_ValueType_nullable :: Name
_ValueType_nullable = (String -> Name
Core.Name String
"nullable")

data StructOrEnumType = 
  StructOrEnumTypeStruct StructType |
  StructOrEnumTypeEnum EnumType
  deriving (StructOrEnumType -> StructOrEnumType -> Bool
(StructOrEnumType -> StructOrEnumType -> Bool)
-> (StructOrEnumType -> StructOrEnumType -> Bool)
-> Eq StructOrEnumType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StructOrEnumType -> StructOrEnumType -> Bool
== :: StructOrEnumType -> StructOrEnumType -> Bool
$c/= :: StructOrEnumType -> StructOrEnumType -> Bool
/= :: StructOrEnumType -> StructOrEnumType -> Bool
Eq, Eq StructOrEnumType
Eq StructOrEnumType =>
(StructOrEnumType -> StructOrEnumType -> Ordering)
-> (StructOrEnumType -> StructOrEnumType -> Bool)
-> (StructOrEnumType -> StructOrEnumType -> Bool)
-> (StructOrEnumType -> StructOrEnumType -> Bool)
-> (StructOrEnumType -> StructOrEnumType -> Bool)
-> (StructOrEnumType -> StructOrEnumType -> StructOrEnumType)
-> (StructOrEnumType -> StructOrEnumType -> StructOrEnumType)
-> Ord StructOrEnumType
StructOrEnumType -> StructOrEnumType -> Bool
StructOrEnumType -> StructOrEnumType -> Ordering
StructOrEnumType -> StructOrEnumType -> StructOrEnumType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StructOrEnumType -> StructOrEnumType -> Ordering
compare :: StructOrEnumType -> StructOrEnumType -> Ordering
$c< :: StructOrEnumType -> StructOrEnumType -> Bool
< :: StructOrEnumType -> StructOrEnumType -> Bool
$c<= :: StructOrEnumType -> StructOrEnumType -> Bool
<= :: StructOrEnumType -> StructOrEnumType -> Bool
$c> :: StructOrEnumType -> StructOrEnumType -> Bool
> :: StructOrEnumType -> StructOrEnumType -> Bool
$c>= :: StructOrEnumType -> StructOrEnumType -> Bool
>= :: StructOrEnumType -> StructOrEnumType -> Bool
$cmax :: StructOrEnumType -> StructOrEnumType -> StructOrEnumType
max :: StructOrEnumType -> StructOrEnumType -> StructOrEnumType
$cmin :: StructOrEnumType -> StructOrEnumType -> StructOrEnumType
min :: StructOrEnumType -> StructOrEnumType -> StructOrEnumType
Ord, ReadPrec [StructOrEnumType]
ReadPrec StructOrEnumType
Int -> ReadS StructOrEnumType
ReadS [StructOrEnumType]
(Int -> ReadS StructOrEnumType)
-> ReadS [StructOrEnumType]
-> ReadPrec StructOrEnumType
-> ReadPrec [StructOrEnumType]
-> Read StructOrEnumType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StructOrEnumType
readsPrec :: Int -> ReadS StructOrEnumType
$creadList :: ReadS [StructOrEnumType]
readList :: ReadS [StructOrEnumType]
$creadPrec :: ReadPrec StructOrEnumType
readPrec :: ReadPrec StructOrEnumType
$creadListPrec :: ReadPrec [StructOrEnumType]
readListPrec :: ReadPrec [StructOrEnumType]
Read, Int -> StructOrEnumType -> String -> String
[StructOrEnumType] -> String -> String
StructOrEnumType -> String
(Int -> StructOrEnumType -> String -> String)
-> (StructOrEnumType -> String)
-> ([StructOrEnumType] -> String -> String)
-> Show StructOrEnumType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StructOrEnumType -> String -> String
showsPrec :: Int -> StructOrEnumType -> String -> String
$cshow :: StructOrEnumType -> String
show :: StructOrEnumType -> String
$cshowList :: [StructOrEnumType] -> String -> String
showList :: [StructOrEnumType] -> String -> String
Show)

_StructOrEnumType :: Name
_StructOrEnumType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StructOrEnumType")

_StructOrEnumType_struct :: Name
_StructOrEnumType_struct = (String -> Name
Core.Name String
"struct")

_StructOrEnumType_enum :: Name
_StructOrEnumType_enum = (String -> Name
Core.Name String
"enum")

data StructType = 
  StructTypeTypeName TypeName |
  StructTypeSimple SimpleType |
  StructTypeTuple TupleType
  deriving (StructType -> StructType -> Bool
(StructType -> StructType -> Bool)
-> (StructType -> StructType -> Bool) -> Eq StructType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StructType -> StructType -> Bool
== :: StructType -> StructType -> Bool
$c/= :: StructType -> StructType -> Bool
/= :: StructType -> StructType -> Bool
Eq, Eq StructType
Eq StructType =>
(StructType -> StructType -> Ordering)
-> (StructType -> StructType -> Bool)
-> (StructType -> StructType -> Bool)
-> (StructType -> StructType -> Bool)
-> (StructType -> StructType -> Bool)
-> (StructType -> StructType -> StructType)
-> (StructType -> StructType -> StructType)
-> Ord StructType
StructType -> StructType -> Bool
StructType -> StructType -> Ordering
StructType -> StructType -> StructType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StructType -> StructType -> Ordering
compare :: StructType -> StructType -> Ordering
$c< :: StructType -> StructType -> Bool
< :: StructType -> StructType -> Bool
$c<= :: StructType -> StructType -> Bool
<= :: StructType -> StructType -> Bool
$c> :: StructType -> StructType -> Bool
> :: StructType -> StructType -> Bool
$c>= :: StructType -> StructType -> Bool
>= :: StructType -> StructType -> Bool
$cmax :: StructType -> StructType -> StructType
max :: StructType -> StructType -> StructType
$cmin :: StructType -> StructType -> StructType
min :: StructType -> StructType -> StructType
Ord, ReadPrec [StructType]
ReadPrec StructType
Int -> ReadS StructType
ReadS [StructType]
(Int -> ReadS StructType)
-> ReadS [StructType]
-> ReadPrec StructType
-> ReadPrec [StructType]
-> Read StructType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StructType
readsPrec :: Int -> ReadS StructType
$creadList :: ReadS [StructType]
readList :: ReadS [StructType]
$creadPrec :: ReadPrec StructType
readPrec :: ReadPrec StructType
$creadListPrec :: ReadPrec [StructType]
readListPrec :: ReadPrec [StructType]
Read, Int -> StructType -> String -> String
[StructType] -> String -> String
StructType -> String
(Int -> StructType -> String -> String)
-> (StructType -> String)
-> ([StructType] -> String -> String)
-> Show StructType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StructType -> String -> String
showsPrec :: Int -> StructType -> String -> String
$cshow :: StructType -> String
show :: StructType -> String
$cshowList :: [StructType] -> String -> String
showList :: [StructType] -> String -> String
Show)

_StructType :: Name
_StructType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StructType")

_StructType_typeName :: Name
_StructType_typeName = (String -> Name
Core.Name String
"typeName")

_StructType_simple :: Name
_StructType_simple = (String -> Name
Core.Name String
"simple")

_StructType_tuple :: Name
_StructType_tuple = (String -> Name
Core.Name String
"tuple")

data SimpleType = 
  SimpleTypeNumeric NumericType |
  SimpleTypeBool 
  deriving (SimpleType -> SimpleType -> Bool
(SimpleType -> SimpleType -> Bool)
-> (SimpleType -> SimpleType -> Bool) -> Eq SimpleType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SimpleType -> SimpleType -> Bool
== :: SimpleType -> SimpleType -> Bool
$c/= :: SimpleType -> SimpleType -> Bool
/= :: SimpleType -> SimpleType -> Bool
Eq, Eq SimpleType
Eq SimpleType =>
(SimpleType -> SimpleType -> Ordering)
-> (SimpleType -> SimpleType -> Bool)
-> (SimpleType -> SimpleType -> Bool)
-> (SimpleType -> SimpleType -> Bool)
-> (SimpleType -> SimpleType -> Bool)
-> (SimpleType -> SimpleType -> SimpleType)
-> (SimpleType -> SimpleType -> SimpleType)
-> Ord SimpleType
SimpleType -> SimpleType -> Bool
SimpleType -> SimpleType -> Ordering
SimpleType -> SimpleType -> SimpleType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SimpleType -> SimpleType -> Ordering
compare :: SimpleType -> SimpleType -> Ordering
$c< :: SimpleType -> SimpleType -> Bool
< :: SimpleType -> SimpleType -> Bool
$c<= :: SimpleType -> SimpleType -> Bool
<= :: SimpleType -> SimpleType -> Bool
$c> :: SimpleType -> SimpleType -> Bool
> :: SimpleType -> SimpleType -> Bool
$c>= :: SimpleType -> SimpleType -> Bool
>= :: SimpleType -> SimpleType -> Bool
$cmax :: SimpleType -> SimpleType -> SimpleType
max :: SimpleType -> SimpleType -> SimpleType
$cmin :: SimpleType -> SimpleType -> SimpleType
min :: SimpleType -> SimpleType -> SimpleType
Ord, ReadPrec [SimpleType]
ReadPrec SimpleType
Int -> ReadS SimpleType
ReadS [SimpleType]
(Int -> ReadS SimpleType)
-> ReadS [SimpleType]
-> ReadPrec SimpleType
-> ReadPrec [SimpleType]
-> Read SimpleType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SimpleType
readsPrec :: Int -> ReadS SimpleType
$creadList :: ReadS [SimpleType]
readList :: ReadS [SimpleType]
$creadPrec :: ReadPrec SimpleType
readPrec :: ReadPrec SimpleType
$creadListPrec :: ReadPrec [SimpleType]
readListPrec :: ReadPrec [SimpleType]
Read, Int -> SimpleType -> String -> String
[SimpleType] -> String -> String
SimpleType -> String
(Int -> SimpleType -> String -> String)
-> (SimpleType -> String)
-> ([SimpleType] -> String -> String)
-> Show SimpleType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SimpleType -> String -> String
showsPrec :: Int -> SimpleType -> String -> String
$cshow :: SimpleType -> String
show :: SimpleType -> String
$cshowList :: [SimpleType] -> String -> String
showList :: [SimpleType] -> String -> String
Show)

_SimpleType :: Name
_SimpleType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SimpleType")

_SimpleType_numeric :: Name
_SimpleType_numeric = (String -> Name
Core.Name String
"numeric")

_SimpleType_bool :: Name
_SimpleType_bool = (String -> Name
Core.Name String
"bool")

data NumericType = 
  NumericTypeIntegral IntegralType |
  NumericTypeFloatingPoint FloatingPointType |
  NumericTypeDecimal 
  deriving (NumericType -> NumericType -> Bool
(NumericType -> NumericType -> Bool)
-> (NumericType -> NumericType -> Bool) -> Eq NumericType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NumericType -> NumericType -> Bool
== :: NumericType -> NumericType -> Bool
$c/= :: NumericType -> NumericType -> Bool
/= :: NumericType -> NumericType -> Bool
Eq, Eq NumericType
Eq NumericType =>
(NumericType -> NumericType -> Ordering)
-> (NumericType -> NumericType -> Bool)
-> (NumericType -> NumericType -> Bool)
-> (NumericType -> NumericType -> Bool)
-> (NumericType -> NumericType -> Bool)
-> (NumericType -> NumericType -> NumericType)
-> (NumericType -> NumericType -> NumericType)
-> Ord NumericType
NumericType -> NumericType -> Bool
NumericType -> NumericType -> Ordering
NumericType -> NumericType -> NumericType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NumericType -> NumericType -> Ordering
compare :: NumericType -> NumericType -> Ordering
$c< :: NumericType -> NumericType -> Bool
< :: NumericType -> NumericType -> Bool
$c<= :: NumericType -> NumericType -> Bool
<= :: NumericType -> NumericType -> Bool
$c> :: NumericType -> NumericType -> Bool
> :: NumericType -> NumericType -> Bool
$c>= :: NumericType -> NumericType -> Bool
>= :: NumericType -> NumericType -> Bool
$cmax :: NumericType -> NumericType -> NumericType
max :: NumericType -> NumericType -> NumericType
$cmin :: NumericType -> NumericType -> NumericType
min :: NumericType -> NumericType -> NumericType
Ord, ReadPrec [NumericType]
ReadPrec NumericType
Int -> ReadS NumericType
ReadS [NumericType]
(Int -> ReadS NumericType)
-> ReadS [NumericType]
-> ReadPrec NumericType
-> ReadPrec [NumericType]
-> Read NumericType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NumericType
readsPrec :: Int -> ReadS NumericType
$creadList :: ReadS [NumericType]
readList :: ReadS [NumericType]
$creadPrec :: ReadPrec NumericType
readPrec :: ReadPrec NumericType
$creadListPrec :: ReadPrec [NumericType]
readListPrec :: ReadPrec [NumericType]
Read, Int -> NumericType -> String -> String
[NumericType] -> String -> String
NumericType -> String
(Int -> NumericType -> String -> String)
-> (NumericType -> String)
-> ([NumericType] -> String -> String)
-> Show NumericType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NumericType -> String -> String
showsPrec :: Int -> NumericType -> String -> String
$cshow :: NumericType -> String
show :: NumericType -> String
$cshowList :: [NumericType] -> String -> String
showList :: [NumericType] -> String -> String
Show)

_NumericType :: Name
_NumericType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NumericType")

_NumericType_integral :: Name
_NumericType_integral = (String -> Name
Core.Name String
"integral")

_NumericType_floatingPoint :: Name
_NumericType_floatingPoint = (String -> Name
Core.Name String
"floatingPoint")

_NumericType_decimal :: Name
_NumericType_decimal = (String -> Name
Core.Name String
"decimal")

data IntegralType = 
  IntegralTypeSbyte  |
  IntegralTypeByte  |
  IntegralTypeShort  |
  IntegralTypeUshort  |
  IntegralTypeInt  |
  IntegralTypeUint  |
  IntegralTypeLong  |
  IntegralTypeUlong  |
  IntegralTypeChar 
  deriving (IntegralType -> IntegralType -> Bool
(IntegralType -> IntegralType -> Bool)
-> (IntegralType -> IntegralType -> Bool) -> Eq IntegralType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IntegralType -> IntegralType -> Bool
== :: IntegralType -> IntegralType -> Bool
$c/= :: IntegralType -> IntegralType -> Bool
/= :: IntegralType -> IntegralType -> Bool
Eq, Eq IntegralType
Eq IntegralType =>
(IntegralType -> IntegralType -> Ordering)
-> (IntegralType -> IntegralType -> Bool)
-> (IntegralType -> IntegralType -> Bool)
-> (IntegralType -> IntegralType -> Bool)
-> (IntegralType -> IntegralType -> Bool)
-> (IntegralType -> IntegralType -> IntegralType)
-> (IntegralType -> IntegralType -> IntegralType)
-> Ord IntegralType
IntegralType -> IntegralType -> Bool
IntegralType -> IntegralType -> Ordering
IntegralType -> IntegralType -> IntegralType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IntegralType -> IntegralType -> Ordering
compare :: IntegralType -> IntegralType -> Ordering
$c< :: IntegralType -> IntegralType -> Bool
< :: IntegralType -> IntegralType -> Bool
$c<= :: IntegralType -> IntegralType -> Bool
<= :: IntegralType -> IntegralType -> Bool
$c> :: IntegralType -> IntegralType -> Bool
> :: IntegralType -> IntegralType -> Bool
$c>= :: IntegralType -> IntegralType -> Bool
>= :: IntegralType -> IntegralType -> Bool
$cmax :: IntegralType -> IntegralType -> IntegralType
max :: IntegralType -> IntegralType -> IntegralType
$cmin :: IntegralType -> IntegralType -> IntegralType
min :: IntegralType -> IntegralType -> IntegralType
Ord, ReadPrec [IntegralType]
ReadPrec IntegralType
Int -> ReadS IntegralType
ReadS [IntegralType]
(Int -> ReadS IntegralType)
-> ReadS [IntegralType]
-> ReadPrec IntegralType
-> ReadPrec [IntegralType]
-> Read IntegralType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IntegralType
readsPrec :: Int -> ReadS IntegralType
$creadList :: ReadS [IntegralType]
readList :: ReadS [IntegralType]
$creadPrec :: ReadPrec IntegralType
readPrec :: ReadPrec IntegralType
$creadListPrec :: ReadPrec [IntegralType]
readListPrec :: ReadPrec [IntegralType]
Read, Int -> IntegralType -> String -> String
[IntegralType] -> String -> String
IntegralType -> String
(Int -> IntegralType -> String -> String)
-> (IntegralType -> String)
-> ([IntegralType] -> String -> String)
-> Show IntegralType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IntegralType -> String -> String
showsPrec :: Int -> IntegralType -> String -> String
$cshow :: IntegralType -> String
show :: IntegralType -> String
$cshowList :: [IntegralType] -> String -> String
showList :: [IntegralType] -> String -> String
Show)

_IntegralType :: Name
_IntegralType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IntegralType")

_IntegralType_sbyte :: Name
_IntegralType_sbyte = (String -> Name
Core.Name String
"sbyte")

_IntegralType_byte :: Name
_IntegralType_byte = (String -> Name
Core.Name String
"byte")

_IntegralType_short :: Name
_IntegralType_short = (String -> Name
Core.Name String
"short")

_IntegralType_ushort :: Name
_IntegralType_ushort = (String -> Name
Core.Name String
"ushort")

_IntegralType_int :: Name
_IntegralType_int = (String -> Name
Core.Name String
"int")

_IntegralType_uint :: Name
_IntegralType_uint = (String -> Name
Core.Name String
"uint")

_IntegralType_long :: Name
_IntegralType_long = (String -> Name
Core.Name String
"long")

_IntegralType_ulong :: Name
_IntegralType_ulong = (String -> Name
Core.Name String
"ulong")

_IntegralType_char :: Name
_IntegralType_char = (String -> Name
Core.Name String
"char")

data FloatingPointType = 
  FloatingPointTypeFloat  |
  FloatingPointTypeDouble 
  deriving (FloatingPointType -> FloatingPointType -> Bool
(FloatingPointType -> FloatingPointType -> Bool)
-> (FloatingPointType -> FloatingPointType -> Bool)
-> Eq FloatingPointType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FloatingPointType -> FloatingPointType -> Bool
== :: FloatingPointType -> FloatingPointType -> Bool
$c/= :: FloatingPointType -> FloatingPointType -> Bool
/= :: FloatingPointType -> FloatingPointType -> Bool
Eq, Eq FloatingPointType
Eq FloatingPointType =>
(FloatingPointType -> FloatingPointType -> Ordering)
-> (FloatingPointType -> FloatingPointType -> Bool)
-> (FloatingPointType -> FloatingPointType -> Bool)
-> (FloatingPointType -> FloatingPointType -> Bool)
-> (FloatingPointType -> FloatingPointType -> Bool)
-> (FloatingPointType -> FloatingPointType -> FloatingPointType)
-> (FloatingPointType -> FloatingPointType -> FloatingPointType)
-> Ord FloatingPointType
FloatingPointType -> FloatingPointType -> Bool
FloatingPointType -> FloatingPointType -> Ordering
FloatingPointType -> FloatingPointType -> FloatingPointType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FloatingPointType -> FloatingPointType -> Ordering
compare :: FloatingPointType -> FloatingPointType -> Ordering
$c< :: FloatingPointType -> FloatingPointType -> Bool
< :: FloatingPointType -> FloatingPointType -> Bool
$c<= :: FloatingPointType -> FloatingPointType -> Bool
<= :: FloatingPointType -> FloatingPointType -> Bool
$c> :: FloatingPointType -> FloatingPointType -> Bool
> :: FloatingPointType -> FloatingPointType -> Bool
$c>= :: FloatingPointType -> FloatingPointType -> Bool
>= :: FloatingPointType -> FloatingPointType -> Bool
$cmax :: FloatingPointType -> FloatingPointType -> FloatingPointType
max :: FloatingPointType -> FloatingPointType -> FloatingPointType
$cmin :: FloatingPointType -> FloatingPointType -> FloatingPointType
min :: FloatingPointType -> FloatingPointType -> FloatingPointType
Ord, ReadPrec [FloatingPointType]
ReadPrec FloatingPointType
Int -> ReadS FloatingPointType
ReadS [FloatingPointType]
(Int -> ReadS FloatingPointType)
-> ReadS [FloatingPointType]
-> ReadPrec FloatingPointType
-> ReadPrec [FloatingPointType]
-> Read FloatingPointType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FloatingPointType
readsPrec :: Int -> ReadS FloatingPointType
$creadList :: ReadS [FloatingPointType]
readList :: ReadS [FloatingPointType]
$creadPrec :: ReadPrec FloatingPointType
readPrec :: ReadPrec FloatingPointType
$creadListPrec :: ReadPrec [FloatingPointType]
readListPrec :: ReadPrec [FloatingPointType]
Read, Int -> FloatingPointType -> String -> String
[FloatingPointType] -> String -> String
FloatingPointType -> String
(Int -> FloatingPointType -> String -> String)
-> (FloatingPointType -> String)
-> ([FloatingPointType] -> String -> String)
-> Show FloatingPointType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FloatingPointType -> String -> String
showsPrec :: Int -> FloatingPointType -> String -> String
$cshow :: FloatingPointType -> String
show :: FloatingPointType -> String
$cshowList :: [FloatingPointType] -> String -> String
showList :: [FloatingPointType] -> String -> String
Show)

_FloatingPointType :: Name
_FloatingPointType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FloatingPointType")

_FloatingPointType_float :: Name
_FloatingPointType_float = (String -> Name
Core.Name String
"float")

_FloatingPointType_double :: Name
_FloatingPointType_double = (String -> Name
Core.Name String
"double")

newtype TupleType = 
  TupleType {
    TupleType -> [TupleTypeElement]
unTupleType :: [TupleTypeElement]}
  deriving (TupleType -> TupleType -> Bool
(TupleType -> TupleType -> Bool)
-> (TupleType -> TupleType -> Bool) -> Eq TupleType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TupleType -> TupleType -> Bool
== :: TupleType -> TupleType -> Bool
$c/= :: TupleType -> TupleType -> Bool
/= :: TupleType -> TupleType -> Bool
Eq, Eq TupleType
Eq TupleType =>
(TupleType -> TupleType -> Ordering)
-> (TupleType -> TupleType -> Bool)
-> (TupleType -> TupleType -> Bool)
-> (TupleType -> TupleType -> Bool)
-> (TupleType -> TupleType -> Bool)
-> (TupleType -> TupleType -> TupleType)
-> (TupleType -> TupleType -> TupleType)
-> Ord TupleType
TupleType -> TupleType -> Bool
TupleType -> TupleType -> Ordering
TupleType -> TupleType -> TupleType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TupleType -> TupleType -> Ordering
compare :: TupleType -> TupleType -> Ordering
$c< :: TupleType -> TupleType -> Bool
< :: TupleType -> TupleType -> Bool
$c<= :: TupleType -> TupleType -> Bool
<= :: TupleType -> TupleType -> Bool
$c> :: TupleType -> TupleType -> Bool
> :: TupleType -> TupleType -> Bool
$c>= :: TupleType -> TupleType -> Bool
>= :: TupleType -> TupleType -> Bool
$cmax :: TupleType -> TupleType -> TupleType
max :: TupleType -> TupleType -> TupleType
$cmin :: TupleType -> TupleType -> TupleType
min :: TupleType -> TupleType -> TupleType
Ord, ReadPrec [TupleType]
ReadPrec TupleType
Int -> ReadS TupleType
ReadS [TupleType]
(Int -> ReadS TupleType)
-> ReadS [TupleType]
-> ReadPrec TupleType
-> ReadPrec [TupleType]
-> Read TupleType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TupleType
readsPrec :: Int -> ReadS TupleType
$creadList :: ReadS [TupleType]
readList :: ReadS [TupleType]
$creadPrec :: ReadPrec TupleType
readPrec :: ReadPrec TupleType
$creadListPrec :: ReadPrec [TupleType]
readListPrec :: ReadPrec [TupleType]
Read, Int -> TupleType -> String -> String
[TupleType] -> String -> String
TupleType -> String
(Int -> TupleType -> String -> String)
-> (TupleType -> String)
-> ([TupleType] -> String -> String)
-> Show TupleType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TupleType -> String -> String
showsPrec :: Int -> TupleType -> String -> String
$cshow :: TupleType -> String
show :: TupleType -> String
$cshowList :: [TupleType] -> String -> String
showList :: [TupleType] -> String -> String
Show)

_TupleType :: Name
_TupleType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TupleType")

data TupleTypeElement = 
  TupleTypeElement {
    TupleTypeElement -> Type
tupleTypeElementType :: Type,
    TupleTypeElement -> Maybe Identifier
tupleTypeElementIdentifier :: (Maybe Identifier)}
  deriving (TupleTypeElement -> TupleTypeElement -> Bool
(TupleTypeElement -> TupleTypeElement -> Bool)
-> (TupleTypeElement -> TupleTypeElement -> Bool)
-> Eq TupleTypeElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TupleTypeElement -> TupleTypeElement -> Bool
== :: TupleTypeElement -> TupleTypeElement -> Bool
$c/= :: TupleTypeElement -> TupleTypeElement -> Bool
/= :: TupleTypeElement -> TupleTypeElement -> Bool
Eq, Eq TupleTypeElement
Eq TupleTypeElement =>
(TupleTypeElement -> TupleTypeElement -> Ordering)
-> (TupleTypeElement -> TupleTypeElement -> Bool)
-> (TupleTypeElement -> TupleTypeElement -> Bool)
-> (TupleTypeElement -> TupleTypeElement -> Bool)
-> (TupleTypeElement -> TupleTypeElement -> Bool)
-> (TupleTypeElement -> TupleTypeElement -> TupleTypeElement)
-> (TupleTypeElement -> TupleTypeElement -> TupleTypeElement)
-> Ord TupleTypeElement
TupleTypeElement -> TupleTypeElement -> Bool
TupleTypeElement -> TupleTypeElement -> Ordering
TupleTypeElement -> TupleTypeElement -> TupleTypeElement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TupleTypeElement -> TupleTypeElement -> Ordering
compare :: TupleTypeElement -> TupleTypeElement -> Ordering
$c< :: TupleTypeElement -> TupleTypeElement -> Bool
< :: TupleTypeElement -> TupleTypeElement -> Bool
$c<= :: TupleTypeElement -> TupleTypeElement -> Bool
<= :: TupleTypeElement -> TupleTypeElement -> Bool
$c> :: TupleTypeElement -> TupleTypeElement -> Bool
> :: TupleTypeElement -> TupleTypeElement -> Bool
$c>= :: TupleTypeElement -> TupleTypeElement -> Bool
>= :: TupleTypeElement -> TupleTypeElement -> Bool
$cmax :: TupleTypeElement -> TupleTypeElement -> TupleTypeElement
max :: TupleTypeElement -> TupleTypeElement -> TupleTypeElement
$cmin :: TupleTypeElement -> TupleTypeElement -> TupleTypeElement
min :: TupleTypeElement -> TupleTypeElement -> TupleTypeElement
Ord, ReadPrec [TupleTypeElement]
ReadPrec TupleTypeElement
Int -> ReadS TupleTypeElement
ReadS [TupleTypeElement]
(Int -> ReadS TupleTypeElement)
-> ReadS [TupleTypeElement]
-> ReadPrec TupleTypeElement
-> ReadPrec [TupleTypeElement]
-> Read TupleTypeElement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TupleTypeElement
readsPrec :: Int -> ReadS TupleTypeElement
$creadList :: ReadS [TupleTypeElement]
readList :: ReadS [TupleTypeElement]
$creadPrec :: ReadPrec TupleTypeElement
readPrec :: ReadPrec TupleTypeElement
$creadListPrec :: ReadPrec [TupleTypeElement]
readListPrec :: ReadPrec [TupleTypeElement]
Read, Int -> TupleTypeElement -> String -> String
[TupleTypeElement] -> String -> String
TupleTypeElement -> String
(Int -> TupleTypeElement -> String -> String)
-> (TupleTypeElement -> String)
-> ([TupleTypeElement] -> String -> String)
-> Show TupleTypeElement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TupleTypeElement -> String -> String
showsPrec :: Int -> TupleTypeElement -> String -> String
$cshow :: TupleTypeElement -> String
show :: TupleTypeElement -> String
$cshowList :: [TupleTypeElement] -> String -> String
showList :: [TupleTypeElement] -> String -> String
Show)

_TupleTypeElement :: Name
_TupleTypeElement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TupleTypeElement")

_TupleTypeElement_type :: Name
_TupleTypeElement_type = (String -> Name
Core.Name String
"type")

_TupleTypeElement_identifier :: Name
_TupleTypeElement_identifier = (String -> Name
Core.Name String
"identifier")

newtype EnumType = 
  EnumType {
    EnumType -> TypeName
unEnumType :: TypeName}
  deriving (EnumType -> EnumType -> Bool
(EnumType -> EnumType -> Bool)
-> (EnumType -> EnumType -> Bool) -> Eq EnumType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnumType -> EnumType -> Bool
== :: EnumType -> EnumType -> Bool
$c/= :: EnumType -> EnumType -> Bool
/= :: EnumType -> EnumType -> Bool
Eq, Eq EnumType
Eq EnumType =>
(EnumType -> EnumType -> Ordering)
-> (EnumType -> EnumType -> Bool)
-> (EnumType -> EnumType -> Bool)
-> (EnumType -> EnumType -> Bool)
-> (EnumType -> EnumType -> Bool)
-> (EnumType -> EnumType -> EnumType)
-> (EnumType -> EnumType -> EnumType)
-> Ord EnumType
EnumType -> EnumType -> Bool
EnumType -> EnumType -> Ordering
EnumType -> EnumType -> EnumType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EnumType -> EnumType -> Ordering
compare :: EnumType -> EnumType -> Ordering
$c< :: EnumType -> EnumType -> Bool
< :: EnumType -> EnumType -> Bool
$c<= :: EnumType -> EnumType -> Bool
<= :: EnumType -> EnumType -> Bool
$c> :: EnumType -> EnumType -> Bool
> :: EnumType -> EnumType -> Bool
$c>= :: EnumType -> EnumType -> Bool
>= :: EnumType -> EnumType -> Bool
$cmax :: EnumType -> EnumType -> EnumType
max :: EnumType -> EnumType -> EnumType
$cmin :: EnumType -> EnumType -> EnumType
min :: EnumType -> EnumType -> EnumType
Ord, ReadPrec [EnumType]
ReadPrec EnumType
Int -> ReadS EnumType
ReadS [EnumType]
(Int -> ReadS EnumType)
-> ReadS [EnumType]
-> ReadPrec EnumType
-> ReadPrec [EnumType]
-> Read EnumType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EnumType
readsPrec :: Int -> ReadS EnumType
$creadList :: ReadS [EnumType]
readList :: ReadS [EnumType]
$creadPrec :: ReadPrec EnumType
readPrec :: ReadPrec EnumType
$creadListPrec :: ReadPrec [EnumType]
readListPrec :: ReadPrec [EnumType]
Read, Int -> EnumType -> String -> String
[EnumType] -> String -> String
EnumType -> String
(Int -> EnumType -> String -> String)
-> (EnumType -> String)
-> ([EnumType] -> String -> String)
-> Show EnumType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EnumType -> String -> String
showsPrec :: Int -> EnumType -> String -> String
$cshow :: EnumType -> String
show :: EnumType -> String
$cshowList :: [EnumType] -> String -> String
showList :: [EnumType] -> String -> String
Show)

_EnumType :: Name
_EnumType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EnumType")

newtype TypeArgumentList = 
  TypeArgumentList {
    TypeArgumentList -> [Type]
unTypeArgumentList :: [Type]}
  deriving (TypeArgumentList -> TypeArgumentList -> Bool
(TypeArgumentList -> TypeArgumentList -> Bool)
-> (TypeArgumentList -> TypeArgumentList -> Bool)
-> Eq TypeArgumentList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeArgumentList -> TypeArgumentList -> Bool
== :: TypeArgumentList -> TypeArgumentList -> Bool
$c/= :: TypeArgumentList -> TypeArgumentList -> Bool
/= :: TypeArgumentList -> TypeArgumentList -> Bool
Eq, Eq TypeArgumentList
Eq TypeArgumentList =>
(TypeArgumentList -> TypeArgumentList -> Ordering)
-> (TypeArgumentList -> TypeArgumentList -> Bool)
-> (TypeArgumentList -> TypeArgumentList -> Bool)
-> (TypeArgumentList -> TypeArgumentList -> Bool)
-> (TypeArgumentList -> TypeArgumentList -> Bool)
-> (TypeArgumentList -> TypeArgumentList -> TypeArgumentList)
-> (TypeArgumentList -> TypeArgumentList -> TypeArgumentList)
-> Ord TypeArgumentList
TypeArgumentList -> TypeArgumentList -> Bool
TypeArgumentList -> TypeArgumentList -> Ordering
TypeArgumentList -> TypeArgumentList -> TypeArgumentList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TypeArgumentList -> TypeArgumentList -> Ordering
compare :: TypeArgumentList -> TypeArgumentList -> Ordering
$c< :: TypeArgumentList -> TypeArgumentList -> Bool
< :: TypeArgumentList -> TypeArgumentList -> Bool
$c<= :: TypeArgumentList -> TypeArgumentList -> Bool
<= :: TypeArgumentList -> TypeArgumentList -> Bool
$c> :: TypeArgumentList -> TypeArgumentList -> Bool
> :: TypeArgumentList -> TypeArgumentList -> Bool
$c>= :: TypeArgumentList -> TypeArgumentList -> Bool
>= :: TypeArgumentList -> TypeArgumentList -> Bool
$cmax :: TypeArgumentList -> TypeArgumentList -> TypeArgumentList
max :: TypeArgumentList -> TypeArgumentList -> TypeArgumentList
$cmin :: TypeArgumentList -> TypeArgumentList -> TypeArgumentList
min :: TypeArgumentList -> TypeArgumentList -> TypeArgumentList
Ord, ReadPrec [TypeArgumentList]
ReadPrec TypeArgumentList
Int -> ReadS TypeArgumentList
ReadS [TypeArgumentList]
(Int -> ReadS TypeArgumentList)
-> ReadS [TypeArgumentList]
-> ReadPrec TypeArgumentList
-> ReadPrec [TypeArgumentList]
-> Read TypeArgumentList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeArgumentList
readsPrec :: Int -> ReadS TypeArgumentList
$creadList :: ReadS [TypeArgumentList]
readList :: ReadS [TypeArgumentList]
$creadPrec :: ReadPrec TypeArgumentList
readPrec :: ReadPrec TypeArgumentList
$creadListPrec :: ReadPrec [TypeArgumentList]
readListPrec :: ReadPrec [TypeArgumentList]
Read, Int -> TypeArgumentList -> String -> String
[TypeArgumentList] -> String -> String
TypeArgumentList -> String
(Int -> TypeArgumentList -> String -> String)
-> (TypeArgumentList -> String)
-> ([TypeArgumentList] -> String -> String)
-> Show TypeArgumentList
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TypeArgumentList -> String -> String
showsPrec :: Int -> TypeArgumentList -> String -> String
$cshow :: TypeArgumentList -> String
show :: TypeArgumentList -> String
$cshowList :: [TypeArgumentList] -> String -> String
showList :: [TypeArgumentList] -> String -> String
Show)

_TypeArgumentList :: Name
_TypeArgumentList = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TypeArgumentList")

newtype TypeParameter = 
  TypeParameter {
    TypeParameter -> Identifier
unTypeParameter :: Identifier}
  deriving (TypeParameter -> TypeParameter -> Bool
(TypeParameter -> TypeParameter -> Bool)
-> (TypeParameter -> TypeParameter -> Bool) -> Eq TypeParameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeParameter -> TypeParameter -> Bool
== :: TypeParameter -> TypeParameter -> Bool
$c/= :: TypeParameter -> TypeParameter -> Bool
/= :: TypeParameter -> TypeParameter -> Bool
Eq, Eq TypeParameter
Eq TypeParameter =>
(TypeParameter -> TypeParameter -> Ordering)
-> (TypeParameter -> TypeParameter -> Bool)
-> (TypeParameter -> TypeParameter -> Bool)
-> (TypeParameter -> TypeParameter -> Bool)
-> (TypeParameter -> TypeParameter -> Bool)
-> (TypeParameter -> TypeParameter -> TypeParameter)
-> (TypeParameter -> TypeParameter -> TypeParameter)
-> Ord TypeParameter
TypeParameter -> TypeParameter -> Bool
TypeParameter -> TypeParameter -> Ordering
TypeParameter -> TypeParameter -> TypeParameter
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TypeParameter -> TypeParameter -> Ordering
compare :: TypeParameter -> TypeParameter -> Ordering
$c< :: TypeParameter -> TypeParameter -> Bool
< :: TypeParameter -> TypeParameter -> Bool
$c<= :: TypeParameter -> TypeParameter -> Bool
<= :: TypeParameter -> TypeParameter -> Bool
$c> :: TypeParameter -> TypeParameter -> Bool
> :: TypeParameter -> TypeParameter -> Bool
$c>= :: TypeParameter -> TypeParameter -> Bool
>= :: TypeParameter -> TypeParameter -> Bool
$cmax :: TypeParameter -> TypeParameter -> TypeParameter
max :: TypeParameter -> TypeParameter -> TypeParameter
$cmin :: TypeParameter -> TypeParameter -> TypeParameter
min :: TypeParameter -> TypeParameter -> TypeParameter
Ord, ReadPrec [TypeParameter]
ReadPrec TypeParameter
Int -> ReadS TypeParameter
ReadS [TypeParameter]
(Int -> ReadS TypeParameter)
-> ReadS [TypeParameter]
-> ReadPrec TypeParameter
-> ReadPrec [TypeParameter]
-> Read TypeParameter
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeParameter
readsPrec :: Int -> ReadS TypeParameter
$creadList :: ReadS [TypeParameter]
readList :: ReadS [TypeParameter]
$creadPrec :: ReadPrec TypeParameter
readPrec :: ReadPrec TypeParameter
$creadListPrec :: ReadPrec [TypeParameter]
readListPrec :: ReadPrec [TypeParameter]
Read, Int -> TypeParameter -> String -> String
[TypeParameter] -> String -> String
TypeParameter -> String
(Int -> TypeParameter -> String -> String)
-> (TypeParameter -> String)
-> ([TypeParameter] -> String -> String)
-> Show TypeParameter
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TypeParameter -> String -> String
showsPrec :: Int -> TypeParameter -> String -> String
$cshow :: TypeParameter -> String
show :: TypeParameter -> String
$cshowList :: [TypeParameter] -> String -> String
showList :: [TypeParameter] -> String -> String
Show)

_TypeParameter :: Name
_TypeParameter = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TypeParameter")

data UnmanagedType = 
  UnmanagedTypeValue ValueType |
  UnmanagedTypePointer PointerType
  deriving (UnmanagedType -> UnmanagedType -> Bool
(UnmanagedType -> UnmanagedType -> Bool)
-> (UnmanagedType -> UnmanagedType -> Bool) -> Eq UnmanagedType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnmanagedType -> UnmanagedType -> Bool
== :: UnmanagedType -> UnmanagedType -> Bool
$c/= :: UnmanagedType -> UnmanagedType -> Bool
/= :: UnmanagedType -> UnmanagedType -> Bool
Eq, Eq UnmanagedType
Eq UnmanagedType =>
(UnmanagedType -> UnmanagedType -> Ordering)
-> (UnmanagedType -> UnmanagedType -> Bool)
-> (UnmanagedType -> UnmanagedType -> Bool)
-> (UnmanagedType -> UnmanagedType -> Bool)
-> (UnmanagedType -> UnmanagedType -> Bool)
-> (UnmanagedType -> UnmanagedType -> UnmanagedType)
-> (UnmanagedType -> UnmanagedType -> UnmanagedType)
-> Ord UnmanagedType
UnmanagedType -> UnmanagedType -> Bool
UnmanagedType -> UnmanagedType -> Ordering
UnmanagedType -> UnmanagedType -> UnmanagedType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnmanagedType -> UnmanagedType -> Ordering
compare :: UnmanagedType -> UnmanagedType -> Ordering
$c< :: UnmanagedType -> UnmanagedType -> Bool
< :: UnmanagedType -> UnmanagedType -> Bool
$c<= :: UnmanagedType -> UnmanagedType -> Bool
<= :: UnmanagedType -> UnmanagedType -> Bool
$c> :: UnmanagedType -> UnmanagedType -> Bool
> :: UnmanagedType -> UnmanagedType -> Bool
$c>= :: UnmanagedType -> UnmanagedType -> Bool
>= :: UnmanagedType -> UnmanagedType -> Bool
$cmax :: UnmanagedType -> UnmanagedType -> UnmanagedType
max :: UnmanagedType -> UnmanagedType -> UnmanagedType
$cmin :: UnmanagedType -> UnmanagedType -> UnmanagedType
min :: UnmanagedType -> UnmanagedType -> UnmanagedType
Ord, ReadPrec [UnmanagedType]
ReadPrec UnmanagedType
Int -> ReadS UnmanagedType
ReadS [UnmanagedType]
(Int -> ReadS UnmanagedType)
-> ReadS [UnmanagedType]
-> ReadPrec UnmanagedType
-> ReadPrec [UnmanagedType]
-> Read UnmanagedType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UnmanagedType
readsPrec :: Int -> ReadS UnmanagedType
$creadList :: ReadS [UnmanagedType]
readList :: ReadS [UnmanagedType]
$creadPrec :: ReadPrec UnmanagedType
readPrec :: ReadPrec UnmanagedType
$creadListPrec :: ReadPrec [UnmanagedType]
readListPrec :: ReadPrec [UnmanagedType]
Read, Int -> UnmanagedType -> String -> String
[UnmanagedType] -> String -> String
UnmanagedType -> String
(Int -> UnmanagedType -> String -> String)
-> (UnmanagedType -> String)
-> ([UnmanagedType] -> String -> String)
-> Show UnmanagedType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UnmanagedType -> String -> String
showsPrec :: Int -> UnmanagedType -> String -> String
$cshow :: UnmanagedType -> String
show :: UnmanagedType -> String
$cshowList :: [UnmanagedType] -> String -> String
showList :: [UnmanagedType] -> String -> String
Show)

_UnmanagedType :: Name
_UnmanagedType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.UnmanagedType")

_UnmanagedType_value :: Name
_UnmanagedType_value = (String -> Name
Core.Name String
"value")

_UnmanagedType_pointer :: Name
_UnmanagedType_pointer = (String -> Name
Core.Name String
"pointer")

newtype VariableReference = 
  VariableReference {
    VariableReference -> Expression
unVariableReference :: Expression}
  deriving (VariableReference -> VariableReference -> Bool
(VariableReference -> VariableReference -> Bool)
-> (VariableReference -> VariableReference -> Bool)
-> Eq VariableReference
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariableReference -> VariableReference -> Bool
== :: VariableReference -> VariableReference -> Bool
$c/= :: VariableReference -> VariableReference -> Bool
/= :: VariableReference -> VariableReference -> Bool
Eq, Eq VariableReference
Eq VariableReference =>
(VariableReference -> VariableReference -> Ordering)
-> (VariableReference -> VariableReference -> Bool)
-> (VariableReference -> VariableReference -> Bool)
-> (VariableReference -> VariableReference -> Bool)
-> (VariableReference -> VariableReference -> Bool)
-> (VariableReference -> VariableReference -> VariableReference)
-> (VariableReference -> VariableReference -> VariableReference)
-> Ord VariableReference
VariableReference -> VariableReference -> Bool
VariableReference -> VariableReference -> Ordering
VariableReference -> VariableReference -> VariableReference
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VariableReference -> VariableReference -> Ordering
compare :: VariableReference -> VariableReference -> Ordering
$c< :: VariableReference -> VariableReference -> Bool
< :: VariableReference -> VariableReference -> Bool
$c<= :: VariableReference -> VariableReference -> Bool
<= :: VariableReference -> VariableReference -> Bool
$c> :: VariableReference -> VariableReference -> Bool
> :: VariableReference -> VariableReference -> Bool
$c>= :: VariableReference -> VariableReference -> Bool
>= :: VariableReference -> VariableReference -> Bool
$cmax :: VariableReference -> VariableReference -> VariableReference
max :: VariableReference -> VariableReference -> VariableReference
$cmin :: VariableReference -> VariableReference -> VariableReference
min :: VariableReference -> VariableReference -> VariableReference
Ord, ReadPrec [VariableReference]
ReadPrec VariableReference
Int -> ReadS VariableReference
ReadS [VariableReference]
(Int -> ReadS VariableReference)
-> ReadS [VariableReference]
-> ReadPrec VariableReference
-> ReadPrec [VariableReference]
-> Read VariableReference
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VariableReference
readsPrec :: Int -> ReadS VariableReference
$creadList :: ReadS [VariableReference]
readList :: ReadS [VariableReference]
$creadPrec :: ReadPrec VariableReference
readPrec :: ReadPrec VariableReference
$creadListPrec :: ReadPrec [VariableReference]
readListPrec :: ReadPrec [VariableReference]
Read, Int -> VariableReference -> String -> String
[VariableReference] -> String -> String
VariableReference -> String
(Int -> VariableReference -> String -> String)
-> (VariableReference -> String)
-> ([VariableReference] -> String -> String)
-> Show VariableReference
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VariableReference -> String -> String
showsPrec :: Int -> VariableReference -> String -> String
$cshow :: VariableReference -> String
show :: VariableReference -> String
$cshowList :: [VariableReference] -> String -> String
showList :: [VariableReference] -> String -> String
Show)

_VariableReference :: Name
_VariableReference = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.VariableReference")

data Pattern = 
  PatternDeclaration DeclarationPattern |
  PatternConstant Expression |
  PatternVar Designation
  deriving (Pattern -> Pattern -> Bool
(Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Bool) -> Eq Pattern
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pattern -> Pattern -> Bool
== :: Pattern -> Pattern -> Bool
$c/= :: Pattern -> Pattern -> Bool
/= :: Pattern -> Pattern -> Bool
Eq, Eq Pattern
Eq Pattern =>
(Pattern -> Pattern -> Ordering)
-> (Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Bool)
-> (Pattern -> Pattern -> Pattern)
-> (Pattern -> Pattern -> Pattern)
-> Ord Pattern
Pattern -> Pattern -> Bool
Pattern -> Pattern -> Ordering
Pattern -> Pattern -> Pattern
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pattern -> Pattern -> Ordering
compare :: Pattern -> Pattern -> Ordering
$c< :: Pattern -> Pattern -> Bool
< :: Pattern -> Pattern -> Bool
$c<= :: Pattern -> Pattern -> Bool
<= :: Pattern -> Pattern -> Bool
$c> :: Pattern -> Pattern -> Bool
> :: Pattern -> Pattern -> Bool
$c>= :: Pattern -> Pattern -> Bool
>= :: Pattern -> Pattern -> Bool
$cmax :: Pattern -> Pattern -> Pattern
max :: Pattern -> Pattern -> Pattern
$cmin :: Pattern -> Pattern -> Pattern
min :: Pattern -> Pattern -> Pattern
Ord, ReadPrec [Pattern]
ReadPrec Pattern
Int -> ReadS Pattern
ReadS [Pattern]
(Int -> ReadS Pattern)
-> ReadS [Pattern]
-> ReadPrec Pattern
-> ReadPrec [Pattern]
-> Read Pattern
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pattern
readsPrec :: Int -> ReadS Pattern
$creadList :: ReadS [Pattern]
readList :: ReadS [Pattern]
$creadPrec :: ReadPrec Pattern
readPrec :: ReadPrec Pattern
$creadListPrec :: ReadPrec [Pattern]
readListPrec :: ReadPrec [Pattern]
Read, Int -> Pattern -> String -> String
[Pattern] -> String -> String
Pattern -> String
(Int -> Pattern -> String -> String)
-> (Pattern -> String)
-> ([Pattern] -> String -> String)
-> Show Pattern
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pattern -> String -> String
showsPrec :: Int -> Pattern -> String -> String
$cshow :: Pattern -> String
show :: Pattern -> String
$cshowList :: [Pattern] -> String -> String
showList :: [Pattern] -> String -> String
Show)

_Pattern :: Name
_Pattern = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Pattern")

_Pattern_declaration :: Name
_Pattern_declaration = (String -> Name
Core.Name String
"declaration")

_Pattern_constant :: Name
_Pattern_constant = (String -> Name
Core.Name String
"constant")

_Pattern_var :: Name
_Pattern_var = (String -> Name
Core.Name String
"var")

data DeclarationPattern = 
  DeclarationPattern {
    DeclarationPattern -> Type
declarationPatternType :: Type,
    DeclarationPattern -> Designation
declarationPatternDesignation :: Designation}
  deriving (DeclarationPattern -> DeclarationPattern -> Bool
(DeclarationPattern -> DeclarationPattern -> Bool)
-> (DeclarationPattern -> DeclarationPattern -> Bool)
-> Eq DeclarationPattern
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeclarationPattern -> DeclarationPattern -> Bool
== :: DeclarationPattern -> DeclarationPattern -> Bool
$c/= :: DeclarationPattern -> DeclarationPattern -> Bool
/= :: DeclarationPattern -> DeclarationPattern -> Bool
Eq, Eq DeclarationPattern
Eq DeclarationPattern =>
(DeclarationPattern -> DeclarationPattern -> Ordering)
-> (DeclarationPattern -> DeclarationPattern -> Bool)
-> (DeclarationPattern -> DeclarationPattern -> Bool)
-> (DeclarationPattern -> DeclarationPattern -> Bool)
-> (DeclarationPattern -> DeclarationPattern -> Bool)
-> (DeclarationPattern -> DeclarationPattern -> DeclarationPattern)
-> (DeclarationPattern -> DeclarationPattern -> DeclarationPattern)
-> Ord DeclarationPattern
DeclarationPattern -> DeclarationPattern -> Bool
DeclarationPattern -> DeclarationPattern -> Ordering
DeclarationPattern -> DeclarationPattern -> DeclarationPattern
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DeclarationPattern -> DeclarationPattern -> Ordering
compare :: DeclarationPattern -> DeclarationPattern -> Ordering
$c< :: DeclarationPattern -> DeclarationPattern -> Bool
< :: DeclarationPattern -> DeclarationPattern -> Bool
$c<= :: DeclarationPattern -> DeclarationPattern -> Bool
<= :: DeclarationPattern -> DeclarationPattern -> Bool
$c> :: DeclarationPattern -> DeclarationPattern -> Bool
> :: DeclarationPattern -> DeclarationPattern -> Bool
$c>= :: DeclarationPattern -> DeclarationPattern -> Bool
>= :: DeclarationPattern -> DeclarationPattern -> Bool
$cmax :: DeclarationPattern -> DeclarationPattern -> DeclarationPattern
max :: DeclarationPattern -> DeclarationPattern -> DeclarationPattern
$cmin :: DeclarationPattern -> DeclarationPattern -> DeclarationPattern
min :: DeclarationPattern -> DeclarationPattern -> DeclarationPattern
Ord, ReadPrec [DeclarationPattern]
ReadPrec DeclarationPattern
Int -> ReadS DeclarationPattern
ReadS [DeclarationPattern]
(Int -> ReadS DeclarationPattern)
-> ReadS [DeclarationPattern]
-> ReadPrec DeclarationPattern
-> ReadPrec [DeclarationPattern]
-> Read DeclarationPattern
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DeclarationPattern
readsPrec :: Int -> ReadS DeclarationPattern
$creadList :: ReadS [DeclarationPattern]
readList :: ReadS [DeclarationPattern]
$creadPrec :: ReadPrec DeclarationPattern
readPrec :: ReadPrec DeclarationPattern
$creadListPrec :: ReadPrec [DeclarationPattern]
readListPrec :: ReadPrec [DeclarationPattern]
Read, Int -> DeclarationPattern -> String -> String
[DeclarationPattern] -> String -> String
DeclarationPattern -> String
(Int -> DeclarationPattern -> String -> String)
-> (DeclarationPattern -> String)
-> ([DeclarationPattern] -> String -> String)
-> Show DeclarationPattern
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DeclarationPattern -> String -> String
showsPrec :: Int -> DeclarationPattern -> String -> String
$cshow :: DeclarationPattern -> String
show :: DeclarationPattern -> String
$cshowList :: [DeclarationPattern] -> String -> String
showList :: [DeclarationPattern] -> String -> String
Show)

_DeclarationPattern :: Name
_DeclarationPattern = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DeclarationPattern")

_DeclarationPattern_type :: Name
_DeclarationPattern_type = (String -> Name
Core.Name String
"type")

_DeclarationPattern_designation :: Name
_DeclarationPattern_designation = (String -> Name
Core.Name String
"designation")

newtype Designation = 
  Designation {
    Designation -> Identifier
unDesignation :: Identifier}
  deriving (Designation -> Designation -> Bool
(Designation -> Designation -> Bool)
-> (Designation -> Designation -> Bool) -> Eq Designation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Designation -> Designation -> Bool
== :: Designation -> Designation -> Bool
$c/= :: Designation -> Designation -> Bool
/= :: Designation -> Designation -> Bool
Eq, Eq Designation
Eq Designation =>
(Designation -> Designation -> Ordering)
-> (Designation -> Designation -> Bool)
-> (Designation -> Designation -> Bool)
-> (Designation -> Designation -> Bool)
-> (Designation -> Designation -> Bool)
-> (Designation -> Designation -> Designation)
-> (Designation -> Designation -> Designation)
-> Ord Designation
Designation -> Designation -> Bool
Designation -> Designation -> Ordering
Designation -> Designation -> Designation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Designation -> Designation -> Ordering
compare :: Designation -> Designation -> Ordering
$c< :: Designation -> Designation -> Bool
< :: Designation -> Designation -> Bool
$c<= :: Designation -> Designation -> Bool
<= :: Designation -> Designation -> Bool
$c> :: Designation -> Designation -> Bool
> :: Designation -> Designation -> Bool
$c>= :: Designation -> Designation -> Bool
>= :: Designation -> Designation -> Bool
$cmax :: Designation -> Designation -> Designation
max :: Designation -> Designation -> Designation
$cmin :: Designation -> Designation -> Designation
min :: Designation -> Designation -> Designation
Ord, ReadPrec [Designation]
ReadPrec Designation
Int -> ReadS Designation
ReadS [Designation]
(Int -> ReadS Designation)
-> ReadS [Designation]
-> ReadPrec Designation
-> ReadPrec [Designation]
-> Read Designation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Designation
readsPrec :: Int -> ReadS Designation
$creadList :: ReadS [Designation]
readList :: ReadS [Designation]
$creadPrec :: ReadPrec Designation
readPrec :: ReadPrec Designation
$creadListPrec :: ReadPrec [Designation]
readListPrec :: ReadPrec [Designation]
Read, Int -> Designation -> String -> String
[Designation] -> String -> String
Designation -> String
(Int -> Designation -> String -> String)
-> (Designation -> String)
-> ([Designation] -> String -> String)
-> Show Designation
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Designation -> String -> String
showsPrec :: Int -> Designation -> String -> String
$cshow :: Designation -> String
show :: Designation -> String
$cshowList :: [Designation] -> String -> String
showList :: [Designation] -> String -> String
Show)

_Designation :: Name
_Designation = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Designation")

newtype ArgumentList = 
  ArgumentList {
    ArgumentList -> [Argument]
unArgumentList :: [Argument]}
  deriving (ArgumentList -> ArgumentList -> Bool
(ArgumentList -> ArgumentList -> Bool)
-> (ArgumentList -> ArgumentList -> Bool) -> Eq ArgumentList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArgumentList -> ArgumentList -> Bool
== :: ArgumentList -> ArgumentList -> Bool
$c/= :: ArgumentList -> ArgumentList -> Bool
/= :: ArgumentList -> ArgumentList -> Bool
Eq, Eq ArgumentList
Eq ArgumentList =>
(ArgumentList -> ArgumentList -> Ordering)
-> (ArgumentList -> ArgumentList -> Bool)
-> (ArgumentList -> ArgumentList -> Bool)
-> (ArgumentList -> ArgumentList -> Bool)
-> (ArgumentList -> ArgumentList -> Bool)
-> (ArgumentList -> ArgumentList -> ArgumentList)
-> (ArgumentList -> ArgumentList -> ArgumentList)
-> Ord ArgumentList
ArgumentList -> ArgumentList -> Bool
ArgumentList -> ArgumentList -> Ordering
ArgumentList -> ArgumentList -> ArgumentList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ArgumentList -> ArgumentList -> Ordering
compare :: ArgumentList -> ArgumentList -> Ordering
$c< :: ArgumentList -> ArgumentList -> Bool
< :: ArgumentList -> ArgumentList -> Bool
$c<= :: ArgumentList -> ArgumentList -> Bool
<= :: ArgumentList -> ArgumentList -> Bool
$c> :: ArgumentList -> ArgumentList -> Bool
> :: ArgumentList -> ArgumentList -> Bool
$c>= :: ArgumentList -> ArgumentList -> Bool
>= :: ArgumentList -> ArgumentList -> Bool
$cmax :: ArgumentList -> ArgumentList -> ArgumentList
max :: ArgumentList -> ArgumentList -> ArgumentList
$cmin :: ArgumentList -> ArgumentList -> ArgumentList
min :: ArgumentList -> ArgumentList -> ArgumentList
Ord, ReadPrec [ArgumentList]
ReadPrec ArgumentList
Int -> ReadS ArgumentList
ReadS [ArgumentList]
(Int -> ReadS ArgumentList)
-> ReadS [ArgumentList]
-> ReadPrec ArgumentList
-> ReadPrec [ArgumentList]
-> Read ArgumentList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ArgumentList
readsPrec :: Int -> ReadS ArgumentList
$creadList :: ReadS [ArgumentList]
readList :: ReadS [ArgumentList]
$creadPrec :: ReadPrec ArgumentList
readPrec :: ReadPrec ArgumentList
$creadListPrec :: ReadPrec [ArgumentList]
readListPrec :: ReadPrec [ArgumentList]
Read, Int -> ArgumentList -> String -> String
[ArgumentList] -> String -> String
ArgumentList -> String
(Int -> ArgumentList -> String -> String)
-> (ArgumentList -> String)
-> ([ArgumentList] -> String -> String)
-> Show ArgumentList
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ArgumentList -> String -> String
showsPrec :: Int -> ArgumentList -> String -> String
$cshow :: ArgumentList -> String
show :: ArgumentList -> String
$cshowList :: [ArgumentList] -> String -> String
showList :: [ArgumentList] -> String -> String
Show)

_ArgumentList :: Name
_ArgumentList = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ArgumentList")

data Argument = 
  Argument {
    Argument -> Maybe Identifier
argumentName :: (Maybe Identifier),
    Argument -> ArgumentValue
argumentValue :: ArgumentValue}
  deriving (Argument -> Argument -> Bool
(Argument -> Argument -> Bool)
-> (Argument -> Argument -> Bool) -> Eq Argument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Argument -> Argument -> Bool
== :: Argument -> Argument -> Bool
$c/= :: Argument -> Argument -> Bool
/= :: Argument -> Argument -> Bool
Eq, Eq Argument
Eq Argument =>
(Argument -> Argument -> Ordering)
-> (Argument -> Argument -> Bool)
-> (Argument -> Argument -> Bool)
-> (Argument -> Argument -> Bool)
-> (Argument -> Argument -> Bool)
-> (Argument -> Argument -> Argument)
-> (Argument -> Argument -> Argument)
-> Ord Argument
Argument -> Argument -> Bool
Argument -> Argument -> Ordering
Argument -> Argument -> Argument
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Argument -> Argument -> Ordering
compare :: Argument -> Argument -> Ordering
$c< :: Argument -> Argument -> Bool
< :: Argument -> Argument -> Bool
$c<= :: Argument -> Argument -> Bool
<= :: Argument -> Argument -> Bool
$c> :: Argument -> Argument -> Bool
> :: Argument -> Argument -> Bool
$c>= :: Argument -> Argument -> Bool
>= :: Argument -> Argument -> Bool
$cmax :: Argument -> Argument -> Argument
max :: Argument -> Argument -> Argument
$cmin :: Argument -> Argument -> Argument
min :: Argument -> Argument -> Argument
Ord, ReadPrec [Argument]
ReadPrec Argument
Int -> ReadS Argument
ReadS [Argument]
(Int -> ReadS Argument)
-> ReadS [Argument]
-> ReadPrec Argument
-> ReadPrec [Argument]
-> Read Argument
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Argument
readsPrec :: Int -> ReadS Argument
$creadList :: ReadS [Argument]
readList :: ReadS [Argument]
$creadPrec :: ReadPrec Argument
readPrec :: ReadPrec Argument
$creadListPrec :: ReadPrec [Argument]
readListPrec :: ReadPrec [Argument]
Read, Int -> Argument -> String -> String
[Argument] -> String -> String
Argument -> String
(Int -> Argument -> String -> String)
-> (Argument -> String)
-> ([Argument] -> String -> String)
-> Show Argument
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Argument -> String -> String
showsPrec :: Int -> Argument -> String -> String
$cshow :: Argument -> String
show :: Argument -> String
$cshowList :: [Argument] -> String -> String
showList :: [Argument] -> String -> String
Show)

_Argument :: Name
_Argument = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Argument")

_Argument_name :: Name
_Argument_name = (String -> Name
Core.Name String
"name")

_Argument_value :: Name
_Argument_value = (String -> Name
Core.Name String
"value")

data ArgumentValue = 
  ArgumentValueExpression Expression |
  ArgumentValueIn VariableReference |
  ArgumentValueRef VariableReference |
  ArgumentValueOut VariableReference
  deriving (ArgumentValue -> ArgumentValue -> Bool
(ArgumentValue -> ArgumentValue -> Bool)
-> (ArgumentValue -> ArgumentValue -> Bool) -> Eq ArgumentValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArgumentValue -> ArgumentValue -> Bool
== :: ArgumentValue -> ArgumentValue -> Bool
$c/= :: ArgumentValue -> ArgumentValue -> Bool
/= :: ArgumentValue -> ArgumentValue -> Bool
Eq, Eq ArgumentValue
Eq ArgumentValue =>
(ArgumentValue -> ArgumentValue -> Ordering)
-> (ArgumentValue -> ArgumentValue -> Bool)
-> (ArgumentValue -> ArgumentValue -> Bool)
-> (ArgumentValue -> ArgumentValue -> Bool)
-> (ArgumentValue -> ArgumentValue -> Bool)
-> (ArgumentValue -> ArgumentValue -> ArgumentValue)
-> (ArgumentValue -> ArgumentValue -> ArgumentValue)
-> Ord ArgumentValue
ArgumentValue -> ArgumentValue -> Bool
ArgumentValue -> ArgumentValue -> Ordering
ArgumentValue -> ArgumentValue -> ArgumentValue
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ArgumentValue -> ArgumentValue -> Ordering
compare :: ArgumentValue -> ArgumentValue -> Ordering
$c< :: ArgumentValue -> ArgumentValue -> Bool
< :: ArgumentValue -> ArgumentValue -> Bool
$c<= :: ArgumentValue -> ArgumentValue -> Bool
<= :: ArgumentValue -> ArgumentValue -> Bool
$c> :: ArgumentValue -> ArgumentValue -> Bool
> :: ArgumentValue -> ArgumentValue -> Bool
$c>= :: ArgumentValue -> ArgumentValue -> Bool
>= :: ArgumentValue -> ArgumentValue -> Bool
$cmax :: ArgumentValue -> ArgumentValue -> ArgumentValue
max :: ArgumentValue -> ArgumentValue -> ArgumentValue
$cmin :: ArgumentValue -> ArgumentValue -> ArgumentValue
min :: ArgumentValue -> ArgumentValue -> ArgumentValue
Ord, ReadPrec [ArgumentValue]
ReadPrec ArgumentValue
Int -> ReadS ArgumentValue
ReadS [ArgumentValue]
(Int -> ReadS ArgumentValue)
-> ReadS [ArgumentValue]
-> ReadPrec ArgumentValue
-> ReadPrec [ArgumentValue]
-> Read ArgumentValue
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ArgumentValue
readsPrec :: Int -> ReadS ArgumentValue
$creadList :: ReadS [ArgumentValue]
readList :: ReadS [ArgumentValue]
$creadPrec :: ReadPrec ArgumentValue
readPrec :: ReadPrec ArgumentValue
$creadListPrec :: ReadPrec [ArgumentValue]
readListPrec :: ReadPrec [ArgumentValue]
Read, Int -> ArgumentValue -> String -> String
[ArgumentValue] -> String -> String
ArgumentValue -> String
(Int -> ArgumentValue -> String -> String)
-> (ArgumentValue -> String)
-> ([ArgumentValue] -> String -> String)
-> Show ArgumentValue
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ArgumentValue -> String -> String
showsPrec :: Int -> ArgumentValue -> String -> String
$cshow :: ArgumentValue -> String
show :: ArgumentValue -> String
$cshowList :: [ArgumentValue] -> String -> String
showList :: [ArgumentValue] -> String -> String
Show)

_ArgumentValue :: Name
_ArgumentValue = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ArgumentValue")

_ArgumentValue_expression :: Name
_ArgumentValue_expression = (String -> Name
Core.Name String
"expression")

_ArgumentValue_in :: Name
_ArgumentValue_in = (String -> Name
Core.Name String
"in")

_ArgumentValue_ref :: Name
_ArgumentValue_ref = (String -> Name
Core.Name String
"ref")

_ArgumentValue_out :: Name
_ArgumentValue_out = (String -> Name
Core.Name String
"out")

data PrimaryExpression = 
  PrimaryExpressionNoArray PrimaryNoArrayCreationExpression |
  PrimaryExpressionArray ArrayCreationExpression
  deriving (PrimaryExpression -> PrimaryExpression -> Bool
(PrimaryExpression -> PrimaryExpression -> Bool)
-> (PrimaryExpression -> PrimaryExpression -> Bool)
-> Eq PrimaryExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrimaryExpression -> PrimaryExpression -> Bool
== :: PrimaryExpression -> PrimaryExpression -> Bool
$c/= :: PrimaryExpression -> PrimaryExpression -> Bool
/= :: PrimaryExpression -> PrimaryExpression -> Bool
Eq, Eq PrimaryExpression
Eq PrimaryExpression =>
(PrimaryExpression -> PrimaryExpression -> Ordering)
-> (PrimaryExpression -> PrimaryExpression -> Bool)
-> (PrimaryExpression -> PrimaryExpression -> Bool)
-> (PrimaryExpression -> PrimaryExpression -> Bool)
-> (PrimaryExpression -> PrimaryExpression -> Bool)
-> (PrimaryExpression -> PrimaryExpression -> PrimaryExpression)
-> (PrimaryExpression -> PrimaryExpression -> PrimaryExpression)
-> Ord PrimaryExpression
PrimaryExpression -> PrimaryExpression -> Bool
PrimaryExpression -> PrimaryExpression -> Ordering
PrimaryExpression -> PrimaryExpression -> PrimaryExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PrimaryExpression -> PrimaryExpression -> Ordering
compare :: PrimaryExpression -> PrimaryExpression -> Ordering
$c< :: PrimaryExpression -> PrimaryExpression -> Bool
< :: PrimaryExpression -> PrimaryExpression -> Bool
$c<= :: PrimaryExpression -> PrimaryExpression -> Bool
<= :: PrimaryExpression -> PrimaryExpression -> Bool
$c> :: PrimaryExpression -> PrimaryExpression -> Bool
> :: PrimaryExpression -> PrimaryExpression -> Bool
$c>= :: PrimaryExpression -> PrimaryExpression -> Bool
>= :: PrimaryExpression -> PrimaryExpression -> Bool
$cmax :: PrimaryExpression -> PrimaryExpression -> PrimaryExpression
max :: PrimaryExpression -> PrimaryExpression -> PrimaryExpression
$cmin :: PrimaryExpression -> PrimaryExpression -> PrimaryExpression
min :: PrimaryExpression -> PrimaryExpression -> PrimaryExpression
Ord, ReadPrec [PrimaryExpression]
ReadPrec PrimaryExpression
Int -> ReadS PrimaryExpression
ReadS [PrimaryExpression]
(Int -> ReadS PrimaryExpression)
-> ReadS [PrimaryExpression]
-> ReadPrec PrimaryExpression
-> ReadPrec [PrimaryExpression]
-> Read PrimaryExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PrimaryExpression
readsPrec :: Int -> ReadS PrimaryExpression
$creadList :: ReadS [PrimaryExpression]
readList :: ReadS [PrimaryExpression]
$creadPrec :: ReadPrec PrimaryExpression
readPrec :: ReadPrec PrimaryExpression
$creadListPrec :: ReadPrec [PrimaryExpression]
readListPrec :: ReadPrec [PrimaryExpression]
Read, Int -> PrimaryExpression -> String -> String
[PrimaryExpression] -> String -> String
PrimaryExpression -> String
(Int -> PrimaryExpression -> String -> String)
-> (PrimaryExpression -> String)
-> ([PrimaryExpression] -> String -> String)
-> Show PrimaryExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PrimaryExpression -> String -> String
showsPrec :: Int -> PrimaryExpression -> String -> String
$cshow :: PrimaryExpression -> String
show :: PrimaryExpression -> String
$cshowList :: [PrimaryExpression] -> String -> String
showList :: [PrimaryExpression] -> String -> String
Show)

_PrimaryExpression :: Name
_PrimaryExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PrimaryExpression")

_PrimaryExpression_noArray :: Name
_PrimaryExpression_noArray = (String -> Name
Core.Name String
"noArray")

_PrimaryExpression_array :: Name
_PrimaryExpression_array = (String -> Name
Core.Name String
"array")

data PrimaryNoArrayCreationExpression = 
  PrimaryNoArrayCreationExpressionLiteral Literal |
  PrimaryNoArrayCreationExpressionInterpolatedString InterpolatedStringExpression |
  PrimaryNoArrayCreationExpressionSimpleName SimpleName |
  PrimaryNoArrayCreationExpressionParenthesized Expression |
  PrimaryNoArrayCreationExpressionTuple TupleExpression |
  PrimaryNoArrayCreationExpressionMemberAccess MemberAccess |
  PrimaryNoArrayCreationExpressionNullConditionalMemberAccess NullConditionalMemberAccess |
  PrimaryNoArrayCreationExpressionInvocation InvocationExpression |
  PrimaryNoArrayCreationExpressionElementAccess ElementAccess |
  PrimaryNoArrayCreationExpressionNullConditionalElementAccess NullConditionalElementAccess |
  PrimaryNoArrayCreationExpressionThisAccess  |
  PrimaryNoArrayCreationExpressionBaseAccess BaseAccess |
  PrimaryNoArrayCreationExpressionPostIncrement PrimaryExpression |
  PrimaryNoArrayCreationExpressionPostDecrement PrimaryExpression |
  PrimaryNoArrayCreationExpressionObjectCreation ObjectCreationExpression |
  PrimaryNoArrayCreationExpressionDelegateCreation DelegateCreationExpression |
  PrimaryNoArrayCreationExpressionAnonymousObjectCreation (Maybe MemberDeclaratorList) |
  PrimaryNoArrayCreationExpressionTypeof TypeofExpression |
  PrimaryNoArrayCreationExpressionSizeof UnmanagedType |
  PrimaryNoArrayCreationExpressionChecked Expression |
  PrimaryNoArrayCreationExpressionUnchecked Expression |
  PrimaryNoArrayCreationExpressionDefaultValue DefaultValueExpression |
  PrimaryNoArrayCreationExpressionNameof NamedEntity |
  PrimaryNoArrayCreationExpressionAnonymousMethod AnonymousMethodExpression |
  PrimaryNoArrayCreationExpressionPointerMemberAccess PointerMemberAccess |
  PrimaryNoArrayCreationExpressionPointerElementAccess PointerElementAccess |
  PrimaryNoArrayCreationExpressionStackalloc StackallocExpression
  deriving (PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
(PrimaryNoArrayCreationExpression
 -> PrimaryNoArrayCreationExpression -> Bool)
-> (PrimaryNoArrayCreationExpression
    -> PrimaryNoArrayCreationExpression -> Bool)
-> Eq PrimaryNoArrayCreationExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
== :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
$c/= :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
/= :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
Eq, Eq PrimaryNoArrayCreationExpression
Eq PrimaryNoArrayCreationExpression =>
(PrimaryNoArrayCreationExpression
 -> PrimaryNoArrayCreationExpression -> Ordering)
-> (PrimaryNoArrayCreationExpression
    -> PrimaryNoArrayCreationExpression -> Bool)
-> (PrimaryNoArrayCreationExpression
    -> PrimaryNoArrayCreationExpression -> Bool)
-> (PrimaryNoArrayCreationExpression
    -> PrimaryNoArrayCreationExpression -> Bool)
-> (PrimaryNoArrayCreationExpression
    -> PrimaryNoArrayCreationExpression -> Bool)
-> (PrimaryNoArrayCreationExpression
    -> PrimaryNoArrayCreationExpression
    -> PrimaryNoArrayCreationExpression)
-> (PrimaryNoArrayCreationExpression
    -> PrimaryNoArrayCreationExpression
    -> PrimaryNoArrayCreationExpression)
-> Ord PrimaryNoArrayCreationExpression
PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Ordering
PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Ordering
compare :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Ordering
$c< :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
< :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
$c<= :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
<= :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
$c> :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
> :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
$c>= :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
>= :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression -> Bool
$cmax :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression
max :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression
$cmin :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression
min :: PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression
-> PrimaryNoArrayCreationExpression
Ord, ReadPrec [PrimaryNoArrayCreationExpression]
ReadPrec PrimaryNoArrayCreationExpression
Int -> ReadS PrimaryNoArrayCreationExpression
ReadS [PrimaryNoArrayCreationExpression]
(Int -> ReadS PrimaryNoArrayCreationExpression)
-> ReadS [PrimaryNoArrayCreationExpression]
-> ReadPrec PrimaryNoArrayCreationExpression
-> ReadPrec [PrimaryNoArrayCreationExpression]
-> Read PrimaryNoArrayCreationExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PrimaryNoArrayCreationExpression
readsPrec :: Int -> ReadS PrimaryNoArrayCreationExpression
$creadList :: ReadS [PrimaryNoArrayCreationExpression]
readList :: ReadS [PrimaryNoArrayCreationExpression]
$creadPrec :: ReadPrec PrimaryNoArrayCreationExpression
readPrec :: ReadPrec PrimaryNoArrayCreationExpression
$creadListPrec :: ReadPrec [PrimaryNoArrayCreationExpression]
readListPrec :: ReadPrec [PrimaryNoArrayCreationExpression]
Read, Int -> PrimaryNoArrayCreationExpression -> String -> String
[PrimaryNoArrayCreationExpression] -> String -> String
PrimaryNoArrayCreationExpression -> String
(Int -> PrimaryNoArrayCreationExpression -> String -> String)
-> (PrimaryNoArrayCreationExpression -> String)
-> ([PrimaryNoArrayCreationExpression] -> String -> String)
-> Show PrimaryNoArrayCreationExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PrimaryNoArrayCreationExpression -> String -> String
showsPrec :: Int -> PrimaryNoArrayCreationExpression -> String -> String
$cshow :: PrimaryNoArrayCreationExpression -> String
show :: PrimaryNoArrayCreationExpression -> String
$cshowList :: [PrimaryNoArrayCreationExpression] -> String -> String
showList :: [PrimaryNoArrayCreationExpression] -> String -> String
Show)

_PrimaryNoArrayCreationExpression :: Name
_PrimaryNoArrayCreationExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PrimaryNoArrayCreationExpression")

_PrimaryNoArrayCreationExpression_literal :: Name
_PrimaryNoArrayCreationExpression_literal = (String -> Name
Core.Name String
"literal")

_PrimaryNoArrayCreationExpression_interpolatedString :: Name
_PrimaryNoArrayCreationExpression_interpolatedString = (String -> Name
Core.Name String
"interpolatedString")

_PrimaryNoArrayCreationExpression_simpleName :: Name
_PrimaryNoArrayCreationExpression_simpleName = (String -> Name
Core.Name String
"simpleName")

_PrimaryNoArrayCreationExpression_parenthesized :: Name
_PrimaryNoArrayCreationExpression_parenthesized = (String -> Name
Core.Name String
"parenthesized")

_PrimaryNoArrayCreationExpression_tuple :: Name
_PrimaryNoArrayCreationExpression_tuple = (String -> Name
Core.Name String
"tuple")

_PrimaryNoArrayCreationExpression_memberAccess :: Name
_PrimaryNoArrayCreationExpression_memberAccess = (String -> Name
Core.Name String
"memberAccess")

_PrimaryNoArrayCreationExpression_nullConditionalMemberAccess :: Name
_PrimaryNoArrayCreationExpression_nullConditionalMemberAccess = (String -> Name
Core.Name String
"nullConditionalMemberAccess")

_PrimaryNoArrayCreationExpression_invocation :: Name
_PrimaryNoArrayCreationExpression_invocation = (String -> Name
Core.Name String
"invocation")

_PrimaryNoArrayCreationExpression_elementAccess :: Name
_PrimaryNoArrayCreationExpression_elementAccess = (String -> Name
Core.Name String
"elementAccess")

_PrimaryNoArrayCreationExpression_nullConditionalElementAccess :: Name
_PrimaryNoArrayCreationExpression_nullConditionalElementAccess = (String -> Name
Core.Name String
"nullConditionalElementAccess")

_PrimaryNoArrayCreationExpression_thisAccess :: Name
_PrimaryNoArrayCreationExpression_thisAccess = (String -> Name
Core.Name String
"thisAccess")

_PrimaryNoArrayCreationExpression_baseAccess :: Name
_PrimaryNoArrayCreationExpression_baseAccess = (String -> Name
Core.Name String
"baseAccess")

_PrimaryNoArrayCreationExpression_postIncrement :: Name
_PrimaryNoArrayCreationExpression_postIncrement = (String -> Name
Core.Name String
"postIncrement")

_PrimaryNoArrayCreationExpression_postDecrement :: Name
_PrimaryNoArrayCreationExpression_postDecrement = (String -> Name
Core.Name String
"postDecrement")

_PrimaryNoArrayCreationExpression_objectCreation :: Name
_PrimaryNoArrayCreationExpression_objectCreation = (String -> Name
Core.Name String
"objectCreation")

_PrimaryNoArrayCreationExpression_delegateCreation :: Name
_PrimaryNoArrayCreationExpression_delegateCreation = (String -> Name
Core.Name String
"delegateCreation")

_PrimaryNoArrayCreationExpression_anonymousObjectCreation :: Name
_PrimaryNoArrayCreationExpression_anonymousObjectCreation = (String -> Name
Core.Name String
"anonymousObjectCreation")

_PrimaryNoArrayCreationExpression_typeof :: Name
_PrimaryNoArrayCreationExpression_typeof = (String -> Name
Core.Name String
"typeof")

_PrimaryNoArrayCreationExpression_sizeof :: Name
_PrimaryNoArrayCreationExpression_sizeof = (String -> Name
Core.Name String
"sizeof")

_PrimaryNoArrayCreationExpression_checked :: Name
_PrimaryNoArrayCreationExpression_checked = (String -> Name
Core.Name String
"checked")

_PrimaryNoArrayCreationExpression_unchecked :: Name
_PrimaryNoArrayCreationExpression_unchecked = (String -> Name
Core.Name String
"unchecked")

_PrimaryNoArrayCreationExpression_defaultValue :: Name
_PrimaryNoArrayCreationExpression_defaultValue = (String -> Name
Core.Name String
"defaultValue")

_PrimaryNoArrayCreationExpression_nameof :: Name
_PrimaryNoArrayCreationExpression_nameof = (String -> Name
Core.Name String
"nameof")

_PrimaryNoArrayCreationExpression_anonymousMethod :: Name
_PrimaryNoArrayCreationExpression_anonymousMethod = (String -> Name
Core.Name String
"anonymousMethod")

_PrimaryNoArrayCreationExpression_pointerMemberAccess :: Name
_PrimaryNoArrayCreationExpression_pointerMemberAccess = (String -> Name
Core.Name String
"pointerMemberAccess")

_PrimaryNoArrayCreationExpression_pointerElementAccess :: Name
_PrimaryNoArrayCreationExpression_pointerElementAccess = (String -> Name
Core.Name String
"pointerElementAccess")

_PrimaryNoArrayCreationExpression_stackalloc :: Name
_PrimaryNoArrayCreationExpression_stackalloc = (String -> Name
Core.Name String
"stackalloc")

data InterpolatedStringExpression = 
  InterpolatedStringExpressionRegular InterpolatedRegularStringExpression |
  InterpolatedStringExpressionVerbatim InterpolatedVerbatimStringExpression
  deriving (InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
(InterpolatedStringExpression
 -> InterpolatedStringExpression -> Bool)
-> (InterpolatedStringExpression
    -> InterpolatedStringExpression -> Bool)
-> Eq InterpolatedStringExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
== :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
$c/= :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
/= :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
Eq, Eq InterpolatedStringExpression
Eq InterpolatedStringExpression =>
(InterpolatedStringExpression
 -> InterpolatedStringExpression -> Ordering)
-> (InterpolatedStringExpression
    -> InterpolatedStringExpression -> Bool)
-> (InterpolatedStringExpression
    -> InterpolatedStringExpression -> Bool)
-> (InterpolatedStringExpression
    -> InterpolatedStringExpression -> Bool)
-> (InterpolatedStringExpression
    -> InterpolatedStringExpression -> Bool)
-> (InterpolatedStringExpression
    -> InterpolatedStringExpression -> InterpolatedStringExpression)
-> (InterpolatedStringExpression
    -> InterpolatedStringExpression -> InterpolatedStringExpression)
-> Ord InterpolatedStringExpression
InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
InterpolatedStringExpression
-> InterpolatedStringExpression -> Ordering
InterpolatedStringExpression
-> InterpolatedStringExpression -> InterpolatedStringExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Ordering
compare :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Ordering
$c< :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
< :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
$c<= :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
<= :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
$c> :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
> :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
$c>= :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
>= :: InterpolatedStringExpression
-> InterpolatedStringExpression -> Bool
$cmax :: InterpolatedStringExpression
-> InterpolatedStringExpression -> InterpolatedStringExpression
max :: InterpolatedStringExpression
-> InterpolatedStringExpression -> InterpolatedStringExpression
$cmin :: InterpolatedStringExpression
-> InterpolatedStringExpression -> InterpolatedStringExpression
min :: InterpolatedStringExpression
-> InterpolatedStringExpression -> InterpolatedStringExpression
Ord, ReadPrec [InterpolatedStringExpression]
ReadPrec InterpolatedStringExpression
Int -> ReadS InterpolatedStringExpression
ReadS [InterpolatedStringExpression]
(Int -> ReadS InterpolatedStringExpression)
-> ReadS [InterpolatedStringExpression]
-> ReadPrec InterpolatedStringExpression
-> ReadPrec [InterpolatedStringExpression]
-> Read InterpolatedStringExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterpolatedStringExpression
readsPrec :: Int -> ReadS InterpolatedStringExpression
$creadList :: ReadS [InterpolatedStringExpression]
readList :: ReadS [InterpolatedStringExpression]
$creadPrec :: ReadPrec InterpolatedStringExpression
readPrec :: ReadPrec InterpolatedStringExpression
$creadListPrec :: ReadPrec [InterpolatedStringExpression]
readListPrec :: ReadPrec [InterpolatedStringExpression]
Read, Int -> InterpolatedStringExpression -> String -> String
[InterpolatedStringExpression] -> String -> String
InterpolatedStringExpression -> String
(Int -> InterpolatedStringExpression -> String -> String)
-> (InterpolatedStringExpression -> String)
-> ([InterpolatedStringExpression] -> String -> String)
-> Show InterpolatedStringExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterpolatedStringExpression -> String -> String
showsPrec :: Int -> InterpolatedStringExpression -> String -> String
$cshow :: InterpolatedStringExpression -> String
show :: InterpolatedStringExpression -> String
$cshowList :: [InterpolatedStringExpression] -> String -> String
showList :: [InterpolatedStringExpression] -> String -> String
Show)

_InterpolatedStringExpression :: Name
_InterpolatedStringExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterpolatedStringExpression")

_InterpolatedStringExpression_regular :: Name
_InterpolatedStringExpression_regular = (String -> Name
Core.Name String
"regular")

_InterpolatedStringExpression_verbatim :: Name
_InterpolatedStringExpression_verbatim = (String -> Name
Core.Name String
"verbatim")

newtype InterpolatedRegularStringExpression = 
  InterpolatedRegularStringExpression {
    InterpolatedRegularStringExpression -> String
unInterpolatedRegularStringExpression :: String}
  deriving (InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
(InterpolatedRegularStringExpression
 -> InterpolatedRegularStringExpression -> Bool)
-> (InterpolatedRegularStringExpression
    -> InterpolatedRegularStringExpression -> Bool)
-> Eq InterpolatedRegularStringExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
== :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
$c/= :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
/= :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
Eq, Eq InterpolatedRegularStringExpression
Eq InterpolatedRegularStringExpression =>
(InterpolatedRegularStringExpression
 -> InterpolatedRegularStringExpression -> Ordering)
-> (InterpolatedRegularStringExpression
    -> InterpolatedRegularStringExpression -> Bool)
-> (InterpolatedRegularStringExpression
    -> InterpolatedRegularStringExpression -> Bool)
-> (InterpolatedRegularStringExpression
    -> InterpolatedRegularStringExpression -> Bool)
-> (InterpolatedRegularStringExpression
    -> InterpolatedRegularStringExpression -> Bool)
-> (InterpolatedRegularStringExpression
    -> InterpolatedRegularStringExpression
    -> InterpolatedRegularStringExpression)
-> (InterpolatedRegularStringExpression
    -> InterpolatedRegularStringExpression
    -> InterpolatedRegularStringExpression)
-> Ord InterpolatedRegularStringExpression
InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Ordering
InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Ordering
compare :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Ordering
$c< :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
< :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
$c<= :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
<= :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
$c> :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
> :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
$c>= :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
>= :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression -> Bool
$cmax :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression
max :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression
$cmin :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression
min :: InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression
-> InterpolatedRegularStringExpression
Ord, ReadPrec [InterpolatedRegularStringExpression]
ReadPrec InterpolatedRegularStringExpression
Int -> ReadS InterpolatedRegularStringExpression
ReadS [InterpolatedRegularStringExpression]
(Int -> ReadS InterpolatedRegularStringExpression)
-> ReadS [InterpolatedRegularStringExpression]
-> ReadPrec InterpolatedRegularStringExpression
-> ReadPrec [InterpolatedRegularStringExpression]
-> Read InterpolatedRegularStringExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterpolatedRegularStringExpression
readsPrec :: Int -> ReadS InterpolatedRegularStringExpression
$creadList :: ReadS [InterpolatedRegularStringExpression]
readList :: ReadS [InterpolatedRegularStringExpression]
$creadPrec :: ReadPrec InterpolatedRegularStringExpression
readPrec :: ReadPrec InterpolatedRegularStringExpression
$creadListPrec :: ReadPrec [InterpolatedRegularStringExpression]
readListPrec :: ReadPrec [InterpolatedRegularStringExpression]
Read, Int -> InterpolatedRegularStringExpression -> String -> String
[InterpolatedRegularStringExpression] -> String -> String
InterpolatedRegularStringExpression -> String
(Int -> InterpolatedRegularStringExpression -> String -> String)
-> (InterpolatedRegularStringExpression -> String)
-> ([InterpolatedRegularStringExpression] -> String -> String)
-> Show InterpolatedRegularStringExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterpolatedRegularStringExpression -> String -> String
showsPrec :: Int -> InterpolatedRegularStringExpression -> String -> String
$cshow :: InterpolatedRegularStringExpression -> String
show :: InterpolatedRegularStringExpression -> String
$cshowList :: [InterpolatedRegularStringExpression] -> String -> String
showList :: [InterpolatedRegularStringExpression] -> String -> String
Show)

_InterpolatedRegularStringExpression :: Name
_InterpolatedRegularStringExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterpolatedRegularStringExpression")

data RegularInterpolation = 
  RegularInterpolation {
    RegularInterpolation -> Expression
regularInterpolationExpression :: Expression,
    RegularInterpolation -> Maybe Expression
regularInterpolationWidth :: (Maybe Expression),
    RegularInterpolation -> Maybe String
regularInterpolationFormat :: (Maybe String)}
  deriving (RegularInterpolation -> RegularInterpolation -> Bool
(RegularInterpolation -> RegularInterpolation -> Bool)
-> (RegularInterpolation -> RegularInterpolation -> Bool)
-> Eq RegularInterpolation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RegularInterpolation -> RegularInterpolation -> Bool
== :: RegularInterpolation -> RegularInterpolation -> Bool
$c/= :: RegularInterpolation -> RegularInterpolation -> Bool
/= :: RegularInterpolation -> RegularInterpolation -> Bool
Eq, Eq RegularInterpolation
Eq RegularInterpolation =>
(RegularInterpolation -> RegularInterpolation -> Ordering)
-> (RegularInterpolation -> RegularInterpolation -> Bool)
-> (RegularInterpolation -> RegularInterpolation -> Bool)
-> (RegularInterpolation -> RegularInterpolation -> Bool)
-> (RegularInterpolation -> RegularInterpolation -> Bool)
-> (RegularInterpolation
    -> RegularInterpolation -> RegularInterpolation)
-> (RegularInterpolation
    -> RegularInterpolation -> RegularInterpolation)
-> Ord RegularInterpolation
RegularInterpolation -> RegularInterpolation -> Bool
RegularInterpolation -> RegularInterpolation -> Ordering
RegularInterpolation
-> RegularInterpolation -> RegularInterpolation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RegularInterpolation -> RegularInterpolation -> Ordering
compare :: RegularInterpolation -> RegularInterpolation -> Ordering
$c< :: RegularInterpolation -> RegularInterpolation -> Bool
< :: RegularInterpolation -> RegularInterpolation -> Bool
$c<= :: RegularInterpolation -> RegularInterpolation -> Bool
<= :: RegularInterpolation -> RegularInterpolation -> Bool
$c> :: RegularInterpolation -> RegularInterpolation -> Bool
> :: RegularInterpolation -> RegularInterpolation -> Bool
$c>= :: RegularInterpolation -> RegularInterpolation -> Bool
>= :: RegularInterpolation -> RegularInterpolation -> Bool
$cmax :: RegularInterpolation
-> RegularInterpolation -> RegularInterpolation
max :: RegularInterpolation
-> RegularInterpolation -> RegularInterpolation
$cmin :: RegularInterpolation
-> RegularInterpolation -> RegularInterpolation
min :: RegularInterpolation
-> RegularInterpolation -> RegularInterpolation
Ord, ReadPrec [RegularInterpolation]
ReadPrec RegularInterpolation
Int -> ReadS RegularInterpolation
ReadS [RegularInterpolation]
(Int -> ReadS RegularInterpolation)
-> ReadS [RegularInterpolation]
-> ReadPrec RegularInterpolation
-> ReadPrec [RegularInterpolation]
-> Read RegularInterpolation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RegularInterpolation
readsPrec :: Int -> ReadS RegularInterpolation
$creadList :: ReadS [RegularInterpolation]
readList :: ReadS [RegularInterpolation]
$creadPrec :: ReadPrec RegularInterpolation
readPrec :: ReadPrec RegularInterpolation
$creadListPrec :: ReadPrec [RegularInterpolation]
readListPrec :: ReadPrec [RegularInterpolation]
Read, Int -> RegularInterpolation -> String -> String
[RegularInterpolation] -> String -> String
RegularInterpolation -> String
(Int -> RegularInterpolation -> String -> String)
-> (RegularInterpolation -> String)
-> ([RegularInterpolation] -> String -> String)
-> Show RegularInterpolation
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RegularInterpolation -> String -> String
showsPrec :: Int -> RegularInterpolation -> String -> String
$cshow :: RegularInterpolation -> String
show :: RegularInterpolation -> String
$cshowList :: [RegularInterpolation] -> String -> String
showList :: [RegularInterpolation] -> String -> String
Show)

_RegularInterpolation :: Name
_RegularInterpolation = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RegularInterpolation")

_RegularInterpolation_expression :: Name
_RegularInterpolation_expression = (String -> Name
Core.Name String
"expression")

_RegularInterpolation_width :: Name
_RegularInterpolation_width = (String -> Name
Core.Name String
"width")

_RegularInterpolation_format :: Name
_RegularInterpolation_format = (String -> Name
Core.Name String
"format")

newtype InterpolatedVerbatimStringExpression = 
  InterpolatedVerbatimStringExpression {
    InterpolatedVerbatimStringExpression -> String
unInterpolatedVerbatimStringExpression :: String}
  deriving (InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
(InterpolatedVerbatimStringExpression
 -> InterpolatedVerbatimStringExpression -> Bool)
-> (InterpolatedVerbatimStringExpression
    -> InterpolatedVerbatimStringExpression -> Bool)
-> Eq InterpolatedVerbatimStringExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
== :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
$c/= :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
/= :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
Eq, Eq InterpolatedVerbatimStringExpression
Eq InterpolatedVerbatimStringExpression =>
(InterpolatedVerbatimStringExpression
 -> InterpolatedVerbatimStringExpression -> Ordering)
-> (InterpolatedVerbatimStringExpression
    -> InterpolatedVerbatimStringExpression -> Bool)
-> (InterpolatedVerbatimStringExpression
    -> InterpolatedVerbatimStringExpression -> Bool)
-> (InterpolatedVerbatimStringExpression
    -> InterpolatedVerbatimStringExpression -> Bool)
-> (InterpolatedVerbatimStringExpression
    -> InterpolatedVerbatimStringExpression -> Bool)
-> (InterpolatedVerbatimStringExpression
    -> InterpolatedVerbatimStringExpression
    -> InterpolatedVerbatimStringExpression)
-> (InterpolatedVerbatimStringExpression
    -> InterpolatedVerbatimStringExpression
    -> InterpolatedVerbatimStringExpression)
-> Ord InterpolatedVerbatimStringExpression
InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Ordering
InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Ordering
compare :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Ordering
$c< :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
< :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
$c<= :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
<= :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
$c> :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
> :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
$c>= :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
>= :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression -> Bool
$cmax :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression
max :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression
$cmin :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression
min :: InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression
-> InterpolatedVerbatimStringExpression
Ord, ReadPrec [InterpolatedVerbatimStringExpression]
ReadPrec InterpolatedVerbatimStringExpression
Int -> ReadS InterpolatedVerbatimStringExpression
ReadS [InterpolatedVerbatimStringExpression]
(Int -> ReadS InterpolatedVerbatimStringExpression)
-> ReadS [InterpolatedVerbatimStringExpression]
-> ReadPrec InterpolatedVerbatimStringExpression
-> ReadPrec [InterpolatedVerbatimStringExpression]
-> Read InterpolatedVerbatimStringExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterpolatedVerbatimStringExpression
readsPrec :: Int -> ReadS InterpolatedVerbatimStringExpression
$creadList :: ReadS [InterpolatedVerbatimStringExpression]
readList :: ReadS [InterpolatedVerbatimStringExpression]
$creadPrec :: ReadPrec InterpolatedVerbatimStringExpression
readPrec :: ReadPrec InterpolatedVerbatimStringExpression
$creadListPrec :: ReadPrec [InterpolatedVerbatimStringExpression]
readListPrec :: ReadPrec [InterpolatedVerbatimStringExpression]
Read, Int -> InterpolatedVerbatimStringExpression -> String -> String
[InterpolatedVerbatimStringExpression] -> String -> String
InterpolatedVerbatimStringExpression -> String
(Int -> InterpolatedVerbatimStringExpression -> String -> String)
-> (InterpolatedVerbatimStringExpression -> String)
-> ([InterpolatedVerbatimStringExpression] -> String -> String)
-> Show InterpolatedVerbatimStringExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterpolatedVerbatimStringExpression -> String -> String
showsPrec :: Int -> InterpolatedVerbatimStringExpression -> String -> String
$cshow :: InterpolatedVerbatimStringExpression -> String
show :: InterpolatedVerbatimStringExpression -> String
$cshowList :: [InterpolatedVerbatimStringExpression] -> String -> String
showList :: [InterpolatedVerbatimStringExpression] -> String -> String
Show)

_InterpolatedVerbatimStringExpression :: Name
_InterpolatedVerbatimStringExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterpolatedVerbatimStringExpression")

data VerbatimInterpolation = 
  VerbatimInterpolation {
    VerbatimInterpolation -> Expression
verbatimInterpolationExpression :: Expression,
    VerbatimInterpolation -> Maybe ConstantExpression
verbatimInterpolationWidth :: (Maybe ConstantExpression),
    VerbatimInterpolation -> Maybe String
verbatimInterpolationFormat :: (Maybe String)}
  deriving (VerbatimInterpolation -> VerbatimInterpolation -> Bool
(VerbatimInterpolation -> VerbatimInterpolation -> Bool)
-> (VerbatimInterpolation -> VerbatimInterpolation -> Bool)
-> Eq VerbatimInterpolation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
== :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
$c/= :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
/= :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
Eq, Eq VerbatimInterpolation
Eq VerbatimInterpolation =>
(VerbatimInterpolation -> VerbatimInterpolation -> Ordering)
-> (VerbatimInterpolation -> VerbatimInterpolation -> Bool)
-> (VerbatimInterpolation -> VerbatimInterpolation -> Bool)
-> (VerbatimInterpolation -> VerbatimInterpolation -> Bool)
-> (VerbatimInterpolation -> VerbatimInterpolation -> Bool)
-> (VerbatimInterpolation
    -> VerbatimInterpolation -> VerbatimInterpolation)
-> (VerbatimInterpolation
    -> VerbatimInterpolation -> VerbatimInterpolation)
-> Ord VerbatimInterpolation
VerbatimInterpolation -> VerbatimInterpolation -> Bool
VerbatimInterpolation -> VerbatimInterpolation -> Ordering
VerbatimInterpolation
-> VerbatimInterpolation -> VerbatimInterpolation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VerbatimInterpolation -> VerbatimInterpolation -> Ordering
compare :: VerbatimInterpolation -> VerbatimInterpolation -> Ordering
$c< :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
< :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
$c<= :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
<= :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
$c> :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
> :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
$c>= :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
>= :: VerbatimInterpolation -> VerbatimInterpolation -> Bool
$cmax :: VerbatimInterpolation
-> VerbatimInterpolation -> VerbatimInterpolation
max :: VerbatimInterpolation
-> VerbatimInterpolation -> VerbatimInterpolation
$cmin :: VerbatimInterpolation
-> VerbatimInterpolation -> VerbatimInterpolation
min :: VerbatimInterpolation
-> VerbatimInterpolation -> VerbatimInterpolation
Ord, ReadPrec [VerbatimInterpolation]
ReadPrec VerbatimInterpolation
Int -> ReadS VerbatimInterpolation
ReadS [VerbatimInterpolation]
(Int -> ReadS VerbatimInterpolation)
-> ReadS [VerbatimInterpolation]
-> ReadPrec VerbatimInterpolation
-> ReadPrec [VerbatimInterpolation]
-> Read VerbatimInterpolation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VerbatimInterpolation
readsPrec :: Int -> ReadS VerbatimInterpolation
$creadList :: ReadS [VerbatimInterpolation]
readList :: ReadS [VerbatimInterpolation]
$creadPrec :: ReadPrec VerbatimInterpolation
readPrec :: ReadPrec VerbatimInterpolation
$creadListPrec :: ReadPrec [VerbatimInterpolation]
readListPrec :: ReadPrec [VerbatimInterpolation]
Read, Int -> VerbatimInterpolation -> String -> String
[VerbatimInterpolation] -> String -> String
VerbatimInterpolation -> String
(Int -> VerbatimInterpolation -> String -> String)
-> (VerbatimInterpolation -> String)
-> ([VerbatimInterpolation] -> String -> String)
-> Show VerbatimInterpolation
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VerbatimInterpolation -> String -> String
showsPrec :: Int -> VerbatimInterpolation -> String -> String
$cshow :: VerbatimInterpolation -> String
show :: VerbatimInterpolation -> String
$cshowList :: [VerbatimInterpolation] -> String -> String
showList :: [VerbatimInterpolation] -> String -> String
Show)

_VerbatimInterpolation :: Name
_VerbatimInterpolation = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.VerbatimInterpolation")

_VerbatimInterpolation_expression :: Name
_VerbatimInterpolation_expression = (String -> Name
Core.Name String
"expression")

_VerbatimInterpolation_width :: Name
_VerbatimInterpolation_width = (String -> Name
Core.Name String
"width")

_VerbatimInterpolation_format :: Name
_VerbatimInterpolation_format = (String -> Name
Core.Name String
"format")

data SimpleName = 
  SimpleName {
    SimpleName -> Identifier
simpleNameIdentifier :: Identifier,
    SimpleName -> Maybe TypeArgumentList
simpleNameTypeArguments :: (Maybe TypeArgumentList)}
  deriving (SimpleName -> SimpleName -> Bool
(SimpleName -> SimpleName -> Bool)
-> (SimpleName -> SimpleName -> Bool) -> Eq SimpleName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SimpleName -> SimpleName -> Bool
== :: SimpleName -> SimpleName -> Bool
$c/= :: SimpleName -> SimpleName -> Bool
/= :: SimpleName -> SimpleName -> Bool
Eq, Eq SimpleName
Eq SimpleName =>
(SimpleName -> SimpleName -> Ordering)
-> (SimpleName -> SimpleName -> Bool)
-> (SimpleName -> SimpleName -> Bool)
-> (SimpleName -> SimpleName -> Bool)
-> (SimpleName -> SimpleName -> Bool)
-> (SimpleName -> SimpleName -> SimpleName)
-> (SimpleName -> SimpleName -> SimpleName)
-> Ord SimpleName
SimpleName -> SimpleName -> Bool
SimpleName -> SimpleName -> Ordering
SimpleName -> SimpleName -> SimpleName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SimpleName -> SimpleName -> Ordering
compare :: SimpleName -> SimpleName -> Ordering
$c< :: SimpleName -> SimpleName -> Bool
< :: SimpleName -> SimpleName -> Bool
$c<= :: SimpleName -> SimpleName -> Bool
<= :: SimpleName -> SimpleName -> Bool
$c> :: SimpleName -> SimpleName -> Bool
> :: SimpleName -> SimpleName -> Bool
$c>= :: SimpleName -> SimpleName -> Bool
>= :: SimpleName -> SimpleName -> Bool
$cmax :: SimpleName -> SimpleName -> SimpleName
max :: SimpleName -> SimpleName -> SimpleName
$cmin :: SimpleName -> SimpleName -> SimpleName
min :: SimpleName -> SimpleName -> SimpleName
Ord, ReadPrec [SimpleName]
ReadPrec SimpleName
Int -> ReadS SimpleName
ReadS [SimpleName]
(Int -> ReadS SimpleName)
-> ReadS [SimpleName]
-> ReadPrec SimpleName
-> ReadPrec [SimpleName]
-> Read SimpleName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SimpleName
readsPrec :: Int -> ReadS SimpleName
$creadList :: ReadS [SimpleName]
readList :: ReadS [SimpleName]
$creadPrec :: ReadPrec SimpleName
readPrec :: ReadPrec SimpleName
$creadListPrec :: ReadPrec [SimpleName]
readListPrec :: ReadPrec [SimpleName]
Read, Int -> SimpleName -> String -> String
[SimpleName] -> String -> String
SimpleName -> String
(Int -> SimpleName -> String -> String)
-> (SimpleName -> String)
-> ([SimpleName] -> String -> String)
-> Show SimpleName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SimpleName -> String -> String
showsPrec :: Int -> SimpleName -> String -> String
$cshow :: SimpleName -> String
show :: SimpleName -> String
$cshowList :: [SimpleName] -> String -> String
showList :: [SimpleName] -> String -> String
Show)

_SimpleName :: Name
_SimpleName = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SimpleName")

_SimpleName_identifier :: Name
_SimpleName_identifier = (String -> Name
Core.Name String
"identifier")

_SimpleName_typeArguments :: Name
_SimpleName_typeArguments = (String -> Name
Core.Name String
"typeArguments")

data TupleExpression = 
  TupleExpressionElements [TupleElement] |
  TupleExpressionDeconstruction DeconstructionTuple
  deriving (TupleExpression -> TupleExpression -> Bool
(TupleExpression -> TupleExpression -> Bool)
-> (TupleExpression -> TupleExpression -> Bool)
-> Eq TupleExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TupleExpression -> TupleExpression -> Bool
== :: TupleExpression -> TupleExpression -> Bool
$c/= :: TupleExpression -> TupleExpression -> Bool
/= :: TupleExpression -> TupleExpression -> Bool
Eq, Eq TupleExpression
Eq TupleExpression =>
(TupleExpression -> TupleExpression -> Ordering)
-> (TupleExpression -> TupleExpression -> Bool)
-> (TupleExpression -> TupleExpression -> Bool)
-> (TupleExpression -> TupleExpression -> Bool)
-> (TupleExpression -> TupleExpression -> Bool)
-> (TupleExpression -> TupleExpression -> TupleExpression)
-> (TupleExpression -> TupleExpression -> TupleExpression)
-> Ord TupleExpression
TupleExpression -> TupleExpression -> Bool
TupleExpression -> TupleExpression -> Ordering
TupleExpression -> TupleExpression -> TupleExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TupleExpression -> TupleExpression -> Ordering
compare :: TupleExpression -> TupleExpression -> Ordering
$c< :: TupleExpression -> TupleExpression -> Bool
< :: TupleExpression -> TupleExpression -> Bool
$c<= :: TupleExpression -> TupleExpression -> Bool
<= :: TupleExpression -> TupleExpression -> Bool
$c> :: TupleExpression -> TupleExpression -> Bool
> :: TupleExpression -> TupleExpression -> Bool
$c>= :: TupleExpression -> TupleExpression -> Bool
>= :: TupleExpression -> TupleExpression -> Bool
$cmax :: TupleExpression -> TupleExpression -> TupleExpression
max :: TupleExpression -> TupleExpression -> TupleExpression
$cmin :: TupleExpression -> TupleExpression -> TupleExpression
min :: TupleExpression -> TupleExpression -> TupleExpression
Ord, ReadPrec [TupleExpression]
ReadPrec TupleExpression
Int -> ReadS TupleExpression
ReadS [TupleExpression]
(Int -> ReadS TupleExpression)
-> ReadS [TupleExpression]
-> ReadPrec TupleExpression
-> ReadPrec [TupleExpression]
-> Read TupleExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TupleExpression
readsPrec :: Int -> ReadS TupleExpression
$creadList :: ReadS [TupleExpression]
readList :: ReadS [TupleExpression]
$creadPrec :: ReadPrec TupleExpression
readPrec :: ReadPrec TupleExpression
$creadListPrec :: ReadPrec [TupleExpression]
readListPrec :: ReadPrec [TupleExpression]
Read, Int -> TupleExpression -> String -> String
[TupleExpression] -> String -> String
TupleExpression -> String
(Int -> TupleExpression -> String -> String)
-> (TupleExpression -> String)
-> ([TupleExpression] -> String -> String)
-> Show TupleExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TupleExpression -> String -> String
showsPrec :: Int -> TupleExpression -> String -> String
$cshow :: TupleExpression -> String
show :: TupleExpression -> String
$cshowList :: [TupleExpression] -> String -> String
showList :: [TupleExpression] -> String -> String
Show)

_TupleExpression :: Name
_TupleExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TupleExpression")

_TupleExpression_elements :: Name
_TupleExpression_elements = (String -> Name
Core.Name String
"elements")

_TupleExpression_deconstruction :: Name
_TupleExpression_deconstruction = (String -> Name
Core.Name String
"deconstruction")

data TupleElement = 
  TupleElement {
    TupleElement -> Maybe Identifier
tupleElementName :: (Maybe Identifier),
    TupleElement -> Expression
tupleElementExpression :: Expression}
  deriving (TupleElement -> TupleElement -> Bool
(TupleElement -> TupleElement -> Bool)
-> (TupleElement -> TupleElement -> Bool) -> Eq TupleElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TupleElement -> TupleElement -> Bool
== :: TupleElement -> TupleElement -> Bool
$c/= :: TupleElement -> TupleElement -> Bool
/= :: TupleElement -> TupleElement -> Bool
Eq, Eq TupleElement
Eq TupleElement =>
(TupleElement -> TupleElement -> Ordering)
-> (TupleElement -> TupleElement -> Bool)
-> (TupleElement -> TupleElement -> Bool)
-> (TupleElement -> TupleElement -> Bool)
-> (TupleElement -> TupleElement -> Bool)
-> (TupleElement -> TupleElement -> TupleElement)
-> (TupleElement -> TupleElement -> TupleElement)
-> Ord TupleElement
TupleElement -> TupleElement -> Bool
TupleElement -> TupleElement -> Ordering
TupleElement -> TupleElement -> TupleElement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TupleElement -> TupleElement -> Ordering
compare :: TupleElement -> TupleElement -> Ordering
$c< :: TupleElement -> TupleElement -> Bool
< :: TupleElement -> TupleElement -> Bool
$c<= :: TupleElement -> TupleElement -> Bool
<= :: TupleElement -> TupleElement -> Bool
$c> :: TupleElement -> TupleElement -> Bool
> :: TupleElement -> TupleElement -> Bool
$c>= :: TupleElement -> TupleElement -> Bool
>= :: TupleElement -> TupleElement -> Bool
$cmax :: TupleElement -> TupleElement -> TupleElement
max :: TupleElement -> TupleElement -> TupleElement
$cmin :: TupleElement -> TupleElement -> TupleElement
min :: TupleElement -> TupleElement -> TupleElement
Ord, ReadPrec [TupleElement]
ReadPrec TupleElement
Int -> ReadS TupleElement
ReadS [TupleElement]
(Int -> ReadS TupleElement)
-> ReadS [TupleElement]
-> ReadPrec TupleElement
-> ReadPrec [TupleElement]
-> Read TupleElement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TupleElement
readsPrec :: Int -> ReadS TupleElement
$creadList :: ReadS [TupleElement]
readList :: ReadS [TupleElement]
$creadPrec :: ReadPrec TupleElement
readPrec :: ReadPrec TupleElement
$creadListPrec :: ReadPrec [TupleElement]
readListPrec :: ReadPrec [TupleElement]
Read, Int -> TupleElement -> String -> String
[TupleElement] -> String -> String
TupleElement -> String
(Int -> TupleElement -> String -> String)
-> (TupleElement -> String)
-> ([TupleElement] -> String -> String)
-> Show TupleElement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TupleElement -> String -> String
showsPrec :: Int -> TupleElement -> String -> String
$cshow :: TupleElement -> String
show :: TupleElement -> String
$cshowList :: [TupleElement] -> String -> String
showList :: [TupleElement] -> String -> String
Show)

_TupleElement :: Name
_TupleElement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TupleElement")

_TupleElement_name :: Name
_TupleElement_name = (String -> Name
Core.Name String
"name")

_TupleElement_expression :: Name
_TupleElement_expression = (String -> Name
Core.Name String
"expression")

newtype DeconstructionTuple = 
  DeconstructionTuple {
    DeconstructionTuple -> [DeconstructionElement]
unDeconstructionTuple :: [DeconstructionElement]}
  deriving (DeconstructionTuple -> DeconstructionTuple -> Bool
(DeconstructionTuple -> DeconstructionTuple -> Bool)
-> (DeconstructionTuple -> DeconstructionTuple -> Bool)
-> Eq DeconstructionTuple
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeconstructionTuple -> DeconstructionTuple -> Bool
== :: DeconstructionTuple -> DeconstructionTuple -> Bool
$c/= :: DeconstructionTuple -> DeconstructionTuple -> Bool
/= :: DeconstructionTuple -> DeconstructionTuple -> Bool
Eq, Eq DeconstructionTuple
Eq DeconstructionTuple =>
(DeconstructionTuple -> DeconstructionTuple -> Ordering)
-> (DeconstructionTuple -> DeconstructionTuple -> Bool)
-> (DeconstructionTuple -> DeconstructionTuple -> Bool)
-> (DeconstructionTuple -> DeconstructionTuple -> Bool)
-> (DeconstructionTuple -> DeconstructionTuple -> Bool)
-> (DeconstructionTuple
    -> DeconstructionTuple -> DeconstructionTuple)
-> (DeconstructionTuple
    -> DeconstructionTuple -> DeconstructionTuple)
-> Ord DeconstructionTuple
DeconstructionTuple -> DeconstructionTuple -> Bool
DeconstructionTuple -> DeconstructionTuple -> Ordering
DeconstructionTuple -> DeconstructionTuple -> DeconstructionTuple
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DeconstructionTuple -> DeconstructionTuple -> Ordering
compare :: DeconstructionTuple -> DeconstructionTuple -> Ordering
$c< :: DeconstructionTuple -> DeconstructionTuple -> Bool
< :: DeconstructionTuple -> DeconstructionTuple -> Bool
$c<= :: DeconstructionTuple -> DeconstructionTuple -> Bool
<= :: DeconstructionTuple -> DeconstructionTuple -> Bool
$c> :: DeconstructionTuple -> DeconstructionTuple -> Bool
> :: DeconstructionTuple -> DeconstructionTuple -> Bool
$c>= :: DeconstructionTuple -> DeconstructionTuple -> Bool
>= :: DeconstructionTuple -> DeconstructionTuple -> Bool
$cmax :: DeconstructionTuple -> DeconstructionTuple -> DeconstructionTuple
max :: DeconstructionTuple -> DeconstructionTuple -> DeconstructionTuple
$cmin :: DeconstructionTuple -> DeconstructionTuple -> DeconstructionTuple
min :: DeconstructionTuple -> DeconstructionTuple -> DeconstructionTuple
Ord, ReadPrec [DeconstructionTuple]
ReadPrec DeconstructionTuple
Int -> ReadS DeconstructionTuple
ReadS [DeconstructionTuple]
(Int -> ReadS DeconstructionTuple)
-> ReadS [DeconstructionTuple]
-> ReadPrec DeconstructionTuple
-> ReadPrec [DeconstructionTuple]
-> Read DeconstructionTuple
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DeconstructionTuple
readsPrec :: Int -> ReadS DeconstructionTuple
$creadList :: ReadS [DeconstructionTuple]
readList :: ReadS [DeconstructionTuple]
$creadPrec :: ReadPrec DeconstructionTuple
readPrec :: ReadPrec DeconstructionTuple
$creadListPrec :: ReadPrec [DeconstructionTuple]
readListPrec :: ReadPrec [DeconstructionTuple]
Read, Int -> DeconstructionTuple -> String -> String
[DeconstructionTuple] -> String -> String
DeconstructionTuple -> String
(Int -> DeconstructionTuple -> String -> String)
-> (DeconstructionTuple -> String)
-> ([DeconstructionTuple] -> String -> String)
-> Show DeconstructionTuple
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DeconstructionTuple -> String -> String
showsPrec :: Int -> DeconstructionTuple -> String -> String
$cshow :: DeconstructionTuple -> String
show :: DeconstructionTuple -> String
$cshowList :: [DeconstructionTuple] -> String -> String
showList :: [DeconstructionTuple] -> String -> String
Show)

_DeconstructionTuple :: Name
_DeconstructionTuple = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DeconstructionTuple")

data DeconstructionElement = 
  DeconstructionElementTuple DeconstructionTuple |
  DeconstructionElementIdentifier Identifier
  deriving (DeconstructionElement -> DeconstructionElement -> Bool
(DeconstructionElement -> DeconstructionElement -> Bool)
-> (DeconstructionElement -> DeconstructionElement -> Bool)
-> Eq DeconstructionElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeconstructionElement -> DeconstructionElement -> Bool
== :: DeconstructionElement -> DeconstructionElement -> Bool
$c/= :: DeconstructionElement -> DeconstructionElement -> Bool
/= :: DeconstructionElement -> DeconstructionElement -> Bool
Eq, Eq DeconstructionElement
Eq DeconstructionElement =>
(DeconstructionElement -> DeconstructionElement -> Ordering)
-> (DeconstructionElement -> DeconstructionElement -> Bool)
-> (DeconstructionElement -> DeconstructionElement -> Bool)
-> (DeconstructionElement -> DeconstructionElement -> Bool)
-> (DeconstructionElement -> DeconstructionElement -> Bool)
-> (DeconstructionElement
    -> DeconstructionElement -> DeconstructionElement)
-> (DeconstructionElement
    -> DeconstructionElement -> DeconstructionElement)
-> Ord DeconstructionElement
DeconstructionElement -> DeconstructionElement -> Bool
DeconstructionElement -> DeconstructionElement -> Ordering
DeconstructionElement
-> DeconstructionElement -> DeconstructionElement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DeconstructionElement -> DeconstructionElement -> Ordering
compare :: DeconstructionElement -> DeconstructionElement -> Ordering
$c< :: DeconstructionElement -> DeconstructionElement -> Bool
< :: DeconstructionElement -> DeconstructionElement -> Bool
$c<= :: DeconstructionElement -> DeconstructionElement -> Bool
<= :: DeconstructionElement -> DeconstructionElement -> Bool
$c> :: DeconstructionElement -> DeconstructionElement -> Bool
> :: DeconstructionElement -> DeconstructionElement -> Bool
$c>= :: DeconstructionElement -> DeconstructionElement -> Bool
>= :: DeconstructionElement -> DeconstructionElement -> Bool
$cmax :: DeconstructionElement
-> DeconstructionElement -> DeconstructionElement
max :: DeconstructionElement
-> DeconstructionElement -> DeconstructionElement
$cmin :: DeconstructionElement
-> DeconstructionElement -> DeconstructionElement
min :: DeconstructionElement
-> DeconstructionElement -> DeconstructionElement
Ord, ReadPrec [DeconstructionElement]
ReadPrec DeconstructionElement
Int -> ReadS DeconstructionElement
ReadS [DeconstructionElement]
(Int -> ReadS DeconstructionElement)
-> ReadS [DeconstructionElement]
-> ReadPrec DeconstructionElement
-> ReadPrec [DeconstructionElement]
-> Read DeconstructionElement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DeconstructionElement
readsPrec :: Int -> ReadS DeconstructionElement
$creadList :: ReadS [DeconstructionElement]
readList :: ReadS [DeconstructionElement]
$creadPrec :: ReadPrec DeconstructionElement
readPrec :: ReadPrec DeconstructionElement
$creadListPrec :: ReadPrec [DeconstructionElement]
readListPrec :: ReadPrec [DeconstructionElement]
Read, Int -> DeconstructionElement -> String -> String
[DeconstructionElement] -> String -> String
DeconstructionElement -> String
(Int -> DeconstructionElement -> String -> String)
-> (DeconstructionElement -> String)
-> ([DeconstructionElement] -> String -> String)
-> Show DeconstructionElement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DeconstructionElement -> String -> String
showsPrec :: Int -> DeconstructionElement -> String -> String
$cshow :: DeconstructionElement -> String
show :: DeconstructionElement -> String
$cshowList :: [DeconstructionElement] -> String -> String
showList :: [DeconstructionElement] -> String -> String
Show)

_DeconstructionElement :: Name
_DeconstructionElement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DeconstructionElement")

_DeconstructionElement_tuple :: Name
_DeconstructionElement_tuple = (String -> Name
Core.Name String
"tuple")

_DeconstructionElement_identifier :: Name
_DeconstructionElement_identifier = (String -> Name
Core.Name String
"identifier")

data MemberAccess = 
  MemberAccess {
    MemberAccess -> MemberAccessHead
memberAccessHead :: MemberAccessHead,
    MemberAccess -> Identifier
memberAccessIdentifier :: Identifier,
    MemberAccess -> Maybe TypeArgumentList
memberAccessTypeArguments :: (Maybe TypeArgumentList)}
  deriving (MemberAccess -> MemberAccess -> Bool
(MemberAccess -> MemberAccess -> Bool)
-> (MemberAccess -> MemberAccess -> Bool) -> Eq MemberAccess
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemberAccess -> MemberAccess -> Bool
== :: MemberAccess -> MemberAccess -> Bool
$c/= :: MemberAccess -> MemberAccess -> Bool
/= :: MemberAccess -> MemberAccess -> Bool
Eq, Eq MemberAccess
Eq MemberAccess =>
(MemberAccess -> MemberAccess -> Ordering)
-> (MemberAccess -> MemberAccess -> Bool)
-> (MemberAccess -> MemberAccess -> Bool)
-> (MemberAccess -> MemberAccess -> Bool)
-> (MemberAccess -> MemberAccess -> Bool)
-> (MemberAccess -> MemberAccess -> MemberAccess)
-> (MemberAccess -> MemberAccess -> MemberAccess)
-> Ord MemberAccess
MemberAccess -> MemberAccess -> Bool
MemberAccess -> MemberAccess -> Ordering
MemberAccess -> MemberAccess -> MemberAccess
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MemberAccess -> MemberAccess -> Ordering
compare :: MemberAccess -> MemberAccess -> Ordering
$c< :: MemberAccess -> MemberAccess -> Bool
< :: MemberAccess -> MemberAccess -> Bool
$c<= :: MemberAccess -> MemberAccess -> Bool
<= :: MemberAccess -> MemberAccess -> Bool
$c> :: MemberAccess -> MemberAccess -> Bool
> :: MemberAccess -> MemberAccess -> Bool
$c>= :: MemberAccess -> MemberAccess -> Bool
>= :: MemberAccess -> MemberAccess -> Bool
$cmax :: MemberAccess -> MemberAccess -> MemberAccess
max :: MemberAccess -> MemberAccess -> MemberAccess
$cmin :: MemberAccess -> MemberAccess -> MemberAccess
min :: MemberAccess -> MemberAccess -> MemberAccess
Ord, ReadPrec [MemberAccess]
ReadPrec MemberAccess
Int -> ReadS MemberAccess
ReadS [MemberAccess]
(Int -> ReadS MemberAccess)
-> ReadS [MemberAccess]
-> ReadPrec MemberAccess
-> ReadPrec [MemberAccess]
-> Read MemberAccess
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MemberAccess
readsPrec :: Int -> ReadS MemberAccess
$creadList :: ReadS [MemberAccess]
readList :: ReadS [MemberAccess]
$creadPrec :: ReadPrec MemberAccess
readPrec :: ReadPrec MemberAccess
$creadListPrec :: ReadPrec [MemberAccess]
readListPrec :: ReadPrec [MemberAccess]
Read, Int -> MemberAccess -> String -> String
[MemberAccess] -> String -> String
MemberAccess -> String
(Int -> MemberAccess -> String -> String)
-> (MemberAccess -> String)
-> ([MemberAccess] -> String -> String)
-> Show MemberAccess
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MemberAccess -> String -> String
showsPrec :: Int -> MemberAccess -> String -> String
$cshow :: MemberAccess -> String
show :: MemberAccess -> String
$cshowList :: [MemberAccess] -> String -> String
showList :: [MemberAccess] -> String -> String
Show)

_MemberAccess :: Name
_MemberAccess = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MemberAccess")

_MemberAccess_head :: Name
_MemberAccess_head = (String -> Name
Core.Name String
"head")

_MemberAccess_identifier :: Name
_MemberAccess_identifier = (String -> Name
Core.Name String
"identifier")

_MemberAccess_typeArguments :: Name
_MemberAccess_typeArguments = (String -> Name
Core.Name String
"typeArguments")

data MemberAccessHead = 
  MemberAccessHeadPrimary PrimaryExpression |
  MemberAccessHeadPredefined PredefinedType |
  MemberAccessHeadQualifiedAlias QualifiedAliasMember
  deriving (MemberAccessHead -> MemberAccessHead -> Bool
(MemberAccessHead -> MemberAccessHead -> Bool)
-> (MemberAccessHead -> MemberAccessHead -> Bool)
-> Eq MemberAccessHead
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemberAccessHead -> MemberAccessHead -> Bool
== :: MemberAccessHead -> MemberAccessHead -> Bool
$c/= :: MemberAccessHead -> MemberAccessHead -> Bool
/= :: MemberAccessHead -> MemberAccessHead -> Bool
Eq, Eq MemberAccessHead
Eq MemberAccessHead =>
(MemberAccessHead -> MemberAccessHead -> Ordering)
-> (MemberAccessHead -> MemberAccessHead -> Bool)
-> (MemberAccessHead -> MemberAccessHead -> Bool)
-> (MemberAccessHead -> MemberAccessHead -> Bool)
-> (MemberAccessHead -> MemberAccessHead -> Bool)
-> (MemberAccessHead -> MemberAccessHead -> MemberAccessHead)
-> (MemberAccessHead -> MemberAccessHead -> MemberAccessHead)
-> Ord MemberAccessHead
MemberAccessHead -> MemberAccessHead -> Bool
MemberAccessHead -> MemberAccessHead -> Ordering
MemberAccessHead -> MemberAccessHead -> MemberAccessHead
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MemberAccessHead -> MemberAccessHead -> Ordering
compare :: MemberAccessHead -> MemberAccessHead -> Ordering
$c< :: MemberAccessHead -> MemberAccessHead -> Bool
< :: MemberAccessHead -> MemberAccessHead -> Bool
$c<= :: MemberAccessHead -> MemberAccessHead -> Bool
<= :: MemberAccessHead -> MemberAccessHead -> Bool
$c> :: MemberAccessHead -> MemberAccessHead -> Bool
> :: MemberAccessHead -> MemberAccessHead -> Bool
$c>= :: MemberAccessHead -> MemberAccessHead -> Bool
>= :: MemberAccessHead -> MemberAccessHead -> Bool
$cmax :: MemberAccessHead -> MemberAccessHead -> MemberAccessHead
max :: MemberAccessHead -> MemberAccessHead -> MemberAccessHead
$cmin :: MemberAccessHead -> MemberAccessHead -> MemberAccessHead
min :: MemberAccessHead -> MemberAccessHead -> MemberAccessHead
Ord, ReadPrec [MemberAccessHead]
ReadPrec MemberAccessHead
Int -> ReadS MemberAccessHead
ReadS [MemberAccessHead]
(Int -> ReadS MemberAccessHead)
-> ReadS [MemberAccessHead]
-> ReadPrec MemberAccessHead
-> ReadPrec [MemberAccessHead]
-> Read MemberAccessHead
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MemberAccessHead
readsPrec :: Int -> ReadS MemberAccessHead
$creadList :: ReadS [MemberAccessHead]
readList :: ReadS [MemberAccessHead]
$creadPrec :: ReadPrec MemberAccessHead
readPrec :: ReadPrec MemberAccessHead
$creadListPrec :: ReadPrec [MemberAccessHead]
readListPrec :: ReadPrec [MemberAccessHead]
Read, Int -> MemberAccessHead -> String -> String
[MemberAccessHead] -> String -> String
MemberAccessHead -> String
(Int -> MemberAccessHead -> String -> String)
-> (MemberAccessHead -> String)
-> ([MemberAccessHead] -> String -> String)
-> Show MemberAccessHead
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MemberAccessHead -> String -> String
showsPrec :: Int -> MemberAccessHead -> String -> String
$cshow :: MemberAccessHead -> String
show :: MemberAccessHead -> String
$cshowList :: [MemberAccessHead] -> String -> String
showList :: [MemberAccessHead] -> String -> String
Show)

_MemberAccessHead :: Name
_MemberAccessHead = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MemberAccessHead")

_MemberAccessHead_primary :: Name
_MemberAccessHead_primary = (String -> Name
Core.Name String
"primary")

_MemberAccessHead_predefined :: Name
_MemberAccessHead_predefined = (String -> Name
Core.Name String
"predefined")

_MemberAccessHead_qualifiedAlias :: Name
_MemberAccessHead_qualifiedAlias = (String -> Name
Core.Name String
"qualifiedAlias")

data PredefinedType = 
  PredefinedTypeBool  |
  PredefinedTypeByte  |
  PredefinedTypeChar  |
  PredefinedTypeDecimal  |
  PredefinedTypeDouble  |
  PredefinedTypeFloat  |
  PredefinedTypeInt  |
  PredefinedTypeLong  |
  PredefinedTypeObject  |
  PredefinedTypeSbyte  |
  PredefinedTypeShort  |
  PredefinedTypeString  |
  PredefinedTypeUint  |
  PredefinedTypeUlong  |
  PredefinedTypeUshort 
  deriving (PredefinedType -> PredefinedType -> Bool
(PredefinedType -> PredefinedType -> Bool)
-> (PredefinedType -> PredefinedType -> Bool) -> Eq PredefinedType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PredefinedType -> PredefinedType -> Bool
== :: PredefinedType -> PredefinedType -> Bool
$c/= :: PredefinedType -> PredefinedType -> Bool
/= :: PredefinedType -> PredefinedType -> Bool
Eq, Eq PredefinedType
Eq PredefinedType =>
(PredefinedType -> PredefinedType -> Ordering)
-> (PredefinedType -> PredefinedType -> Bool)
-> (PredefinedType -> PredefinedType -> Bool)
-> (PredefinedType -> PredefinedType -> Bool)
-> (PredefinedType -> PredefinedType -> Bool)
-> (PredefinedType -> PredefinedType -> PredefinedType)
-> (PredefinedType -> PredefinedType -> PredefinedType)
-> Ord PredefinedType
PredefinedType -> PredefinedType -> Bool
PredefinedType -> PredefinedType -> Ordering
PredefinedType -> PredefinedType -> PredefinedType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PredefinedType -> PredefinedType -> Ordering
compare :: PredefinedType -> PredefinedType -> Ordering
$c< :: PredefinedType -> PredefinedType -> Bool
< :: PredefinedType -> PredefinedType -> Bool
$c<= :: PredefinedType -> PredefinedType -> Bool
<= :: PredefinedType -> PredefinedType -> Bool
$c> :: PredefinedType -> PredefinedType -> Bool
> :: PredefinedType -> PredefinedType -> Bool
$c>= :: PredefinedType -> PredefinedType -> Bool
>= :: PredefinedType -> PredefinedType -> Bool
$cmax :: PredefinedType -> PredefinedType -> PredefinedType
max :: PredefinedType -> PredefinedType -> PredefinedType
$cmin :: PredefinedType -> PredefinedType -> PredefinedType
min :: PredefinedType -> PredefinedType -> PredefinedType
Ord, ReadPrec [PredefinedType]
ReadPrec PredefinedType
Int -> ReadS PredefinedType
ReadS [PredefinedType]
(Int -> ReadS PredefinedType)
-> ReadS [PredefinedType]
-> ReadPrec PredefinedType
-> ReadPrec [PredefinedType]
-> Read PredefinedType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PredefinedType
readsPrec :: Int -> ReadS PredefinedType
$creadList :: ReadS [PredefinedType]
readList :: ReadS [PredefinedType]
$creadPrec :: ReadPrec PredefinedType
readPrec :: ReadPrec PredefinedType
$creadListPrec :: ReadPrec [PredefinedType]
readListPrec :: ReadPrec [PredefinedType]
Read, Int -> PredefinedType -> String -> String
[PredefinedType] -> String -> String
PredefinedType -> String
(Int -> PredefinedType -> String -> String)
-> (PredefinedType -> String)
-> ([PredefinedType] -> String -> String)
-> Show PredefinedType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PredefinedType -> String -> String
showsPrec :: Int -> PredefinedType -> String -> String
$cshow :: PredefinedType -> String
show :: PredefinedType -> String
$cshowList :: [PredefinedType] -> String -> String
showList :: [PredefinedType] -> String -> String
Show)

_PredefinedType :: Name
_PredefinedType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PredefinedType")

_PredefinedType_bool :: Name
_PredefinedType_bool = (String -> Name
Core.Name String
"bool")

_PredefinedType_byte :: Name
_PredefinedType_byte = (String -> Name
Core.Name String
"byte")

_PredefinedType_char :: Name
_PredefinedType_char = (String -> Name
Core.Name String
"char")

_PredefinedType_decimal :: Name
_PredefinedType_decimal = (String -> Name
Core.Name String
"decimal")

_PredefinedType_double :: Name
_PredefinedType_double = (String -> Name
Core.Name String
"double")

_PredefinedType_float :: Name
_PredefinedType_float = (String -> Name
Core.Name String
"float")

_PredefinedType_int :: Name
_PredefinedType_int = (String -> Name
Core.Name String
"int")

_PredefinedType_long :: Name
_PredefinedType_long = (String -> Name
Core.Name String
"long")

_PredefinedType_object :: Name
_PredefinedType_object = (String -> Name
Core.Name String
"object")

_PredefinedType_sbyte :: Name
_PredefinedType_sbyte = (String -> Name
Core.Name String
"sbyte")

_PredefinedType_short :: Name
_PredefinedType_short = (String -> Name
Core.Name String
"short")

_PredefinedType_string :: Name
_PredefinedType_string = (String -> Name
Core.Name String
"string")

_PredefinedType_uint :: Name
_PredefinedType_uint = (String -> Name
Core.Name String
"uint")

_PredefinedType_ulong :: Name
_PredefinedType_ulong = (String -> Name
Core.Name String
"ulong")

_PredefinedType_ushort :: Name
_PredefinedType_ushort = (String -> Name
Core.Name String
"ushort")

data NullConditionalMemberAccess = 
  NullConditionalMemberAccess {
    NullConditionalMemberAccess -> PrimaryExpression
nullConditionalMemberAccessExpression :: PrimaryExpression,
    NullConditionalMemberAccess -> Identifier
nullConditionalMemberAccessIdentifier :: Identifier,
    NullConditionalMemberAccess -> Maybe TypeArgumentList
nullConditionalMemberAccessTypeArguments :: (Maybe TypeArgumentList),
    NullConditionalMemberAccess -> [DependentAccess]
nullConditionalMemberAccessDependentAccess :: [DependentAccess]}
  deriving (NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
(NullConditionalMemberAccess
 -> NullConditionalMemberAccess -> Bool)
-> (NullConditionalMemberAccess
    -> NullConditionalMemberAccess -> Bool)
-> Eq NullConditionalMemberAccess
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
== :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
$c/= :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
/= :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
Eq, Eq NullConditionalMemberAccess
Eq NullConditionalMemberAccess =>
(NullConditionalMemberAccess
 -> NullConditionalMemberAccess -> Ordering)
-> (NullConditionalMemberAccess
    -> NullConditionalMemberAccess -> Bool)
-> (NullConditionalMemberAccess
    -> NullConditionalMemberAccess -> Bool)
-> (NullConditionalMemberAccess
    -> NullConditionalMemberAccess -> Bool)
-> (NullConditionalMemberAccess
    -> NullConditionalMemberAccess -> Bool)
-> (NullConditionalMemberAccess
    -> NullConditionalMemberAccess -> NullConditionalMemberAccess)
-> (NullConditionalMemberAccess
    -> NullConditionalMemberAccess -> NullConditionalMemberAccess)
-> Ord NullConditionalMemberAccess
NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
NullConditionalMemberAccess
-> NullConditionalMemberAccess -> Ordering
NullConditionalMemberAccess
-> NullConditionalMemberAccess -> NullConditionalMemberAccess
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NullConditionalMemberAccess
-> NullConditionalMemberAccess -> Ordering
compare :: NullConditionalMemberAccess
-> NullConditionalMemberAccess -> Ordering
$c< :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
< :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
$c<= :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
<= :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
$c> :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
> :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
$c>= :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
>= :: NullConditionalMemberAccess -> NullConditionalMemberAccess -> Bool
$cmax :: NullConditionalMemberAccess
-> NullConditionalMemberAccess -> NullConditionalMemberAccess
max :: NullConditionalMemberAccess
-> NullConditionalMemberAccess -> NullConditionalMemberAccess
$cmin :: NullConditionalMemberAccess
-> NullConditionalMemberAccess -> NullConditionalMemberAccess
min :: NullConditionalMemberAccess
-> NullConditionalMemberAccess -> NullConditionalMemberAccess
Ord, ReadPrec [NullConditionalMemberAccess]
ReadPrec NullConditionalMemberAccess
Int -> ReadS NullConditionalMemberAccess
ReadS [NullConditionalMemberAccess]
(Int -> ReadS NullConditionalMemberAccess)
-> ReadS [NullConditionalMemberAccess]
-> ReadPrec NullConditionalMemberAccess
-> ReadPrec [NullConditionalMemberAccess]
-> Read NullConditionalMemberAccess
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NullConditionalMemberAccess
readsPrec :: Int -> ReadS NullConditionalMemberAccess
$creadList :: ReadS [NullConditionalMemberAccess]
readList :: ReadS [NullConditionalMemberAccess]
$creadPrec :: ReadPrec NullConditionalMemberAccess
readPrec :: ReadPrec NullConditionalMemberAccess
$creadListPrec :: ReadPrec [NullConditionalMemberAccess]
readListPrec :: ReadPrec [NullConditionalMemberAccess]
Read, Int -> NullConditionalMemberAccess -> String -> String
[NullConditionalMemberAccess] -> String -> String
NullConditionalMemberAccess -> String
(Int -> NullConditionalMemberAccess -> String -> String)
-> (NullConditionalMemberAccess -> String)
-> ([NullConditionalMemberAccess] -> String -> String)
-> Show NullConditionalMemberAccess
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NullConditionalMemberAccess -> String -> String
showsPrec :: Int -> NullConditionalMemberAccess -> String -> String
$cshow :: NullConditionalMemberAccess -> String
show :: NullConditionalMemberAccess -> String
$cshowList :: [NullConditionalMemberAccess] -> String -> String
showList :: [NullConditionalMemberAccess] -> String -> String
Show)

_NullConditionalMemberAccess :: Name
_NullConditionalMemberAccess = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NullConditionalMemberAccess")

_NullConditionalMemberAccess_expression :: Name
_NullConditionalMemberAccess_expression = (String -> Name
Core.Name String
"expression")

_NullConditionalMemberAccess_identifier :: Name
_NullConditionalMemberAccess_identifier = (String -> Name
Core.Name String
"identifier")

_NullConditionalMemberAccess_typeArguments :: Name
_NullConditionalMemberAccess_typeArguments = (String -> Name
Core.Name String
"typeArguments")

_NullConditionalMemberAccess_dependentAccess :: Name
_NullConditionalMemberAccess_dependentAccess = (String -> Name
Core.Name String
"dependentAccess")

data DependentAccess = 
  DependentAccessMemberAccess DependentAccessForMember |
  DependentAccessElementAccess ArgumentList |
  DependentAccessInvocation (Maybe ArgumentList)
  deriving (DependentAccess -> DependentAccess -> Bool
(DependentAccess -> DependentAccess -> Bool)
-> (DependentAccess -> DependentAccess -> Bool)
-> Eq DependentAccess
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DependentAccess -> DependentAccess -> Bool
== :: DependentAccess -> DependentAccess -> Bool
$c/= :: DependentAccess -> DependentAccess -> Bool
/= :: DependentAccess -> DependentAccess -> Bool
Eq, Eq DependentAccess
Eq DependentAccess =>
(DependentAccess -> DependentAccess -> Ordering)
-> (DependentAccess -> DependentAccess -> Bool)
-> (DependentAccess -> DependentAccess -> Bool)
-> (DependentAccess -> DependentAccess -> Bool)
-> (DependentAccess -> DependentAccess -> Bool)
-> (DependentAccess -> DependentAccess -> DependentAccess)
-> (DependentAccess -> DependentAccess -> DependentAccess)
-> Ord DependentAccess
DependentAccess -> DependentAccess -> Bool
DependentAccess -> DependentAccess -> Ordering
DependentAccess -> DependentAccess -> DependentAccess
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DependentAccess -> DependentAccess -> Ordering
compare :: DependentAccess -> DependentAccess -> Ordering
$c< :: DependentAccess -> DependentAccess -> Bool
< :: DependentAccess -> DependentAccess -> Bool
$c<= :: DependentAccess -> DependentAccess -> Bool
<= :: DependentAccess -> DependentAccess -> Bool
$c> :: DependentAccess -> DependentAccess -> Bool
> :: DependentAccess -> DependentAccess -> Bool
$c>= :: DependentAccess -> DependentAccess -> Bool
>= :: DependentAccess -> DependentAccess -> Bool
$cmax :: DependentAccess -> DependentAccess -> DependentAccess
max :: DependentAccess -> DependentAccess -> DependentAccess
$cmin :: DependentAccess -> DependentAccess -> DependentAccess
min :: DependentAccess -> DependentAccess -> DependentAccess
Ord, ReadPrec [DependentAccess]
ReadPrec DependentAccess
Int -> ReadS DependentAccess
ReadS [DependentAccess]
(Int -> ReadS DependentAccess)
-> ReadS [DependentAccess]
-> ReadPrec DependentAccess
-> ReadPrec [DependentAccess]
-> Read DependentAccess
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DependentAccess
readsPrec :: Int -> ReadS DependentAccess
$creadList :: ReadS [DependentAccess]
readList :: ReadS [DependentAccess]
$creadPrec :: ReadPrec DependentAccess
readPrec :: ReadPrec DependentAccess
$creadListPrec :: ReadPrec [DependentAccess]
readListPrec :: ReadPrec [DependentAccess]
Read, Int -> DependentAccess -> String -> String
[DependentAccess] -> String -> String
DependentAccess -> String
(Int -> DependentAccess -> String -> String)
-> (DependentAccess -> String)
-> ([DependentAccess] -> String -> String)
-> Show DependentAccess
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DependentAccess -> String -> String
showsPrec :: Int -> DependentAccess -> String -> String
$cshow :: DependentAccess -> String
show :: DependentAccess -> String
$cshowList :: [DependentAccess] -> String -> String
showList :: [DependentAccess] -> String -> String
Show)

_DependentAccess :: Name
_DependentAccess = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DependentAccess")

_DependentAccess_memberAccess :: Name
_DependentAccess_memberAccess = (String -> Name
Core.Name String
"memberAccess")

_DependentAccess_elementAccess :: Name
_DependentAccess_elementAccess = (String -> Name
Core.Name String
"elementAccess")

_DependentAccess_invocation :: Name
_DependentAccess_invocation = (String -> Name
Core.Name String
"invocation")

data DependentAccessForMember = 
  DependentAccessForMember {
    DependentAccessForMember -> Identifier
dependentAccessForMemberIdentifier :: Identifier,
    DependentAccessForMember -> Maybe TypeArgumentList
dependentAccessForMemberTypeArguments :: (Maybe TypeArgumentList)}
  deriving (DependentAccessForMember -> DependentAccessForMember -> Bool
(DependentAccessForMember -> DependentAccessForMember -> Bool)
-> (DependentAccessForMember -> DependentAccessForMember -> Bool)
-> Eq DependentAccessForMember
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DependentAccessForMember -> DependentAccessForMember -> Bool
== :: DependentAccessForMember -> DependentAccessForMember -> Bool
$c/= :: DependentAccessForMember -> DependentAccessForMember -> Bool
/= :: DependentAccessForMember -> DependentAccessForMember -> Bool
Eq, Eq DependentAccessForMember
Eq DependentAccessForMember =>
(DependentAccessForMember -> DependentAccessForMember -> Ordering)
-> (DependentAccessForMember -> DependentAccessForMember -> Bool)
-> (DependentAccessForMember -> DependentAccessForMember -> Bool)
-> (DependentAccessForMember -> DependentAccessForMember -> Bool)
-> (DependentAccessForMember -> DependentAccessForMember -> Bool)
-> (DependentAccessForMember
    -> DependentAccessForMember -> DependentAccessForMember)
-> (DependentAccessForMember
    -> DependentAccessForMember -> DependentAccessForMember)
-> Ord DependentAccessForMember
DependentAccessForMember -> DependentAccessForMember -> Bool
DependentAccessForMember -> DependentAccessForMember -> Ordering
DependentAccessForMember
-> DependentAccessForMember -> DependentAccessForMember
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DependentAccessForMember -> DependentAccessForMember -> Ordering
compare :: DependentAccessForMember -> DependentAccessForMember -> Ordering
$c< :: DependentAccessForMember -> DependentAccessForMember -> Bool
< :: DependentAccessForMember -> DependentAccessForMember -> Bool
$c<= :: DependentAccessForMember -> DependentAccessForMember -> Bool
<= :: DependentAccessForMember -> DependentAccessForMember -> Bool
$c> :: DependentAccessForMember -> DependentAccessForMember -> Bool
> :: DependentAccessForMember -> DependentAccessForMember -> Bool
$c>= :: DependentAccessForMember -> DependentAccessForMember -> Bool
>= :: DependentAccessForMember -> DependentAccessForMember -> Bool
$cmax :: DependentAccessForMember
-> DependentAccessForMember -> DependentAccessForMember
max :: DependentAccessForMember
-> DependentAccessForMember -> DependentAccessForMember
$cmin :: DependentAccessForMember
-> DependentAccessForMember -> DependentAccessForMember
min :: DependentAccessForMember
-> DependentAccessForMember -> DependentAccessForMember
Ord, ReadPrec [DependentAccessForMember]
ReadPrec DependentAccessForMember
Int -> ReadS DependentAccessForMember
ReadS [DependentAccessForMember]
(Int -> ReadS DependentAccessForMember)
-> ReadS [DependentAccessForMember]
-> ReadPrec DependentAccessForMember
-> ReadPrec [DependentAccessForMember]
-> Read DependentAccessForMember
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DependentAccessForMember
readsPrec :: Int -> ReadS DependentAccessForMember
$creadList :: ReadS [DependentAccessForMember]
readList :: ReadS [DependentAccessForMember]
$creadPrec :: ReadPrec DependentAccessForMember
readPrec :: ReadPrec DependentAccessForMember
$creadListPrec :: ReadPrec [DependentAccessForMember]
readListPrec :: ReadPrec [DependentAccessForMember]
Read, Int -> DependentAccessForMember -> String -> String
[DependentAccessForMember] -> String -> String
DependentAccessForMember -> String
(Int -> DependentAccessForMember -> String -> String)
-> (DependentAccessForMember -> String)
-> ([DependentAccessForMember] -> String -> String)
-> Show DependentAccessForMember
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DependentAccessForMember -> String -> String
showsPrec :: Int -> DependentAccessForMember -> String -> String
$cshow :: DependentAccessForMember -> String
show :: DependentAccessForMember -> String
$cshowList :: [DependentAccessForMember] -> String -> String
showList :: [DependentAccessForMember] -> String -> String
Show)

_DependentAccessForMember :: Name
_DependentAccessForMember = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DependentAccessForMember")

_DependentAccessForMember_identifier :: Name
_DependentAccessForMember_identifier = (String -> Name
Core.Name String
"identifier")

_DependentAccessForMember_typeArguments :: Name
_DependentAccessForMember_typeArguments = (String -> Name
Core.Name String
"typeArguments")

data NullConditionalProjectionInitializer = 
  NullConditionalProjectionInitializer {
    NullConditionalProjectionInitializer -> PrimaryExpression
nullConditionalProjectionInitializerExpression :: PrimaryExpression,
    NullConditionalProjectionInitializer -> Identifier
nullConditionalProjectionInitializerIdentifier :: Identifier,
    NullConditionalProjectionInitializer -> Maybe TypeArgumentList
nullConditionalProjectionInitializerTypeArguments :: (Maybe TypeArgumentList)}
  deriving (NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
(NullConditionalProjectionInitializer
 -> NullConditionalProjectionInitializer -> Bool)
-> (NullConditionalProjectionInitializer
    -> NullConditionalProjectionInitializer -> Bool)
-> Eq NullConditionalProjectionInitializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
== :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
$c/= :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
/= :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
Eq, Eq NullConditionalProjectionInitializer
Eq NullConditionalProjectionInitializer =>
(NullConditionalProjectionInitializer
 -> NullConditionalProjectionInitializer -> Ordering)
-> (NullConditionalProjectionInitializer
    -> NullConditionalProjectionInitializer -> Bool)
-> (NullConditionalProjectionInitializer
    -> NullConditionalProjectionInitializer -> Bool)
-> (NullConditionalProjectionInitializer
    -> NullConditionalProjectionInitializer -> Bool)
-> (NullConditionalProjectionInitializer
    -> NullConditionalProjectionInitializer -> Bool)
-> (NullConditionalProjectionInitializer
    -> NullConditionalProjectionInitializer
    -> NullConditionalProjectionInitializer)
-> (NullConditionalProjectionInitializer
    -> NullConditionalProjectionInitializer
    -> NullConditionalProjectionInitializer)
-> Ord NullConditionalProjectionInitializer
NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Ordering
NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Ordering
compare :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Ordering
$c< :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
< :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
$c<= :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
<= :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
$c> :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
> :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
$c>= :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
>= :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer -> Bool
$cmax :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer
max :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer
$cmin :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer
min :: NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer
-> NullConditionalProjectionInitializer
Ord, ReadPrec [NullConditionalProjectionInitializer]
ReadPrec NullConditionalProjectionInitializer
Int -> ReadS NullConditionalProjectionInitializer
ReadS [NullConditionalProjectionInitializer]
(Int -> ReadS NullConditionalProjectionInitializer)
-> ReadS [NullConditionalProjectionInitializer]
-> ReadPrec NullConditionalProjectionInitializer
-> ReadPrec [NullConditionalProjectionInitializer]
-> Read NullConditionalProjectionInitializer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NullConditionalProjectionInitializer
readsPrec :: Int -> ReadS NullConditionalProjectionInitializer
$creadList :: ReadS [NullConditionalProjectionInitializer]
readList :: ReadS [NullConditionalProjectionInitializer]
$creadPrec :: ReadPrec NullConditionalProjectionInitializer
readPrec :: ReadPrec NullConditionalProjectionInitializer
$creadListPrec :: ReadPrec [NullConditionalProjectionInitializer]
readListPrec :: ReadPrec [NullConditionalProjectionInitializer]
Read, Int -> NullConditionalProjectionInitializer -> String -> String
[NullConditionalProjectionInitializer] -> String -> String
NullConditionalProjectionInitializer -> String
(Int -> NullConditionalProjectionInitializer -> String -> String)
-> (NullConditionalProjectionInitializer -> String)
-> ([NullConditionalProjectionInitializer] -> String -> String)
-> Show NullConditionalProjectionInitializer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NullConditionalProjectionInitializer -> String -> String
showsPrec :: Int -> NullConditionalProjectionInitializer -> String -> String
$cshow :: NullConditionalProjectionInitializer -> String
show :: NullConditionalProjectionInitializer -> String
$cshowList :: [NullConditionalProjectionInitializer] -> String -> String
showList :: [NullConditionalProjectionInitializer] -> String -> String
Show)

_NullConditionalProjectionInitializer :: Name
_NullConditionalProjectionInitializer = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NullConditionalProjectionInitializer")

_NullConditionalProjectionInitializer_expression :: Name
_NullConditionalProjectionInitializer_expression = (String -> Name
Core.Name String
"expression")

_NullConditionalProjectionInitializer_identifier :: Name
_NullConditionalProjectionInitializer_identifier = (String -> Name
Core.Name String
"identifier")

_NullConditionalProjectionInitializer_typeArguments :: Name
_NullConditionalProjectionInitializer_typeArguments = (String -> Name
Core.Name String
"typeArguments")

data InvocationExpression = 
  InvocationExpression {
    InvocationExpression -> PrimaryExpression
invocationExpressionExpression :: PrimaryExpression,
    InvocationExpression -> Maybe ArgumentList
invocationExpressionArguments :: (Maybe ArgumentList)}
  deriving (InvocationExpression -> InvocationExpression -> Bool
(InvocationExpression -> InvocationExpression -> Bool)
-> (InvocationExpression -> InvocationExpression -> Bool)
-> Eq InvocationExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InvocationExpression -> InvocationExpression -> Bool
== :: InvocationExpression -> InvocationExpression -> Bool
$c/= :: InvocationExpression -> InvocationExpression -> Bool
/= :: InvocationExpression -> InvocationExpression -> Bool
Eq, Eq InvocationExpression
Eq InvocationExpression =>
(InvocationExpression -> InvocationExpression -> Ordering)
-> (InvocationExpression -> InvocationExpression -> Bool)
-> (InvocationExpression -> InvocationExpression -> Bool)
-> (InvocationExpression -> InvocationExpression -> Bool)
-> (InvocationExpression -> InvocationExpression -> Bool)
-> (InvocationExpression
    -> InvocationExpression -> InvocationExpression)
-> (InvocationExpression
    -> InvocationExpression -> InvocationExpression)
-> Ord InvocationExpression
InvocationExpression -> InvocationExpression -> Bool
InvocationExpression -> InvocationExpression -> Ordering
InvocationExpression
-> InvocationExpression -> InvocationExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InvocationExpression -> InvocationExpression -> Ordering
compare :: InvocationExpression -> InvocationExpression -> Ordering
$c< :: InvocationExpression -> InvocationExpression -> Bool
< :: InvocationExpression -> InvocationExpression -> Bool
$c<= :: InvocationExpression -> InvocationExpression -> Bool
<= :: InvocationExpression -> InvocationExpression -> Bool
$c> :: InvocationExpression -> InvocationExpression -> Bool
> :: InvocationExpression -> InvocationExpression -> Bool
$c>= :: InvocationExpression -> InvocationExpression -> Bool
>= :: InvocationExpression -> InvocationExpression -> Bool
$cmax :: InvocationExpression
-> InvocationExpression -> InvocationExpression
max :: InvocationExpression
-> InvocationExpression -> InvocationExpression
$cmin :: InvocationExpression
-> InvocationExpression -> InvocationExpression
min :: InvocationExpression
-> InvocationExpression -> InvocationExpression
Ord, ReadPrec [InvocationExpression]
ReadPrec InvocationExpression
Int -> ReadS InvocationExpression
ReadS [InvocationExpression]
(Int -> ReadS InvocationExpression)
-> ReadS [InvocationExpression]
-> ReadPrec InvocationExpression
-> ReadPrec [InvocationExpression]
-> Read InvocationExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InvocationExpression
readsPrec :: Int -> ReadS InvocationExpression
$creadList :: ReadS [InvocationExpression]
readList :: ReadS [InvocationExpression]
$creadPrec :: ReadPrec InvocationExpression
readPrec :: ReadPrec InvocationExpression
$creadListPrec :: ReadPrec [InvocationExpression]
readListPrec :: ReadPrec [InvocationExpression]
Read, Int -> InvocationExpression -> String -> String
[InvocationExpression] -> String -> String
InvocationExpression -> String
(Int -> InvocationExpression -> String -> String)
-> (InvocationExpression -> String)
-> ([InvocationExpression] -> String -> String)
-> Show InvocationExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InvocationExpression -> String -> String
showsPrec :: Int -> InvocationExpression -> String -> String
$cshow :: InvocationExpression -> String
show :: InvocationExpression -> String
$cshowList :: [InvocationExpression] -> String -> String
showList :: [InvocationExpression] -> String -> String
Show)

_InvocationExpression :: Name
_InvocationExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InvocationExpression")

_InvocationExpression_expression :: Name
_InvocationExpression_expression = (String -> Name
Core.Name String
"expression")

_InvocationExpression_arguments :: Name
_InvocationExpression_arguments = (String -> Name
Core.Name String
"arguments")

data NullConditionalInvocationExpression = 
  NullConditionalInvocationExpression {
    NullConditionalInvocationExpression
-> NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHead :: NullConditionalInvocationExpressionHead,
    NullConditionalInvocationExpression -> Maybe ArgumentList
nullConditionalInvocationExpressionArguments :: (Maybe ArgumentList)}
  deriving (NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
(NullConditionalInvocationExpression
 -> NullConditionalInvocationExpression -> Bool)
-> (NullConditionalInvocationExpression
    -> NullConditionalInvocationExpression -> Bool)
-> Eq NullConditionalInvocationExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
== :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
$c/= :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
/= :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
Eq, Eq NullConditionalInvocationExpression
Eq NullConditionalInvocationExpression =>
(NullConditionalInvocationExpression
 -> NullConditionalInvocationExpression -> Ordering)
-> (NullConditionalInvocationExpression
    -> NullConditionalInvocationExpression -> Bool)
-> (NullConditionalInvocationExpression
    -> NullConditionalInvocationExpression -> Bool)
-> (NullConditionalInvocationExpression
    -> NullConditionalInvocationExpression -> Bool)
-> (NullConditionalInvocationExpression
    -> NullConditionalInvocationExpression -> Bool)
-> (NullConditionalInvocationExpression
    -> NullConditionalInvocationExpression
    -> NullConditionalInvocationExpression)
-> (NullConditionalInvocationExpression
    -> NullConditionalInvocationExpression
    -> NullConditionalInvocationExpression)
-> Ord NullConditionalInvocationExpression
NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Ordering
NullConditionalInvocationExpression
-> NullConditionalInvocationExpression
-> NullConditionalInvocationExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Ordering
compare :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Ordering
$c< :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
< :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
$c<= :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
<= :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
$c> :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
> :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
$c>= :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
>= :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression -> Bool
$cmax :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression
-> NullConditionalInvocationExpression
max :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression
-> NullConditionalInvocationExpression
$cmin :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression
-> NullConditionalInvocationExpression
min :: NullConditionalInvocationExpression
-> NullConditionalInvocationExpression
-> NullConditionalInvocationExpression
Ord, ReadPrec [NullConditionalInvocationExpression]
ReadPrec NullConditionalInvocationExpression
Int -> ReadS NullConditionalInvocationExpression
ReadS [NullConditionalInvocationExpression]
(Int -> ReadS NullConditionalInvocationExpression)
-> ReadS [NullConditionalInvocationExpression]
-> ReadPrec NullConditionalInvocationExpression
-> ReadPrec [NullConditionalInvocationExpression]
-> Read NullConditionalInvocationExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NullConditionalInvocationExpression
readsPrec :: Int -> ReadS NullConditionalInvocationExpression
$creadList :: ReadS [NullConditionalInvocationExpression]
readList :: ReadS [NullConditionalInvocationExpression]
$creadPrec :: ReadPrec NullConditionalInvocationExpression
readPrec :: ReadPrec NullConditionalInvocationExpression
$creadListPrec :: ReadPrec [NullConditionalInvocationExpression]
readListPrec :: ReadPrec [NullConditionalInvocationExpression]
Read, Int -> NullConditionalInvocationExpression -> String -> String
[NullConditionalInvocationExpression] -> String -> String
NullConditionalInvocationExpression -> String
(Int -> NullConditionalInvocationExpression -> String -> String)
-> (NullConditionalInvocationExpression -> String)
-> ([NullConditionalInvocationExpression] -> String -> String)
-> Show NullConditionalInvocationExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NullConditionalInvocationExpression -> String -> String
showsPrec :: Int -> NullConditionalInvocationExpression -> String -> String
$cshow :: NullConditionalInvocationExpression -> String
show :: NullConditionalInvocationExpression -> String
$cshowList :: [NullConditionalInvocationExpression] -> String -> String
showList :: [NullConditionalInvocationExpression] -> String -> String
Show)

_NullConditionalInvocationExpression :: Name
_NullConditionalInvocationExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NullConditionalInvocationExpression")

_NullConditionalInvocationExpression_head :: Name
_NullConditionalInvocationExpression_head = (String -> Name
Core.Name String
"head")

_NullConditionalInvocationExpression_arguments :: Name
_NullConditionalInvocationExpression_arguments = (String -> Name
Core.Name String
"arguments")

data NullConditionalInvocationExpressionHead = 
  NullConditionalInvocationExpressionHeadMember NullConditionalMemberAccess |
  NullConditionalInvocationExpressionHeadElement NullConditionalElementAccess
  deriving (NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
(NullConditionalInvocationExpressionHead
 -> NullConditionalInvocationExpressionHead -> Bool)
-> (NullConditionalInvocationExpressionHead
    -> NullConditionalInvocationExpressionHead -> Bool)
-> Eq NullConditionalInvocationExpressionHead
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
== :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
$c/= :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
/= :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
Eq, Eq NullConditionalInvocationExpressionHead
Eq NullConditionalInvocationExpressionHead =>
(NullConditionalInvocationExpressionHead
 -> NullConditionalInvocationExpressionHead -> Ordering)
-> (NullConditionalInvocationExpressionHead
    -> NullConditionalInvocationExpressionHead -> Bool)
-> (NullConditionalInvocationExpressionHead
    -> NullConditionalInvocationExpressionHead -> Bool)
-> (NullConditionalInvocationExpressionHead
    -> NullConditionalInvocationExpressionHead -> Bool)
-> (NullConditionalInvocationExpressionHead
    -> NullConditionalInvocationExpressionHead -> Bool)
-> (NullConditionalInvocationExpressionHead
    -> NullConditionalInvocationExpressionHead
    -> NullConditionalInvocationExpressionHead)
-> (NullConditionalInvocationExpressionHead
    -> NullConditionalInvocationExpressionHead
    -> NullConditionalInvocationExpressionHead)
-> Ord NullConditionalInvocationExpressionHead
NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Ordering
NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Ordering
compare :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Ordering
$c< :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
< :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
$c<= :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
<= :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
$c> :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
> :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
$c>= :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
>= :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead -> Bool
$cmax :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead
max :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead
$cmin :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead
min :: NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead
-> NullConditionalInvocationExpressionHead
Ord, ReadPrec [NullConditionalInvocationExpressionHead]
ReadPrec NullConditionalInvocationExpressionHead
Int -> ReadS NullConditionalInvocationExpressionHead
ReadS [NullConditionalInvocationExpressionHead]
(Int -> ReadS NullConditionalInvocationExpressionHead)
-> ReadS [NullConditionalInvocationExpressionHead]
-> ReadPrec NullConditionalInvocationExpressionHead
-> ReadPrec [NullConditionalInvocationExpressionHead]
-> Read NullConditionalInvocationExpressionHead
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NullConditionalInvocationExpressionHead
readsPrec :: Int -> ReadS NullConditionalInvocationExpressionHead
$creadList :: ReadS [NullConditionalInvocationExpressionHead]
readList :: ReadS [NullConditionalInvocationExpressionHead]
$creadPrec :: ReadPrec NullConditionalInvocationExpressionHead
readPrec :: ReadPrec NullConditionalInvocationExpressionHead
$creadListPrec :: ReadPrec [NullConditionalInvocationExpressionHead]
readListPrec :: ReadPrec [NullConditionalInvocationExpressionHead]
Read, Int -> NullConditionalInvocationExpressionHead -> String -> String
[NullConditionalInvocationExpressionHead] -> String -> String
NullConditionalInvocationExpressionHead -> String
(Int
 -> NullConditionalInvocationExpressionHead -> String -> String)
-> (NullConditionalInvocationExpressionHead -> String)
-> ([NullConditionalInvocationExpressionHead] -> String -> String)
-> Show NullConditionalInvocationExpressionHead
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NullConditionalInvocationExpressionHead -> String -> String
showsPrec :: Int -> NullConditionalInvocationExpressionHead -> String -> String
$cshow :: NullConditionalInvocationExpressionHead -> String
show :: NullConditionalInvocationExpressionHead -> String
$cshowList :: [NullConditionalInvocationExpressionHead] -> String -> String
showList :: [NullConditionalInvocationExpressionHead] -> String -> String
Show)

_NullConditionalInvocationExpressionHead :: Name
_NullConditionalInvocationExpressionHead = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NullConditionalInvocationExpressionHead")

_NullConditionalInvocationExpressionHead_member :: Name
_NullConditionalInvocationExpressionHead_member = (String -> Name
Core.Name String
"member")

_NullConditionalInvocationExpressionHead_element :: Name
_NullConditionalInvocationExpressionHead_element = (String -> Name
Core.Name String
"element")

data ElementAccess = 
  ElementAccess {
    ElementAccess -> PrimaryNoArrayCreationExpression
elementAccessExpression :: PrimaryNoArrayCreationExpression,
    ElementAccess -> ArgumentList
elementAccessArguments :: ArgumentList}
  deriving (ElementAccess -> ElementAccess -> Bool
(ElementAccess -> ElementAccess -> Bool)
-> (ElementAccess -> ElementAccess -> Bool) -> Eq ElementAccess
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ElementAccess -> ElementAccess -> Bool
== :: ElementAccess -> ElementAccess -> Bool
$c/= :: ElementAccess -> ElementAccess -> Bool
/= :: ElementAccess -> ElementAccess -> Bool
Eq, Eq ElementAccess
Eq ElementAccess =>
(ElementAccess -> ElementAccess -> Ordering)
-> (ElementAccess -> ElementAccess -> Bool)
-> (ElementAccess -> ElementAccess -> Bool)
-> (ElementAccess -> ElementAccess -> Bool)
-> (ElementAccess -> ElementAccess -> Bool)
-> (ElementAccess -> ElementAccess -> ElementAccess)
-> (ElementAccess -> ElementAccess -> ElementAccess)
-> Ord ElementAccess
ElementAccess -> ElementAccess -> Bool
ElementAccess -> ElementAccess -> Ordering
ElementAccess -> ElementAccess -> ElementAccess
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ElementAccess -> ElementAccess -> Ordering
compare :: ElementAccess -> ElementAccess -> Ordering
$c< :: ElementAccess -> ElementAccess -> Bool
< :: ElementAccess -> ElementAccess -> Bool
$c<= :: ElementAccess -> ElementAccess -> Bool
<= :: ElementAccess -> ElementAccess -> Bool
$c> :: ElementAccess -> ElementAccess -> Bool
> :: ElementAccess -> ElementAccess -> Bool
$c>= :: ElementAccess -> ElementAccess -> Bool
>= :: ElementAccess -> ElementAccess -> Bool
$cmax :: ElementAccess -> ElementAccess -> ElementAccess
max :: ElementAccess -> ElementAccess -> ElementAccess
$cmin :: ElementAccess -> ElementAccess -> ElementAccess
min :: ElementAccess -> ElementAccess -> ElementAccess
Ord, ReadPrec [ElementAccess]
ReadPrec ElementAccess
Int -> ReadS ElementAccess
ReadS [ElementAccess]
(Int -> ReadS ElementAccess)
-> ReadS [ElementAccess]
-> ReadPrec ElementAccess
-> ReadPrec [ElementAccess]
-> Read ElementAccess
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ElementAccess
readsPrec :: Int -> ReadS ElementAccess
$creadList :: ReadS [ElementAccess]
readList :: ReadS [ElementAccess]
$creadPrec :: ReadPrec ElementAccess
readPrec :: ReadPrec ElementAccess
$creadListPrec :: ReadPrec [ElementAccess]
readListPrec :: ReadPrec [ElementAccess]
Read, Int -> ElementAccess -> String -> String
[ElementAccess] -> String -> String
ElementAccess -> String
(Int -> ElementAccess -> String -> String)
-> (ElementAccess -> String)
-> ([ElementAccess] -> String -> String)
-> Show ElementAccess
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ElementAccess -> String -> String
showsPrec :: Int -> ElementAccess -> String -> String
$cshow :: ElementAccess -> String
show :: ElementAccess -> String
$cshowList :: [ElementAccess] -> String -> String
showList :: [ElementAccess] -> String -> String
Show)

_ElementAccess :: Name
_ElementAccess = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ElementAccess")

_ElementAccess_expression :: Name
_ElementAccess_expression = (String -> Name
Core.Name String
"expression")

_ElementAccess_arguments :: Name
_ElementAccess_arguments = (String -> Name
Core.Name String
"arguments")

data NullConditionalElementAccess = 
  NullConditionalElementAccess {
    NullConditionalElementAccess -> PrimaryNoArrayCreationExpression
nullConditionalElementAccessExpression :: PrimaryNoArrayCreationExpression,
    NullConditionalElementAccess -> ArgumentList
nullConditionalElementAccessArguments :: ArgumentList,
    NullConditionalElementAccess -> [DependentAccess]
nullConditionalElementAccessDependentAccess :: [DependentAccess]}
  deriving (NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
(NullConditionalElementAccess
 -> NullConditionalElementAccess -> Bool)
-> (NullConditionalElementAccess
    -> NullConditionalElementAccess -> Bool)
-> Eq NullConditionalElementAccess
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
== :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
$c/= :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
/= :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
Eq, Eq NullConditionalElementAccess
Eq NullConditionalElementAccess =>
(NullConditionalElementAccess
 -> NullConditionalElementAccess -> Ordering)
-> (NullConditionalElementAccess
    -> NullConditionalElementAccess -> Bool)
-> (NullConditionalElementAccess
    -> NullConditionalElementAccess -> Bool)
-> (NullConditionalElementAccess
    -> NullConditionalElementAccess -> Bool)
-> (NullConditionalElementAccess
    -> NullConditionalElementAccess -> Bool)
-> (NullConditionalElementAccess
    -> NullConditionalElementAccess -> NullConditionalElementAccess)
-> (NullConditionalElementAccess
    -> NullConditionalElementAccess -> NullConditionalElementAccess)
-> Ord NullConditionalElementAccess
NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
NullConditionalElementAccess
-> NullConditionalElementAccess -> Ordering
NullConditionalElementAccess
-> NullConditionalElementAccess -> NullConditionalElementAccess
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Ordering
compare :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Ordering
$c< :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
< :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
$c<= :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
<= :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
$c> :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
> :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
$c>= :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
>= :: NullConditionalElementAccess
-> NullConditionalElementAccess -> Bool
$cmax :: NullConditionalElementAccess
-> NullConditionalElementAccess -> NullConditionalElementAccess
max :: NullConditionalElementAccess
-> NullConditionalElementAccess -> NullConditionalElementAccess
$cmin :: NullConditionalElementAccess
-> NullConditionalElementAccess -> NullConditionalElementAccess
min :: NullConditionalElementAccess
-> NullConditionalElementAccess -> NullConditionalElementAccess
Ord, ReadPrec [NullConditionalElementAccess]
ReadPrec NullConditionalElementAccess
Int -> ReadS NullConditionalElementAccess
ReadS [NullConditionalElementAccess]
(Int -> ReadS NullConditionalElementAccess)
-> ReadS [NullConditionalElementAccess]
-> ReadPrec NullConditionalElementAccess
-> ReadPrec [NullConditionalElementAccess]
-> Read NullConditionalElementAccess
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NullConditionalElementAccess
readsPrec :: Int -> ReadS NullConditionalElementAccess
$creadList :: ReadS [NullConditionalElementAccess]
readList :: ReadS [NullConditionalElementAccess]
$creadPrec :: ReadPrec NullConditionalElementAccess
readPrec :: ReadPrec NullConditionalElementAccess
$creadListPrec :: ReadPrec [NullConditionalElementAccess]
readListPrec :: ReadPrec [NullConditionalElementAccess]
Read, Int -> NullConditionalElementAccess -> String -> String
[NullConditionalElementAccess] -> String -> String
NullConditionalElementAccess -> String
(Int -> NullConditionalElementAccess -> String -> String)
-> (NullConditionalElementAccess -> String)
-> ([NullConditionalElementAccess] -> String -> String)
-> Show NullConditionalElementAccess
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NullConditionalElementAccess -> String -> String
showsPrec :: Int -> NullConditionalElementAccess -> String -> String
$cshow :: NullConditionalElementAccess -> String
show :: NullConditionalElementAccess -> String
$cshowList :: [NullConditionalElementAccess] -> String -> String
showList :: [NullConditionalElementAccess] -> String -> String
Show)

_NullConditionalElementAccess :: Name
_NullConditionalElementAccess = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NullConditionalElementAccess")

_NullConditionalElementAccess_expression :: Name
_NullConditionalElementAccess_expression = (String -> Name
Core.Name String
"expression")

_NullConditionalElementAccess_arguments :: Name
_NullConditionalElementAccess_arguments = (String -> Name
Core.Name String
"arguments")

_NullConditionalElementAccess_dependentAccess :: Name
_NullConditionalElementAccess_dependentAccess = (String -> Name
Core.Name String
"dependentAccess")

data BaseAccess = 
  BaseAccessIdentifier BaseAccessWithIdentifier |
  BaseAccessArguments ArgumentList
  deriving (BaseAccess -> BaseAccess -> Bool
(BaseAccess -> BaseAccess -> Bool)
-> (BaseAccess -> BaseAccess -> Bool) -> Eq BaseAccess
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BaseAccess -> BaseAccess -> Bool
== :: BaseAccess -> BaseAccess -> Bool
$c/= :: BaseAccess -> BaseAccess -> Bool
/= :: BaseAccess -> BaseAccess -> Bool
Eq, Eq BaseAccess
Eq BaseAccess =>
(BaseAccess -> BaseAccess -> Ordering)
-> (BaseAccess -> BaseAccess -> Bool)
-> (BaseAccess -> BaseAccess -> Bool)
-> (BaseAccess -> BaseAccess -> Bool)
-> (BaseAccess -> BaseAccess -> Bool)
-> (BaseAccess -> BaseAccess -> BaseAccess)
-> (BaseAccess -> BaseAccess -> BaseAccess)
-> Ord BaseAccess
BaseAccess -> BaseAccess -> Bool
BaseAccess -> BaseAccess -> Ordering
BaseAccess -> BaseAccess -> BaseAccess
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BaseAccess -> BaseAccess -> Ordering
compare :: BaseAccess -> BaseAccess -> Ordering
$c< :: BaseAccess -> BaseAccess -> Bool
< :: BaseAccess -> BaseAccess -> Bool
$c<= :: BaseAccess -> BaseAccess -> Bool
<= :: BaseAccess -> BaseAccess -> Bool
$c> :: BaseAccess -> BaseAccess -> Bool
> :: BaseAccess -> BaseAccess -> Bool
$c>= :: BaseAccess -> BaseAccess -> Bool
>= :: BaseAccess -> BaseAccess -> Bool
$cmax :: BaseAccess -> BaseAccess -> BaseAccess
max :: BaseAccess -> BaseAccess -> BaseAccess
$cmin :: BaseAccess -> BaseAccess -> BaseAccess
min :: BaseAccess -> BaseAccess -> BaseAccess
Ord, ReadPrec [BaseAccess]
ReadPrec BaseAccess
Int -> ReadS BaseAccess
ReadS [BaseAccess]
(Int -> ReadS BaseAccess)
-> ReadS [BaseAccess]
-> ReadPrec BaseAccess
-> ReadPrec [BaseAccess]
-> Read BaseAccess
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BaseAccess
readsPrec :: Int -> ReadS BaseAccess
$creadList :: ReadS [BaseAccess]
readList :: ReadS [BaseAccess]
$creadPrec :: ReadPrec BaseAccess
readPrec :: ReadPrec BaseAccess
$creadListPrec :: ReadPrec [BaseAccess]
readListPrec :: ReadPrec [BaseAccess]
Read, Int -> BaseAccess -> String -> String
[BaseAccess] -> String -> String
BaseAccess -> String
(Int -> BaseAccess -> String -> String)
-> (BaseAccess -> String)
-> ([BaseAccess] -> String -> String)
-> Show BaseAccess
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BaseAccess -> String -> String
showsPrec :: Int -> BaseAccess -> String -> String
$cshow :: BaseAccess -> String
show :: BaseAccess -> String
$cshowList :: [BaseAccess] -> String -> String
showList :: [BaseAccess] -> String -> String
Show)

_BaseAccess :: Name
_BaseAccess = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BaseAccess")

_BaseAccess_identifier :: Name
_BaseAccess_identifier = (String -> Name
Core.Name String
"identifier")

_BaseAccess_arguments :: Name
_BaseAccess_arguments = (String -> Name
Core.Name String
"arguments")

data BaseAccessWithIdentifier = 
  BaseAccessWithIdentifier {
    BaseAccessWithIdentifier -> Identifier
baseAccessWithIdentifierIdentifier :: Identifier,
    BaseAccessWithIdentifier -> Maybe TypeArgumentList
baseAccessWithIdentifierTypeArguments :: (Maybe TypeArgumentList)}
  deriving (BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
(BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool)
-> (BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool)
-> Eq BaseAccessWithIdentifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
== :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
$c/= :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
/= :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
Eq, Eq BaseAccessWithIdentifier
Eq BaseAccessWithIdentifier =>
(BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Ordering)
-> (BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool)
-> (BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool)
-> (BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool)
-> (BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool)
-> (BaseAccessWithIdentifier
    -> BaseAccessWithIdentifier -> BaseAccessWithIdentifier)
-> (BaseAccessWithIdentifier
    -> BaseAccessWithIdentifier -> BaseAccessWithIdentifier)
-> Ord BaseAccessWithIdentifier
BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Ordering
BaseAccessWithIdentifier
-> BaseAccessWithIdentifier -> BaseAccessWithIdentifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Ordering
compare :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Ordering
$c< :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
< :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
$c<= :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
<= :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
$c> :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
> :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
$c>= :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
>= :: BaseAccessWithIdentifier -> BaseAccessWithIdentifier -> Bool
$cmax :: BaseAccessWithIdentifier
-> BaseAccessWithIdentifier -> BaseAccessWithIdentifier
max :: BaseAccessWithIdentifier
-> BaseAccessWithIdentifier -> BaseAccessWithIdentifier
$cmin :: BaseAccessWithIdentifier
-> BaseAccessWithIdentifier -> BaseAccessWithIdentifier
min :: BaseAccessWithIdentifier
-> BaseAccessWithIdentifier -> BaseAccessWithIdentifier
Ord, ReadPrec [BaseAccessWithIdentifier]
ReadPrec BaseAccessWithIdentifier
Int -> ReadS BaseAccessWithIdentifier
ReadS [BaseAccessWithIdentifier]
(Int -> ReadS BaseAccessWithIdentifier)
-> ReadS [BaseAccessWithIdentifier]
-> ReadPrec BaseAccessWithIdentifier
-> ReadPrec [BaseAccessWithIdentifier]
-> Read BaseAccessWithIdentifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BaseAccessWithIdentifier
readsPrec :: Int -> ReadS BaseAccessWithIdentifier
$creadList :: ReadS [BaseAccessWithIdentifier]
readList :: ReadS [BaseAccessWithIdentifier]
$creadPrec :: ReadPrec BaseAccessWithIdentifier
readPrec :: ReadPrec BaseAccessWithIdentifier
$creadListPrec :: ReadPrec [BaseAccessWithIdentifier]
readListPrec :: ReadPrec [BaseAccessWithIdentifier]
Read, Int -> BaseAccessWithIdentifier -> String -> String
[BaseAccessWithIdentifier] -> String -> String
BaseAccessWithIdentifier -> String
(Int -> BaseAccessWithIdentifier -> String -> String)
-> (BaseAccessWithIdentifier -> String)
-> ([BaseAccessWithIdentifier] -> String -> String)
-> Show BaseAccessWithIdentifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BaseAccessWithIdentifier -> String -> String
showsPrec :: Int -> BaseAccessWithIdentifier -> String -> String
$cshow :: BaseAccessWithIdentifier -> String
show :: BaseAccessWithIdentifier -> String
$cshowList :: [BaseAccessWithIdentifier] -> String -> String
showList :: [BaseAccessWithIdentifier] -> String -> String
Show)

_BaseAccessWithIdentifier :: Name
_BaseAccessWithIdentifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BaseAccessWithIdentifier")

_BaseAccessWithIdentifier_identifier :: Name
_BaseAccessWithIdentifier_identifier = (String -> Name
Core.Name String
"identifier")

_BaseAccessWithIdentifier_typeArguments :: Name
_BaseAccessWithIdentifier_typeArguments = (String -> Name
Core.Name String
"typeArguments")

data ObjectCreationExpression = 
  ObjectCreationExpression {
    ObjectCreationExpression -> Type
objectCreationExpressionType :: Type,
    ObjectCreationExpression -> Maybe ArgumentList
objectCreationExpressionArguments :: (Maybe ArgumentList),
    ObjectCreationExpression -> Maybe ObjectOrCollectionInitializer
objectCreationExpressionInitializer :: (Maybe ObjectOrCollectionInitializer)}
  deriving (ObjectCreationExpression -> ObjectCreationExpression -> Bool
(ObjectCreationExpression -> ObjectCreationExpression -> Bool)
-> (ObjectCreationExpression -> ObjectCreationExpression -> Bool)
-> Eq ObjectCreationExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
== :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
$c/= :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
/= :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
Eq, Eq ObjectCreationExpression
Eq ObjectCreationExpression =>
(ObjectCreationExpression -> ObjectCreationExpression -> Ordering)
-> (ObjectCreationExpression -> ObjectCreationExpression -> Bool)
-> (ObjectCreationExpression -> ObjectCreationExpression -> Bool)
-> (ObjectCreationExpression -> ObjectCreationExpression -> Bool)
-> (ObjectCreationExpression -> ObjectCreationExpression -> Bool)
-> (ObjectCreationExpression
    -> ObjectCreationExpression -> ObjectCreationExpression)
-> (ObjectCreationExpression
    -> ObjectCreationExpression -> ObjectCreationExpression)
-> Ord ObjectCreationExpression
ObjectCreationExpression -> ObjectCreationExpression -> Bool
ObjectCreationExpression -> ObjectCreationExpression -> Ordering
ObjectCreationExpression
-> ObjectCreationExpression -> ObjectCreationExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ObjectCreationExpression -> ObjectCreationExpression -> Ordering
compare :: ObjectCreationExpression -> ObjectCreationExpression -> Ordering
$c< :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
< :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
$c<= :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
<= :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
$c> :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
> :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
$c>= :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
>= :: ObjectCreationExpression -> ObjectCreationExpression -> Bool
$cmax :: ObjectCreationExpression
-> ObjectCreationExpression -> ObjectCreationExpression
max :: ObjectCreationExpression
-> ObjectCreationExpression -> ObjectCreationExpression
$cmin :: ObjectCreationExpression
-> ObjectCreationExpression -> ObjectCreationExpression
min :: ObjectCreationExpression
-> ObjectCreationExpression -> ObjectCreationExpression
Ord, ReadPrec [ObjectCreationExpression]
ReadPrec ObjectCreationExpression
Int -> ReadS ObjectCreationExpression
ReadS [ObjectCreationExpression]
(Int -> ReadS ObjectCreationExpression)
-> ReadS [ObjectCreationExpression]
-> ReadPrec ObjectCreationExpression
-> ReadPrec [ObjectCreationExpression]
-> Read ObjectCreationExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ObjectCreationExpression
readsPrec :: Int -> ReadS ObjectCreationExpression
$creadList :: ReadS [ObjectCreationExpression]
readList :: ReadS [ObjectCreationExpression]
$creadPrec :: ReadPrec ObjectCreationExpression
readPrec :: ReadPrec ObjectCreationExpression
$creadListPrec :: ReadPrec [ObjectCreationExpression]
readListPrec :: ReadPrec [ObjectCreationExpression]
Read, Int -> ObjectCreationExpression -> String -> String
[ObjectCreationExpression] -> String -> String
ObjectCreationExpression -> String
(Int -> ObjectCreationExpression -> String -> String)
-> (ObjectCreationExpression -> String)
-> ([ObjectCreationExpression] -> String -> String)
-> Show ObjectCreationExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ObjectCreationExpression -> String -> String
showsPrec :: Int -> ObjectCreationExpression -> String -> String
$cshow :: ObjectCreationExpression -> String
show :: ObjectCreationExpression -> String
$cshowList :: [ObjectCreationExpression] -> String -> String
showList :: [ObjectCreationExpression] -> String -> String
Show)

_ObjectCreationExpression :: Name
_ObjectCreationExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ObjectCreationExpression")

_ObjectCreationExpression_type :: Name
_ObjectCreationExpression_type = (String -> Name
Core.Name String
"type")

_ObjectCreationExpression_arguments :: Name
_ObjectCreationExpression_arguments = (String -> Name
Core.Name String
"arguments")

_ObjectCreationExpression_initializer :: Name
_ObjectCreationExpression_initializer = (String -> Name
Core.Name String
"initializer")

data ObjectOrCollectionInitializer = 
  ObjectOrCollectionInitializerObject [MemberInitializer] |
  ObjectOrCollectionInitializerCollection [ElementInitializer]
  deriving (ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
(ObjectOrCollectionInitializer
 -> ObjectOrCollectionInitializer -> Bool)
-> (ObjectOrCollectionInitializer
    -> ObjectOrCollectionInitializer -> Bool)
-> Eq ObjectOrCollectionInitializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
== :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
$c/= :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
/= :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
Eq, Eq ObjectOrCollectionInitializer
Eq ObjectOrCollectionInitializer =>
(ObjectOrCollectionInitializer
 -> ObjectOrCollectionInitializer -> Ordering)
-> (ObjectOrCollectionInitializer
    -> ObjectOrCollectionInitializer -> Bool)
-> (ObjectOrCollectionInitializer
    -> ObjectOrCollectionInitializer -> Bool)
-> (ObjectOrCollectionInitializer
    -> ObjectOrCollectionInitializer -> Bool)
-> (ObjectOrCollectionInitializer
    -> ObjectOrCollectionInitializer -> Bool)
-> (ObjectOrCollectionInitializer
    -> ObjectOrCollectionInitializer -> ObjectOrCollectionInitializer)
-> (ObjectOrCollectionInitializer
    -> ObjectOrCollectionInitializer -> ObjectOrCollectionInitializer)
-> Ord ObjectOrCollectionInitializer
ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Ordering
ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> ObjectOrCollectionInitializer
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Ordering
compare :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Ordering
$c< :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
< :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
$c<= :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
<= :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
$c> :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
> :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
$c>= :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
>= :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> Bool
$cmax :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> ObjectOrCollectionInitializer
max :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> ObjectOrCollectionInitializer
$cmin :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> ObjectOrCollectionInitializer
min :: ObjectOrCollectionInitializer
-> ObjectOrCollectionInitializer -> ObjectOrCollectionInitializer
Ord, ReadPrec [ObjectOrCollectionInitializer]
ReadPrec ObjectOrCollectionInitializer
Int -> ReadS ObjectOrCollectionInitializer
ReadS [ObjectOrCollectionInitializer]
(Int -> ReadS ObjectOrCollectionInitializer)
-> ReadS [ObjectOrCollectionInitializer]
-> ReadPrec ObjectOrCollectionInitializer
-> ReadPrec [ObjectOrCollectionInitializer]
-> Read ObjectOrCollectionInitializer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ObjectOrCollectionInitializer
readsPrec :: Int -> ReadS ObjectOrCollectionInitializer
$creadList :: ReadS [ObjectOrCollectionInitializer]
readList :: ReadS [ObjectOrCollectionInitializer]
$creadPrec :: ReadPrec ObjectOrCollectionInitializer
readPrec :: ReadPrec ObjectOrCollectionInitializer
$creadListPrec :: ReadPrec [ObjectOrCollectionInitializer]
readListPrec :: ReadPrec [ObjectOrCollectionInitializer]
Read, Int -> ObjectOrCollectionInitializer -> String -> String
[ObjectOrCollectionInitializer] -> String -> String
ObjectOrCollectionInitializer -> String
(Int -> ObjectOrCollectionInitializer -> String -> String)
-> (ObjectOrCollectionInitializer -> String)
-> ([ObjectOrCollectionInitializer] -> String -> String)
-> Show ObjectOrCollectionInitializer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ObjectOrCollectionInitializer -> String -> String
showsPrec :: Int -> ObjectOrCollectionInitializer -> String -> String
$cshow :: ObjectOrCollectionInitializer -> String
show :: ObjectOrCollectionInitializer -> String
$cshowList :: [ObjectOrCollectionInitializer] -> String -> String
showList :: [ObjectOrCollectionInitializer] -> String -> String
Show)

_ObjectOrCollectionInitializer :: Name
_ObjectOrCollectionInitializer = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ObjectOrCollectionInitializer")

_ObjectOrCollectionInitializer_object :: Name
_ObjectOrCollectionInitializer_object = (String -> Name
Core.Name String
"object")

_ObjectOrCollectionInitializer_collection :: Name
_ObjectOrCollectionInitializer_collection = (String -> Name
Core.Name String
"collection")

data MemberInitializer = 
  MemberInitializer {
    MemberInitializer -> InitializerTarget
memberInitializerTarget :: InitializerTarget,
    MemberInitializer -> InitializerValue
memberInitializerValue :: InitializerValue}
  deriving (MemberInitializer -> MemberInitializer -> Bool
(MemberInitializer -> MemberInitializer -> Bool)
-> (MemberInitializer -> MemberInitializer -> Bool)
-> Eq MemberInitializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemberInitializer -> MemberInitializer -> Bool
== :: MemberInitializer -> MemberInitializer -> Bool
$c/= :: MemberInitializer -> MemberInitializer -> Bool
/= :: MemberInitializer -> MemberInitializer -> Bool
Eq, Eq MemberInitializer
Eq MemberInitializer =>
(MemberInitializer -> MemberInitializer -> Ordering)
-> (MemberInitializer -> MemberInitializer -> Bool)
-> (MemberInitializer -> MemberInitializer -> Bool)
-> (MemberInitializer -> MemberInitializer -> Bool)
-> (MemberInitializer -> MemberInitializer -> Bool)
-> (MemberInitializer -> MemberInitializer -> MemberInitializer)
-> (MemberInitializer -> MemberInitializer -> MemberInitializer)
-> Ord MemberInitializer
MemberInitializer -> MemberInitializer -> Bool
MemberInitializer -> MemberInitializer -> Ordering
MemberInitializer -> MemberInitializer -> MemberInitializer
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MemberInitializer -> MemberInitializer -> Ordering
compare :: MemberInitializer -> MemberInitializer -> Ordering
$c< :: MemberInitializer -> MemberInitializer -> Bool
< :: MemberInitializer -> MemberInitializer -> Bool
$c<= :: MemberInitializer -> MemberInitializer -> Bool
<= :: MemberInitializer -> MemberInitializer -> Bool
$c> :: MemberInitializer -> MemberInitializer -> Bool
> :: MemberInitializer -> MemberInitializer -> Bool
$c>= :: MemberInitializer -> MemberInitializer -> Bool
>= :: MemberInitializer -> MemberInitializer -> Bool
$cmax :: MemberInitializer -> MemberInitializer -> MemberInitializer
max :: MemberInitializer -> MemberInitializer -> MemberInitializer
$cmin :: MemberInitializer -> MemberInitializer -> MemberInitializer
min :: MemberInitializer -> MemberInitializer -> MemberInitializer
Ord, ReadPrec [MemberInitializer]
ReadPrec MemberInitializer
Int -> ReadS MemberInitializer
ReadS [MemberInitializer]
(Int -> ReadS MemberInitializer)
-> ReadS [MemberInitializer]
-> ReadPrec MemberInitializer
-> ReadPrec [MemberInitializer]
-> Read MemberInitializer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MemberInitializer
readsPrec :: Int -> ReadS MemberInitializer
$creadList :: ReadS [MemberInitializer]
readList :: ReadS [MemberInitializer]
$creadPrec :: ReadPrec MemberInitializer
readPrec :: ReadPrec MemberInitializer
$creadListPrec :: ReadPrec [MemberInitializer]
readListPrec :: ReadPrec [MemberInitializer]
Read, Int -> MemberInitializer -> String -> String
[MemberInitializer] -> String -> String
MemberInitializer -> String
(Int -> MemberInitializer -> String -> String)
-> (MemberInitializer -> String)
-> ([MemberInitializer] -> String -> String)
-> Show MemberInitializer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MemberInitializer -> String -> String
showsPrec :: Int -> MemberInitializer -> String -> String
$cshow :: MemberInitializer -> String
show :: MemberInitializer -> String
$cshowList :: [MemberInitializer] -> String -> String
showList :: [MemberInitializer] -> String -> String
Show)

_MemberInitializer :: Name
_MemberInitializer = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MemberInitializer")

_MemberInitializer_target :: Name
_MemberInitializer_target = (String -> Name
Core.Name String
"target")

_MemberInitializer_value :: Name
_MemberInitializer_value = (String -> Name
Core.Name String
"value")

data InitializerTarget = 
  InitializerTargetIdentifier Identifier |
  InitializerTargetArguments ArgumentList
  deriving (InitializerTarget -> InitializerTarget -> Bool
(InitializerTarget -> InitializerTarget -> Bool)
-> (InitializerTarget -> InitializerTarget -> Bool)
-> Eq InitializerTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InitializerTarget -> InitializerTarget -> Bool
== :: InitializerTarget -> InitializerTarget -> Bool
$c/= :: InitializerTarget -> InitializerTarget -> Bool
/= :: InitializerTarget -> InitializerTarget -> Bool
Eq, Eq InitializerTarget
Eq InitializerTarget =>
(InitializerTarget -> InitializerTarget -> Ordering)
-> (InitializerTarget -> InitializerTarget -> Bool)
-> (InitializerTarget -> InitializerTarget -> Bool)
-> (InitializerTarget -> InitializerTarget -> Bool)
-> (InitializerTarget -> InitializerTarget -> Bool)
-> (InitializerTarget -> InitializerTarget -> InitializerTarget)
-> (InitializerTarget -> InitializerTarget -> InitializerTarget)
-> Ord InitializerTarget
InitializerTarget -> InitializerTarget -> Bool
InitializerTarget -> InitializerTarget -> Ordering
InitializerTarget -> InitializerTarget -> InitializerTarget
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InitializerTarget -> InitializerTarget -> Ordering
compare :: InitializerTarget -> InitializerTarget -> Ordering
$c< :: InitializerTarget -> InitializerTarget -> Bool
< :: InitializerTarget -> InitializerTarget -> Bool
$c<= :: InitializerTarget -> InitializerTarget -> Bool
<= :: InitializerTarget -> InitializerTarget -> Bool
$c> :: InitializerTarget -> InitializerTarget -> Bool
> :: InitializerTarget -> InitializerTarget -> Bool
$c>= :: InitializerTarget -> InitializerTarget -> Bool
>= :: InitializerTarget -> InitializerTarget -> Bool
$cmax :: InitializerTarget -> InitializerTarget -> InitializerTarget
max :: InitializerTarget -> InitializerTarget -> InitializerTarget
$cmin :: InitializerTarget -> InitializerTarget -> InitializerTarget
min :: InitializerTarget -> InitializerTarget -> InitializerTarget
Ord, ReadPrec [InitializerTarget]
ReadPrec InitializerTarget
Int -> ReadS InitializerTarget
ReadS [InitializerTarget]
(Int -> ReadS InitializerTarget)
-> ReadS [InitializerTarget]
-> ReadPrec InitializerTarget
-> ReadPrec [InitializerTarget]
-> Read InitializerTarget
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InitializerTarget
readsPrec :: Int -> ReadS InitializerTarget
$creadList :: ReadS [InitializerTarget]
readList :: ReadS [InitializerTarget]
$creadPrec :: ReadPrec InitializerTarget
readPrec :: ReadPrec InitializerTarget
$creadListPrec :: ReadPrec [InitializerTarget]
readListPrec :: ReadPrec [InitializerTarget]
Read, Int -> InitializerTarget -> String -> String
[InitializerTarget] -> String -> String
InitializerTarget -> String
(Int -> InitializerTarget -> String -> String)
-> (InitializerTarget -> String)
-> ([InitializerTarget] -> String -> String)
-> Show InitializerTarget
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InitializerTarget -> String -> String
showsPrec :: Int -> InitializerTarget -> String -> String
$cshow :: InitializerTarget -> String
show :: InitializerTarget -> String
$cshowList :: [InitializerTarget] -> String -> String
showList :: [InitializerTarget] -> String -> String
Show)

_InitializerTarget :: Name
_InitializerTarget = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InitializerTarget")

_InitializerTarget_identifier :: Name
_InitializerTarget_identifier = (String -> Name
Core.Name String
"identifier")

_InitializerTarget_arguments :: Name
_InitializerTarget_arguments = (String -> Name
Core.Name String
"arguments")

data InitializerValue = 
  InitializerValueExpression Expression |
  InitializerValueObjectOrCollection ObjectOrCollectionInitializer
  deriving (InitializerValue -> InitializerValue -> Bool
(InitializerValue -> InitializerValue -> Bool)
-> (InitializerValue -> InitializerValue -> Bool)
-> Eq InitializerValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InitializerValue -> InitializerValue -> Bool
== :: InitializerValue -> InitializerValue -> Bool
$c/= :: InitializerValue -> InitializerValue -> Bool
/= :: InitializerValue -> InitializerValue -> Bool
Eq, Eq InitializerValue
Eq InitializerValue =>
(InitializerValue -> InitializerValue -> Ordering)
-> (InitializerValue -> InitializerValue -> Bool)
-> (InitializerValue -> InitializerValue -> Bool)
-> (InitializerValue -> InitializerValue -> Bool)
-> (InitializerValue -> InitializerValue -> Bool)
-> (InitializerValue -> InitializerValue -> InitializerValue)
-> (InitializerValue -> InitializerValue -> InitializerValue)
-> Ord InitializerValue
InitializerValue -> InitializerValue -> Bool
InitializerValue -> InitializerValue -> Ordering
InitializerValue -> InitializerValue -> InitializerValue
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InitializerValue -> InitializerValue -> Ordering
compare :: InitializerValue -> InitializerValue -> Ordering
$c< :: InitializerValue -> InitializerValue -> Bool
< :: InitializerValue -> InitializerValue -> Bool
$c<= :: InitializerValue -> InitializerValue -> Bool
<= :: InitializerValue -> InitializerValue -> Bool
$c> :: InitializerValue -> InitializerValue -> Bool
> :: InitializerValue -> InitializerValue -> Bool
$c>= :: InitializerValue -> InitializerValue -> Bool
>= :: InitializerValue -> InitializerValue -> Bool
$cmax :: InitializerValue -> InitializerValue -> InitializerValue
max :: InitializerValue -> InitializerValue -> InitializerValue
$cmin :: InitializerValue -> InitializerValue -> InitializerValue
min :: InitializerValue -> InitializerValue -> InitializerValue
Ord, ReadPrec [InitializerValue]
ReadPrec InitializerValue
Int -> ReadS InitializerValue
ReadS [InitializerValue]
(Int -> ReadS InitializerValue)
-> ReadS [InitializerValue]
-> ReadPrec InitializerValue
-> ReadPrec [InitializerValue]
-> Read InitializerValue
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InitializerValue
readsPrec :: Int -> ReadS InitializerValue
$creadList :: ReadS [InitializerValue]
readList :: ReadS [InitializerValue]
$creadPrec :: ReadPrec InitializerValue
readPrec :: ReadPrec InitializerValue
$creadListPrec :: ReadPrec [InitializerValue]
readListPrec :: ReadPrec [InitializerValue]
Read, Int -> InitializerValue -> String -> String
[InitializerValue] -> String -> String
InitializerValue -> String
(Int -> InitializerValue -> String -> String)
-> (InitializerValue -> String)
-> ([InitializerValue] -> String -> String)
-> Show InitializerValue
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InitializerValue -> String -> String
showsPrec :: Int -> InitializerValue -> String -> String
$cshow :: InitializerValue -> String
show :: InitializerValue -> String
$cshowList :: [InitializerValue] -> String -> String
showList :: [InitializerValue] -> String -> String
Show)

_InitializerValue :: Name
_InitializerValue = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InitializerValue")

_InitializerValue_expression :: Name
_InitializerValue_expression = (String -> Name
Core.Name String
"expression")

_InitializerValue_objectOrCollection :: Name
_InitializerValue_objectOrCollection = (String -> Name
Core.Name String
"objectOrCollection")

data ElementInitializer = 
  ElementInitializerSingle NonAssignmentExpression |
  ElementInitializerList ExpressionList
  deriving (ElementInitializer -> ElementInitializer -> Bool
(ElementInitializer -> ElementInitializer -> Bool)
-> (ElementInitializer -> ElementInitializer -> Bool)
-> Eq ElementInitializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ElementInitializer -> ElementInitializer -> Bool
== :: ElementInitializer -> ElementInitializer -> Bool
$c/= :: ElementInitializer -> ElementInitializer -> Bool
/= :: ElementInitializer -> ElementInitializer -> Bool
Eq, Eq ElementInitializer
Eq ElementInitializer =>
(ElementInitializer -> ElementInitializer -> Ordering)
-> (ElementInitializer -> ElementInitializer -> Bool)
-> (ElementInitializer -> ElementInitializer -> Bool)
-> (ElementInitializer -> ElementInitializer -> Bool)
-> (ElementInitializer -> ElementInitializer -> Bool)
-> (ElementInitializer -> ElementInitializer -> ElementInitializer)
-> (ElementInitializer -> ElementInitializer -> ElementInitializer)
-> Ord ElementInitializer
ElementInitializer -> ElementInitializer -> Bool
ElementInitializer -> ElementInitializer -> Ordering
ElementInitializer -> ElementInitializer -> ElementInitializer
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ElementInitializer -> ElementInitializer -> Ordering
compare :: ElementInitializer -> ElementInitializer -> Ordering
$c< :: ElementInitializer -> ElementInitializer -> Bool
< :: ElementInitializer -> ElementInitializer -> Bool
$c<= :: ElementInitializer -> ElementInitializer -> Bool
<= :: ElementInitializer -> ElementInitializer -> Bool
$c> :: ElementInitializer -> ElementInitializer -> Bool
> :: ElementInitializer -> ElementInitializer -> Bool
$c>= :: ElementInitializer -> ElementInitializer -> Bool
>= :: ElementInitializer -> ElementInitializer -> Bool
$cmax :: ElementInitializer -> ElementInitializer -> ElementInitializer
max :: ElementInitializer -> ElementInitializer -> ElementInitializer
$cmin :: ElementInitializer -> ElementInitializer -> ElementInitializer
min :: ElementInitializer -> ElementInitializer -> ElementInitializer
Ord, ReadPrec [ElementInitializer]
ReadPrec ElementInitializer
Int -> ReadS ElementInitializer
ReadS [ElementInitializer]
(Int -> ReadS ElementInitializer)
-> ReadS [ElementInitializer]
-> ReadPrec ElementInitializer
-> ReadPrec [ElementInitializer]
-> Read ElementInitializer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ElementInitializer
readsPrec :: Int -> ReadS ElementInitializer
$creadList :: ReadS [ElementInitializer]
readList :: ReadS [ElementInitializer]
$creadPrec :: ReadPrec ElementInitializer
readPrec :: ReadPrec ElementInitializer
$creadListPrec :: ReadPrec [ElementInitializer]
readListPrec :: ReadPrec [ElementInitializer]
Read, Int -> ElementInitializer -> String -> String
[ElementInitializer] -> String -> String
ElementInitializer -> String
(Int -> ElementInitializer -> String -> String)
-> (ElementInitializer -> String)
-> ([ElementInitializer] -> String -> String)
-> Show ElementInitializer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ElementInitializer -> String -> String
showsPrec :: Int -> ElementInitializer -> String -> String
$cshow :: ElementInitializer -> String
show :: ElementInitializer -> String
$cshowList :: [ElementInitializer] -> String -> String
showList :: [ElementInitializer] -> String -> String
Show)

_ElementInitializer :: Name
_ElementInitializer = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ElementInitializer")

_ElementInitializer_single :: Name
_ElementInitializer_single = (String -> Name
Core.Name String
"single")

_ElementInitializer_list :: Name
_ElementInitializer_list = (String -> Name
Core.Name String
"list")

newtype ExpressionList = 
  ExpressionList {
    ExpressionList -> [Expression]
unExpressionList :: [Expression]}
  deriving (ExpressionList -> ExpressionList -> Bool
(ExpressionList -> ExpressionList -> Bool)
-> (ExpressionList -> ExpressionList -> Bool) -> Eq ExpressionList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExpressionList -> ExpressionList -> Bool
== :: ExpressionList -> ExpressionList -> Bool
$c/= :: ExpressionList -> ExpressionList -> Bool
/= :: ExpressionList -> ExpressionList -> Bool
Eq, Eq ExpressionList
Eq ExpressionList =>
(ExpressionList -> ExpressionList -> Ordering)
-> (ExpressionList -> ExpressionList -> Bool)
-> (ExpressionList -> ExpressionList -> Bool)
-> (ExpressionList -> ExpressionList -> Bool)
-> (ExpressionList -> ExpressionList -> Bool)
-> (ExpressionList -> ExpressionList -> ExpressionList)
-> (ExpressionList -> ExpressionList -> ExpressionList)
-> Ord ExpressionList
ExpressionList -> ExpressionList -> Bool
ExpressionList -> ExpressionList -> Ordering
ExpressionList -> ExpressionList -> ExpressionList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ExpressionList -> ExpressionList -> Ordering
compare :: ExpressionList -> ExpressionList -> Ordering
$c< :: ExpressionList -> ExpressionList -> Bool
< :: ExpressionList -> ExpressionList -> Bool
$c<= :: ExpressionList -> ExpressionList -> Bool
<= :: ExpressionList -> ExpressionList -> Bool
$c> :: ExpressionList -> ExpressionList -> Bool
> :: ExpressionList -> ExpressionList -> Bool
$c>= :: ExpressionList -> ExpressionList -> Bool
>= :: ExpressionList -> ExpressionList -> Bool
$cmax :: ExpressionList -> ExpressionList -> ExpressionList
max :: ExpressionList -> ExpressionList -> ExpressionList
$cmin :: ExpressionList -> ExpressionList -> ExpressionList
min :: ExpressionList -> ExpressionList -> ExpressionList
Ord, ReadPrec [ExpressionList]
ReadPrec ExpressionList
Int -> ReadS ExpressionList
ReadS [ExpressionList]
(Int -> ReadS ExpressionList)
-> ReadS [ExpressionList]
-> ReadPrec ExpressionList
-> ReadPrec [ExpressionList]
-> Read ExpressionList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExpressionList
readsPrec :: Int -> ReadS ExpressionList
$creadList :: ReadS [ExpressionList]
readList :: ReadS [ExpressionList]
$creadPrec :: ReadPrec ExpressionList
readPrec :: ReadPrec ExpressionList
$creadListPrec :: ReadPrec [ExpressionList]
readListPrec :: ReadPrec [ExpressionList]
Read, Int -> ExpressionList -> String -> String
[ExpressionList] -> String -> String
ExpressionList -> String
(Int -> ExpressionList -> String -> String)
-> (ExpressionList -> String)
-> ([ExpressionList] -> String -> String)
-> Show ExpressionList
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ExpressionList -> String -> String
showsPrec :: Int -> ExpressionList -> String -> String
$cshow :: ExpressionList -> String
show :: ExpressionList -> String
$cshowList :: [ExpressionList] -> String -> String
showList :: [ExpressionList] -> String -> String
Show)

_ExpressionList :: Name
_ExpressionList = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ExpressionList")

data ArrayCreationExpression = 
  ArrayCreationExpressionNonArrayType NonArrayTypeArrayCreationExpression |
  ArrayCreationExpressionArrayType ArrayTypeArrayCreationExpression |
  ArrayCreationExpressionRankSpecifier RankSpecifierArrayCreationExpression
  deriving (ArrayCreationExpression -> ArrayCreationExpression -> Bool
(ArrayCreationExpression -> ArrayCreationExpression -> Bool)
-> (ArrayCreationExpression -> ArrayCreationExpression -> Bool)
-> Eq ArrayCreationExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
== :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
$c/= :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
/= :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
Eq, Eq ArrayCreationExpression
Eq ArrayCreationExpression =>
(ArrayCreationExpression -> ArrayCreationExpression -> Ordering)
-> (ArrayCreationExpression -> ArrayCreationExpression -> Bool)
-> (ArrayCreationExpression -> ArrayCreationExpression -> Bool)
-> (ArrayCreationExpression -> ArrayCreationExpression -> Bool)
-> (ArrayCreationExpression -> ArrayCreationExpression -> Bool)
-> (ArrayCreationExpression
    -> ArrayCreationExpression -> ArrayCreationExpression)
-> (ArrayCreationExpression
    -> ArrayCreationExpression -> ArrayCreationExpression)
-> Ord ArrayCreationExpression
ArrayCreationExpression -> ArrayCreationExpression -> Bool
ArrayCreationExpression -> ArrayCreationExpression -> Ordering
ArrayCreationExpression
-> ArrayCreationExpression -> ArrayCreationExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ArrayCreationExpression -> ArrayCreationExpression -> Ordering
compare :: ArrayCreationExpression -> ArrayCreationExpression -> Ordering
$c< :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
< :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
$c<= :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
<= :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
$c> :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
> :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
$c>= :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
>= :: ArrayCreationExpression -> ArrayCreationExpression -> Bool
$cmax :: ArrayCreationExpression
-> ArrayCreationExpression -> ArrayCreationExpression
max :: ArrayCreationExpression
-> ArrayCreationExpression -> ArrayCreationExpression
$cmin :: ArrayCreationExpression
-> ArrayCreationExpression -> ArrayCreationExpression
min :: ArrayCreationExpression
-> ArrayCreationExpression -> ArrayCreationExpression
Ord, ReadPrec [ArrayCreationExpression]
ReadPrec ArrayCreationExpression
Int -> ReadS ArrayCreationExpression
ReadS [ArrayCreationExpression]
(Int -> ReadS ArrayCreationExpression)
-> ReadS [ArrayCreationExpression]
-> ReadPrec ArrayCreationExpression
-> ReadPrec [ArrayCreationExpression]
-> Read ArrayCreationExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ArrayCreationExpression
readsPrec :: Int -> ReadS ArrayCreationExpression
$creadList :: ReadS [ArrayCreationExpression]
readList :: ReadS [ArrayCreationExpression]
$creadPrec :: ReadPrec ArrayCreationExpression
readPrec :: ReadPrec ArrayCreationExpression
$creadListPrec :: ReadPrec [ArrayCreationExpression]
readListPrec :: ReadPrec [ArrayCreationExpression]
Read, Int -> ArrayCreationExpression -> String -> String
[ArrayCreationExpression] -> String -> String
ArrayCreationExpression -> String
(Int -> ArrayCreationExpression -> String -> String)
-> (ArrayCreationExpression -> String)
-> ([ArrayCreationExpression] -> String -> String)
-> Show ArrayCreationExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ArrayCreationExpression -> String -> String
showsPrec :: Int -> ArrayCreationExpression -> String -> String
$cshow :: ArrayCreationExpression -> String
show :: ArrayCreationExpression -> String
$cshowList :: [ArrayCreationExpression] -> String -> String
showList :: [ArrayCreationExpression] -> String -> String
Show)

_ArrayCreationExpression :: Name
_ArrayCreationExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ArrayCreationExpression")

_ArrayCreationExpression_nonArrayType :: Name
_ArrayCreationExpression_nonArrayType = (String -> Name
Core.Name String
"nonArrayType")

_ArrayCreationExpression_arrayType :: Name
_ArrayCreationExpression_arrayType = (String -> Name
Core.Name String
"arrayType")

_ArrayCreationExpression_rankSpecifier :: Name
_ArrayCreationExpression_rankSpecifier = (String -> Name
Core.Name String
"rankSpecifier")

data NonArrayTypeArrayCreationExpression = 
  NonArrayTypeArrayCreationExpression {
    NonArrayTypeArrayCreationExpression -> NonArrayType
nonArrayTypeArrayCreationExpressionType :: NonArrayType,
    NonArrayTypeArrayCreationExpression -> ExpressionList
nonArrayTypeArrayCreationExpressionExpressions :: ExpressionList,
    NonArrayTypeArrayCreationExpression -> [RankSpecifier]
nonArrayTypeArrayCreationExpressionRankSpecifiers :: [RankSpecifier],
    NonArrayTypeArrayCreationExpression -> Maybe ArrayInitializer
nonArrayTypeArrayCreationExpressionInitializer :: (Maybe ArrayInitializer)}
  deriving (NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
(NonArrayTypeArrayCreationExpression
 -> NonArrayTypeArrayCreationExpression -> Bool)
-> (NonArrayTypeArrayCreationExpression
    -> NonArrayTypeArrayCreationExpression -> Bool)
-> Eq NonArrayTypeArrayCreationExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
== :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
$c/= :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
/= :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
Eq, Eq NonArrayTypeArrayCreationExpression
Eq NonArrayTypeArrayCreationExpression =>
(NonArrayTypeArrayCreationExpression
 -> NonArrayTypeArrayCreationExpression -> Ordering)
-> (NonArrayTypeArrayCreationExpression
    -> NonArrayTypeArrayCreationExpression -> Bool)
-> (NonArrayTypeArrayCreationExpression
    -> NonArrayTypeArrayCreationExpression -> Bool)
-> (NonArrayTypeArrayCreationExpression
    -> NonArrayTypeArrayCreationExpression -> Bool)
-> (NonArrayTypeArrayCreationExpression
    -> NonArrayTypeArrayCreationExpression -> Bool)
-> (NonArrayTypeArrayCreationExpression
    -> NonArrayTypeArrayCreationExpression
    -> NonArrayTypeArrayCreationExpression)
-> (NonArrayTypeArrayCreationExpression
    -> NonArrayTypeArrayCreationExpression
    -> NonArrayTypeArrayCreationExpression)
-> Ord NonArrayTypeArrayCreationExpression
NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Ordering
NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Ordering
compare :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Ordering
$c< :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
< :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
$c<= :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
<= :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
$c> :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
> :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
$c>= :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
>= :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression -> Bool
$cmax :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression
max :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression
$cmin :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression
min :: NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression
-> NonArrayTypeArrayCreationExpression
Ord, ReadPrec [NonArrayTypeArrayCreationExpression]
ReadPrec NonArrayTypeArrayCreationExpression
Int -> ReadS NonArrayTypeArrayCreationExpression
ReadS [NonArrayTypeArrayCreationExpression]
(Int -> ReadS NonArrayTypeArrayCreationExpression)
-> ReadS [NonArrayTypeArrayCreationExpression]
-> ReadPrec NonArrayTypeArrayCreationExpression
-> ReadPrec [NonArrayTypeArrayCreationExpression]
-> Read NonArrayTypeArrayCreationExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NonArrayTypeArrayCreationExpression
readsPrec :: Int -> ReadS NonArrayTypeArrayCreationExpression
$creadList :: ReadS [NonArrayTypeArrayCreationExpression]
readList :: ReadS [NonArrayTypeArrayCreationExpression]
$creadPrec :: ReadPrec NonArrayTypeArrayCreationExpression
readPrec :: ReadPrec NonArrayTypeArrayCreationExpression
$creadListPrec :: ReadPrec [NonArrayTypeArrayCreationExpression]
readListPrec :: ReadPrec [NonArrayTypeArrayCreationExpression]
Read, Int -> NonArrayTypeArrayCreationExpression -> String -> String
[NonArrayTypeArrayCreationExpression] -> String -> String
NonArrayTypeArrayCreationExpression -> String
(Int -> NonArrayTypeArrayCreationExpression -> String -> String)
-> (NonArrayTypeArrayCreationExpression -> String)
-> ([NonArrayTypeArrayCreationExpression] -> String -> String)
-> Show NonArrayTypeArrayCreationExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NonArrayTypeArrayCreationExpression -> String -> String
showsPrec :: Int -> NonArrayTypeArrayCreationExpression -> String -> String
$cshow :: NonArrayTypeArrayCreationExpression -> String
show :: NonArrayTypeArrayCreationExpression -> String
$cshowList :: [NonArrayTypeArrayCreationExpression] -> String -> String
showList :: [NonArrayTypeArrayCreationExpression] -> String -> String
Show)

_NonArrayTypeArrayCreationExpression :: Name
_NonArrayTypeArrayCreationExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NonArrayTypeArrayCreationExpression")

_NonArrayTypeArrayCreationExpression_type :: Name
_NonArrayTypeArrayCreationExpression_type = (String -> Name
Core.Name String
"type")

_NonArrayTypeArrayCreationExpression_expressions :: Name
_NonArrayTypeArrayCreationExpression_expressions = (String -> Name
Core.Name String
"expressions")

_NonArrayTypeArrayCreationExpression_rankSpecifiers :: Name
_NonArrayTypeArrayCreationExpression_rankSpecifiers = (String -> Name
Core.Name String
"rankSpecifiers")

_NonArrayTypeArrayCreationExpression_initializer :: Name
_NonArrayTypeArrayCreationExpression_initializer = (String -> Name
Core.Name String
"initializer")

data ArrayTypeArrayCreationExpression = 
  ArrayTypeArrayCreationExpression {
    ArrayTypeArrayCreationExpression -> ArrayType
arrayTypeArrayCreationExpressionType :: ArrayType,
    ArrayTypeArrayCreationExpression -> ArrayInitializer
arrayTypeArrayCreationExpressionInitializer :: ArrayInitializer}
  deriving (ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
(ArrayTypeArrayCreationExpression
 -> ArrayTypeArrayCreationExpression -> Bool)
-> (ArrayTypeArrayCreationExpression
    -> ArrayTypeArrayCreationExpression -> Bool)
-> Eq ArrayTypeArrayCreationExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
== :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
$c/= :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
/= :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
Eq, Eq ArrayTypeArrayCreationExpression
Eq ArrayTypeArrayCreationExpression =>
(ArrayTypeArrayCreationExpression
 -> ArrayTypeArrayCreationExpression -> Ordering)
-> (ArrayTypeArrayCreationExpression
    -> ArrayTypeArrayCreationExpression -> Bool)
-> (ArrayTypeArrayCreationExpression
    -> ArrayTypeArrayCreationExpression -> Bool)
-> (ArrayTypeArrayCreationExpression
    -> ArrayTypeArrayCreationExpression -> Bool)
-> (ArrayTypeArrayCreationExpression
    -> ArrayTypeArrayCreationExpression -> Bool)
-> (ArrayTypeArrayCreationExpression
    -> ArrayTypeArrayCreationExpression
    -> ArrayTypeArrayCreationExpression)
-> (ArrayTypeArrayCreationExpression
    -> ArrayTypeArrayCreationExpression
    -> ArrayTypeArrayCreationExpression)
-> Ord ArrayTypeArrayCreationExpression
ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Ordering
ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Ordering
compare :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Ordering
$c< :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
< :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
$c<= :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
<= :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
$c> :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
> :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
$c>= :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
>= :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression -> Bool
$cmax :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression
max :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression
$cmin :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression
min :: ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression
-> ArrayTypeArrayCreationExpression
Ord, ReadPrec [ArrayTypeArrayCreationExpression]
ReadPrec ArrayTypeArrayCreationExpression
Int -> ReadS ArrayTypeArrayCreationExpression
ReadS [ArrayTypeArrayCreationExpression]
(Int -> ReadS ArrayTypeArrayCreationExpression)
-> ReadS [ArrayTypeArrayCreationExpression]
-> ReadPrec ArrayTypeArrayCreationExpression
-> ReadPrec [ArrayTypeArrayCreationExpression]
-> Read ArrayTypeArrayCreationExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ArrayTypeArrayCreationExpression
readsPrec :: Int -> ReadS ArrayTypeArrayCreationExpression
$creadList :: ReadS [ArrayTypeArrayCreationExpression]
readList :: ReadS [ArrayTypeArrayCreationExpression]
$creadPrec :: ReadPrec ArrayTypeArrayCreationExpression
readPrec :: ReadPrec ArrayTypeArrayCreationExpression
$creadListPrec :: ReadPrec [ArrayTypeArrayCreationExpression]
readListPrec :: ReadPrec [ArrayTypeArrayCreationExpression]
Read, Int -> ArrayTypeArrayCreationExpression -> String -> String
[ArrayTypeArrayCreationExpression] -> String -> String
ArrayTypeArrayCreationExpression -> String
(Int -> ArrayTypeArrayCreationExpression -> String -> String)
-> (ArrayTypeArrayCreationExpression -> String)
-> ([ArrayTypeArrayCreationExpression] -> String -> String)
-> Show ArrayTypeArrayCreationExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ArrayTypeArrayCreationExpression -> String -> String
showsPrec :: Int -> ArrayTypeArrayCreationExpression -> String -> String
$cshow :: ArrayTypeArrayCreationExpression -> String
show :: ArrayTypeArrayCreationExpression -> String
$cshowList :: [ArrayTypeArrayCreationExpression] -> String -> String
showList :: [ArrayTypeArrayCreationExpression] -> String -> String
Show)

_ArrayTypeArrayCreationExpression :: Name
_ArrayTypeArrayCreationExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ArrayTypeArrayCreationExpression")

_ArrayTypeArrayCreationExpression_type :: Name
_ArrayTypeArrayCreationExpression_type = (String -> Name
Core.Name String
"type")

_ArrayTypeArrayCreationExpression_initializer :: Name
_ArrayTypeArrayCreationExpression_initializer = (String -> Name
Core.Name String
"initializer")

data RankSpecifierArrayCreationExpression = 
  RankSpecifierArrayCreationExpression {
    RankSpecifierArrayCreationExpression -> RankSpecifier
rankSpecifierArrayCreationExpressionRankSpecifier :: RankSpecifier,
    RankSpecifierArrayCreationExpression -> ArrayInitializer
rankSpecifierArrayCreationExpressionInitializer :: ArrayInitializer}
  deriving (RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
(RankSpecifierArrayCreationExpression
 -> RankSpecifierArrayCreationExpression -> Bool)
-> (RankSpecifierArrayCreationExpression
    -> RankSpecifierArrayCreationExpression -> Bool)
-> Eq RankSpecifierArrayCreationExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
== :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
$c/= :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
/= :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
Eq, Eq RankSpecifierArrayCreationExpression
Eq RankSpecifierArrayCreationExpression =>
(RankSpecifierArrayCreationExpression
 -> RankSpecifierArrayCreationExpression -> Ordering)
-> (RankSpecifierArrayCreationExpression
    -> RankSpecifierArrayCreationExpression -> Bool)
-> (RankSpecifierArrayCreationExpression
    -> RankSpecifierArrayCreationExpression -> Bool)
-> (RankSpecifierArrayCreationExpression
    -> RankSpecifierArrayCreationExpression -> Bool)
-> (RankSpecifierArrayCreationExpression
    -> RankSpecifierArrayCreationExpression -> Bool)
-> (RankSpecifierArrayCreationExpression
    -> RankSpecifierArrayCreationExpression
    -> RankSpecifierArrayCreationExpression)
-> (RankSpecifierArrayCreationExpression
    -> RankSpecifierArrayCreationExpression
    -> RankSpecifierArrayCreationExpression)
-> Ord RankSpecifierArrayCreationExpression
RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Ordering
RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Ordering
compare :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Ordering
$c< :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
< :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
$c<= :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
<= :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
$c> :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
> :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
$c>= :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
>= :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression -> Bool
$cmax :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression
max :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression
$cmin :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression
min :: RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression
-> RankSpecifierArrayCreationExpression
Ord, ReadPrec [RankSpecifierArrayCreationExpression]
ReadPrec RankSpecifierArrayCreationExpression
Int -> ReadS RankSpecifierArrayCreationExpression
ReadS [RankSpecifierArrayCreationExpression]
(Int -> ReadS RankSpecifierArrayCreationExpression)
-> ReadS [RankSpecifierArrayCreationExpression]
-> ReadPrec RankSpecifierArrayCreationExpression
-> ReadPrec [RankSpecifierArrayCreationExpression]
-> Read RankSpecifierArrayCreationExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RankSpecifierArrayCreationExpression
readsPrec :: Int -> ReadS RankSpecifierArrayCreationExpression
$creadList :: ReadS [RankSpecifierArrayCreationExpression]
readList :: ReadS [RankSpecifierArrayCreationExpression]
$creadPrec :: ReadPrec RankSpecifierArrayCreationExpression
readPrec :: ReadPrec RankSpecifierArrayCreationExpression
$creadListPrec :: ReadPrec [RankSpecifierArrayCreationExpression]
readListPrec :: ReadPrec [RankSpecifierArrayCreationExpression]
Read, Int -> RankSpecifierArrayCreationExpression -> String -> String
[RankSpecifierArrayCreationExpression] -> String -> String
RankSpecifierArrayCreationExpression -> String
(Int -> RankSpecifierArrayCreationExpression -> String -> String)
-> (RankSpecifierArrayCreationExpression -> String)
-> ([RankSpecifierArrayCreationExpression] -> String -> String)
-> Show RankSpecifierArrayCreationExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RankSpecifierArrayCreationExpression -> String -> String
showsPrec :: Int -> RankSpecifierArrayCreationExpression -> String -> String
$cshow :: RankSpecifierArrayCreationExpression -> String
show :: RankSpecifierArrayCreationExpression -> String
$cshowList :: [RankSpecifierArrayCreationExpression] -> String -> String
showList :: [RankSpecifierArrayCreationExpression] -> String -> String
Show)

_RankSpecifierArrayCreationExpression :: Name
_RankSpecifierArrayCreationExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RankSpecifierArrayCreationExpression")

_RankSpecifierArrayCreationExpression_rankSpecifier :: Name
_RankSpecifierArrayCreationExpression_rankSpecifier = (String -> Name
Core.Name String
"rankSpecifier")

_RankSpecifierArrayCreationExpression_initializer :: Name
_RankSpecifierArrayCreationExpression_initializer = (String -> Name
Core.Name String
"initializer")

data DelegateCreationExpression = 
  DelegateCreationExpression {
    DelegateCreationExpression -> DelegateType
delegateCreationExpressionType :: DelegateType,
    DelegateCreationExpression -> Expression
delegateCreationExpressionExpression :: Expression}
  deriving (DelegateCreationExpression -> DelegateCreationExpression -> Bool
(DelegateCreationExpression -> DelegateCreationExpression -> Bool)
-> (DelegateCreationExpression
    -> DelegateCreationExpression -> Bool)
-> Eq DelegateCreationExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
== :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
$c/= :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
/= :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
Eq, Eq DelegateCreationExpression
Eq DelegateCreationExpression =>
(DelegateCreationExpression
 -> DelegateCreationExpression -> Ordering)
-> (DelegateCreationExpression
    -> DelegateCreationExpression -> Bool)
-> (DelegateCreationExpression
    -> DelegateCreationExpression -> Bool)
-> (DelegateCreationExpression
    -> DelegateCreationExpression -> Bool)
-> (DelegateCreationExpression
    -> DelegateCreationExpression -> Bool)
-> (DelegateCreationExpression
    -> DelegateCreationExpression -> DelegateCreationExpression)
-> (DelegateCreationExpression
    -> DelegateCreationExpression -> DelegateCreationExpression)
-> Ord DelegateCreationExpression
DelegateCreationExpression -> DelegateCreationExpression -> Bool
DelegateCreationExpression
-> DelegateCreationExpression -> Ordering
DelegateCreationExpression
-> DelegateCreationExpression -> DelegateCreationExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DelegateCreationExpression
-> DelegateCreationExpression -> Ordering
compare :: DelegateCreationExpression
-> DelegateCreationExpression -> Ordering
$c< :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
< :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
$c<= :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
<= :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
$c> :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
> :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
$c>= :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
>= :: DelegateCreationExpression -> DelegateCreationExpression -> Bool
$cmax :: DelegateCreationExpression
-> DelegateCreationExpression -> DelegateCreationExpression
max :: DelegateCreationExpression
-> DelegateCreationExpression -> DelegateCreationExpression
$cmin :: DelegateCreationExpression
-> DelegateCreationExpression -> DelegateCreationExpression
min :: DelegateCreationExpression
-> DelegateCreationExpression -> DelegateCreationExpression
Ord, ReadPrec [DelegateCreationExpression]
ReadPrec DelegateCreationExpression
Int -> ReadS DelegateCreationExpression
ReadS [DelegateCreationExpression]
(Int -> ReadS DelegateCreationExpression)
-> ReadS [DelegateCreationExpression]
-> ReadPrec DelegateCreationExpression
-> ReadPrec [DelegateCreationExpression]
-> Read DelegateCreationExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DelegateCreationExpression
readsPrec :: Int -> ReadS DelegateCreationExpression
$creadList :: ReadS [DelegateCreationExpression]
readList :: ReadS [DelegateCreationExpression]
$creadPrec :: ReadPrec DelegateCreationExpression
readPrec :: ReadPrec DelegateCreationExpression
$creadListPrec :: ReadPrec [DelegateCreationExpression]
readListPrec :: ReadPrec [DelegateCreationExpression]
Read, Int -> DelegateCreationExpression -> String -> String
[DelegateCreationExpression] -> String -> String
DelegateCreationExpression -> String
(Int -> DelegateCreationExpression -> String -> String)
-> (DelegateCreationExpression -> String)
-> ([DelegateCreationExpression] -> String -> String)
-> Show DelegateCreationExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DelegateCreationExpression -> String -> String
showsPrec :: Int -> DelegateCreationExpression -> String -> String
$cshow :: DelegateCreationExpression -> String
show :: DelegateCreationExpression -> String
$cshowList :: [DelegateCreationExpression] -> String -> String
showList :: [DelegateCreationExpression] -> String -> String
Show)

_DelegateCreationExpression :: Name
_DelegateCreationExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DelegateCreationExpression")

_DelegateCreationExpression_type :: Name
_DelegateCreationExpression_type = (String -> Name
Core.Name String
"type")

_DelegateCreationExpression_expression :: Name
_DelegateCreationExpression_expression = (String -> Name
Core.Name String
"expression")

newtype MemberDeclaratorList = 
  MemberDeclaratorList {
    MemberDeclaratorList -> [MemberDeclarator]
unMemberDeclaratorList :: [MemberDeclarator]}
  deriving (MemberDeclaratorList -> MemberDeclaratorList -> Bool
(MemberDeclaratorList -> MemberDeclaratorList -> Bool)
-> (MemberDeclaratorList -> MemberDeclaratorList -> Bool)
-> Eq MemberDeclaratorList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
== :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
$c/= :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
/= :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
Eq, Eq MemberDeclaratorList
Eq MemberDeclaratorList =>
(MemberDeclaratorList -> MemberDeclaratorList -> Ordering)
-> (MemberDeclaratorList -> MemberDeclaratorList -> Bool)
-> (MemberDeclaratorList -> MemberDeclaratorList -> Bool)
-> (MemberDeclaratorList -> MemberDeclaratorList -> Bool)
-> (MemberDeclaratorList -> MemberDeclaratorList -> Bool)
-> (MemberDeclaratorList
    -> MemberDeclaratorList -> MemberDeclaratorList)
-> (MemberDeclaratorList
    -> MemberDeclaratorList -> MemberDeclaratorList)
-> Ord MemberDeclaratorList
MemberDeclaratorList -> MemberDeclaratorList -> Bool
MemberDeclaratorList -> MemberDeclaratorList -> Ordering
MemberDeclaratorList
-> MemberDeclaratorList -> MemberDeclaratorList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MemberDeclaratorList -> MemberDeclaratorList -> Ordering
compare :: MemberDeclaratorList -> MemberDeclaratorList -> Ordering
$c< :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
< :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
$c<= :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
<= :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
$c> :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
> :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
$c>= :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
>= :: MemberDeclaratorList -> MemberDeclaratorList -> Bool
$cmax :: MemberDeclaratorList
-> MemberDeclaratorList -> MemberDeclaratorList
max :: MemberDeclaratorList
-> MemberDeclaratorList -> MemberDeclaratorList
$cmin :: MemberDeclaratorList
-> MemberDeclaratorList -> MemberDeclaratorList
min :: MemberDeclaratorList
-> MemberDeclaratorList -> MemberDeclaratorList
Ord, ReadPrec [MemberDeclaratorList]
ReadPrec MemberDeclaratorList
Int -> ReadS MemberDeclaratorList
ReadS [MemberDeclaratorList]
(Int -> ReadS MemberDeclaratorList)
-> ReadS [MemberDeclaratorList]
-> ReadPrec MemberDeclaratorList
-> ReadPrec [MemberDeclaratorList]
-> Read MemberDeclaratorList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MemberDeclaratorList
readsPrec :: Int -> ReadS MemberDeclaratorList
$creadList :: ReadS [MemberDeclaratorList]
readList :: ReadS [MemberDeclaratorList]
$creadPrec :: ReadPrec MemberDeclaratorList
readPrec :: ReadPrec MemberDeclaratorList
$creadListPrec :: ReadPrec [MemberDeclaratorList]
readListPrec :: ReadPrec [MemberDeclaratorList]
Read, Int -> MemberDeclaratorList -> String -> String
[MemberDeclaratorList] -> String -> String
MemberDeclaratorList -> String
(Int -> MemberDeclaratorList -> String -> String)
-> (MemberDeclaratorList -> String)
-> ([MemberDeclaratorList] -> String -> String)
-> Show MemberDeclaratorList
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MemberDeclaratorList -> String -> String
showsPrec :: Int -> MemberDeclaratorList -> String -> String
$cshow :: MemberDeclaratorList -> String
show :: MemberDeclaratorList -> String
$cshowList :: [MemberDeclaratorList] -> String -> String
showList :: [MemberDeclaratorList] -> String -> String
Show)

_MemberDeclaratorList :: Name
_MemberDeclaratorList = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MemberDeclaratorList")

data MemberDeclarator = 
  MemberDeclaratorName SimpleName |
  MemberDeclaratorMemberAccess MemberAccess |
  MemberDeclaratorNullConditionalProjectionInitializer NullConditionalProjectionInitializer |
  MemberDeclaratorBaseAccess BaseAccess |
  MemberDeclaratorAssignment AssignmentMemberDeclarator
  deriving (MemberDeclarator -> MemberDeclarator -> Bool
(MemberDeclarator -> MemberDeclarator -> Bool)
-> (MemberDeclarator -> MemberDeclarator -> Bool)
-> Eq MemberDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemberDeclarator -> MemberDeclarator -> Bool
== :: MemberDeclarator -> MemberDeclarator -> Bool
$c/= :: MemberDeclarator -> MemberDeclarator -> Bool
/= :: MemberDeclarator -> MemberDeclarator -> Bool
Eq, Eq MemberDeclarator
Eq MemberDeclarator =>
(MemberDeclarator -> MemberDeclarator -> Ordering)
-> (MemberDeclarator -> MemberDeclarator -> Bool)
-> (MemberDeclarator -> MemberDeclarator -> Bool)
-> (MemberDeclarator -> MemberDeclarator -> Bool)
-> (MemberDeclarator -> MemberDeclarator -> Bool)
-> (MemberDeclarator -> MemberDeclarator -> MemberDeclarator)
-> (MemberDeclarator -> MemberDeclarator -> MemberDeclarator)
-> Ord MemberDeclarator
MemberDeclarator -> MemberDeclarator -> Bool
MemberDeclarator -> MemberDeclarator -> Ordering
MemberDeclarator -> MemberDeclarator -> MemberDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MemberDeclarator -> MemberDeclarator -> Ordering
compare :: MemberDeclarator -> MemberDeclarator -> Ordering
$c< :: MemberDeclarator -> MemberDeclarator -> Bool
< :: MemberDeclarator -> MemberDeclarator -> Bool
$c<= :: MemberDeclarator -> MemberDeclarator -> Bool
<= :: MemberDeclarator -> MemberDeclarator -> Bool
$c> :: MemberDeclarator -> MemberDeclarator -> Bool
> :: MemberDeclarator -> MemberDeclarator -> Bool
$c>= :: MemberDeclarator -> MemberDeclarator -> Bool
>= :: MemberDeclarator -> MemberDeclarator -> Bool
$cmax :: MemberDeclarator -> MemberDeclarator -> MemberDeclarator
max :: MemberDeclarator -> MemberDeclarator -> MemberDeclarator
$cmin :: MemberDeclarator -> MemberDeclarator -> MemberDeclarator
min :: MemberDeclarator -> MemberDeclarator -> MemberDeclarator
Ord, ReadPrec [MemberDeclarator]
ReadPrec MemberDeclarator
Int -> ReadS MemberDeclarator
ReadS [MemberDeclarator]
(Int -> ReadS MemberDeclarator)
-> ReadS [MemberDeclarator]
-> ReadPrec MemberDeclarator
-> ReadPrec [MemberDeclarator]
-> Read MemberDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MemberDeclarator
readsPrec :: Int -> ReadS MemberDeclarator
$creadList :: ReadS [MemberDeclarator]
readList :: ReadS [MemberDeclarator]
$creadPrec :: ReadPrec MemberDeclarator
readPrec :: ReadPrec MemberDeclarator
$creadListPrec :: ReadPrec [MemberDeclarator]
readListPrec :: ReadPrec [MemberDeclarator]
Read, Int -> MemberDeclarator -> String -> String
[MemberDeclarator] -> String -> String
MemberDeclarator -> String
(Int -> MemberDeclarator -> String -> String)
-> (MemberDeclarator -> String)
-> ([MemberDeclarator] -> String -> String)
-> Show MemberDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MemberDeclarator -> String -> String
showsPrec :: Int -> MemberDeclarator -> String -> String
$cshow :: MemberDeclarator -> String
show :: MemberDeclarator -> String
$cshowList :: [MemberDeclarator] -> String -> String
showList :: [MemberDeclarator] -> String -> String
Show)

_MemberDeclarator :: Name
_MemberDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MemberDeclarator")

_MemberDeclarator_name :: Name
_MemberDeclarator_name = (String -> Name
Core.Name String
"name")

_MemberDeclarator_memberAccess :: Name
_MemberDeclarator_memberAccess = (String -> Name
Core.Name String
"memberAccess")

_MemberDeclarator_nullConditionalProjectionInitializer :: Name
_MemberDeclarator_nullConditionalProjectionInitializer = (String -> Name
Core.Name String
"nullConditionalProjectionInitializer")

_MemberDeclarator_baseAccess :: Name
_MemberDeclarator_baseAccess = (String -> Name
Core.Name String
"baseAccess")

_MemberDeclarator_assignment :: Name
_MemberDeclarator_assignment = (String -> Name
Core.Name String
"assignment")

data AssignmentMemberDeclarator = 
  AssignmentMemberDeclarator {
    AssignmentMemberDeclarator -> Identifier
assignmentMemberDeclaratorIdentifier :: Identifier,
    AssignmentMemberDeclarator -> Expression
assignmentMemberDeclaratorExpression :: Expression}
  deriving (AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
(AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool)
-> (AssignmentMemberDeclarator
    -> AssignmentMemberDeclarator -> Bool)
-> Eq AssignmentMemberDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
== :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
$c/= :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
/= :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
Eq, Eq AssignmentMemberDeclarator
Eq AssignmentMemberDeclarator =>
(AssignmentMemberDeclarator
 -> AssignmentMemberDeclarator -> Ordering)
-> (AssignmentMemberDeclarator
    -> AssignmentMemberDeclarator -> Bool)
-> (AssignmentMemberDeclarator
    -> AssignmentMemberDeclarator -> Bool)
-> (AssignmentMemberDeclarator
    -> AssignmentMemberDeclarator -> Bool)
-> (AssignmentMemberDeclarator
    -> AssignmentMemberDeclarator -> Bool)
-> (AssignmentMemberDeclarator
    -> AssignmentMemberDeclarator -> AssignmentMemberDeclarator)
-> (AssignmentMemberDeclarator
    -> AssignmentMemberDeclarator -> AssignmentMemberDeclarator)
-> Ord AssignmentMemberDeclarator
AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
AssignmentMemberDeclarator
-> AssignmentMemberDeclarator -> Ordering
AssignmentMemberDeclarator
-> AssignmentMemberDeclarator -> AssignmentMemberDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AssignmentMemberDeclarator
-> AssignmentMemberDeclarator -> Ordering
compare :: AssignmentMemberDeclarator
-> AssignmentMemberDeclarator -> Ordering
$c< :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
< :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
$c<= :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
<= :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
$c> :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
> :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
$c>= :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
>= :: AssignmentMemberDeclarator -> AssignmentMemberDeclarator -> Bool
$cmax :: AssignmentMemberDeclarator
-> AssignmentMemberDeclarator -> AssignmentMemberDeclarator
max :: AssignmentMemberDeclarator
-> AssignmentMemberDeclarator -> AssignmentMemberDeclarator
$cmin :: AssignmentMemberDeclarator
-> AssignmentMemberDeclarator -> AssignmentMemberDeclarator
min :: AssignmentMemberDeclarator
-> AssignmentMemberDeclarator -> AssignmentMemberDeclarator
Ord, ReadPrec [AssignmentMemberDeclarator]
ReadPrec AssignmentMemberDeclarator
Int -> ReadS AssignmentMemberDeclarator
ReadS [AssignmentMemberDeclarator]
(Int -> ReadS AssignmentMemberDeclarator)
-> ReadS [AssignmentMemberDeclarator]
-> ReadPrec AssignmentMemberDeclarator
-> ReadPrec [AssignmentMemberDeclarator]
-> Read AssignmentMemberDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AssignmentMemberDeclarator
readsPrec :: Int -> ReadS AssignmentMemberDeclarator
$creadList :: ReadS [AssignmentMemberDeclarator]
readList :: ReadS [AssignmentMemberDeclarator]
$creadPrec :: ReadPrec AssignmentMemberDeclarator
readPrec :: ReadPrec AssignmentMemberDeclarator
$creadListPrec :: ReadPrec [AssignmentMemberDeclarator]
readListPrec :: ReadPrec [AssignmentMemberDeclarator]
Read, Int -> AssignmentMemberDeclarator -> String -> String
[AssignmentMemberDeclarator] -> String -> String
AssignmentMemberDeclarator -> String
(Int -> AssignmentMemberDeclarator -> String -> String)
-> (AssignmentMemberDeclarator -> String)
-> ([AssignmentMemberDeclarator] -> String -> String)
-> Show AssignmentMemberDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AssignmentMemberDeclarator -> String -> String
showsPrec :: Int -> AssignmentMemberDeclarator -> String -> String
$cshow :: AssignmentMemberDeclarator -> String
show :: AssignmentMemberDeclarator -> String
$cshowList :: [AssignmentMemberDeclarator] -> String -> String
showList :: [AssignmentMemberDeclarator] -> String -> String
Show)

_AssignmentMemberDeclarator :: Name
_AssignmentMemberDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AssignmentMemberDeclarator")

_AssignmentMemberDeclarator_identifier :: Name
_AssignmentMemberDeclarator_identifier = (String -> Name
Core.Name String
"identifier")

_AssignmentMemberDeclarator_expression :: Name
_AssignmentMemberDeclarator_expression = (String -> Name
Core.Name String
"expression")

data TypeofExpression = 
  TypeofExpressionType Type |
  TypeofExpressionUnboundTypeName UnboundTypeName |
  TypeofExpressionVoid 
  deriving (TypeofExpression -> TypeofExpression -> Bool
(TypeofExpression -> TypeofExpression -> Bool)
-> (TypeofExpression -> TypeofExpression -> Bool)
-> Eq TypeofExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeofExpression -> TypeofExpression -> Bool
== :: TypeofExpression -> TypeofExpression -> Bool
$c/= :: TypeofExpression -> TypeofExpression -> Bool
/= :: TypeofExpression -> TypeofExpression -> Bool
Eq, Eq TypeofExpression
Eq TypeofExpression =>
(TypeofExpression -> TypeofExpression -> Ordering)
-> (TypeofExpression -> TypeofExpression -> Bool)
-> (TypeofExpression -> TypeofExpression -> Bool)
-> (TypeofExpression -> TypeofExpression -> Bool)
-> (TypeofExpression -> TypeofExpression -> Bool)
-> (TypeofExpression -> TypeofExpression -> TypeofExpression)
-> (TypeofExpression -> TypeofExpression -> TypeofExpression)
-> Ord TypeofExpression
TypeofExpression -> TypeofExpression -> Bool
TypeofExpression -> TypeofExpression -> Ordering
TypeofExpression -> TypeofExpression -> TypeofExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TypeofExpression -> TypeofExpression -> Ordering
compare :: TypeofExpression -> TypeofExpression -> Ordering
$c< :: TypeofExpression -> TypeofExpression -> Bool
< :: TypeofExpression -> TypeofExpression -> Bool
$c<= :: TypeofExpression -> TypeofExpression -> Bool
<= :: TypeofExpression -> TypeofExpression -> Bool
$c> :: TypeofExpression -> TypeofExpression -> Bool
> :: TypeofExpression -> TypeofExpression -> Bool
$c>= :: TypeofExpression -> TypeofExpression -> Bool
>= :: TypeofExpression -> TypeofExpression -> Bool
$cmax :: TypeofExpression -> TypeofExpression -> TypeofExpression
max :: TypeofExpression -> TypeofExpression -> TypeofExpression
$cmin :: TypeofExpression -> TypeofExpression -> TypeofExpression
min :: TypeofExpression -> TypeofExpression -> TypeofExpression
Ord, ReadPrec [TypeofExpression]
ReadPrec TypeofExpression
Int -> ReadS TypeofExpression
ReadS [TypeofExpression]
(Int -> ReadS TypeofExpression)
-> ReadS [TypeofExpression]
-> ReadPrec TypeofExpression
-> ReadPrec [TypeofExpression]
-> Read TypeofExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeofExpression
readsPrec :: Int -> ReadS TypeofExpression
$creadList :: ReadS [TypeofExpression]
readList :: ReadS [TypeofExpression]
$creadPrec :: ReadPrec TypeofExpression
readPrec :: ReadPrec TypeofExpression
$creadListPrec :: ReadPrec [TypeofExpression]
readListPrec :: ReadPrec [TypeofExpression]
Read, Int -> TypeofExpression -> String -> String
[TypeofExpression] -> String -> String
TypeofExpression -> String
(Int -> TypeofExpression -> String -> String)
-> (TypeofExpression -> String)
-> ([TypeofExpression] -> String -> String)
-> Show TypeofExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TypeofExpression -> String -> String
showsPrec :: Int -> TypeofExpression -> String -> String
$cshow :: TypeofExpression -> String
show :: TypeofExpression -> String
$cshowList :: [TypeofExpression] -> String -> String
showList :: [TypeofExpression] -> String -> String
Show)

_TypeofExpression :: Name
_TypeofExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TypeofExpression")

_TypeofExpression_type :: Name
_TypeofExpression_type = (String -> Name
Core.Name String
"type")

_TypeofExpression_unboundTypeName :: Name
_TypeofExpression_unboundTypeName = (String -> Name
Core.Name String
"unboundTypeName")

_TypeofExpression_void :: Name
_TypeofExpression_void = (String -> Name
Core.Name String
"void")

newtype UnboundTypeName = 
  UnboundTypeName {
    UnboundTypeName -> [UnboundTypeNamePart]
unUnboundTypeName :: [UnboundTypeNamePart]}
  deriving (UnboundTypeName -> UnboundTypeName -> Bool
(UnboundTypeName -> UnboundTypeName -> Bool)
-> (UnboundTypeName -> UnboundTypeName -> Bool)
-> Eq UnboundTypeName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnboundTypeName -> UnboundTypeName -> Bool
== :: UnboundTypeName -> UnboundTypeName -> Bool
$c/= :: UnboundTypeName -> UnboundTypeName -> Bool
/= :: UnboundTypeName -> UnboundTypeName -> Bool
Eq, Eq UnboundTypeName
Eq UnboundTypeName =>
(UnboundTypeName -> UnboundTypeName -> Ordering)
-> (UnboundTypeName -> UnboundTypeName -> Bool)
-> (UnboundTypeName -> UnboundTypeName -> Bool)
-> (UnboundTypeName -> UnboundTypeName -> Bool)
-> (UnboundTypeName -> UnboundTypeName -> Bool)
-> (UnboundTypeName -> UnboundTypeName -> UnboundTypeName)
-> (UnboundTypeName -> UnboundTypeName -> UnboundTypeName)
-> Ord UnboundTypeName
UnboundTypeName -> UnboundTypeName -> Bool
UnboundTypeName -> UnboundTypeName -> Ordering
UnboundTypeName -> UnboundTypeName -> UnboundTypeName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnboundTypeName -> UnboundTypeName -> Ordering
compare :: UnboundTypeName -> UnboundTypeName -> Ordering
$c< :: UnboundTypeName -> UnboundTypeName -> Bool
< :: UnboundTypeName -> UnboundTypeName -> Bool
$c<= :: UnboundTypeName -> UnboundTypeName -> Bool
<= :: UnboundTypeName -> UnboundTypeName -> Bool
$c> :: UnboundTypeName -> UnboundTypeName -> Bool
> :: UnboundTypeName -> UnboundTypeName -> Bool
$c>= :: UnboundTypeName -> UnboundTypeName -> Bool
>= :: UnboundTypeName -> UnboundTypeName -> Bool
$cmax :: UnboundTypeName -> UnboundTypeName -> UnboundTypeName
max :: UnboundTypeName -> UnboundTypeName -> UnboundTypeName
$cmin :: UnboundTypeName -> UnboundTypeName -> UnboundTypeName
min :: UnboundTypeName -> UnboundTypeName -> UnboundTypeName
Ord, ReadPrec [UnboundTypeName]
ReadPrec UnboundTypeName
Int -> ReadS UnboundTypeName
ReadS [UnboundTypeName]
(Int -> ReadS UnboundTypeName)
-> ReadS [UnboundTypeName]
-> ReadPrec UnboundTypeName
-> ReadPrec [UnboundTypeName]
-> Read UnboundTypeName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UnboundTypeName
readsPrec :: Int -> ReadS UnboundTypeName
$creadList :: ReadS [UnboundTypeName]
readList :: ReadS [UnboundTypeName]
$creadPrec :: ReadPrec UnboundTypeName
readPrec :: ReadPrec UnboundTypeName
$creadListPrec :: ReadPrec [UnboundTypeName]
readListPrec :: ReadPrec [UnboundTypeName]
Read, Int -> UnboundTypeName -> String -> String
[UnboundTypeName] -> String -> String
UnboundTypeName -> String
(Int -> UnboundTypeName -> String -> String)
-> (UnboundTypeName -> String)
-> ([UnboundTypeName] -> String -> String)
-> Show UnboundTypeName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UnboundTypeName -> String -> String
showsPrec :: Int -> UnboundTypeName -> String -> String
$cshow :: UnboundTypeName -> String
show :: UnboundTypeName -> String
$cshowList :: [UnboundTypeName] -> String -> String
showList :: [UnboundTypeName] -> String -> String
Show)

_UnboundTypeName :: Name
_UnboundTypeName = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.UnboundTypeName")

data UnboundTypeNamePart = 
  UnboundTypeNamePart {
    UnboundTypeNamePart -> Identifier
unboundTypeNamePartIdentifier :: Identifier,
    UnboundTypeNamePart -> Bool
unboundTypeNamePartAliased :: Bool,
    UnboundTypeNamePart -> Maybe Int
unboundTypeNamePartDimension :: (Maybe Int)}
  deriving (UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
(UnboundTypeNamePart -> UnboundTypeNamePart -> Bool)
-> (UnboundTypeNamePart -> UnboundTypeNamePart -> Bool)
-> Eq UnboundTypeNamePart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
== :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
$c/= :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
/= :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
Eq, Eq UnboundTypeNamePart
Eq UnboundTypeNamePart =>
(UnboundTypeNamePart -> UnboundTypeNamePart -> Ordering)
-> (UnboundTypeNamePart -> UnboundTypeNamePart -> Bool)
-> (UnboundTypeNamePart -> UnboundTypeNamePart -> Bool)
-> (UnboundTypeNamePart -> UnboundTypeNamePart -> Bool)
-> (UnboundTypeNamePart -> UnboundTypeNamePart -> Bool)
-> (UnboundTypeNamePart
    -> UnboundTypeNamePart -> UnboundTypeNamePart)
-> (UnboundTypeNamePart
    -> UnboundTypeNamePart -> UnboundTypeNamePart)
-> Ord UnboundTypeNamePart
UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
UnboundTypeNamePart -> UnboundTypeNamePart -> Ordering
UnboundTypeNamePart -> UnboundTypeNamePart -> UnboundTypeNamePart
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnboundTypeNamePart -> UnboundTypeNamePart -> Ordering
compare :: UnboundTypeNamePart -> UnboundTypeNamePart -> Ordering
$c< :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
< :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
$c<= :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
<= :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
$c> :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
> :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
$c>= :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
>= :: UnboundTypeNamePart -> UnboundTypeNamePart -> Bool
$cmax :: UnboundTypeNamePart -> UnboundTypeNamePart -> UnboundTypeNamePart
max :: UnboundTypeNamePart -> UnboundTypeNamePart -> UnboundTypeNamePart
$cmin :: UnboundTypeNamePart -> UnboundTypeNamePart -> UnboundTypeNamePart
min :: UnboundTypeNamePart -> UnboundTypeNamePart -> UnboundTypeNamePart
Ord, ReadPrec [UnboundTypeNamePart]
ReadPrec UnboundTypeNamePart
Int -> ReadS UnboundTypeNamePart
ReadS [UnboundTypeNamePart]
(Int -> ReadS UnboundTypeNamePart)
-> ReadS [UnboundTypeNamePart]
-> ReadPrec UnboundTypeNamePart
-> ReadPrec [UnboundTypeNamePart]
-> Read UnboundTypeNamePart
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UnboundTypeNamePart
readsPrec :: Int -> ReadS UnboundTypeNamePart
$creadList :: ReadS [UnboundTypeNamePart]
readList :: ReadS [UnboundTypeNamePart]
$creadPrec :: ReadPrec UnboundTypeNamePart
readPrec :: ReadPrec UnboundTypeNamePart
$creadListPrec :: ReadPrec [UnboundTypeNamePart]
readListPrec :: ReadPrec [UnboundTypeNamePart]
Read, Int -> UnboundTypeNamePart -> String -> String
[UnboundTypeNamePart] -> String -> String
UnboundTypeNamePart -> String
(Int -> UnboundTypeNamePart -> String -> String)
-> (UnboundTypeNamePart -> String)
-> ([UnboundTypeNamePart] -> String -> String)
-> Show UnboundTypeNamePart
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UnboundTypeNamePart -> String -> String
showsPrec :: Int -> UnboundTypeNamePart -> String -> String
$cshow :: UnboundTypeNamePart -> String
show :: UnboundTypeNamePart -> String
$cshowList :: [UnboundTypeNamePart] -> String -> String
showList :: [UnboundTypeNamePart] -> String -> String
Show)

_UnboundTypeNamePart :: Name
_UnboundTypeNamePart = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.UnboundTypeNamePart")

_UnboundTypeNamePart_identifier :: Name
_UnboundTypeNamePart_identifier = (String -> Name
Core.Name String
"identifier")

_UnboundTypeNamePart_aliased :: Name
_UnboundTypeNamePart_aliased = (String -> Name
Core.Name String
"aliased")

_UnboundTypeNamePart_dimension :: Name
_UnboundTypeNamePart_dimension = (String -> Name
Core.Name String
"dimension")

data DefaultValueExpression = 
  DefaultValueExpressionExplicitlyTyped Type |
  DefaultValueExpressionDefaultLiteral 
  deriving (DefaultValueExpression -> DefaultValueExpression -> Bool
(DefaultValueExpression -> DefaultValueExpression -> Bool)
-> (DefaultValueExpression -> DefaultValueExpression -> Bool)
-> Eq DefaultValueExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DefaultValueExpression -> DefaultValueExpression -> Bool
== :: DefaultValueExpression -> DefaultValueExpression -> Bool
$c/= :: DefaultValueExpression -> DefaultValueExpression -> Bool
/= :: DefaultValueExpression -> DefaultValueExpression -> Bool
Eq, Eq DefaultValueExpression
Eq DefaultValueExpression =>
(DefaultValueExpression -> DefaultValueExpression -> Ordering)
-> (DefaultValueExpression -> DefaultValueExpression -> Bool)
-> (DefaultValueExpression -> DefaultValueExpression -> Bool)
-> (DefaultValueExpression -> DefaultValueExpression -> Bool)
-> (DefaultValueExpression -> DefaultValueExpression -> Bool)
-> (DefaultValueExpression
    -> DefaultValueExpression -> DefaultValueExpression)
-> (DefaultValueExpression
    -> DefaultValueExpression -> DefaultValueExpression)
-> Ord DefaultValueExpression
DefaultValueExpression -> DefaultValueExpression -> Bool
DefaultValueExpression -> DefaultValueExpression -> Ordering
DefaultValueExpression
-> DefaultValueExpression -> DefaultValueExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DefaultValueExpression -> DefaultValueExpression -> Ordering
compare :: DefaultValueExpression -> DefaultValueExpression -> Ordering
$c< :: DefaultValueExpression -> DefaultValueExpression -> Bool
< :: DefaultValueExpression -> DefaultValueExpression -> Bool
$c<= :: DefaultValueExpression -> DefaultValueExpression -> Bool
<= :: DefaultValueExpression -> DefaultValueExpression -> Bool
$c> :: DefaultValueExpression -> DefaultValueExpression -> Bool
> :: DefaultValueExpression -> DefaultValueExpression -> Bool
$c>= :: DefaultValueExpression -> DefaultValueExpression -> Bool
>= :: DefaultValueExpression -> DefaultValueExpression -> Bool
$cmax :: DefaultValueExpression
-> DefaultValueExpression -> DefaultValueExpression
max :: DefaultValueExpression
-> DefaultValueExpression -> DefaultValueExpression
$cmin :: DefaultValueExpression
-> DefaultValueExpression -> DefaultValueExpression
min :: DefaultValueExpression
-> DefaultValueExpression -> DefaultValueExpression
Ord, ReadPrec [DefaultValueExpression]
ReadPrec DefaultValueExpression
Int -> ReadS DefaultValueExpression
ReadS [DefaultValueExpression]
(Int -> ReadS DefaultValueExpression)
-> ReadS [DefaultValueExpression]
-> ReadPrec DefaultValueExpression
-> ReadPrec [DefaultValueExpression]
-> Read DefaultValueExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DefaultValueExpression
readsPrec :: Int -> ReadS DefaultValueExpression
$creadList :: ReadS [DefaultValueExpression]
readList :: ReadS [DefaultValueExpression]
$creadPrec :: ReadPrec DefaultValueExpression
readPrec :: ReadPrec DefaultValueExpression
$creadListPrec :: ReadPrec [DefaultValueExpression]
readListPrec :: ReadPrec [DefaultValueExpression]
Read, Int -> DefaultValueExpression -> String -> String
[DefaultValueExpression] -> String -> String
DefaultValueExpression -> String
(Int -> DefaultValueExpression -> String -> String)
-> (DefaultValueExpression -> String)
-> ([DefaultValueExpression] -> String -> String)
-> Show DefaultValueExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DefaultValueExpression -> String -> String
showsPrec :: Int -> DefaultValueExpression -> String -> String
$cshow :: DefaultValueExpression -> String
show :: DefaultValueExpression -> String
$cshowList :: [DefaultValueExpression] -> String -> String
showList :: [DefaultValueExpression] -> String -> String
Show)

_DefaultValueExpression :: Name
_DefaultValueExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DefaultValueExpression")

_DefaultValueExpression_explicitlyTyped :: Name
_DefaultValueExpression_explicitlyTyped = (String -> Name
Core.Name String
"explicitlyTyped")

_DefaultValueExpression_defaultLiteral :: Name
_DefaultValueExpression_defaultLiteral = (String -> Name
Core.Name String
"defaultLiteral")

data StackallocExpression = 
  StackallocExpression {
    StackallocExpression -> Maybe UnmanagedType
stackallocExpressionType :: (Maybe UnmanagedType),
    StackallocExpression -> Maybe ConstantExpression
stackallocExpressionExpression :: (Maybe ConstantExpression),
    StackallocExpression -> [Expression]
stackallocExpressionInitializer :: [Expression]}
  deriving (StackallocExpression -> StackallocExpression -> Bool
(StackallocExpression -> StackallocExpression -> Bool)
-> (StackallocExpression -> StackallocExpression -> Bool)
-> Eq StackallocExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StackallocExpression -> StackallocExpression -> Bool
== :: StackallocExpression -> StackallocExpression -> Bool
$c/= :: StackallocExpression -> StackallocExpression -> Bool
/= :: StackallocExpression -> StackallocExpression -> Bool
Eq, Eq StackallocExpression
Eq StackallocExpression =>
(StackallocExpression -> StackallocExpression -> Ordering)
-> (StackallocExpression -> StackallocExpression -> Bool)
-> (StackallocExpression -> StackallocExpression -> Bool)
-> (StackallocExpression -> StackallocExpression -> Bool)
-> (StackallocExpression -> StackallocExpression -> Bool)
-> (StackallocExpression
    -> StackallocExpression -> StackallocExpression)
-> (StackallocExpression
    -> StackallocExpression -> StackallocExpression)
-> Ord StackallocExpression
StackallocExpression -> StackallocExpression -> Bool
StackallocExpression -> StackallocExpression -> Ordering
StackallocExpression
-> StackallocExpression -> StackallocExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StackallocExpression -> StackallocExpression -> Ordering
compare :: StackallocExpression -> StackallocExpression -> Ordering
$c< :: StackallocExpression -> StackallocExpression -> Bool
< :: StackallocExpression -> StackallocExpression -> Bool
$c<= :: StackallocExpression -> StackallocExpression -> Bool
<= :: StackallocExpression -> StackallocExpression -> Bool
$c> :: StackallocExpression -> StackallocExpression -> Bool
> :: StackallocExpression -> StackallocExpression -> Bool
$c>= :: StackallocExpression -> StackallocExpression -> Bool
>= :: StackallocExpression -> StackallocExpression -> Bool
$cmax :: StackallocExpression
-> StackallocExpression -> StackallocExpression
max :: StackallocExpression
-> StackallocExpression -> StackallocExpression
$cmin :: StackallocExpression
-> StackallocExpression -> StackallocExpression
min :: StackallocExpression
-> StackallocExpression -> StackallocExpression
Ord, ReadPrec [StackallocExpression]
ReadPrec StackallocExpression
Int -> ReadS StackallocExpression
ReadS [StackallocExpression]
(Int -> ReadS StackallocExpression)
-> ReadS [StackallocExpression]
-> ReadPrec StackallocExpression
-> ReadPrec [StackallocExpression]
-> Read StackallocExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StackallocExpression
readsPrec :: Int -> ReadS StackallocExpression
$creadList :: ReadS [StackallocExpression]
readList :: ReadS [StackallocExpression]
$creadPrec :: ReadPrec StackallocExpression
readPrec :: ReadPrec StackallocExpression
$creadListPrec :: ReadPrec [StackallocExpression]
readListPrec :: ReadPrec [StackallocExpression]
Read, Int -> StackallocExpression -> String -> String
[StackallocExpression] -> String -> String
StackallocExpression -> String
(Int -> StackallocExpression -> String -> String)
-> (StackallocExpression -> String)
-> ([StackallocExpression] -> String -> String)
-> Show StackallocExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StackallocExpression -> String -> String
showsPrec :: Int -> StackallocExpression -> String -> String
$cshow :: StackallocExpression -> String
show :: StackallocExpression -> String
$cshowList :: [StackallocExpression] -> String -> String
showList :: [StackallocExpression] -> String -> String
Show)

_StackallocExpression :: Name
_StackallocExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StackallocExpression")

_StackallocExpression_type :: Name
_StackallocExpression_type = (String -> Name
Core.Name String
"type")

_StackallocExpression_expression :: Name
_StackallocExpression_expression = (String -> Name
Core.Name String
"expression")

_StackallocExpression_initializer :: Name
_StackallocExpression_initializer = (String -> Name
Core.Name String
"initializer")

data NamedEntity = 
  NamedEntity {
    NamedEntity -> NamedEntityTarget
namedEntityTarget :: NamedEntityTarget,
    NamedEntity -> [NamedEntityPart]
namedEntityParts :: [NamedEntityPart]}
  deriving (NamedEntity -> NamedEntity -> Bool
(NamedEntity -> NamedEntity -> Bool)
-> (NamedEntity -> NamedEntity -> Bool) -> Eq NamedEntity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamedEntity -> NamedEntity -> Bool
== :: NamedEntity -> NamedEntity -> Bool
$c/= :: NamedEntity -> NamedEntity -> Bool
/= :: NamedEntity -> NamedEntity -> Bool
Eq, Eq NamedEntity
Eq NamedEntity =>
(NamedEntity -> NamedEntity -> Ordering)
-> (NamedEntity -> NamedEntity -> Bool)
-> (NamedEntity -> NamedEntity -> Bool)
-> (NamedEntity -> NamedEntity -> Bool)
-> (NamedEntity -> NamedEntity -> Bool)
-> (NamedEntity -> NamedEntity -> NamedEntity)
-> (NamedEntity -> NamedEntity -> NamedEntity)
-> Ord NamedEntity
NamedEntity -> NamedEntity -> Bool
NamedEntity -> NamedEntity -> Ordering
NamedEntity -> NamedEntity -> NamedEntity
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamedEntity -> NamedEntity -> Ordering
compare :: NamedEntity -> NamedEntity -> Ordering
$c< :: NamedEntity -> NamedEntity -> Bool
< :: NamedEntity -> NamedEntity -> Bool
$c<= :: NamedEntity -> NamedEntity -> Bool
<= :: NamedEntity -> NamedEntity -> Bool
$c> :: NamedEntity -> NamedEntity -> Bool
> :: NamedEntity -> NamedEntity -> Bool
$c>= :: NamedEntity -> NamedEntity -> Bool
>= :: NamedEntity -> NamedEntity -> Bool
$cmax :: NamedEntity -> NamedEntity -> NamedEntity
max :: NamedEntity -> NamedEntity -> NamedEntity
$cmin :: NamedEntity -> NamedEntity -> NamedEntity
min :: NamedEntity -> NamedEntity -> NamedEntity
Ord, ReadPrec [NamedEntity]
ReadPrec NamedEntity
Int -> ReadS NamedEntity
ReadS [NamedEntity]
(Int -> ReadS NamedEntity)
-> ReadS [NamedEntity]
-> ReadPrec NamedEntity
-> ReadPrec [NamedEntity]
-> Read NamedEntity
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamedEntity
readsPrec :: Int -> ReadS NamedEntity
$creadList :: ReadS [NamedEntity]
readList :: ReadS [NamedEntity]
$creadPrec :: ReadPrec NamedEntity
readPrec :: ReadPrec NamedEntity
$creadListPrec :: ReadPrec [NamedEntity]
readListPrec :: ReadPrec [NamedEntity]
Read, Int -> NamedEntity -> String -> String
[NamedEntity] -> String -> String
NamedEntity -> String
(Int -> NamedEntity -> String -> String)
-> (NamedEntity -> String)
-> ([NamedEntity] -> String -> String)
-> Show NamedEntity
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NamedEntity -> String -> String
showsPrec :: Int -> NamedEntity -> String -> String
$cshow :: NamedEntity -> String
show :: NamedEntity -> String
$cshowList :: [NamedEntity] -> String -> String
showList :: [NamedEntity] -> String -> String
Show)

_NamedEntity :: Name
_NamedEntity = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NamedEntity")

_NamedEntity_target :: Name
_NamedEntity_target = (String -> Name
Core.Name String
"target")

_NamedEntity_parts :: Name
_NamedEntity_parts = (String -> Name
Core.Name String
"parts")

data NamedEntityPart = 
  NamedEntityPart {
    NamedEntityPart -> Identifier
namedEntityPartIdentifier :: Identifier,
    NamedEntityPart -> Maybe TypeArgumentList
namedEntityPartTypeArguments :: (Maybe TypeArgumentList)}
  deriving (NamedEntityPart -> NamedEntityPart -> Bool
(NamedEntityPart -> NamedEntityPart -> Bool)
-> (NamedEntityPart -> NamedEntityPart -> Bool)
-> Eq NamedEntityPart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamedEntityPart -> NamedEntityPart -> Bool
== :: NamedEntityPart -> NamedEntityPart -> Bool
$c/= :: NamedEntityPart -> NamedEntityPart -> Bool
/= :: NamedEntityPart -> NamedEntityPart -> Bool
Eq, Eq NamedEntityPart
Eq NamedEntityPart =>
(NamedEntityPart -> NamedEntityPart -> Ordering)
-> (NamedEntityPart -> NamedEntityPart -> Bool)
-> (NamedEntityPart -> NamedEntityPart -> Bool)
-> (NamedEntityPart -> NamedEntityPart -> Bool)
-> (NamedEntityPart -> NamedEntityPart -> Bool)
-> (NamedEntityPart -> NamedEntityPart -> NamedEntityPart)
-> (NamedEntityPart -> NamedEntityPart -> NamedEntityPart)
-> Ord NamedEntityPart
NamedEntityPart -> NamedEntityPart -> Bool
NamedEntityPart -> NamedEntityPart -> Ordering
NamedEntityPart -> NamedEntityPart -> NamedEntityPart
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamedEntityPart -> NamedEntityPart -> Ordering
compare :: NamedEntityPart -> NamedEntityPart -> Ordering
$c< :: NamedEntityPart -> NamedEntityPart -> Bool
< :: NamedEntityPart -> NamedEntityPart -> Bool
$c<= :: NamedEntityPart -> NamedEntityPart -> Bool
<= :: NamedEntityPart -> NamedEntityPart -> Bool
$c> :: NamedEntityPart -> NamedEntityPart -> Bool
> :: NamedEntityPart -> NamedEntityPart -> Bool
$c>= :: NamedEntityPart -> NamedEntityPart -> Bool
>= :: NamedEntityPart -> NamedEntityPart -> Bool
$cmax :: NamedEntityPart -> NamedEntityPart -> NamedEntityPart
max :: NamedEntityPart -> NamedEntityPart -> NamedEntityPart
$cmin :: NamedEntityPart -> NamedEntityPart -> NamedEntityPart
min :: NamedEntityPart -> NamedEntityPart -> NamedEntityPart
Ord, ReadPrec [NamedEntityPart]
ReadPrec NamedEntityPart
Int -> ReadS NamedEntityPart
ReadS [NamedEntityPart]
(Int -> ReadS NamedEntityPart)
-> ReadS [NamedEntityPart]
-> ReadPrec NamedEntityPart
-> ReadPrec [NamedEntityPart]
-> Read NamedEntityPart
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamedEntityPart
readsPrec :: Int -> ReadS NamedEntityPart
$creadList :: ReadS [NamedEntityPart]
readList :: ReadS [NamedEntityPart]
$creadPrec :: ReadPrec NamedEntityPart
readPrec :: ReadPrec NamedEntityPart
$creadListPrec :: ReadPrec [NamedEntityPart]
readListPrec :: ReadPrec [NamedEntityPart]
Read, Int -> NamedEntityPart -> String -> String
[NamedEntityPart] -> String -> String
NamedEntityPart -> String
(Int -> NamedEntityPart -> String -> String)
-> (NamedEntityPart -> String)
-> ([NamedEntityPart] -> String -> String)
-> Show NamedEntityPart
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NamedEntityPart -> String -> String
showsPrec :: Int -> NamedEntityPart -> String -> String
$cshow :: NamedEntityPart -> String
show :: NamedEntityPart -> String
$cshowList :: [NamedEntityPart] -> String -> String
showList :: [NamedEntityPart] -> String -> String
Show)

_NamedEntityPart :: Name
_NamedEntityPart = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NamedEntityPart")

_NamedEntityPart_identifier :: Name
_NamedEntityPart_identifier = (String -> Name
Core.Name String
"identifier")

_NamedEntityPart_typeArguments :: Name
_NamedEntityPart_typeArguments = (String -> Name
Core.Name String
"typeArguments")

data NamedEntityTarget = 
  NamedEntityTargetName SimpleName |
  NamedEntityTargetThis  |
  NamedEntityTargetBase  |
  NamedEntityTargetPredefinedType PredefinedType |
  NamedEntityTargetQualifiedAliasMember QualifiedAliasMember
  deriving (NamedEntityTarget -> NamedEntityTarget -> Bool
(NamedEntityTarget -> NamedEntityTarget -> Bool)
-> (NamedEntityTarget -> NamedEntityTarget -> Bool)
-> Eq NamedEntityTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamedEntityTarget -> NamedEntityTarget -> Bool
== :: NamedEntityTarget -> NamedEntityTarget -> Bool
$c/= :: NamedEntityTarget -> NamedEntityTarget -> Bool
/= :: NamedEntityTarget -> NamedEntityTarget -> Bool
Eq, Eq NamedEntityTarget
Eq NamedEntityTarget =>
(NamedEntityTarget -> NamedEntityTarget -> Ordering)
-> (NamedEntityTarget -> NamedEntityTarget -> Bool)
-> (NamedEntityTarget -> NamedEntityTarget -> Bool)
-> (NamedEntityTarget -> NamedEntityTarget -> Bool)
-> (NamedEntityTarget -> NamedEntityTarget -> Bool)
-> (NamedEntityTarget -> NamedEntityTarget -> NamedEntityTarget)
-> (NamedEntityTarget -> NamedEntityTarget -> NamedEntityTarget)
-> Ord NamedEntityTarget
NamedEntityTarget -> NamedEntityTarget -> Bool
NamedEntityTarget -> NamedEntityTarget -> Ordering
NamedEntityTarget -> NamedEntityTarget -> NamedEntityTarget
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamedEntityTarget -> NamedEntityTarget -> Ordering
compare :: NamedEntityTarget -> NamedEntityTarget -> Ordering
$c< :: NamedEntityTarget -> NamedEntityTarget -> Bool
< :: NamedEntityTarget -> NamedEntityTarget -> Bool
$c<= :: NamedEntityTarget -> NamedEntityTarget -> Bool
<= :: NamedEntityTarget -> NamedEntityTarget -> Bool
$c> :: NamedEntityTarget -> NamedEntityTarget -> Bool
> :: NamedEntityTarget -> NamedEntityTarget -> Bool
$c>= :: NamedEntityTarget -> NamedEntityTarget -> Bool
>= :: NamedEntityTarget -> NamedEntityTarget -> Bool
$cmax :: NamedEntityTarget -> NamedEntityTarget -> NamedEntityTarget
max :: NamedEntityTarget -> NamedEntityTarget -> NamedEntityTarget
$cmin :: NamedEntityTarget -> NamedEntityTarget -> NamedEntityTarget
min :: NamedEntityTarget -> NamedEntityTarget -> NamedEntityTarget
Ord, ReadPrec [NamedEntityTarget]
ReadPrec NamedEntityTarget
Int -> ReadS NamedEntityTarget
ReadS [NamedEntityTarget]
(Int -> ReadS NamedEntityTarget)
-> ReadS [NamedEntityTarget]
-> ReadPrec NamedEntityTarget
-> ReadPrec [NamedEntityTarget]
-> Read NamedEntityTarget
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamedEntityTarget
readsPrec :: Int -> ReadS NamedEntityTarget
$creadList :: ReadS [NamedEntityTarget]
readList :: ReadS [NamedEntityTarget]
$creadPrec :: ReadPrec NamedEntityTarget
readPrec :: ReadPrec NamedEntityTarget
$creadListPrec :: ReadPrec [NamedEntityTarget]
readListPrec :: ReadPrec [NamedEntityTarget]
Read, Int -> NamedEntityTarget -> String -> String
[NamedEntityTarget] -> String -> String
NamedEntityTarget -> String
(Int -> NamedEntityTarget -> String -> String)
-> (NamedEntityTarget -> String)
-> ([NamedEntityTarget] -> String -> String)
-> Show NamedEntityTarget
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NamedEntityTarget -> String -> String
showsPrec :: Int -> NamedEntityTarget -> String -> String
$cshow :: NamedEntityTarget -> String
show :: NamedEntityTarget -> String
$cshowList :: [NamedEntityTarget] -> String -> String
showList :: [NamedEntityTarget] -> String -> String
Show)

_NamedEntityTarget :: Name
_NamedEntityTarget = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NamedEntityTarget")

_NamedEntityTarget_name :: Name
_NamedEntityTarget_name = (String -> Name
Core.Name String
"name")

_NamedEntityTarget_this :: Name
_NamedEntityTarget_this = (String -> Name
Core.Name String
"this")

_NamedEntityTarget_base :: Name
_NamedEntityTarget_base = (String -> Name
Core.Name String
"base")

_NamedEntityTarget_predefinedType :: Name
_NamedEntityTarget_predefinedType = (String -> Name
Core.Name String
"predefinedType")

_NamedEntityTarget_qualifiedAliasMember :: Name
_NamedEntityTarget_qualifiedAliasMember = (String -> Name
Core.Name String
"qualifiedAliasMember")

data UnaryExpression = 
  UnaryExpressionPrimary PrimaryExpression |
  UnaryExpressionPlus UnaryExpression |
  UnaryExpressionMinus UnaryExpression |
  UnaryExpressionNot UnaryExpression |
  UnaryExpressionBitwiseComplement UnaryExpression |
  UnaryExpressionPreIncrement UnaryExpression |
  UnaryExpressionPreDecrement UnaryExpression |
  UnaryExpressionCast CastExpression |
  UnaryExpressionAwait UnaryExpression |
  UnaryExpressionPointerIndirection UnaryExpression |
  UnaryExpressionAddressOf UnaryExpression
  deriving (UnaryExpression -> UnaryExpression -> Bool
(UnaryExpression -> UnaryExpression -> Bool)
-> (UnaryExpression -> UnaryExpression -> Bool)
-> Eq UnaryExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnaryExpression -> UnaryExpression -> Bool
== :: UnaryExpression -> UnaryExpression -> Bool
$c/= :: UnaryExpression -> UnaryExpression -> Bool
/= :: UnaryExpression -> UnaryExpression -> Bool
Eq, Eq UnaryExpression
Eq UnaryExpression =>
(UnaryExpression -> UnaryExpression -> Ordering)
-> (UnaryExpression -> UnaryExpression -> Bool)
-> (UnaryExpression -> UnaryExpression -> Bool)
-> (UnaryExpression -> UnaryExpression -> Bool)
-> (UnaryExpression -> UnaryExpression -> Bool)
-> (UnaryExpression -> UnaryExpression -> UnaryExpression)
-> (UnaryExpression -> UnaryExpression -> UnaryExpression)
-> Ord UnaryExpression
UnaryExpression -> UnaryExpression -> Bool
UnaryExpression -> UnaryExpression -> Ordering
UnaryExpression -> UnaryExpression -> UnaryExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnaryExpression -> UnaryExpression -> Ordering
compare :: UnaryExpression -> UnaryExpression -> Ordering
$c< :: UnaryExpression -> UnaryExpression -> Bool
< :: UnaryExpression -> UnaryExpression -> Bool
$c<= :: UnaryExpression -> UnaryExpression -> Bool
<= :: UnaryExpression -> UnaryExpression -> Bool
$c> :: UnaryExpression -> UnaryExpression -> Bool
> :: UnaryExpression -> UnaryExpression -> Bool
$c>= :: UnaryExpression -> UnaryExpression -> Bool
>= :: UnaryExpression -> UnaryExpression -> Bool
$cmax :: UnaryExpression -> UnaryExpression -> UnaryExpression
max :: UnaryExpression -> UnaryExpression -> UnaryExpression
$cmin :: UnaryExpression -> UnaryExpression -> UnaryExpression
min :: UnaryExpression -> UnaryExpression -> UnaryExpression
Ord, ReadPrec [UnaryExpression]
ReadPrec UnaryExpression
Int -> ReadS UnaryExpression
ReadS [UnaryExpression]
(Int -> ReadS UnaryExpression)
-> ReadS [UnaryExpression]
-> ReadPrec UnaryExpression
-> ReadPrec [UnaryExpression]
-> Read UnaryExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UnaryExpression
readsPrec :: Int -> ReadS UnaryExpression
$creadList :: ReadS [UnaryExpression]
readList :: ReadS [UnaryExpression]
$creadPrec :: ReadPrec UnaryExpression
readPrec :: ReadPrec UnaryExpression
$creadListPrec :: ReadPrec [UnaryExpression]
readListPrec :: ReadPrec [UnaryExpression]
Read, Int -> UnaryExpression -> String -> String
[UnaryExpression] -> String -> String
UnaryExpression -> String
(Int -> UnaryExpression -> String -> String)
-> (UnaryExpression -> String)
-> ([UnaryExpression] -> String -> String)
-> Show UnaryExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UnaryExpression -> String -> String
showsPrec :: Int -> UnaryExpression -> String -> String
$cshow :: UnaryExpression -> String
show :: UnaryExpression -> String
$cshowList :: [UnaryExpression] -> String -> String
showList :: [UnaryExpression] -> String -> String
Show)

_UnaryExpression :: Name
_UnaryExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.UnaryExpression")

_UnaryExpression_primary :: Name
_UnaryExpression_primary = (String -> Name
Core.Name String
"primary")

_UnaryExpression_plus :: Name
_UnaryExpression_plus = (String -> Name
Core.Name String
"plus")

_UnaryExpression_minus :: Name
_UnaryExpression_minus = (String -> Name
Core.Name String
"minus")

_UnaryExpression_not :: Name
_UnaryExpression_not = (String -> Name
Core.Name String
"not")

_UnaryExpression_bitwiseComplement :: Name
_UnaryExpression_bitwiseComplement = (String -> Name
Core.Name String
"bitwiseComplement")

_UnaryExpression_preIncrement :: Name
_UnaryExpression_preIncrement = (String -> Name
Core.Name String
"preIncrement")

_UnaryExpression_preDecrement :: Name
_UnaryExpression_preDecrement = (String -> Name
Core.Name String
"preDecrement")

_UnaryExpression_cast :: Name
_UnaryExpression_cast = (String -> Name
Core.Name String
"cast")

_UnaryExpression_await :: Name
_UnaryExpression_await = (String -> Name
Core.Name String
"await")

_UnaryExpression_pointerIndirection :: Name
_UnaryExpression_pointerIndirection = (String -> Name
Core.Name String
"pointerIndirection")

_UnaryExpression_addressOf :: Name
_UnaryExpression_addressOf = (String -> Name
Core.Name String
"addressOf")

data CastExpression = 
  CastExpression {
    CastExpression -> Type
castExpressionType :: Type,
    CastExpression -> UnaryExpression
castExpressionExpression :: UnaryExpression}
  deriving (CastExpression -> CastExpression -> Bool
(CastExpression -> CastExpression -> Bool)
-> (CastExpression -> CastExpression -> Bool) -> Eq CastExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CastExpression -> CastExpression -> Bool
== :: CastExpression -> CastExpression -> Bool
$c/= :: CastExpression -> CastExpression -> Bool
/= :: CastExpression -> CastExpression -> Bool
Eq, Eq CastExpression
Eq CastExpression =>
(CastExpression -> CastExpression -> Ordering)
-> (CastExpression -> CastExpression -> Bool)
-> (CastExpression -> CastExpression -> Bool)
-> (CastExpression -> CastExpression -> Bool)
-> (CastExpression -> CastExpression -> Bool)
-> (CastExpression -> CastExpression -> CastExpression)
-> (CastExpression -> CastExpression -> CastExpression)
-> Ord CastExpression
CastExpression -> CastExpression -> Bool
CastExpression -> CastExpression -> Ordering
CastExpression -> CastExpression -> CastExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CastExpression -> CastExpression -> Ordering
compare :: CastExpression -> CastExpression -> Ordering
$c< :: CastExpression -> CastExpression -> Bool
< :: CastExpression -> CastExpression -> Bool
$c<= :: CastExpression -> CastExpression -> Bool
<= :: CastExpression -> CastExpression -> Bool
$c> :: CastExpression -> CastExpression -> Bool
> :: CastExpression -> CastExpression -> Bool
$c>= :: CastExpression -> CastExpression -> Bool
>= :: CastExpression -> CastExpression -> Bool
$cmax :: CastExpression -> CastExpression -> CastExpression
max :: CastExpression -> CastExpression -> CastExpression
$cmin :: CastExpression -> CastExpression -> CastExpression
min :: CastExpression -> CastExpression -> CastExpression
Ord, ReadPrec [CastExpression]
ReadPrec CastExpression
Int -> ReadS CastExpression
ReadS [CastExpression]
(Int -> ReadS CastExpression)
-> ReadS [CastExpression]
-> ReadPrec CastExpression
-> ReadPrec [CastExpression]
-> Read CastExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CastExpression
readsPrec :: Int -> ReadS CastExpression
$creadList :: ReadS [CastExpression]
readList :: ReadS [CastExpression]
$creadPrec :: ReadPrec CastExpression
readPrec :: ReadPrec CastExpression
$creadListPrec :: ReadPrec [CastExpression]
readListPrec :: ReadPrec [CastExpression]
Read, Int -> CastExpression -> String -> String
[CastExpression] -> String -> String
CastExpression -> String
(Int -> CastExpression -> String -> String)
-> (CastExpression -> String)
-> ([CastExpression] -> String -> String)
-> Show CastExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> CastExpression -> String -> String
showsPrec :: Int -> CastExpression -> String -> String
$cshow :: CastExpression -> String
show :: CastExpression -> String
$cshowList :: [CastExpression] -> String -> String
showList :: [CastExpression] -> String -> String
Show)

_CastExpression :: Name
_CastExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.CastExpression")

_CastExpression_type :: Name
_CastExpression_type = (String -> Name
Core.Name String
"type")

_CastExpression_expression :: Name
_CastExpression_expression = (String -> Name
Core.Name String
"expression")

data MultiplicativeExpression = 
  MultiplicativeExpressionSimple UnaryExpression |
  MultiplicativeExpressionBinary BinaryMultiplicativeExpression
  deriving (MultiplicativeExpression -> MultiplicativeExpression -> Bool
(MultiplicativeExpression -> MultiplicativeExpression -> Bool)
-> (MultiplicativeExpression -> MultiplicativeExpression -> Bool)
-> Eq MultiplicativeExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
== :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
$c/= :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
/= :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
Eq, Eq MultiplicativeExpression
Eq MultiplicativeExpression =>
(MultiplicativeExpression -> MultiplicativeExpression -> Ordering)
-> (MultiplicativeExpression -> MultiplicativeExpression -> Bool)
-> (MultiplicativeExpression -> MultiplicativeExpression -> Bool)
-> (MultiplicativeExpression -> MultiplicativeExpression -> Bool)
-> (MultiplicativeExpression -> MultiplicativeExpression -> Bool)
-> (MultiplicativeExpression
    -> MultiplicativeExpression -> MultiplicativeExpression)
-> (MultiplicativeExpression
    -> MultiplicativeExpression -> MultiplicativeExpression)
-> Ord MultiplicativeExpression
MultiplicativeExpression -> MultiplicativeExpression -> Bool
MultiplicativeExpression -> MultiplicativeExpression -> Ordering
MultiplicativeExpression
-> MultiplicativeExpression -> MultiplicativeExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MultiplicativeExpression -> MultiplicativeExpression -> Ordering
compare :: MultiplicativeExpression -> MultiplicativeExpression -> Ordering
$c< :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
< :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
$c<= :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
<= :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
$c> :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
> :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
$c>= :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
>= :: MultiplicativeExpression -> MultiplicativeExpression -> Bool
$cmax :: MultiplicativeExpression
-> MultiplicativeExpression -> MultiplicativeExpression
max :: MultiplicativeExpression
-> MultiplicativeExpression -> MultiplicativeExpression
$cmin :: MultiplicativeExpression
-> MultiplicativeExpression -> MultiplicativeExpression
min :: MultiplicativeExpression
-> MultiplicativeExpression -> MultiplicativeExpression
Ord, ReadPrec [MultiplicativeExpression]
ReadPrec MultiplicativeExpression
Int -> ReadS MultiplicativeExpression
ReadS [MultiplicativeExpression]
(Int -> ReadS MultiplicativeExpression)
-> ReadS [MultiplicativeExpression]
-> ReadPrec MultiplicativeExpression
-> ReadPrec [MultiplicativeExpression]
-> Read MultiplicativeExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MultiplicativeExpression
readsPrec :: Int -> ReadS MultiplicativeExpression
$creadList :: ReadS [MultiplicativeExpression]
readList :: ReadS [MultiplicativeExpression]
$creadPrec :: ReadPrec MultiplicativeExpression
readPrec :: ReadPrec MultiplicativeExpression
$creadListPrec :: ReadPrec [MultiplicativeExpression]
readListPrec :: ReadPrec [MultiplicativeExpression]
Read, Int -> MultiplicativeExpression -> String -> String
[MultiplicativeExpression] -> String -> String
MultiplicativeExpression -> String
(Int -> MultiplicativeExpression -> String -> String)
-> (MultiplicativeExpression -> String)
-> ([MultiplicativeExpression] -> String -> String)
-> Show MultiplicativeExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MultiplicativeExpression -> String -> String
showsPrec :: Int -> MultiplicativeExpression -> String -> String
$cshow :: MultiplicativeExpression -> String
show :: MultiplicativeExpression -> String
$cshowList :: [MultiplicativeExpression] -> String -> String
showList :: [MultiplicativeExpression] -> String -> String
Show)

_MultiplicativeExpression :: Name
_MultiplicativeExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MultiplicativeExpression")

_MultiplicativeExpression_simple :: Name
_MultiplicativeExpression_simple = (String -> Name
Core.Name String
"simple")

_MultiplicativeExpression_binary :: Name
_MultiplicativeExpression_binary = (String -> Name
Core.Name String
"binary")

data BinaryMultiplicativeExpression = 
  BinaryMultiplicativeExpression {
    BinaryMultiplicativeExpression -> MultiplicativeExpression
binaryMultiplicativeExpressionLeft :: MultiplicativeExpression,
    BinaryMultiplicativeExpression -> MultiplicativeOperator
binaryMultiplicativeExpressionOperator :: MultiplicativeOperator,
    BinaryMultiplicativeExpression -> UnaryExpression
binaryMultiplicativeExpressionRight :: UnaryExpression}
  deriving (BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
(BinaryMultiplicativeExpression
 -> BinaryMultiplicativeExpression -> Bool)
-> (BinaryMultiplicativeExpression
    -> BinaryMultiplicativeExpression -> Bool)
-> Eq BinaryMultiplicativeExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
== :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
$c/= :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
/= :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
Eq, Eq BinaryMultiplicativeExpression
Eq BinaryMultiplicativeExpression =>
(BinaryMultiplicativeExpression
 -> BinaryMultiplicativeExpression -> Ordering)
-> (BinaryMultiplicativeExpression
    -> BinaryMultiplicativeExpression -> Bool)
-> (BinaryMultiplicativeExpression
    -> BinaryMultiplicativeExpression -> Bool)
-> (BinaryMultiplicativeExpression
    -> BinaryMultiplicativeExpression -> Bool)
-> (BinaryMultiplicativeExpression
    -> BinaryMultiplicativeExpression -> Bool)
-> (BinaryMultiplicativeExpression
    -> BinaryMultiplicativeExpression
    -> BinaryMultiplicativeExpression)
-> (BinaryMultiplicativeExpression
    -> BinaryMultiplicativeExpression
    -> BinaryMultiplicativeExpression)
-> Ord BinaryMultiplicativeExpression
BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Ordering
BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> BinaryMultiplicativeExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Ordering
compare :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Ordering
$c< :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
< :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
$c<= :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
<= :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
$c> :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
> :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
$c>= :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
>= :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> Bool
$cmax :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> BinaryMultiplicativeExpression
max :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> BinaryMultiplicativeExpression
$cmin :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> BinaryMultiplicativeExpression
min :: BinaryMultiplicativeExpression
-> BinaryMultiplicativeExpression -> BinaryMultiplicativeExpression
Ord, ReadPrec [BinaryMultiplicativeExpression]
ReadPrec BinaryMultiplicativeExpression
Int -> ReadS BinaryMultiplicativeExpression
ReadS [BinaryMultiplicativeExpression]
(Int -> ReadS BinaryMultiplicativeExpression)
-> ReadS [BinaryMultiplicativeExpression]
-> ReadPrec BinaryMultiplicativeExpression
-> ReadPrec [BinaryMultiplicativeExpression]
-> Read BinaryMultiplicativeExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryMultiplicativeExpression
readsPrec :: Int -> ReadS BinaryMultiplicativeExpression
$creadList :: ReadS [BinaryMultiplicativeExpression]
readList :: ReadS [BinaryMultiplicativeExpression]
$creadPrec :: ReadPrec BinaryMultiplicativeExpression
readPrec :: ReadPrec BinaryMultiplicativeExpression
$creadListPrec :: ReadPrec [BinaryMultiplicativeExpression]
readListPrec :: ReadPrec [BinaryMultiplicativeExpression]
Read, Int -> BinaryMultiplicativeExpression -> String -> String
[BinaryMultiplicativeExpression] -> String -> String
BinaryMultiplicativeExpression -> String
(Int -> BinaryMultiplicativeExpression -> String -> String)
-> (BinaryMultiplicativeExpression -> String)
-> ([BinaryMultiplicativeExpression] -> String -> String)
-> Show BinaryMultiplicativeExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryMultiplicativeExpression -> String -> String
showsPrec :: Int -> BinaryMultiplicativeExpression -> String -> String
$cshow :: BinaryMultiplicativeExpression -> String
show :: BinaryMultiplicativeExpression -> String
$cshowList :: [BinaryMultiplicativeExpression] -> String -> String
showList :: [BinaryMultiplicativeExpression] -> String -> String
Show)

_BinaryMultiplicativeExpression :: Name
_BinaryMultiplicativeExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryMultiplicativeExpression")

_BinaryMultiplicativeExpression_left :: Name
_BinaryMultiplicativeExpression_left = (String -> Name
Core.Name String
"left")

_BinaryMultiplicativeExpression_operator :: Name
_BinaryMultiplicativeExpression_operator = (String -> Name
Core.Name String
"operator")

_BinaryMultiplicativeExpression_right :: Name
_BinaryMultiplicativeExpression_right = (String -> Name
Core.Name String
"right")

data MultiplicativeOperator = 
  MultiplicativeOperatorTimes  |
  MultiplicativeOperatorDivide  |
  MultiplicativeOperatorModulo 
  deriving (MultiplicativeOperator -> MultiplicativeOperator -> Bool
(MultiplicativeOperator -> MultiplicativeOperator -> Bool)
-> (MultiplicativeOperator -> MultiplicativeOperator -> Bool)
-> Eq MultiplicativeOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
== :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
$c/= :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
/= :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
Eq, Eq MultiplicativeOperator
Eq MultiplicativeOperator =>
(MultiplicativeOperator -> MultiplicativeOperator -> Ordering)
-> (MultiplicativeOperator -> MultiplicativeOperator -> Bool)
-> (MultiplicativeOperator -> MultiplicativeOperator -> Bool)
-> (MultiplicativeOperator -> MultiplicativeOperator -> Bool)
-> (MultiplicativeOperator -> MultiplicativeOperator -> Bool)
-> (MultiplicativeOperator
    -> MultiplicativeOperator -> MultiplicativeOperator)
-> (MultiplicativeOperator
    -> MultiplicativeOperator -> MultiplicativeOperator)
-> Ord MultiplicativeOperator
MultiplicativeOperator -> MultiplicativeOperator -> Bool
MultiplicativeOperator -> MultiplicativeOperator -> Ordering
MultiplicativeOperator
-> MultiplicativeOperator -> MultiplicativeOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MultiplicativeOperator -> MultiplicativeOperator -> Ordering
compare :: MultiplicativeOperator -> MultiplicativeOperator -> Ordering
$c< :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
< :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
$c<= :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
<= :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
$c> :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
> :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
$c>= :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
>= :: MultiplicativeOperator -> MultiplicativeOperator -> Bool
$cmax :: MultiplicativeOperator
-> MultiplicativeOperator -> MultiplicativeOperator
max :: MultiplicativeOperator
-> MultiplicativeOperator -> MultiplicativeOperator
$cmin :: MultiplicativeOperator
-> MultiplicativeOperator -> MultiplicativeOperator
min :: MultiplicativeOperator
-> MultiplicativeOperator -> MultiplicativeOperator
Ord, ReadPrec [MultiplicativeOperator]
ReadPrec MultiplicativeOperator
Int -> ReadS MultiplicativeOperator
ReadS [MultiplicativeOperator]
(Int -> ReadS MultiplicativeOperator)
-> ReadS [MultiplicativeOperator]
-> ReadPrec MultiplicativeOperator
-> ReadPrec [MultiplicativeOperator]
-> Read MultiplicativeOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MultiplicativeOperator
readsPrec :: Int -> ReadS MultiplicativeOperator
$creadList :: ReadS [MultiplicativeOperator]
readList :: ReadS [MultiplicativeOperator]
$creadPrec :: ReadPrec MultiplicativeOperator
readPrec :: ReadPrec MultiplicativeOperator
$creadListPrec :: ReadPrec [MultiplicativeOperator]
readListPrec :: ReadPrec [MultiplicativeOperator]
Read, Int -> MultiplicativeOperator -> String -> String
[MultiplicativeOperator] -> String -> String
MultiplicativeOperator -> String
(Int -> MultiplicativeOperator -> String -> String)
-> (MultiplicativeOperator -> String)
-> ([MultiplicativeOperator] -> String -> String)
-> Show MultiplicativeOperator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MultiplicativeOperator -> String -> String
showsPrec :: Int -> MultiplicativeOperator -> String -> String
$cshow :: MultiplicativeOperator -> String
show :: MultiplicativeOperator -> String
$cshowList :: [MultiplicativeOperator] -> String -> String
showList :: [MultiplicativeOperator] -> String -> String
Show)

_MultiplicativeOperator :: Name
_MultiplicativeOperator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MultiplicativeOperator")

_MultiplicativeOperator_times :: Name
_MultiplicativeOperator_times = (String -> Name
Core.Name String
"times")

_MultiplicativeOperator_divide :: Name
_MultiplicativeOperator_divide = (String -> Name
Core.Name String
"divide")

_MultiplicativeOperator_modulo :: Name
_MultiplicativeOperator_modulo = (String -> Name
Core.Name String
"modulo")

data AdditiveExpression = 
  AdditiveExpressionSimple MultiplicativeExpression |
  AdditiveExpressionBinary BinaryAdditiveExpression
  deriving (AdditiveExpression -> AdditiveExpression -> Bool
(AdditiveExpression -> AdditiveExpression -> Bool)
-> (AdditiveExpression -> AdditiveExpression -> Bool)
-> Eq AdditiveExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AdditiveExpression -> AdditiveExpression -> Bool
== :: AdditiveExpression -> AdditiveExpression -> Bool
$c/= :: AdditiveExpression -> AdditiveExpression -> Bool
/= :: AdditiveExpression -> AdditiveExpression -> Bool
Eq, Eq AdditiveExpression
Eq AdditiveExpression =>
(AdditiveExpression -> AdditiveExpression -> Ordering)
-> (AdditiveExpression -> AdditiveExpression -> Bool)
-> (AdditiveExpression -> AdditiveExpression -> Bool)
-> (AdditiveExpression -> AdditiveExpression -> Bool)
-> (AdditiveExpression -> AdditiveExpression -> Bool)
-> (AdditiveExpression -> AdditiveExpression -> AdditiveExpression)
-> (AdditiveExpression -> AdditiveExpression -> AdditiveExpression)
-> Ord AdditiveExpression
AdditiveExpression -> AdditiveExpression -> Bool
AdditiveExpression -> AdditiveExpression -> Ordering
AdditiveExpression -> AdditiveExpression -> AdditiveExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AdditiveExpression -> AdditiveExpression -> Ordering
compare :: AdditiveExpression -> AdditiveExpression -> Ordering
$c< :: AdditiveExpression -> AdditiveExpression -> Bool
< :: AdditiveExpression -> AdditiveExpression -> Bool
$c<= :: AdditiveExpression -> AdditiveExpression -> Bool
<= :: AdditiveExpression -> AdditiveExpression -> Bool
$c> :: AdditiveExpression -> AdditiveExpression -> Bool
> :: AdditiveExpression -> AdditiveExpression -> Bool
$c>= :: AdditiveExpression -> AdditiveExpression -> Bool
>= :: AdditiveExpression -> AdditiveExpression -> Bool
$cmax :: AdditiveExpression -> AdditiveExpression -> AdditiveExpression
max :: AdditiveExpression -> AdditiveExpression -> AdditiveExpression
$cmin :: AdditiveExpression -> AdditiveExpression -> AdditiveExpression
min :: AdditiveExpression -> AdditiveExpression -> AdditiveExpression
Ord, ReadPrec [AdditiveExpression]
ReadPrec AdditiveExpression
Int -> ReadS AdditiveExpression
ReadS [AdditiveExpression]
(Int -> ReadS AdditiveExpression)
-> ReadS [AdditiveExpression]
-> ReadPrec AdditiveExpression
-> ReadPrec [AdditiveExpression]
-> Read AdditiveExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AdditiveExpression
readsPrec :: Int -> ReadS AdditiveExpression
$creadList :: ReadS [AdditiveExpression]
readList :: ReadS [AdditiveExpression]
$creadPrec :: ReadPrec AdditiveExpression
readPrec :: ReadPrec AdditiveExpression
$creadListPrec :: ReadPrec [AdditiveExpression]
readListPrec :: ReadPrec [AdditiveExpression]
Read, Int -> AdditiveExpression -> String -> String
[AdditiveExpression] -> String -> String
AdditiveExpression -> String
(Int -> AdditiveExpression -> String -> String)
-> (AdditiveExpression -> String)
-> ([AdditiveExpression] -> String -> String)
-> Show AdditiveExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AdditiveExpression -> String -> String
showsPrec :: Int -> AdditiveExpression -> String -> String
$cshow :: AdditiveExpression -> String
show :: AdditiveExpression -> String
$cshowList :: [AdditiveExpression] -> String -> String
showList :: [AdditiveExpression] -> String -> String
Show)

_AdditiveExpression :: Name
_AdditiveExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AdditiveExpression")

_AdditiveExpression_simple :: Name
_AdditiveExpression_simple = (String -> Name
Core.Name String
"simple")

_AdditiveExpression_binary :: Name
_AdditiveExpression_binary = (String -> Name
Core.Name String
"binary")

data BinaryAdditiveExpression = 
  BinaryAdditiveExpression {
    BinaryAdditiveExpression -> AdditiveExpression
binaryAdditiveExpressionLeft :: AdditiveExpression,
    BinaryAdditiveExpression -> AdditiveOperator
binaryAdditiveExpressionOperator :: AdditiveOperator,
    BinaryAdditiveExpression -> MultiplicativeExpression
binaryAdditiveExpressionRight :: MultiplicativeExpression}
  deriving (BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
(BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool)
-> (BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool)
-> Eq BinaryAdditiveExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
== :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
$c/= :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
/= :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
Eq, Eq BinaryAdditiveExpression
Eq BinaryAdditiveExpression =>
(BinaryAdditiveExpression -> BinaryAdditiveExpression -> Ordering)
-> (BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool)
-> (BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool)
-> (BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool)
-> (BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool)
-> (BinaryAdditiveExpression
    -> BinaryAdditiveExpression -> BinaryAdditiveExpression)
-> (BinaryAdditiveExpression
    -> BinaryAdditiveExpression -> BinaryAdditiveExpression)
-> Ord BinaryAdditiveExpression
BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
BinaryAdditiveExpression -> BinaryAdditiveExpression -> Ordering
BinaryAdditiveExpression
-> BinaryAdditiveExpression -> BinaryAdditiveExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Ordering
compare :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Ordering
$c< :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
< :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
$c<= :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
<= :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
$c> :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
> :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
$c>= :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
>= :: BinaryAdditiveExpression -> BinaryAdditiveExpression -> Bool
$cmax :: BinaryAdditiveExpression
-> BinaryAdditiveExpression -> BinaryAdditiveExpression
max :: BinaryAdditiveExpression
-> BinaryAdditiveExpression -> BinaryAdditiveExpression
$cmin :: BinaryAdditiveExpression
-> BinaryAdditiveExpression -> BinaryAdditiveExpression
min :: BinaryAdditiveExpression
-> BinaryAdditiveExpression -> BinaryAdditiveExpression
Ord, ReadPrec [BinaryAdditiveExpression]
ReadPrec BinaryAdditiveExpression
Int -> ReadS BinaryAdditiveExpression
ReadS [BinaryAdditiveExpression]
(Int -> ReadS BinaryAdditiveExpression)
-> ReadS [BinaryAdditiveExpression]
-> ReadPrec BinaryAdditiveExpression
-> ReadPrec [BinaryAdditiveExpression]
-> Read BinaryAdditiveExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryAdditiveExpression
readsPrec :: Int -> ReadS BinaryAdditiveExpression
$creadList :: ReadS [BinaryAdditiveExpression]
readList :: ReadS [BinaryAdditiveExpression]
$creadPrec :: ReadPrec BinaryAdditiveExpression
readPrec :: ReadPrec BinaryAdditiveExpression
$creadListPrec :: ReadPrec [BinaryAdditiveExpression]
readListPrec :: ReadPrec [BinaryAdditiveExpression]
Read, Int -> BinaryAdditiveExpression -> String -> String
[BinaryAdditiveExpression] -> String -> String
BinaryAdditiveExpression -> String
(Int -> BinaryAdditiveExpression -> String -> String)
-> (BinaryAdditiveExpression -> String)
-> ([BinaryAdditiveExpression] -> String -> String)
-> Show BinaryAdditiveExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryAdditiveExpression -> String -> String
showsPrec :: Int -> BinaryAdditiveExpression -> String -> String
$cshow :: BinaryAdditiveExpression -> String
show :: BinaryAdditiveExpression -> String
$cshowList :: [BinaryAdditiveExpression] -> String -> String
showList :: [BinaryAdditiveExpression] -> String -> String
Show)

_BinaryAdditiveExpression :: Name
_BinaryAdditiveExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryAdditiveExpression")

_BinaryAdditiveExpression_left :: Name
_BinaryAdditiveExpression_left = (String -> Name
Core.Name String
"left")

_BinaryAdditiveExpression_operator :: Name
_BinaryAdditiveExpression_operator = (String -> Name
Core.Name String
"operator")

_BinaryAdditiveExpression_right :: Name
_BinaryAdditiveExpression_right = (String -> Name
Core.Name String
"right")

data AdditiveOperator = 
  AdditiveOperatorPlus  |
  AdditiveOperatorMinus 
  deriving (AdditiveOperator -> AdditiveOperator -> Bool
(AdditiveOperator -> AdditiveOperator -> Bool)
-> (AdditiveOperator -> AdditiveOperator -> Bool)
-> Eq AdditiveOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AdditiveOperator -> AdditiveOperator -> Bool
== :: AdditiveOperator -> AdditiveOperator -> Bool
$c/= :: AdditiveOperator -> AdditiveOperator -> Bool
/= :: AdditiveOperator -> AdditiveOperator -> Bool
Eq, Eq AdditiveOperator
Eq AdditiveOperator =>
(AdditiveOperator -> AdditiveOperator -> Ordering)
-> (AdditiveOperator -> AdditiveOperator -> Bool)
-> (AdditiveOperator -> AdditiveOperator -> Bool)
-> (AdditiveOperator -> AdditiveOperator -> Bool)
-> (AdditiveOperator -> AdditiveOperator -> Bool)
-> (AdditiveOperator -> AdditiveOperator -> AdditiveOperator)
-> (AdditiveOperator -> AdditiveOperator -> AdditiveOperator)
-> Ord AdditiveOperator
AdditiveOperator -> AdditiveOperator -> Bool
AdditiveOperator -> AdditiveOperator -> Ordering
AdditiveOperator -> AdditiveOperator -> AdditiveOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AdditiveOperator -> AdditiveOperator -> Ordering
compare :: AdditiveOperator -> AdditiveOperator -> Ordering
$c< :: AdditiveOperator -> AdditiveOperator -> Bool
< :: AdditiveOperator -> AdditiveOperator -> Bool
$c<= :: AdditiveOperator -> AdditiveOperator -> Bool
<= :: AdditiveOperator -> AdditiveOperator -> Bool
$c> :: AdditiveOperator -> AdditiveOperator -> Bool
> :: AdditiveOperator -> AdditiveOperator -> Bool
$c>= :: AdditiveOperator -> AdditiveOperator -> Bool
>= :: AdditiveOperator -> AdditiveOperator -> Bool
$cmax :: AdditiveOperator -> AdditiveOperator -> AdditiveOperator
max :: AdditiveOperator -> AdditiveOperator -> AdditiveOperator
$cmin :: AdditiveOperator -> AdditiveOperator -> AdditiveOperator
min :: AdditiveOperator -> AdditiveOperator -> AdditiveOperator
Ord, ReadPrec [AdditiveOperator]
ReadPrec AdditiveOperator
Int -> ReadS AdditiveOperator
ReadS [AdditiveOperator]
(Int -> ReadS AdditiveOperator)
-> ReadS [AdditiveOperator]
-> ReadPrec AdditiveOperator
-> ReadPrec [AdditiveOperator]
-> Read AdditiveOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AdditiveOperator
readsPrec :: Int -> ReadS AdditiveOperator
$creadList :: ReadS [AdditiveOperator]
readList :: ReadS [AdditiveOperator]
$creadPrec :: ReadPrec AdditiveOperator
readPrec :: ReadPrec AdditiveOperator
$creadListPrec :: ReadPrec [AdditiveOperator]
readListPrec :: ReadPrec [AdditiveOperator]
Read, Int -> AdditiveOperator -> String -> String
[AdditiveOperator] -> String -> String
AdditiveOperator -> String
(Int -> AdditiveOperator -> String -> String)
-> (AdditiveOperator -> String)
-> ([AdditiveOperator] -> String -> String)
-> Show AdditiveOperator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AdditiveOperator -> String -> String
showsPrec :: Int -> AdditiveOperator -> String -> String
$cshow :: AdditiveOperator -> String
show :: AdditiveOperator -> String
$cshowList :: [AdditiveOperator] -> String -> String
showList :: [AdditiveOperator] -> String -> String
Show)

_AdditiveOperator :: Name
_AdditiveOperator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AdditiveOperator")

_AdditiveOperator_plus :: Name
_AdditiveOperator_plus = (String -> Name
Core.Name String
"plus")

_AdditiveOperator_minus :: Name
_AdditiveOperator_minus = (String -> Name
Core.Name String
"minus")

data ShiftExpression = 
  ShiftExpressionSimple AdditiveExpression |
  ShiftExpressionBinary BinaryShiftExpression
  deriving (ShiftExpression -> ShiftExpression -> Bool
(ShiftExpression -> ShiftExpression -> Bool)
-> (ShiftExpression -> ShiftExpression -> Bool)
-> Eq ShiftExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShiftExpression -> ShiftExpression -> Bool
== :: ShiftExpression -> ShiftExpression -> Bool
$c/= :: ShiftExpression -> ShiftExpression -> Bool
/= :: ShiftExpression -> ShiftExpression -> Bool
Eq, Eq ShiftExpression
Eq ShiftExpression =>
(ShiftExpression -> ShiftExpression -> Ordering)
-> (ShiftExpression -> ShiftExpression -> Bool)
-> (ShiftExpression -> ShiftExpression -> Bool)
-> (ShiftExpression -> ShiftExpression -> Bool)
-> (ShiftExpression -> ShiftExpression -> Bool)
-> (ShiftExpression -> ShiftExpression -> ShiftExpression)
-> (ShiftExpression -> ShiftExpression -> ShiftExpression)
-> Ord ShiftExpression
ShiftExpression -> ShiftExpression -> Bool
ShiftExpression -> ShiftExpression -> Ordering
ShiftExpression -> ShiftExpression -> ShiftExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ShiftExpression -> ShiftExpression -> Ordering
compare :: ShiftExpression -> ShiftExpression -> Ordering
$c< :: ShiftExpression -> ShiftExpression -> Bool
< :: ShiftExpression -> ShiftExpression -> Bool
$c<= :: ShiftExpression -> ShiftExpression -> Bool
<= :: ShiftExpression -> ShiftExpression -> Bool
$c> :: ShiftExpression -> ShiftExpression -> Bool
> :: ShiftExpression -> ShiftExpression -> Bool
$c>= :: ShiftExpression -> ShiftExpression -> Bool
>= :: ShiftExpression -> ShiftExpression -> Bool
$cmax :: ShiftExpression -> ShiftExpression -> ShiftExpression
max :: ShiftExpression -> ShiftExpression -> ShiftExpression
$cmin :: ShiftExpression -> ShiftExpression -> ShiftExpression
min :: ShiftExpression -> ShiftExpression -> ShiftExpression
Ord, ReadPrec [ShiftExpression]
ReadPrec ShiftExpression
Int -> ReadS ShiftExpression
ReadS [ShiftExpression]
(Int -> ReadS ShiftExpression)
-> ReadS [ShiftExpression]
-> ReadPrec ShiftExpression
-> ReadPrec [ShiftExpression]
-> Read ShiftExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ShiftExpression
readsPrec :: Int -> ReadS ShiftExpression
$creadList :: ReadS [ShiftExpression]
readList :: ReadS [ShiftExpression]
$creadPrec :: ReadPrec ShiftExpression
readPrec :: ReadPrec ShiftExpression
$creadListPrec :: ReadPrec [ShiftExpression]
readListPrec :: ReadPrec [ShiftExpression]
Read, Int -> ShiftExpression -> String -> String
[ShiftExpression] -> String -> String
ShiftExpression -> String
(Int -> ShiftExpression -> String -> String)
-> (ShiftExpression -> String)
-> ([ShiftExpression] -> String -> String)
-> Show ShiftExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ShiftExpression -> String -> String
showsPrec :: Int -> ShiftExpression -> String -> String
$cshow :: ShiftExpression -> String
show :: ShiftExpression -> String
$cshowList :: [ShiftExpression] -> String -> String
showList :: [ShiftExpression] -> String -> String
Show)

_ShiftExpression :: Name
_ShiftExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ShiftExpression")

_ShiftExpression_simple :: Name
_ShiftExpression_simple = (String -> Name
Core.Name String
"simple")

_ShiftExpression_binary :: Name
_ShiftExpression_binary = (String -> Name
Core.Name String
"binary")

data BinaryShiftExpression = 
  BinaryShiftExpression {
    BinaryShiftExpression -> ShiftExpression
binaryShiftExpressionLeft :: ShiftExpression,
    BinaryShiftExpression -> ShiftOperator
binaryShiftExpressionOperator :: ShiftOperator,
    BinaryShiftExpression -> AdditiveExpression
binaryShiftExpressionRight :: AdditiveExpression}
  deriving (BinaryShiftExpression -> BinaryShiftExpression -> Bool
(BinaryShiftExpression -> BinaryShiftExpression -> Bool)
-> (BinaryShiftExpression -> BinaryShiftExpression -> Bool)
-> Eq BinaryShiftExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
== :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
$c/= :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
/= :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
Eq, Eq BinaryShiftExpression
Eq BinaryShiftExpression =>
(BinaryShiftExpression -> BinaryShiftExpression -> Ordering)
-> (BinaryShiftExpression -> BinaryShiftExpression -> Bool)
-> (BinaryShiftExpression -> BinaryShiftExpression -> Bool)
-> (BinaryShiftExpression -> BinaryShiftExpression -> Bool)
-> (BinaryShiftExpression -> BinaryShiftExpression -> Bool)
-> (BinaryShiftExpression
    -> BinaryShiftExpression -> BinaryShiftExpression)
-> (BinaryShiftExpression
    -> BinaryShiftExpression -> BinaryShiftExpression)
-> Ord BinaryShiftExpression
BinaryShiftExpression -> BinaryShiftExpression -> Bool
BinaryShiftExpression -> BinaryShiftExpression -> Ordering
BinaryShiftExpression
-> BinaryShiftExpression -> BinaryShiftExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryShiftExpression -> BinaryShiftExpression -> Ordering
compare :: BinaryShiftExpression -> BinaryShiftExpression -> Ordering
$c< :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
< :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
$c<= :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
<= :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
$c> :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
> :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
$c>= :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
>= :: BinaryShiftExpression -> BinaryShiftExpression -> Bool
$cmax :: BinaryShiftExpression
-> BinaryShiftExpression -> BinaryShiftExpression
max :: BinaryShiftExpression
-> BinaryShiftExpression -> BinaryShiftExpression
$cmin :: BinaryShiftExpression
-> BinaryShiftExpression -> BinaryShiftExpression
min :: BinaryShiftExpression
-> BinaryShiftExpression -> BinaryShiftExpression
Ord, ReadPrec [BinaryShiftExpression]
ReadPrec BinaryShiftExpression
Int -> ReadS BinaryShiftExpression
ReadS [BinaryShiftExpression]
(Int -> ReadS BinaryShiftExpression)
-> ReadS [BinaryShiftExpression]
-> ReadPrec BinaryShiftExpression
-> ReadPrec [BinaryShiftExpression]
-> Read BinaryShiftExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryShiftExpression
readsPrec :: Int -> ReadS BinaryShiftExpression
$creadList :: ReadS [BinaryShiftExpression]
readList :: ReadS [BinaryShiftExpression]
$creadPrec :: ReadPrec BinaryShiftExpression
readPrec :: ReadPrec BinaryShiftExpression
$creadListPrec :: ReadPrec [BinaryShiftExpression]
readListPrec :: ReadPrec [BinaryShiftExpression]
Read, Int -> BinaryShiftExpression -> String -> String
[BinaryShiftExpression] -> String -> String
BinaryShiftExpression -> String
(Int -> BinaryShiftExpression -> String -> String)
-> (BinaryShiftExpression -> String)
-> ([BinaryShiftExpression] -> String -> String)
-> Show BinaryShiftExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryShiftExpression -> String -> String
showsPrec :: Int -> BinaryShiftExpression -> String -> String
$cshow :: BinaryShiftExpression -> String
show :: BinaryShiftExpression -> String
$cshowList :: [BinaryShiftExpression] -> String -> String
showList :: [BinaryShiftExpression] -> String -> String
Show)

_BinaryShiftExpression :: Name
_BinaryShiftExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryShiftExpression")

_BinaryShiftExpression_left :: Name
_BinaryShiftExpression_left = (String -> Name
Core.Name String
"left")

_BinaryShiftExpression_operator :: Name
_BinaryShiftExpression_operator = (String -> Name
Core.Name String
"operator")

_BinaryShiftExpression_right :: Name
_BinaryShiftExpression_right = (String -> Name
Core.Name String
"right")

data ShiftOperator = 
  ShiftOperatorLeft  |
  ShiftOperatorRight 
  deriving (ShiftOperator -> ShiftOperator -> Bool
(ShiftOperator -> ShiftOperator -> Bool)
-> (ShiftOperator -> ShiftOperator -> Bool) -> Eq ShiftOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShiftOperator -> ShiftOperator -> Bool
== :: ShiftOperator -> ShiftOperator -> Bool
$c/= :: ShiftOperator -> ShiftOperator -> Bool
/= :: ShiftOperator -> ShiftOperator -> Bool
Eq, Eq ShiftOperator
Eq ShiftOperator =>
(ShiftOperator -> ShiftOperator -> Ordering)
-> (ShiftOperator -> ShiftOperator -> Bool)
-> (ShiftOperator -> ShiftOperator -> Bool)
-> (ShiftOperator -> ShiftOperator -> Bool)
-> (ShiftOperator -> ShiftOperator -> Bool)
-> (ShiftOperator -> ShiftOperator -> ShiftOperator)
-> (ShiftOperator -> ShiftOperator -> ShiftOperator)
-> Ord ShiftOperator
ShiftOperator -> ShiftOperator -> Bool
ShiftOperator -> ShiftOperator -> Ordering
ShiftOperator -> ShiftOperator -> ShiftOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ShiftOperator -> ShiftOperator -> Ordering
compare :: ShiftOperator -> ShiftOperator -> Ordering
$c< :: ShiftOperator -> ShiftOperator -> Bool
< :: ShiftOperator -> ShiftOperator -> Bool
$c<= :: ShiftOperator -> ShiftOperator -> Bool
<= :: ShiftOperator -> ShiftOperator -> Bool
$c> :: ShiftOperator -> ShiftOperator -> Bool
> :: ShiftOperator -> ShiftOperator -> Bool
$c>= :: ShiftOperator -> ShiftOperator -> Bool
>= :: ShiftOperator -> ShiftOperator -> Bool
$cmax :: ShiftOperator -> ShiftOperator -> ShiftOperator
max :: ShiftOperator -> ShiftOperator -> ShiftOperator
$cmin :: ShiftOperator -> ShiftOperator -> ShiftOperator
min :: ShiftOperator -> ShiftOperator -> ShiftOperator
Ord, ReadPrec [ShiftOperator]
ReadPrec ShiftOperator
Int -> ReadS ShiftOperator
ReadS [ShiftOperator]
(Int -> ReadS ShiftOperator)
-> ReadS [ShiftOperator]
-> ReadPrec ShiftOperator
-> ReadPrec [ShiftOperator]
-> Read ShiftOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ShiftOperator
readsPrec :: Int -> ReadS ShiftOperator
$creadList :: ReadS [ShiftOperator]
readList :: ReadS [ShiftOperator]
$creadPrec :: ReadPrec ShiftOperator
readPrec :: ReadPrec ShiftOperator
$creadListPrec :: ReadPrec [ShiftOperator]
readListPrec :: ReadPrec [ShiftOperator]
Read, Int -> ShiftOperator -> String -> String
[ShiftOperator] -> String -> String
ShiftOperator -> String
(Int -> ShiftOperator -> String -> String)
-> (ShiftOperator -> String)
-> ([ShiftOperator] -> String -> String)
-> Show ShiftOperator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ShiftOperator -> String -> String
showsPrec :: Int -> ShiftOperator -> String -> String
$cshow :: ShiftOperator -> String
show :: ShiftOperator -> String
$cshowList :: [ShiftOperator] -> String -> String
showList :: [ShiftOperator] -> String -> String
Show)

_ShiftOperator :: Name
_ShiftOperator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ShiftOperator")

_ShiftOperator_left :: Name
_ShiftOperator_left = (String -> Name
Core.Name String
"left")

_ShiftOperator_right :: Name
_ShiftOperator_right = (String -> Name
Core.Name String
"right")

data RelationalExpression = 
  RelationalExpressionSimple ShiftExpression |
  RelationalExpressionBinary BinaryRelationalExpression |
  RelationalExpressionIsType IsTypeExpression |
  RelationalExpressionIsPattern IsPatternExpression |
  RelationalExpressionAsType AsTypeExpression
  deriving (RelationalExpression -> RelationalExpression -> Bool
(RelationalExpression -> RelationalExpression -> Bool)
-> (RelationalExpression -> RelationalExpression -> Bool)
-> Eq RelationalExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelationalExpression -> RelationalExpression -> Bool
== :: RelationalExpression -> RelationalExpression -> Bool
$c/= :: RelationalExpression -> RelationalExpression -> Bool
/= :: RelationalExpression -> RelationalExpression -> Bool
Eq, Eq RelationalExpression
Eq RelationalExpression =>
(RelationalExpression -> RelationalExpression -> Ordering)
-> (RelationalExpression -> RelationalExpression -> Bool)
-> (RelationalExpression -> RelationalExpression -> Bool)
-> (RelationalExpression -> RelationalExpression -> Bool)
-> (RelationalExpression -> RelationalExpression -> Bool)
-> (RelationalExpression
    -> RelationalExpression -> RelationalExpression)
-> (RelationalExpression
    -> RelationalExpression -> RelationalExpression)
-> Ord RelationalExpression
RelationalExpression -> RelationalExpression -> Bool
RelationalExpression -> RelationalExpression -> Ordering
RelationalExpression
-> RelationalExpression -> RelationalExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RelationalExpression -> RelationalExpression -> Ordering
compare :: RelationalExpression -> RelationalExpression -> Ordering
$c< :: RelationalExpression -> RelationalExpression -> Bool
< :: RelationalExpression -> RelationalExpression -> Bool
$c<= :: RelationalExpression -> RelationalExpression -> Bool
<= :: RelationalExpression -> RelationalExpression -> Bool
$c> :: RelationalExpression -> RelationalExpression -> Bool
> :: RelationalExpression -> RelationalExpression -> Bool
$c>= :: RelationalExpression -> RelationalExpression -> Bool
>= :: RelationalExpression -> RelationalExpression -> Bool
$cmax :: RelationalExpression
-> RelationalExpression -> RelationalExpression
max :: RelationalExpression
-> RelationalExpression -> RelationalExpression
$cmin :: RelationalExpression
-> RelationalExpression -> RelationalExpression
min :: RelationalExpression
-> RelationalExpression -> RelationalExpression
Ord, ReadPrec [RelationalExpression]
ReadPrec RelationalExpression
Int -> ReadS RelationalExpression
ReadS [RelationalExpression]
(Int -> ReadS RelationalExpression)
-> ReadS [RelationalExpression]
-> ReadPrec RelationalExpression
-> ReadPrec [RelationalExpression]
-> Read RelationalExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RelationalExpression
readsPrec :: Int -> ReadS RelationalExpression
$creadList :: ReadS [RelationalExpression]
readList :: ReadS [RelationalExpression]
$creadPrec :: ReadPrec RelationalExpression
readPrec :: ReadPrec RelationalExpression
$creadListPrec :: ReadPrec [RelationalExpression]
readListPrec :: ReadPrec [RelationalExpression]
Read, Int -> RelationalExpression -> String -> String
[RelationalExpression] -> String -> String
RelationalExpression -> String
(Int -> RelationalExpression -> String -> String)
-> (RelationalExpression -> String)
-> ([RelationalExpression] -> String -> String)
-> Show RelationalExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RelationalExpression -> String -> String
showsPrec :: Int -> RelationalExpression -> String -> String
$cshow :: RelationalExpression -> String
show :: RelationalExpression -> String
$cshowList :: [RelationalExpression] -> String -> String
showList :: [RelationalExpression] -> String -> String
Show)

_RelationalExpression :: Name
_RelationalExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RelationalExpression")

_RelationalExpression_simple :: Name
_RelationalExpression_simple = (String -> Name
Core.Name String
"simple")

_RelationalExpression_binary :: Name
_RelationalExpression_binary = (String -> Name
Core.Name String
"binary")

_RelationalExpression_isType :: Name
_RelationalExpression_isType = (String -> Name
Core.Name String
"isType")

_RelationalExpression_isPattern :: Name
_RelationalExpression_isPattern = (String -> Name
Core.Name String
"isPattern")

_RelationalExpression_asType :: Name
_RelationalExpression_asType = (String -> Name
Core.Name String
"asType")

data BinaryRelationalExpression = 
  BinaryRelationalExpression {
    BinaryRelationalExpression -> RelationalExpression
binaryRelationalExpressionLeft :: RelationalExpression,
    BinaryRelationalExpression -> RelationalOperator
binaryRelationalExpressionOperator :: RelationalOperator,
    BinaryRelationalExpression -> ShiftExpression
binaryRelationalExpressionRight :: ShiftExpression}
  deriving (BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
(BinaryRelationalExpression -> BinaryRelationalExpression -> Bool)
-> (BinaryRelationalExpression
    -> BinaryRelationalExpression -> Bool)
-> Eq BinaryRelationalExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
== :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
$c/= :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
/= :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
Eq, Eq BinaryRelationalExpression
Eq BinaryRelationalExpression =>
(BinaryRelationalExpression
 -> BinaryRelationalExpression -> Ordering)
-> (BinaryRelationalExpression
    -> BinaryRelationalExpression -> Bool)
-> (BinaryRelationalExpression
    -> BinaryRelationalExpression -> Bool)
-> (BinaryRelationalExpression
    -> BinaryRelationalExpression -> Bool)
-> (BinaryRelationalExpression
    -> BinaryRelationalExpression -> Bool)
-> (BinaryRelationalExpression
    -> BinaryRelationalExpression -> BinaryRelationalExpression)
-> (BinaryRelationalExpression
    -> BinaryRelationalExpression -> BinaryRelationalExpression)
-> Ord BinaryRelationalExpression
BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
BinaryRelationalExpression
-> BinaryRelationalExpression -> Ordering
BinaryRelationalExpression
-> BinaryRelationalExpression -> BinaryRelationalExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryRelationalExpression
-> BinaryRelationalExpression -> Ordering
compare :: BinaryRelationalExpression
-> BinaryRelationalExpression -> Ordering
$c< :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
< :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
$c<= :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
<= :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
$c> :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
> :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
$c>= :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
>= :: BinaryRelationalExpression -> BinaryRelationalExpression -> Bool
$cmax :: BinaryRelationalExpression
-> BinaryRelationalExpression -> BinaryRelationalExpression
max :: BinaryRelationalExpression
-> BinaryRelationalExpression -> BinaryRelationalExpression
$cmin :: BinaryRelationalExpression
-> BinaryRelationalExpression -> BinaryRelationalExpression
min :: BinaryRelationalExpression
-> BinaryRelationalExpression -> BinaryRelationalExpression
Ord, ReadPrec [BinaryRelationalExpression]
ReadPrec BinaryRelationalExpression
Int -> ReadS BinaryRelationalExpression
ReadS [BinaryRelationalExpression]
(Int -> ReadS BinaryRelationalExpression)
-> ReadS [BinaryRelationalExpression]
-> ReadPrec BinaryRelationalExpression
-> ReadPrec [BinaryRelationalExpression]
-> Read BinaryRelationalExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryRelationalExpression
readsPrec :: Int -> ReadS BinaryRelationalExpression
$creadList :: ReadS [BinaryRelationalExpression]
readList :: ReadS [BinaryRelationalExpression]
$creadPrec :: ReadPrec BinaryRelationalExpression
readPrec :: ReadPrec BinaryRelationalExpression
$creadListPrec :: ReadPrec [BinaryRelationalExpression]
readListPrec :: ReadPrec [BinaryRelationalExpression]
Read, Int -> BinaryRelationalExpression -> String -> String
[BinaryRelationalExpression] -> String -> String
BinaryRelationalExpression -> String
(Int -> BinaryRelationalExpression -> String -> String)
-> (BinaryRelationalExpression -> String)
-> ([BinaryRelationalExpression] -> String -> String)
-> Show BinaryRelationalExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryRelationalExpression -> String -> String
showsPrec :: Int -> BinaryRelationalExpression -> String -> String
$cshow :: BinaryRelationalExpression -> String
show :: BinaryRelationalExpression -> String
$cshowList :: [BinaryRelationalExpression] -> String -> String
showList :: [BinaryRelationalExpression] -> String -> String
Show)

_BinaryRelationalExpression :: Name
_BinaryRelationalExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryRelationalExpression")

_BinaryRelationalExpression_left :: Name
_BinaryRelationalExpression_left = (String -> Name
Core.Name String
"left")

_BinaryRelationalExpression_operator :: Name
_BinaryRelationalExpression_operator = (String -> Name
Core.Name String
"operator")

_BinaryRelationalExpression_right :: Name
_BinaryRelationalExpression_right = (String -> Name
Core.Name String
"right")

data RelationalOperator = 
  RelationalOperatorLessThan  |
  RelationalOperatorGreaterThan  |
  RelationalOperatorLessThanOrEqual  |
  RelationalOperatorGreaterThanOrEqual 
  deriving (RelationalOperator -> RelationalOperator -> Bool
(RelationalOperator -> RelationalOperator -> Bool)
-> (RelationalOperator -> RelationalOperator -> Bool)
-> Eq RelationalOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RelationalOperator -> RelationalOperator -> Bool
== :: RelationalOperator -> RelationalOperator -> Bool
$c/= :: RelationalOperator -> RelationalOperator -> Bool
/= :: RelationalOperator -> RelationalOperator -> Bool
Eq, Eq RelationalOperator
Eq RelationalOperator =>
(RelationalOperator -> RelationalOperator -> Ordering)
-> (RelationalOperator -> RelationalOperator -> Bool)
-> (RelationalOperator -> RelationalOperator -> Bool)
-> (RelationalOperator -> RelationalOperator -> Bool)
-> (RelationalOperator -> RelationalOperator -> Bool)
-> (RelationalOperator -> RelationalOperator -> RelationalOperator)
-> (RelationalOperator -> RelationalOperator -> RelationalOperator)
-> Ord RelationalOperator
RelationalOperator -> RelationalOperator -> Bool
RelationalOperator -> RelationalOperator -> Ordering
RelationalOperator -> RelationalOperator -> RelationalOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RelationalOperator -> RelationalOperator -> Ordering
compare :: RelationalOperator -> RelationalOperator -> Ordering
$c< :: RelationalOperator -> RelationalOperator -> Bool
< :: RelationalOperator -> RelationalOperator -> Bool
$c<= :: RelationalOperator -> RelationalOperator -> Bool
<= :: RelationalOperator -> RelationalOperator -> Bool
$c> :: RelationalOperator -> RelationalOperator -> Bool
> :: RelationalOperator -> RelationalOperator -> Bool
$c>= :: RelationalOperator -> RelationalOperator -> Bool
>= :: RelationalOperator -> RelationalOperator -> Bool
$cmax :: RelationalOperator -> RelationalOperator -> RelationalOperator
max :: RelationalOperator -> RelationalOperator -> RelationalOperator
$cmin :: RelationalOperator -> RelationalOperator -> RelationalOperator
min :: RelationalOperator -> RelationalOperator -> RelationalOperator
Ord, ReadPrec [RelationalOperator]
ReadPrec RelationalOperator
Int -> ReadS RelationalOperator
ReadS [RelationalOperator]
(Int -> ReadS RelationalOperator)
-> ReadS [RelationalOperator]
-> ReadPrec RelationalOperator
-> ReadPrec [RelationalOperator]
-> Read RelationalOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RelationalOperator
readsPrec :: Int -> ReadS RelationalOperator
$creadList :: ReadS [RelationalOperator]
readList :: ReadS [RelationalOperator]
$creadPrec :: ReadPrec RelationalOperator
readPrec :: ReadPrec RelationalOperator
$creadListPrec :: ReadPrec [RelationalOperator]
readListPrec :: ReadPrec [RelationalOperator]
Read, Int -> RelationalOperator -> String -> String
[RelationalOperator] -> String -> String
RelationalOperator -> String
(Int -> RelationalOperator -> String -> String)
-> (RelationalOperator -> String)
-> ([RelationalOperator] -> String -> String)
-> Show RelationalOperator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RelationalOperator -> String -> String
showsPrec :: Int -> RelationalOperator -> String -> String
$cshow :: RelationalOperator -> String
show :: RelationalOperator -> String
$cshowList :: [RelationalOperator] -> String -> String
showList :: [RelationalOperator] -> String -> String
Show)

_RelationalOperator :: Name
_RelationalOperator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RelationalOperator")

_RelationalOperator_lessThan :: Name
_RelationalOperator_lessThan = (String -> Name
Core.Name String
"lessThan")

_RelationalOperator_greaterThan :: Name
_RelationalOperator_greaterThan = (String -> Name
Core.Name String
"greaterThan")

_RelationalOperator_lessThanOrEqual :: Name
_RelationalOperator_lessThanOrEqual = (String -> Name
Core.Name String
"lessThanOrEqual")

_RelationalOperator_greaterThanOrEqual :: Name
_RelationalOperator_greaterThanOrEqual = (String -> Name
Core.Name String
"greaterThanOrEqual")

data IsTypeExpression = 
  IsTypeExpression {
    IsTypeExpression -> RelationalExpression
isTypeExpressionExpression :: RelationalExpression,
    IsTypeExpression -> Type
isTypeExpressionType :: Type}
  deriving (IsTypeExpression -> IsTypeExpression -> Bool
(IsTypeExpression -> IsTypeExpression -> Bool)
-> (IsTypeExpression -> IsTypeExpression -> Bool)
-> Eq IsTypeExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IsTypeExpression -> IsTypeExpression -> Bool
== :: IsTypeExpression -> IsTypeExpression -> Bool
$c/= :: IsTypeExpression -> IsTypeExpression -> Bool
/= :: IsTypeExpression -> IsTypeExpression -> Bool
Eq, Eq IsTypeExpression
Eq IsTypeExpression =>
(IsTypeExpression -> IsTypeExpression -> Ordering)
-> (IsTypeExpression -> IsTypeExpression -> Bool)
-> (IsTypeExpression -> IsTypeExpression -> Bool)
-> (IsTypeExpression -> IsTypeExpression -> Bool)
-> (IsTypeExpression -> IsTypeExpression -> Bool)
-> (IsTypeExpression -> IsTypeExpression -> IsTypeExpression)
-> (IsTypeExpression -> IsTypeExpression -> IsTypeExpression)
-> Ord IsTypeExpression
IsTypeExpression -> IsTypeExpression -> Bool
IsTypeExpression -> IsTypeExpression -> Ordering
IsTypeExpression -> IsTypeExpression -> IsTypeExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IsTypeExpression -> IsTypeExpression -> Ordering
compare :: IsTypeExpression -> IsTypeExpression -> Ordering
$c< :: IsTypeExpression -> IsTypeExpression -> Bool
< :: IsTypeExpression -> IsTypeExpression -> Bool
$c<= :: IsTypeExpression -> IsTypeExpression -> Bool
<= :: IsTypeExpression -> IsTypeExpression -> Bool
$c> :: IsTypeExpression -> IsTypeExpression -> Bool
> :: IsTypeExpression -> IsTypeExpression -> Bool
$c>= :: IsTypeExpression -> IsTypeExpression -> Bool
>= :: IsTypeExpression -> IsTypeExpression -> Bool
$cmax :: IsTypeExpression -> IsTypeExpression -> IsTypeExpression
max :: IsTypeExpression -> IsTypeExpression -> IsTypeExpression
$cmin :: IsTypeExpression -> IsTypeExpression -> IsTypeExpression
min :: IsTypeExpression -> IsTypeExpression -> IsTypeExpression
Ord, ReadPrec [IsTypeExpression]
ReadPrec IsTypeExpression
Int -> ReadS IsTypeExpression
ReadS [IsTypeExpression]
(Int -> ReadS IsTypeExpression)
-> ReadS [IsTypeExpression]
-> ReadPrec IsTypeExpression
-> ReadPrec [IsTypeExpression]
-> Read IsTypeExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IsTypeExpression
readsPrec :: Int -> ReadS IsTypeExpression
$creadList :: ReadS [IsTypeExpression]
readList :: ReadS [IsTypeExpression]
$creadPrec :: ReadPrec IsTypeExpression
readPrec :: ReadPrec IsTypeExpression
$creadListPrec :: ReadPrec [IsTypeExpression]
readListPrec :: ReadPrec [IsTypeExpression]
Read, Int -> IsTypeExpression -> String -> String
[IsTypeExpression] -> String -> String
IsTypeExpression -> String
(Int -> IsTypeExpression -> String -> String)
-> (IsTypeExpression -> String)
-> ([IsTypeExpression] -> String -> String)
-> Show IsTypeExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IsTypeExpression -> String -> String
showsPrec :: Int -> IsTypeExpression -> String -> String
$cshow :: IsTypeExpression -> String
show :: IsTypeExpression -> String
$cshowList :: [IsTypeExpression] -> String -> String
showList :: [IsTypeExpression] -> String -> String
Show)

_IsTypeExpression :: Name
_IsTypeExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IsTypeExpression")

_IsTypeExpression_expression :: Name
_IsTypeExpression_expression = (String -> Name
Core.Name String
"expression")

_IsTypeExpression_type :: Name
_IsTypeExpression_type = (String -> Name
Core.Name String
"type")

data IsPatternExpression = 
  IsPatternExpression {
    IsPatternExpression -> RelationalExpression
isPatternExpressionExpression :: RelationalExpression,
    IsPatternExpression -> Pattern
isPatternExpressionPattern :: Pattern}
  deriving (IsPatternExpression -> IsPatternExpression -> Bool
(IsPatternExpression -> IsPatternExpression -> Bool)
-> (IsPatternExpression -> IsPatternExpression -> Bool)
-> Eq IsPatternExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IsPatternExpression -> IsPatternExpression -> Bool
== :: IsPatternExpression -> IsPatternExpression -> Bool
$c/= :: IsPatternExpression -> IsPatternExpression -> Bool
/= :: IsPatternExpression -> IsPatternExpression -> Bool
Eq, Eq IsPatternExpression
Eq IsPatternExpression =>
(IsPatternExpression -> IsPatternExpression -> Ordering)
-> (IsPatternExpression -> IsPatternExpression -> Bool)
-> (IsPatternExpression -> IsPatternExpression -> Bool)
-> (IsPatternExpression -> IsPatternExpression -> Bool)
-> (IsPatternExpression -> IsPatternExpression -> Bool)
-> (IsPatternExpression
    -> IsPatternExpression -> IsPatternExpression)
-> (IsPatternExpression
    -> IsPatternExpression -> IsPatternExpression)
-> Ord IsPatternExpression
IsPatternExpression -> IsPatternExpression -> Bool
IsPatternExpression -> IsPatternExpression -> Ordering
IsPatternExpression -> IsPatternExpression -> IsPatternExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IsPatternExpression -> IsPatternExpression -> Ordering
compare :: IsPatternExpression -> IsPatternExpression -> Ordering
$c< :: IsPatternExpression -> IsPatternExpression -> Bool
< :: IsPatternExpression -> IsPatternExpression -> Bool
$c<= :: IsPatternExpression -> IsPatternExpression -> Bool
<= :: IsPatternExpression -> IsPatternExpression -> Bool
$c> :: IsPatternExpression -> IsPatternExpression -> Bool
> :: IsPatternExpression -> IsPatternExpression -> Bool
$c>= :: IsPatternExpression -> IsPatternExpression -> Bool
>= :: IsPatternExpression -> IsPatternExpression -> Bool
$cmax :: IsPatternExpression -> IsPatternExpression -> IsPatternExpression
max :: IsPatternExpression -> IsPatternExpression -> IsPatternExpression
$cmin :: IsPatternExpression -> IsPatternExpression -> IsPatternExpression
min :: IsPatternExpression -> IsPatternExpression -> IsPatternExpression
Ord, ReadPrec [IsPatternExpression]
ReadPrec IsPatternExpression
Int -> ReadS IsPatternExpression
ReadS [IsPatternExpression]
(Int -> ReadS IsPatternExpression)
-> ReadS [IsPatternExpression]
-> ReadPrec IsPatternExpression
-> ReadPrec [IsPatternExpression]
-> Read IsPatternExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IsPatternExpression
readsPrec :: Int -> ReadS IsPatternExpression
$creadList :: ReadS [IsPatternExpression]
readList :: ReadS [IsPatternExpression]
$creadPrec :: ReadPrec IsPatternExpression
readPrec :: ReadPrec IsPatternExpression
$creadListPrec :: ReadPrec [IsPatternExpression]
readListPrec :: ReadPrec [IsPatternExpression]
Read, Int -> IsPatternExpression -> String -> String
[IsPatternExpression] -> String -> String
IsPatternExpression -> String
(Int -> IsPatternExpression -> String -> String)
-> (IsPatternExpression -> String)
-> ([IsPatternExpression] -> String -> String)
-> Show IsPatternExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IsPatternExpression -> String -> String
showsPrec :: Int -> IsPatternExpression -> String -> String
$cshow :: IsPatternExpression -> String
show :: IsPatternExpression -> String
$cshowList :: [IsPatternExpression] -> String -> String
showList :: [IsPatternExpression] -> String -> String
Show)

_IsPatternExpression :: Name
_IsPatternExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IsPatternExpression")

_IsPatternExpression_expression :: Name
_IsPatternExpression_expression = (String -> Name
Core.Name String
"expression")

_IsPatternExpression_pattern :: Name
_IsPatternExpression_pattern = (String -> Name
Core.Name String
"pattern")

data AsTypeExpression = 
  AsTypeExpression {
    AsTypeExpression -> RelationalExpression
asTypeExpressionExpression :: RelationalExpression,
    AsTypeExpression -> Type
asTypeExpressionType :: Type}
  deriving (AsTypeExpression -> AsTypeExpression -> Bool
(AsTypeExpression -> AsTypeExpression -> Bool)
-> (AsTypeExpression -> AsTypeExpression -> Bool)
-> Eq AsTypeExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AsTypeExpression -> AsTypeExpression -> Bool
== :: AsTypeExpression -> AsTypeExpression -> Bool
$c/= :: AsTypeExpression -> AsTypeExpression -> Bool
/= :: AsTypeExpression -> AsTypeExpression -> Bool
Eq, Eq AsTypeExpression
Eq AsTypeExpression =>
(AsTypeExpression -> AsTypeExpression -> Ordering)
-> (AsTypeExpression -> AsTypeExpression -> Bool)
-> (AsTypeExpression -> AsTypeExpression -> Bool)
-> (AsTypeExpression -> AsTypeExpression -> Bool)
-> (AsTypeExpression -> AsTypeExpression -> Bool)
-> (AsTypeExpression -> AsTypeExpression -> AsTypeExpression)
-> (AsTypeExpression -> AsTypeExpression -> AsTypeExpression)
-> Ord AsTypeExpression
AsTypeExpression -> AsTypeExpression -> Bool
AsTypeExpression -> AsTypeExpression -> Ordering
AsTypeExpression -> AsTypeExpression -> AsTypeExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AsTypeExpression -> AsTypeExpression -> Ordering
compare :: AsTypeExpression -> AsTypeExpression -> Ordering
$c< :: AsTypeExpression -> AsTypeExpression -> Bool
< :: AsTypeExpression -> AsTypeExpression -> Bool
$c<= :: AsTypeExpression -> AsTypeExpression -> Bool
<= :: AsTypeExpression -> AsTypeExpression -> Bool
$c> :: AsTypeExpression -> AsTypeExpression -> Bool
> :: AsTypeExpression -> AsTypeExpression -> Bool
$c>= :: AsTypeExpression -> AsTypeExpression -> Bool
>= :: AsTypeExpression -> AsTypeExpression -> Bool
$cmax :: AsTypeExpression -> AsTypeExpression -> AsTypeExpression
max :: AsTypeExpression -> AsTypeExpression -> AsTypeExpression
$cmin :: AsTypeExpression -> AsTypeExpression -> AsTypeExpression
min :: AsTypeExpression -> AsTypeExpression -> AsTypeExpression
Ord, ReadPrec [AsTypeExpression]
ReadPrec AsTypeExpression
Int -> ReadS AsTypeExpression
ReadS [AsTypeExpression]
(Int -> ReadS AsTypeExpression)
-> ReadS [AsTypeExpression]
-> ReadPrec AsTypeExpression
-> ReadPrec [AsTypeExpression]
-> Read AsTypeExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AsTypeExpression
readsPrec :: Int -> ReadS AsTypeExpression
$creadList :: ReadS [AsTypeExpression]
readList :: ReadS [AsTypeExpression]
$creadPrec :: ReadPrec AsTypeExpression
readPrec :: ReadPrec AsTypeExpression
$creadListPrec :: ReadPrec [AsTypeExpression]
readListPrec :: ReadPrec [AsTypeExpression]
Read, Int -> AsTypeExpression -> String -> String
[AsTypeExpression] -> String -> String
AsTypeExpression -> String
(Int -> AsTypeExpression -> String -> String)
-> (AsTypeExpression -> String)
-> ([AsTypeExpression] -> String -> String)
-> Show AsTypeExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AsTypeExpression -> String -> String
showsPrec :: Int -> AsTypeExpression -> String -> String
$cshow :: AsTypeExpression -> String
show :: AsTypeExpression -> String
$cshowList :: [AsTypeExpression] -> String -> String
showList :: [AsTypeExpression] -> String -> String
Show)

_AsTypeExpression :: Name
_AsTypeExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AsTypeExpression")

_AsTypeExpression_expression :: Name
_AsTypeExpression_expression = (String -> Name
Core.Name String
"expression")

_AsTypeExpression_type :: Name
_AsTypeExpression_type = (String -> Name
Core.Name String
"type")

data EqualityExpression = 
  EqualityExpressionSimple RelationalExpression |
  EqualityExpressionBinary BinaryEqualityExpression
  deriving (EqualityExpression -> EqualityExpression -> Bool
(EqualityExpression -> EqualityExpression -> Bool)
-> (EqualityExpression -> EqualityExpression -> Bool)
-> Eq EqualityExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EqualityExpression -> EqualityExpression -> Bool
== :: EqualityExpression -> EqualityExpression -> Bool
$c/= :: EqualityExpression -> EqualityExpression -> Bool
/= :: EqualityExpression -> EqualityExpression -> Bool
Eq, Eq EqualityExpression
Eq EqualityExpression =>
(EqualityExpression -> EqualityExpression -> Ordering)
-> (EqualityExpression -> EqualityExpression -> Bool)
-> (EqualityExpression -> EqualityExpression -> Bool)
-> (EqualityExpression -> EqualityExpression -> Bool)
-> (EqualityExpression -> EqualityExpression -> Bool)
-> (EqualityExpression -> EqualityExpression -> EqualityExpression)
-> (EqualityExpression -> EqualityExpression -> EqualityExpression)
-> Ord EqualityExpression
EqualityExpression -> EqualityExpression -> Bool
EqualityExpression -> EqualityExpression -> Ordering
EqualityExpression -> EqualityExpression -> EqualityExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EqualityExpression -> EqualityExpression -> Ordering
compare :: EqualityExpression -> EqualityExpression -> Ordering
$c< :: EqualityExpression -> EqualityExpression -> Bool
< :: EqualityExpression -> EqualityExpression -> Bool
$c<= :: EqualityExpression -> EqualityExpression -> Bool
<= :: EqualityExpression -> EqualityExpression -> Bool
$c> :: EqualityExpression -> EqualityExpression -> Bool
> :: EqualityExpression -> EqualityExpression -> Bool
$c>= :: EqualityExpression -> EqualityExpression -> Bool
>= :: EqualityExpression -> EqualityExpression -> Bool
$cmax :: EqualityExpression -> EqualityExpression -> EqualityExpression
max :: EqualityExpression -> EqualityExpression -> EqualityExpression
$cmin :: EqualityExpression -> EqualityExpression -> EqualityExpression
min :: EqualityExpression -> EqualityExpression -> EqualityExpression
Ord, ReadPrec [EqualityExpression]
ReadPrec EqualityExpression
Int -> ReadS EqualityExpression
ReadS [EqualityExpression]
(Int -> ReadS EqualityExpression)
-> ReadS [EqualityExpression]
-> ReadPrec EqualityExpression
-> ReadPrec [EqualityExpression]
-> Read EqualityExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EqualityExpression
readsPrec :: Int -> ReadS EqualityExpression
$creadList :: ReadS [EqualityExpression]
readList :: ReadS [EqualityExpression]
$creadPrec :: ReadPrec EqualityExpression
readPrec :: ReadPrec EqualityExpression
$creadListPrec :: ReadPrec [EqualityExpression]
readListPrec :: ReadPrec [EqualityExpression]
Read, Int -> EqualityExpression -> String -> String
[EqualityExpression] -> String -> String
EqualityExpression -> String
(Int -> EqualityExpression -> String -> String)
-> (EqualityExpression -> String)
-> ([EqualityExpression] -> String -> String)
-> Show EqualityExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EqualityExpression -> String -> String
showsPrec :: Int -> EqualityExpression -> String -> String
$cshow :: EqualityExpression -> String
show :: EqualityExpression -> String
$cshowList :: [EqualityExpression] -> String -> String
showList :: [EqualityExpression] -> String -> String
Show)

_EqualityExpression :: Name
_EqualityExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EqualityExpression")

_EqualityExpression_simple :: Name
_EqualityExpression_simple = (String -> Name
Core.Name String
"simple")

_EqualityExpression_binary :: Name
_EqualityExpression_binary = (String -> Name
Core.Name String
"binary")

data BinaryEqualityExpression = 
  BinaryEqualityExpression {
    BinaryEqualityExpression -> EqualityExpression
binaryEqualityExpressionLeft :: EqualityExpression,
    BinaryEqualityExpression -> EqualityOperator
binaryEqualityExpressionOperator :: EqualityOperator,
    BinaryEqualityExpression -> RelationalExpression
binaryEqualityExpressionRight :: RelationalExpression}
  deriving (BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
(BinaryEqualityExpression -> BinaryEqualityExpression -> Bool)
-> (BinaryEqualityExpression -> BinaryEqualityExpression -> Bool)
-> Eq BinaryEqualityExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
== :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
$c/= :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
/= :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
Eq, Eq BinaryEqualityExpression
Eq BinaryEqualityExpression =>
(BinaryEqualityExpression -> BinaryEqualityExpression -> Ordering)
-> (BinaryEqualityExpression -> BinaryEqualityExpression -> Bool)
-> (BinaryEqualityExpression -> BinaryEqualityExpression -> Bool)
-> (BinaryEqualityExpression -> BinaryEqualityExpression -> Bool)
-> (BinaryEqualityExpression -> BinaryEqualityExpression -> Bool)
-> (BinaryEqualityExpression
    -> BinaryEqualityExpression -> BinaryEqualityExpression)
-> (BinaryEqualityExpression
    -> BinaryEqualityExpression -> BinaryEqualityExpression)
-> Ord BinaryEqualityExpression
BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
BinaryEqualityExpression -> BinaryEqualityExpression -> Ordering
BinaryEqualityExpression
-> BinaryEqualityExpression -> BinaryEqualityExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryEqualityExpression -> BinaryEqualityExpression -> Ordering
compare :: BinaryEqualityExpression -> BinaryEqualityExpression -> Ordering
$c< :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
< :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
$c<= :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
<= :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
$c> :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
> :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
$c>= :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
>= :: BinaryEqualityExpression -> BinaryEqualityExpression -> Bool
$cmax :: BinaryEqualityExpression
-> BinaryEqualityExpression -> BinaryEqualityExpression
max :: BinaryEqualityExpression
-> BinaryEqualityExpression -> BinaryEqualityExpression
$cmin :: BinaryEqualityExpression
-> BinaryEqualityExpression -> BinaryEqualityExpression
min :: BinaryEqualityExpression
-> BinaryEqualityExpression -> BinaryEqualityExpression
Ord, ReadPrec [BinaryEqualityExpression]
ReadPrec BinaryEqualityExpression
Int -> ReadS BinaryEqualityExpression
ReadS [BinaryEqualityExpression]
(Int -> ReadS BinaryEqualityExpression)
-> ReadS [BinaryEqualityExpression]
-> ReadPrec BinaryEqualityExpression
-> ReadPrec [BinaryEqualityExpression]
-> Read BinaryEqualityExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryEqualityExpression
readsPrec :: Int -> ReadS BinaryEqualityExpression
$creadList :: ReadS [BinaryEqualityExpression]
readList :: ReadS [BinaryEqualityExpression]
$creadPrec :: ReadPrec BinaryEqualityExpression
readPrec :: ReadPrec BinaryEqualityExpression
$creadListPrec :: ReadPrec [BinaryEqualityExpression]
readListPrec :: ReadPrec [BinaryEqualityExpression]
Read, Int -> BinaryEqualityExpression -> String -> String
[BinaryEqualityExpression] -> String -> String
BinaryEqualityExpression -> String
(Int -> BinaryEqualityExpression -> String -> String)
-> (BinaryEqualityExpression -> String)
-> ([BinaryEqualityExpression] -> String -> String)
-> Show BinaryEqualityExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryEqualityExpression -> String -> String
showsPrec :: Int -> BinaryEqualityExpression -> String -> String
$cshow :: BinaryEqualityExpression -> String
show :: BinaryEqualityExpression -> String
$cshowList :: [BinaryEqualityExpression] -> String -> String
showList :: [BinaryEqualityExpression] -> String -> String
Show)

_BinaryEqualityExpression :: Name
_BinaryEqualityExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryEqualityExpression")

_BinaryEqualityExpression_left :: Name
_BinaryEqualityExpression_left = (String -> Name
Core.Name String
"left")

_BinaryEqualityExpression_operator :: Name
_BinaryEqualityExpression_operator = (String -> Name
Core.Name String
"operator")

_BinaryEqualityExpression_right :: Name
_BinaryEqualityExpression_right = (String -> Name
Core.Name String
"right")

data EqualityOperator = 
  EqualityOperatorEqual  |
  EqualityOperatorNotEqual 
  deriving (EqualityOperator -> EqualityOperator -> Bool
(EqualityOperator -> EqualityOperator -> Bool)
-> (EqualityOperator -> EqualityOperator -> Bool)
-> Eq EqualityOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EqualityOperator -> EqualityOperator -> Bool
== :: EqualityOperator -> EqualityOperator -> Bool
$c/= :: EqualityOperator -> EqualityOperator -> Bool
/= :: EqualityOperator -> EqualityOperator -> Bool
Eq, Eq EqualityOperator
Eq EqualityOperator =>
(EqualityOperator -> EqualityOperator -> Ordering)
-> (EqualityOperator -> EqualityOperator -> Bool)
-> (EqualityOperator -> EqualityOperator -> Bool)
-> (EqualityOperator -> EqualityOperator -> Bool)
-> (EqualityOperator -> EqualityOperator -> Bool)
-> (EqualityOperator -> EqualityOperator -> EqualityOperator)
-> (EqualityOperator -> EqualityOperator -> EqualityOperator)
-> Ord EqualityOperator
EqualityOperator -> EqualityOperator -> Bool
EqualityOperator -> EqualityOperator -> Ordering
EqualityOperator -> EqualityOperator -> EqualityOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EqualityOperator -> EqualityOperator -> Ordering
compare :: EqualityOperator -> EqualityOperator -> Ordering
$c< :: EqualityOperator -> EqualityOperator -> Bool
< :: EqualityOperator -> EqualityOperator -> Bool
$c<= :: EqualityOperator -> EqualityOperator -> Bool
<= :: EqualityOperator -> EqualityOperator -> Bool
$c> :: EqualityOperator -> EqualityOperator -> Bool
> :: EqualityOperator -> EqualityOperator -> Bool
$c>= :: EqualityOperator -> EqualityOperator -> Bool
>= :: EqualityOperator -> EqualityOperator -> Bool
$cmax :: EqualityOperator -> EqualityOperator -> EqualityOperator
max :: EqualityOperator -> EqualityOperator -> EqualityOperator
$cmin :: EqualityOperator -> EqualityOperator -> EqualityOperator
min :: EqualityOperator -> EqualityOperator -> EqualityOperator
Ord, ReadPrec [EqualityOperator]
ReadPrec EqualityOperator
Int -> ReadS EqualityOperator
ReadS [EqualityOperator]
(Int -> ReadS EqualityOperator)
-> ReadS [EqualityOperator]
-> ReadPrec EqualityOperator
-> ReadPrec [EqualityOperator]
-> Read EqualityOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EqualityOperator
readsPrec :: Int -> ReadS EqualityOperator
$creadList :: ReadS [EqualityOperator]
readList :: ReadS [EqualityOperator]
$creadPrec :: ReadPrec EqualityOperator
readPrec :: ReadPrec EqualityOperator
$creadListPrec :: ReadPrec [EqualityOperator]
readListPrec :: ReadPrec [EqualityOperator]
Read, Int -> EqualityOperator -> String -> String
[EqualityOperator] -> String -> String
EqualityOperator -> String
(Int -> EqualityOperator -> String -> String)
-> (EqualityOperator -> String)
-> ([EqualityOperator] -> String -> String)
-> Show EqualityOperator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EqualityOperator -> String -> String
showsPrec :: Int -> EqualityOperator -> String -> String
$cshow :: EqualityOperator -> String
show :: EqualityOperator -> String
$cshowList :: [EqualityOperator] -> String -> String
showList :: [EqualityOperator] -> String -> String
Show)

_EqualityOperator :: Name
_EqualityOperator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EqualityOperator")

_EqualityOperator_equal :: Name
_EqualityOperator_equal = (String -> Name
Core.Name String
"equal")

_EqualityOperator_notEqual :: Name
_EqualityOperator_notEqual = (String -> Name
Core.Name String
"notEqual")

data AndExpression = 
  AndExpressionSimple EqualityExpression |
  AndExpressionBinary BinaryAndExpression
  deriving (AndExpression -> AndExpression -> Bool
(AndExpression -> AndExpression -> Bool)
-> (AndExpression -> AndExpression -> Bool) -> Eq AndExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AndExpression -> AndExpression -> Bool
== :: AndExpression -> AndExpression -> Bool
$c/= :: AndExpression -> AndExpression -> Bool
/= :: AndExpression -> AndExpression -> Bool
Eq, Eq AndExpression
Eq AndExpression =>
(AndExpression -> AndExpression -> Ordering)
-> (AndExpression -> AndExpression -> Bool)
-> (AndExpression -> AndExpression -> Bool)
-> (AndExpression -> AndExpression -> Bool)
-> (AndExpression -> AndExpression -> Bool)
-> (AndExpression -> AndExpression -> AndExpression)
-> (AndExpression -> AndExpression -> AndExpression)
-> Ord AndExpression
AndExpression -> AndExpression -> Bool
AndExpression -> AndExpression -> Ordering
AndExpression -> AndExpression -> AndExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AndExpression -> AndExpression -> Ordering
compare :: AndExpression -> AndExpression -> Ordering
$c< :: AndExpression -> AndExpression -> Bool
< :: AndExpression -> AndExpression -> Bool
$c<= :: AndExpression -> AndExpression -> Bool
<= :: AndExpression -> AndExpression -> Bool
$c> :: AndExpression -> AndExpression -> Bool
> :: AndExpression -> AndExpression -> Bool
$c>= :: AndExpression -> AndExpression -> Bool
>= :: AndExpression -> AndExpression -> Bool
$cmax :: AndExpression -> AndExpression -> AndExpression
max :: AndExpression -> AndExpression -> AndExpression
$cmin :: AndExpression -> AndExpression -> AndExpression
min :: AndExpression -> AndExpression -> AndExpression
Ord, ReadPrec [AndExpression]
ReadPrec AndExpression
Int -> ReadS AndExpression
ReadS [AndExpression]
(Int -> ReadS AndExpression)
-> ReadS [AndExpression]
-> ReadPrec AndExpression
-> ReadPrec [AndExpression]
-> Read AndExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AndExpression
readsPrec :: Int -> ReadS AndExpression
$creadList :: ReadS [AndExpression]
readList :: ReadS [AndExpression]
$creadPrec :: ReadPrec AndExpression
readPrec :: ReadPrec AndExpression
$creadListPrec :: ReadPrec [AndExpression]
readListPrec :: ReadPrec [AndExpression]
Read, Int -> AndExpression -> String -> String
[AndExpression] -> String -> String
AndExpression -> String
(Int -> AndExpression -> String -> String)
-> (AndExpression -> String)
-> ([AndExpression] -> String -> String)
-> Show AndExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AndExpression -> String -> String
showsPrec :: Int -> AndExpression -> String -> String
$cshow :: AndExpression -> String
show :: AndExpression -> String
$cshowList :: [AndExpression] -> String -> String
showList :: [AndExpression] -> String -> String
Show)

_AndExpression :: Name
_AndExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AndExpression")

_AndExpression_simple :: Name
_AndExpression_simple = (String -> Name
Core.Name String
"simple")

_AndExpression_binary :: Name
_AndExpression_binary = (String -> Name
Core.Name String
"binary")

data BinaryAndExpression = 
  BinaryAndExpression {
    BinaryAndExpression -> AndExpression
binaryAndExpressionLeft :: AndExpression,
    BinaryAndExpression -> EqualityExpression
binaryAndExpressionRight :: EqualityExpression}
  deriving (BinaryAndExpression -> BinaryAndExpression -> Bool
(BinaryAndExpression -> BinaryAndExpression -> Bool)
-> (BinaryAndExpression -> BinaryAndExpression -> Bool)
-> Eq BinaryAndExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryAndExpression -> BinaryAndExpression -> Bool
== :: BinaryAndExpression -> BinaryAndExpression -> Bool
$c/= :: BinaryAndExpression -> BinaryAndExpression -> Bool
/= :: BinaryAndExpression -> BinaryAndExpression -> Bool
Eq, Eq BinaryAndExpression
Eq BinaryAndExpression =>
(BinaryAndExpression -> BinaryAndExpression -> Ordering)
-> (BinaryAndExpression -> BinaryAndExpression -> Bool)
-> (BinaryAndExpression -> BinaryAndExpression -> Bool)
-> (BinaryAndExpression -> BinaryAndExpression -> Bool)
-> (BinaryAndExpression -> BinaryAndExpression -> Bool)
-> (BinaryAndExpression
    -> BinaryAndExpression -> BinaryAndExpression)
-> (BinaryAndExpression
    -> BinaryAndExpression -> BinaryAndExpression)
-> Ord BinaryAndExpression
BinaryAndExpression -> BinaryAndExpression -> Bool
BinaryAndExpression -> BinaryAndExpression -> Ordering
BinaryAndExpression -> BinaryAndExpression -> BinaryAndExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryAndExpression -> BinaryAndExpression -> Ordering
compare :: BinaryAndExpression -> BinaryAndExpression -> Ordering
$c< :: BinaryAndExpression -> BinaryAndExpression -> Bool
< :: BinaryAndExpression -> BinaryAndExpression -> Bool
$c<= :: BinaryAndExpression -> BinaryAndExpression -> Bool
<= :: BinaryAndExpression -> BinaryAndExpression -> Bool
$c> :: BinaryAndExpression -> BinaryAndExpression -> Bool
> :: BinaryAndExpression -> BinaryAndExpression -> Bool
$c>= :: BinaryAndExpression -> BinaryAndExpression -> Bool
>= :: BinaryAndExpression -> BinaryAndExpression -> Bool
$cmax :: BinaryAndExpression -> BinaryAndExpression -> BinaryAndExpression
max :: BinaryAndExpression -> BinaryAndExpression -> BinaryAndExpression
$cmin :: BinaryAndExpression -> BinaryAndExpression -> BinaryAndExpression
min :: BinaryAndExpression -> BinaryAndExpression -> BinaryAndExpression
Ord, ReadPrec [BinaryAndExpression]
ReadPrec BinaryAndExpression
Int -> ReadS BinaryAndExpression
ReadS [BinaryAndExpression]
(Int -> ReadS BinaryAndExpression)
-> ReadS [BinaryAndExpression]
-> ReadPrec BinaryAndExpression
-> ReadPrec [BinaryAndExpression]
-> Read BinaryAndExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryAndExpression
readsPrec :: Int -> ReadS BinaryAndExpression
$creadList :: ReadS [BinaryAndExpression]
readList :: ReadS [BinaryAndExpression]
$creadPrec :: ReadPrec BinaryAndExpression
readPrec :: ReadPrec BinaryAndExpression
$creadListPrec :: ReadPrec [BinaryAndExpression]
readListPrec :: ReadPrec [BinaryAndExpression]
Read, Int -> BinaryAndExpression -> String -> String
[BinaryAndExpression] -> String -> String
BinaryAndExpression -> String
(Int -> BinaryAndExpression -> String -> String)
-> (BinaryAndExpression -> String)
-> ([BinaryAndExpression] -> String -> String)
-> Show BinaryAndExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryAndExpression -> String -> String
showsPrec :: Int -> BinaryAndExpression -> String -> String
$cshow :: BinaryAndExpression -> String
show :: BinaryAndExpression -> String
$cshowList :: [BinaryAndExpression] -> String -> String
showList :: [BinaryAndExpression] -> String -> String
Show)

_BinaryAndExpression :: Name
_BinaryAndExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryAndExpression")

_BinaryAndExpression_left :: Name
_BinaryAndExpression_left = (String -> Name
Core.Name String
"left")

_BinaryAndExpression_right :: Name
_BinaryAndExpression_right = (String -> Name
Core.Name String
"right")

data ExclusiveOrExpression = 
  ExclusiveOrExpressionSimple AndExpression |
  ExclusiveOrExpressionBinary BinaryExclusiveOrExpression
  deriving (ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
(ExclusiveOrExpression -> ExclusiveOrExpression -> Bool)
-> (ExclusiveOrExpression -> ExclusiveOrExpression -> Bool)
-> Eq ExclusiveOrExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
== :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
$c/= :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
/= :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
Eq, Eq ExclusiveOrExpression
Eq ExclusiveOrExpression =>
(ExclusiveOrExpression -> ExclusiveOrExpression -> Ordering)
-> (ExclusiveOrExpression -> ExclusiveOrExpression -> Bool)
-> (ExclusiveOrExpression -> ExclusiveOrExpression -> Bool)
-> (ExclusiveOrExpression -> ExclusiveOrExpression -> Bool)
-> (ExclusiveOrExpression -> ExclusiveOrExpression -> Bool)
-> (ExclusiveOrExpression
    -> ExclusiveOrExpression -> ExclusiveOrExpression)
-> (ExclusiveOrExpression
    -> ExclusiveOrExpression -> ExclusiveOrExpression)
-> Ord ExclusiveOrExpression
ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
ExclusiveOrExpression -> ExclusiveOrExpression -> Ordering
ExclusiveOrExpression
-> ExclusiveOrExpression -> ExclusiveOrExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ExclusiveOrExpression -> ExclusiveOrExpression -> Ordering
compare :: ExclusiveOrExpression -> ExclusiveOrExpression -> Ordering
$c< :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
< :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
$c<= :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
<= :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
$c> :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
> :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
$c>= :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
>= :: ExclusiveOrExpression -> ExclusiveOrExpression -> Bool
$cmax :: ExclusiveOrExpression
-> ExclusiveOrExpression -> ExclusiveOrExpression
max :: ExclusiveOrExpression
-> ExclusiveOrExpression -> ExclusiveOrExpression
$cmin :: ExclusiveOrExpression
-> ExclusiveOrExpression -> ExclusiveOrExpression
min :: ExclusiveOrExpression
-> ExclusiveOrExpression -> ExclusiveOrExpression
Ord, ReadPrec [ExclusiveOrExpression]
ReadPrec ExclusiveOrExpression
Int -> ReadS ExclusiveOrExpression
ReadS [ExclusiveOrExpression]
(Int -> ReadS ExclusiveOrExpression)
-> ReadS [ExclusiveOrExpression]
-> ReadPrec ExclusiveOrExpression
-> ReadPrec [ExclusiveOrExpression]
-> Read ExclusiveOrExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExclusiveOrExpression
readsPrec :: Int -> ReadS ExclusiveOrExpression
$creadList :: ReadS [ExclusiveOrExpression]
readList :: ReadS [ExclusiveOrExpression]
$creadPrec :: ReadPrec ExclusiveOrExpression
readPrec :: ReadPrec ExclusiveOrExpression
$creadListPrec :: ReadPrec [ExclusiveOrExpression]
readListPrec :: ReadPrec [ExclusiveOrExpression]
Read, Int -> ExclusiveOrExpression -> String -> String
[ExclusiveOrExpression] -> String -> String
ExclusiveOrExpression -> String
(Int -> ExclusiveOrExpression -> String -> String)
-> (ExclusiveOrExpression -> String)
-> ([ExclusiveOrExpression] -> String -> String)
-> Show ExclusiveOrExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ExclusiveOrExpression -> String -> String
showsPrec :: Int -> ExclusiveOrExpression -> String -> String
$cshow :: ExclusiveOrExpression -> String
show :: ExclusiveOrExpression -> String
$cshowList :: [ExclusiveOrExpression] -> String -> String
showList :: [ExclusiveOrExpression] -> String -> String
Show)

_ExclusiveOrExpression :: Name
_ExclusiveOrExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ExclusiveOrExpression")

_ExclusiveOrExpression_simple :: Name
_ExclusiveOrExpression_simple = (String -> Name
Core.Name String
"simple")

_ExclusiveOrExpression_binary :: Name
_ExclusiveOrExpression_binary = (String -> Name
Core.Name String
"binary")

data BinaryExclusiveOrExpression = 
  BinaryExclusiveOrExpression {
    BinaryExclusiveOrExpression -> ExclusiveOrExpression
binaryExclusiveOrExpressionLeft :: ExclusiveOrExpression,
    BinaryExclusiveOrExpression -> AndExpression
binaryExclusiveOrExpressionRight :: AndExpression}
  deriving (BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
(BinaryExclusiveOrExpression
 -> BinaryExclusiveOrExpression -> Bool)
-> (BinaryExclusiveOrExpression
    -> BinaryExclusiveOrExpression -> Bool)
-> Eq BinaryExclusiveOrExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
== :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
$c/= :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
/= :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
Eq, Eq BinaryExclusiveOrExpression
Eq BinaryExclusiveOrExpression =>
(BinaryExclusiveOrExpression
 -> BinaryExclusiveOrExpression -> Ordering)
-> (BinaryExclusiveOrExpression
    -> BinaryExclusiveOrExpression -> Bool)
-> (BinaryExclusiveOrExpression
    -> BinaryExclusiveOrExpression -> Bool)
-> (BinaryExclusiveOrExpression
    -> BinaryExclusiveOrExpression -> Bool)
-> (BinaryExclusiveOrExpression
    -> BinaryExclusiveOrExpression -> Bool)
-> (BinaryExclusiveOrExpression
    -> BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression)
-> (BinaryExclusiveOrExpression
    -> BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression)
-> Ord BinaryExclusiveOrExpression
BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
BinaryExclusiveOrExpression
-> BinaryExclusiveOrExpression -> Ordering
BinaryExclusiveOrExpression
-> BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryExclusiveOrExpression
-> BinaryExclusiveOrExpression -> Ordering
compare :: BinaryExclusiveOrExpression
-> BinaryExclusiveOrExpression -> Ordering
$c< :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
< :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
$c<= :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
<= :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
$c> :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
> :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
$c>= :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
>= :: BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression -> Bool
$cmax :: BinaryExclusiveOrExpression
-> BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression
max :: BinaryExclusiveOrExpression
-> BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression
$cmin :: BinaryExclusiveOrExpression
-> BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression
min :: BinaryExclusiveOrExpression
-> BinaryExclusiveOrExpression -> BinaryExclusiveOrExpression
Ord, ReadPrec [BinaryExclusiveOrExpression]
ReadPrec BinaryExclusiveOrExpression
Int -> ReadS BinaryExclusiveOrExpression
ReadS [BinaryExclusiveOrExpression]
(Int -> ReadS BinaryExclusiveOrExpression)
-> ReadS [BinaryExclusiveOrExpression]
-> ReadPrec BinaryExclusiveOrExpression
-> ReadPrec [BinaryExclusiveOrExpression]
-> Read BinaryExclusiveOrExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryExclusiveOrExpression
readsPrec :: Int -> ReadS BinaryExclusiveOrExpression
$creadList :: ReadS [BinaryExclusiveOrExpression]
readList :: ReadS [BinaryExclusiveOrExpression]
$creadPrec :: ReadPrec BinaryExclusiveOrExpression
readPrec :: ReadPrec BinaryExclusiveOrExpression
$creadListPrec :: ReadPrec [BinaryExclusiveOrExpression]
readListPrec :: ReadPrec [BinaryExclusiveOrExpression]
Read, Int -> BinaryExclusiveOrExpression -> String -> String
[BinaryExclusiveOrExpression] -> String -> String
BinaryExclusiveOrExpression -> String
(Int -> BinaryExclusiveOrExpression -> String -> String)
-> (BinaryExclusiveOrExpression -> String)
-> ([BinaryExclusiveOrExpression] -> String -> String)
-> Show BinaryExclusiveOrExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryExclusiveOrExpression -> String -> String
showsPrec :: Int -> BinaryExclusiveOrExpression -> String -> String
$cshow :: BinaryExclusiveOrExpression -> String
show :: BinaryExclusiveOrExpression -> String
$cshowList :: [BinaryExclusiveOrExpression] -> String -> String
showList :: [BinaryExclusiveOrExpression] -> String -> String
Show)

_BinaryExclusiveOrExpression :: Name
_BinaryExclusiveOrExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryExclusiveOrExpression")

_BinaryExclusiveOrExpression_left :: Name
_BinaryExclusiveOrExpression_left = (String -> Name
Core.Name String
"left")

_BinaryExclusiveOrExpression_right :: Name
_BinaryExclusiveOrExpression_right = (String -> Name
Core.Name String
"right")

data InclusiveOrExpression = 
  InclusiveOrExpressionSimple ExclusiveOrExpression |
  InclusiveOrExpressionBinary BinaryInclusiveOrExpression
  deriving (InclusiveOrExpression -> InclusiveOrExpression -> Bool
(InclusiveOrExpression -> InclusiveOrExpression -> Bool)
-> (InclusiveOrExpression -> InclusiveOrExpression -> Bool)
-> Eq InclusiveOrExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
== :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
$c/= :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
/= :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
Eq, Eq InclusiveOrExpression
Eq InclusiveOrExpression =>
(InclusiveOrExpression -> InclusiveOrExpression -> Ordering)
-> (InclusiveOrExpression -> InclusiveOrExpression -> Bool)
-> (InclusiveOrExpression -> InclusiveOrExpression -> Bool)
-> (InclusiveOrExpression -> InclusiveOrExpression -> Bool)
-> (InclusiveOrExpression -> InclusiveOrExpression -> Bool)
-> (InclusiveOrExpression
    -> InclusiveOrExpression -> InclusiveOrExpression)
-> (InclusiveOrExpression
    -> InclusiveOrExpression -> InclusiveOrExpression)
-> Ord InclusiveOrExpression
InclusiveOrExpression -> InclusiveOrExpression -> Bool
InclusiveOrExpression -> InclusiveOrExpression -> Ordering
InclusiveOrExpression
-> InclusiveOrExpression -> InclusiveOrExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InclusiveOrExpression -> InclusiveOrExpression -> Ordering
compare :: InclusiveOrExpression -> InclusiveOrExpression -> Ordering
$c< :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
< :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
$c<= :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
<= :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
$c> :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
> :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
$c>= :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
>= :: InclusiveOrExpression -> InclusiveOrExpression -> Bool
$cmax :: InclusiveOrExpression
-> InclusiveOrExpression -> InclusiveOrExpression
max :: InclusiveOrExpression
-> InclusiveOrExpression -> InclusiveOrExpression
$cmin :: InclusiveOrExpression
-> InclusiveOrExpression -> InclusiveOrExpression
min :: InclusiveOrExpression
-> InclusiveOrExpression -> InclusiveOrExpression
Ord, ReadPrec [InclusiveOrExpression]
ReadPrec InclusiveOrExpression
Int -> ReadS InclusiveOrExpression
ReadS [InclusiveOrExpression]
(Int -> ReadS InclusiveOrExpression)
-> ReadS [InclusiveOrExpression]
-> ReadPrec InclusiveOrExpression
-> ReadPrec [InclusiveOrExpression]
-> Read InclusiveOrExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InclusiveOrExpression
readsPrec :: Int -> ReadS InclusiveOrExpression
$creadList :: ReadS [InclusiveOrExpression]
readList :: ReadS [InclusiveOrExpression]
$creadPrec :: ReadPrec InclusiveOrExpression
readPrec :: ReadPrec InclusiveOrExpression
$creadListPrec :: ReadPrec [InclusiveOrExpression]
readListPrec :: ReadPrec [InclusiveOrExpression]
Read, Int -> InclusiveOrExpression -> String -> String
[InclusiveOrExpression] -> String -> String
InclusiveOrExpression -> String
(Int -> InclusiveOrExpression -> String -> String)
-> (InclusiveOrExpression -> String)
-> ([InclusiveOrExpression] -> String -> String)
-> Show InclusiveOrExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InclusiveOrExpression -> String -> String
showsPrec :: Int -> InclusiveOrExpression -> String -> String
$cshow :: InclusiveOrExpression -> String
show :: InclusiveOrExpression -> String
$cshowList :: [InclusiveOrExpression] -> String -> String
showList :: [InclusiveOrExpression] -> String -> String
Show)

_InclusiveOrExpression :: Name
_InclusiveOrExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InclusiveOrExpression")

_InclusiveOrExpression_simple :: Name
_InclusiveOrExpression_simple = (String -> Name
Core.Name String
"simple")

_InclusiveOrExpression_binary :: Name
_InclusiveOrExpression_binary = (String -> Name
Core.Name String
"binary")

data BinaryInclusiveOrExpression = 
  BinaryInclusiveOrExpression {
    BinaryInclusiveOrExpression -> InclusiveOrExpression
binaryInclusiveOrExpressionLeft :: InclusiveOrExpression,
    BinaryInclusiveOrExpression -> ExclusiveOrExpression
binaryInclusiveOrExpressionRight :: ExclusiveOrExpression}
  deriving (BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
(BinaryInclusiveOrExpression
 -> BinaryInclusiveOrExpression -> Bool)
-> (BinaryInclusiveOrExpression
    -> BinaryInclusiveOrExpression -> Bool)
-> Eq BinaryInclusiveOrExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
== :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
$c/= :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
/= :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
Eq, Eq BinaryInclusiveOrExpression
Eq BinaryInclusiveOrExpression =>
(BinaryInclusiveOrExpression
 -> BinaryInclusiveOrExpression -> Ordering)
-> (BinaryInclusiveOrExpression
    -> BinaryInclusiveOrExpression -> Bool)
-> (BinaryInclusiveOrExpression
    -> BinaryInclusiveOrExpression -> Bool)
-> (BinaryInclusiveOrExpression
    -> BinaryInclusiveOrExpression -> Bool)
-> (BinaryInclusiveOrExpression
    -> BinaryInclusiveOrExpression -> Bool)
-> (BinaryInclusiveOrExpression
    -> BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression)
-> (BinaryInclusiveOrExpression
    -> BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression)
-> Ord BinaryInclusiveOrExpression
BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
BinaryInclusiveOrExpression
-> BinaryInclusiveOrExpression -> Ordering
BinaryInclusiveOrExpression
-> BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryInclusiveOrExpression
-> BinaryInclusiveOrExpression -> Ordering
compare :: BinaryInclusiveOrExpression
-> BinaryInclusiveOrExpression -> Ordering
$c< :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
< :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
$c<= :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
<= :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
$c> :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
> :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
$c>= :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
>= :: BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression -> Bool
$cmax :: BinaryInclusiveOrExpression
-> BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression
max :: BinaryInclusiveOrExpression
-> BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression
$cmin :: BinaryInclusiveOrExpression
-> BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression
min :: BinaryInclusiveOrExpression
-> BinaryInclusiveOrExpression -> BinaryInclusiveOrExpression
Ord, ReadPrec [BinaryInclusiveOrExpression]
ReadPrec BinaryInclusiveOrExpression
Int -> ReadS BinaryInclusiveOrExpression
ReadS [BinaryInclusiveOrExpression]
(Int -> ReadS BinaryInclusiveOrExpression)
-> ReadS [BinaryInclusiveOrExpression]
-> ReadPrec BinaryInclusiveOrExpression
-> ReadPrec [BinaryInclusiveOrExpression]
-> Read BinaryInclusiveOrExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryInclusiveOrExpression
readsPrec :: Int -> ReadS BinaryInclusiveOrExpression
$creadList :: ReadS [BinaryInclusiveOrExpression]
readList :: ReadS [BinaryInclusiveOrExpression]
$creadPrec :: ReadPrec BinaryInclusiveOrExpression
readPrec :: ReadPrec BinaryInclusiveOrExpression
$creadListPrec :: ReadPrec [BinaryInclusiveOrExpression]
readListPrec :: ReadPrec [BinaryInclusiveOrExpression]
Read, Int -> BinaryInclusiveOrExpression -> String -> String
[BinaryInclusiveOrExpression] -> String -> String
BinaryInclusiveOrExpression -> String
(Int -> BinaryInclusiveOrExpression -> String -> String)
-> (BinaryInclusiveOrExpression -> String)
-> ([BinaryInclusiveOrExpression] -> String -> String)
-> Show BinaryInclusiveOrExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryInclusiveOrExpression -> String -> String
showsPrec :: Int -> BinaryInclusiveOrExpression -> String -> String
$cshow :: BinaryInclusiveOrExpression -> String
show :: BinaryInclusiveOrExpression -> String
$cshowList :: [BinaryInclusiveOrExpression] -> String -> String
showList :: [BinaryInclusiveOrExpression] -> String -> String
Show)

_BinaryInclusiveOrExpression :: Name
_BinaryInclusiveOrExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryInclusiveOrExpression")

_BinaryInclusiveOrExpression_left :: Name
_BinaryInclusiveOrExpression_left = (String -> Name
Core.Name String
"left")

_BinaryInclusiveOrExpression_right :: Name
_BinaryInclusiveOrExpression_right = (String -> Name
Core.Name String
"right")

data ConditionalAndExpression = 
  ConditionalAndExpressionSimple InclusiveOrExpression |
  ConditionalAndExpressionBinary BinaryConditionalAndExpression
  deriving (ConditionalAndExpression -> ConditionalAndExpression -> Bool
(ConditionalAndExpression -> ConditionalAndExpression -> Bool)
-> (ConditionalAndExpression -> ConditionalAndExpression -> Bool)
-> Eq ConditionalAndExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
== :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
$c/= :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
/= :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
Eq, Eq ConditionalAndExpression
Eq ConditionalAndExpression =>
(ConditionalAndExpression -> ConditionalAndExpression -> Ordering)
-> (ConditionalAndExpression -> ConditionalAndExpression -> Bool)
-> (ConditionalAndExpression -> ConditionalAndExpression -> Bool)
-> (ConditionalAndExpression -> ConditionalAndExpression -> Bool)
-> (ConditionalAndExpression -> ConditionalAndExpression -> Bool)
-> (ConditionalAndExpression
    -> ConditionalAndExpression -> ConditionalAndExpression)
-> (ConditionalAndExpression
    -> ConditionalAndExpression -> ConditionalAndExpression)
-> Ord ConditionalAndExpression
ConditionalAndExpression -> ConditionalAndExpression -> Bool
ConditionalAndExpression -> ConditionalAndExpression -> Ordering
ConditionalAndExpression
-> ConditionalAndExpression -> ConditionalAndExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConditionalAndExpression -> ConditionalAndExpression -> Ordering
compare :: ConditionalAndExpression -> ConditionalAndExpression -> Ordering
$c< :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
< :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
$c<= :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
<= :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
$c> :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
> :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
$c>= :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
>= :: ConditionalAndExpression -> ConditionalAndExpression -> Bool
$cmax :: ConditionalAndExpression
-> ConditionalAndExpression -> ConditionalAndExpression
max :: ConditionalAndExpression
-> ConditionalAndExpression -> ConditionalAndExpression
$cmin :: ConditionalAndExpression
-> ConditionalAndExpression -> ConditionalAndExpression
min :: ConditionalAndExpression
-> ConditionalAndExpression -> ConditionalAndExpression
Ord, ReadPrec [ConditionalAndExpression]
ReadPrec ConditionalAndExpression
Int -> ReadS ConditionalAndExpression
ReadS [ConditionalAndExpression]
(Int -> ReadS ConditionalAndExpression)
-> ReadS [ConditionalAndExpression]
-> ReadPrec ConditionalAndExpression
-> ReadPrec [ConditionalAndExpression]
-> Read ConditionalAndExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConditionalAndExpression
readsPrec :: Int -> ReadS ConditionalAndExpression
$creadList :: ReadS [ConditionalAndExpression]
readList :: ReadS [ConditionalAndExpression]
$creadPrec :: ReadPrec ConditionalAndExpression
readPrec :: ReadPrec ConditionalAndExpression
$creadListPrec :: ReadPrec [ConditionalAndExpression]
readListPrec :: ReadPrec [ConditionalAndExpression]
Read, Int -> ConditionalAndExpression -> String -> String
[ConditionalAndExpression] -> String -> String
ConditionalAndExpression -> String
(Int -> ConditionalAndExpression -> String -> String)
-> (ConditionalAndExpression -> String)
-> ([ConditionalAndExpression] -> String -> String)
-> Show ConditionalAndExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConditionalAndExpression -> String -> String
showsPrec :: Int -> ConditionalAndExpression -> String -> String
$cshow :: ConditionalAndExpression -> String
show :: ConditionalAndExpression -> String
$cshowList :: [ConditionalAndExpression] -> String -> String
showList :: [ConditionalAndExpression] -> String -> String
Show)

_ConditionalAndExpression :: Name
_ConditionalAndExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConditionalAndExpression")

_ConditionalAndExpression_simple :: Name
_ConditionalAndExpression_simple = (String -> Name
Core.Name String
"simple")

_ConditionalAndExpression_binary :: Name
_ConditionalAndExpression_binary = (String -> Name
Core.Name String
"binary")

data BinaryConditionalAndExpression = 
  BinaryConditionalAndExpression {
    BinaryConditionalAndExpression -> ConditionalAndExpression
binaryConditionalAndExpressionLeft :: ConditionalAndExpression,
    BinaryConditionalAndExpression -> InclusiveOrExpression
binaryConditionalAndExpressionRight :: InclusiveOrExpression}
  deriving (BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
(BinaryConditionalAndExpression
 -> BinaryConditionalAndExpression -> Bool)
-> (BinaryConditionalAndExpression
    -> BinaryConditionalAndExpression -> Bool)
-> Eq BinaryConditionalAndExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
== :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
$c/= :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
/= :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
Eq, Eq BinaryConditionalAndExpression
Eq BinaryConditionalAndExpression =>
(BinaryConditionalAndExpression
 -> BinaryConditionalAndExpression -> Ordering)
-> (BinaryConditionalAndExpression
    -> BinaryConditionalAndExpression -> Bool)
-> (BinaryConditionalAndExpression
    -> BinaryConditionalAndExpression -> Bool)
-> (BinaryConditionalAndExpression
    -> BinaryConditionalAndExpression -> Bool)
-> (BinaryConditionalAndExpression
    -> BinaryConditionalAndExpression -> Bool)
-> (BinaryConditionalAndExpression
    -> BinaryConditionalAndExpression
    -> BinaryConditionalAndExpression)
-> (BinaryConditionalAndExpression
    -> BinaryConditionalAndExpression
    -> BinaryConditionalAndExpression)
-> Ord BinaryConditionalAndExpression
BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Ordering
BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> BinaryConditionalAndExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Ordering
compare :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Ordering
$c< :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
< :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
$c<= :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
<= :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
$c> :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
> :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
$c>= :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
>= :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> Bool
$cmax :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> BinaryConditionalAndExpression
max :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> BinaryConditionalAndExpression
$cmin :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> BinaryConditionalAndExpression
min :: BinaryConditionalAndExpression
-> BinaryConditionalAndExpression -> BinaryConditionalAndExpression
Ord, ReadPrec [BinaryConditionalAndExpression]
ReadPrec BinaryConditionalAndExpression
Int -> ReadS BinaryConditionalAndExpression
ReadS [BinaryConditionalAndExpression]
(Int -> ReadS BinaryConditionalAndExpression)
-> ReadS [BinaryConditionalAndExpression]
-> ReadPrec BinaryConditionalAndExpression
-> ReadPrec [BinaryConditionalAndExpression]
-> Read BinaryConditionalAndExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryConditionalAndExpression
readsPrec :: Int -> ReadS BinaryConditionalAndExpression
$creadList :: ReadS [BinaryConditionalAndExpression]
readList :: ReadS [BinaryConditionalAndExpression]
$creadPrec :: ReadPrec BinaryConditionalAndExpression
readPrec :: ReadPrec BinaryConditionalAndExpression
$creadListPrec :: ReadPrec [BinaryConditionalAndExpression]
readListPrec :: ReadPrec [BinaryConditionalAndExpression]
Read, Int -> BinaryConditionalAndExpression -> String -> String
[BinaryConditionalAndExpression] -> String -> String
BinaryConditionalAndExpression -> String
(Int -> BinaryConditionalAndExpression -> String -> String)
-> (BinaryConditionalAndExpression -> String)
-> ([BinaryConditionalAndExpression] -> String -> String)
-> Show BinaryConditionalAndExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryConditionalAndExpression -> String -> String
showsPrec :: Int -> BinaryConditionalAndExpression -> String -> String
$cshow :: BinaryConditionalAndExpression -> String
show :: BinaryConditionalAndExpression -> String
$cshowList :: [BinaryConditionalAndExpression] -> String -> String
showList :: [BinaryConditionalAndExpression] -> String -> String
Show)

_BinaryConditionalAndExpression :: Name
_BinaryConditionalAndExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryConditionalAndExpression")

_BinaryConditionalAndExpression_left :: Name
_BinaryConditionalAndExpression_left = (String -> Name
Core.Name String
"left")

_BinaryConditionalAndExpression_right :: Name
_BinaryConditionalAndExpression_right = (String -> Name
Core.Name String
"right")

data ConditionalOrExpression = 
  ConditionalOrExpressionSimple ConditionalAndExpression |
  ConditionalOrExpressionBinary BinaryConditionalOrExpression
  deriving (ConditionalOrExpression -> ConditionalOrExpression -> Bool
(ConditionalOrExpression -> ConditionalOrExpression -> Bool)
-> (ConditionalOrExpression -> ConditionalOrExpression -> Bool)
-> Eq ConditionalOrExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
== :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
$c/= :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
/= :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
Eq, Eq ConditionalOrExpression
Eq ConditionalOrExpression =>
(ConditionalOrExpression -> ConditionalOrExpression -> Ordering)
-> (ConditionalOrExpression -> ConditionalOrExpression -> Bool)
-> (ConditionalOrExpression -> ConditionalOrExpression -> Bool)
-> (ConditionalOrExpression -> ConditionalOrExpression -> Bool)
-> (ConditionalOrExpression -> ConditionalOrExpression -> Bool)
-> (ConditionalOrExpression
    -> ConditionalOrExpression -> ConditionalOrExpression)
-> (ConditionalOrExpression
    -> ConditionalOrExpression -> ConditionalOrExpression)
-> Ord ConditionalOrExpression
ConditionalOrExpression -> ConditionalOrExpression -> Bool
ConditionalOrExpression -> ConditionalOrExpression -> Ordering
ConditionalOrExpression
-> ConditionalOrExpression -> ConditionalOrExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConditionalOrExpression -> ConditionalOrExpression -> Ordering
compare :: ConditionalOrExpression -> ConditionalOrExpression -> Ordering
$c< :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
< :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
$c<= :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
<= :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
$c> :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
> :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
$c>= :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
>= :: ConditionalOrExpression -> ConditionalOrExpression -> Bool
$cmax :: ConditionalOrExpression
-> ConditionalOrExpression -> ConditionalOrExpression
max :: ConditionalOrExpression
-> ConditionalOrExpression -> ConditionalOrExpression
$cmin :: ConditionalOrExpression
-> ConditionalOrExpression -> ConditionalOrExpression
min :: ConditionalOrExpression
-> ConditionalOrExpression -> ConditionalOrExpression
Ord, ReadPrec [ConditionalOrExpression]
ReadPrec ConditionalOrExpression
Int -> ReadS ConditionalOrExpression
ReadS [ConditionalOrExpression]
(Int -> ReadS ConditionalOrExpression)
-> ReadS [ConditionalOrExpression]
-> ReadPrec ConditionalOrExpression
-> ReadPrec [ConditionalOrExpression]
-> Read ConditionalOrExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConditionalOrExpression
readsPrec :: Int -> ReadS ConditionalOrExpression
$creadList :: ReadS [ConditionalOrExpression]
readList :: ReadS [ConditionalOrExpression]
$creadPrec :: ReadPrec ConditionalOrExpression
readPrec :: ReadPrec ConditionalOrExpression
$creadListPrec :: ReadPrec [ConditionalOrExpression]
readListPrec :: ReadPrec [ConditionalOrExpression]
Read, Int -> ConditionalOrExpression -> String -> String
[ConditionalOrExpression] -> String -> String
ConditionalOrExpression -> String
(Int -> ConditionalOrExpression -> String -> String)
-> (ConditionalOrExpression -> String)
-> ([ConditionalOrExpression] -> String -> String)
-> Show ConditionalOrExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConditionalOrExpression -> String -> String
showsPrec :: Int -> ConditionalOrExpression -> String -> String
$cshow :: ConditionalOrExpression -> String
show :: ConditionalOrExpression -> String
$cshowList :: [ConditionalOrExpression] -> String -> String
showList :: [ConditionalOrExpression] -> String -> String
Show)

_ConditionalOrExpression :: Name
_ConditionalOrExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConditionalOrExpression")

_ConditionalOrExpression_simple :: Name
_ConditionalOrExpression_simple = (String -> Name
Core.Name String
"simple")

_ConditionalOrExpression_binary :: Name
_ConditionalOrExpression_binary = (String -> Name
Core.Name String
"binary")

data BinaryConditionalOrExpression = 
  BinaryConditionalOrExpression {
    BinaryConditionalOrExpression -> ConditionalOrExpression
binaryConditionalOrExpressionLeft :: ConditionalOrExpression,
    BinaryConditionalOrExpression -> ConditionalAndExpression
binaryConditionalOrExpressionRight :: ConditionalAndExpression}
  deriving (BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
(BinaryConditionalOrExpression
 -> BinaryConditionalOrExpression -> Bool)
-> (BinaryConditionalOrExpression
    -> BinaryConditionalOrExpression -> Bool)
-> Eq BinaryConditionalOrExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
== :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
$c/= :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
/= :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
Eq, Eq BinaryConditionalOrExpression
Eq BinaryConditionalOrExpression =>
(BinaryConditionalOrExpression
 -> BinaryConditionalOrExpression -> Ordering)
-> (BinaryConditionalOrExpression
    -> BinaryConditionalOrExpression -> Bool)
-> (BinaryConditionalOrExpression
    -> BinaryConditionalOrExpression -> Bool)
-> (BinaryConditionalOrExpression
    -> BinaryConditionalOrExpression -> Bool)
-> (BinaryConditionalOrExpression
    -> BinaryConditionalOrExpression -> Bool)
-> (BinaryConditionalOrExpression
    -> BinaryConditionalOrExpression -> BinaryConditionalOrExpression)
-> (BinaryConditionalOrExpression
    -> BinaryConditionalOrExpression -> BinaryConditionalOrExpression)
-> Ord BinaryConditionalOrExpression
BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Ordering
BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> BinaryConditionalOrExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Ordering
compare :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Ordering
$c< :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
< :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
$c<= :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
<= :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
$c> :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
> :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
$c>= :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
>= :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> Bool
$cmax :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> BinaryConditionalOrExpression
max :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> BinaryConditionalOrExpression
$cmin :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> BinaryConditionalOrExpression
min :: BinaryConditionalOrExpression
-> BinaryConditionalOrExpression -> BinaryConditionalOrExpression
Ord, ReadPrec [BinaryConditionalOrExpression]
ReadPrec BinaryConditionalOrExpression
Int -> ReadS BinaryConditionalOrExpression
ReadS [BinaryConditionalOrExpression]
(Int -> ReadS BinaryConditionalOrExpression)
-> ReadS [BinaryConditionalOrExpression]
-> ReadPrec BinaryConditionalOrExpression
-> ReadPrec [BinaryConditionalOrExpression]
-> Read BinaryConditionalOrExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryConditionalOrExpression
readsPrec :: Int -> ReadS BinaryConditionalOrExpression
$creadList :: ReadS [BinaryConditionalOrExpression]
readList :: ReadS [BinaryConditionalOrExpression]
$creadPrec :: ReadPrec BinaryConditionalOrExpression
readPrec :: ReadPrec BinaryConditionalOrExpression
$creadListPrec :: ReadPrec [BinaryConditionalOrExpression]
readListPrec :: ReadPrec [BinaryConditionalOrExpression]
Read, Int -> BinaryConditionalOrExpression -> String -> String
[BinaryConditionalOrExpression] -> String -> String
BinaryConditionalOrExpression -> String
(Int -> BinaryConditionalOrExpression -> String -> String)
-> (BinaryConditionalOrExpression -> String)
-> ([BinaryConditionalOrExpression] -> String -> String)
-> Show BinaryConditionalOrExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryConditionalOrExpression -> String -> String
showsPrec :: Int -> BinaryConditionalOrExpression -> String -> String
$cshow :: BinaryConditionalOrExpression -> String
show :: BinaryConditionalOrExpression -> String
$cshowList :: [BinaryConditionalOrExpression] -> String -> String
showList :: [BinaryConditionalOrExpression] -> String -> String
Show)

_BinaryConditionalOrExpression :: Name
_BinaryConditionalOrExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryConditionalOrExpression")

_BinaryConditionalOrExpression_left :: Name
_BinaryConditionalOrExpression_left = (String -> Name
Core.Name String
"left")

_BinaryConditionalOrExpression_right :: Name
_BinaryConditionalOrExpression_right = (String -> Name
Core.Name String
"right")

data NullCoalescingExpression = 
  NullCoalescingExpressionSimple ConditionalOrExpression |
  NullCoalescingExpressionBinary BinaryNullCoalescingExpression |
  NullCoalescingExpressionThrow NullCoalescingExpression
  deriving (NullCoalescingExpression -> NullCoalescingExpression -> Bool
(NullCoalescingExpression -> NullCoalescingExpression -> Bool)
-> (NullCoalescingExpression -> NullCoalescingExpression -> Bool)
-> Eq NullCoalescingExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
== :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
$c/= :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
/= :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
Eq, Eq NullCoalescingExpression
Eq NullCoalescingExpression =>
(NullCoalescingExpression -> NullCoalescingExpression -> Ordering)
-> (NullCoalescingExpression -> NullCoalescingExpression -> Bool)
-> (NullCoalescingExpression -> NullCoalescingExpression -> Bool)
-> (NullCoalescingExpression -> NullCoalescingExpression -> Bool)
-> (NullCoalescingExpression -> NullCoalescingExpression -> Bool)
-> (NullCoalescingExpression
    -> NullCoalescingExpression -> NullCoalescingExpression)
-> (NullCoalescingExpression
    -> NullCoalescingExpression -> NullCoalescingExpression)
-> Ord NullCoalescingExpression
NullCoalescingExpression -> NullCoalescingExpression -> Bool
NullCoalescingExpression -> NullCoalescingExpression -> Ordering
NullCoalescingExpression
-> NullCoalescingExpression -> NullCoalescingExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NullCoalescingExpression -> NullCoalescingExpression -> Ordering
compare :: NullCoalescingExpression -> NullCoalescingExpression -> Ordering
$c< :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
< :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
$c<= :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
<= :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
$c> :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
> :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
$c>= :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
>= :: NullCoalescingExpression -> NullCoalescingExpression -> Bool
$cmax :: NullCoalescingExpression
-> NullCoalescingExpression -> NullCoalescingExpression
max :: NullCoalescingExpression
-> NullCoalescingExpression -> NullCoalescingExpression
$cmin :: NullCoalescingExpression
-> NullCoalescingExpression -> NullCoalescingExpression
min :: NullCoalescingExpression
-> NullCoalescingExpression -> NullCoalescingExpression
Ord, ReadPrec [NullCoalescingExpression]
ReadPrec NullCoalescingExpression
Int -> ReadS NullCoalescingExpression
ReadS [NullCoalescingExpression]
(Int -> ReadS NullCoalescingExpression)
-> ReadS [NullCoalescingExpression]
-> ReadPrec NullCoalescingExpression
-> ReadPrec [NullCoalescingExpression]
-> Read NullCoalescingExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NullCoalescingExpression
readsPrec :: Int -> ReadS NullCoalescingExpression
$creadList :: ReadS [NullCoalescingExpression]
readList :: ReadS [NullCoalescingExpression]
$creadPrec :: ReadPrec NullCoalescingExpression
readPrec :: ReadPrec NullCoalescingExpression
$creadListPrec :: ReadPrec [NullCoalescingExpression]
readListPrec :: ReadPrec [NullCoalescingExpression]
Read, Int -> NullCoalescingExpression -> String -> String
[NullCoalescingExpression] -> String -> String
NullCoalescingExpression -> String
(Int -> NullCoalescingExpression -> String -> String)
-> (NullCoalescingExpression -> String)
-> ([NullCoalescingExpression] -> String -> String)
-> Show NullCoalescingExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NullCoalescingExpression -> String -> String
showsPrec :: Int -> NullCoalescingExpression -> String -> String
$cshow :: NullCoalescingExpression -> String
show :: NullCoalescingExpression -> String
$cshowList :: [NullCoalescingExpression] -> String -> String
showList :: [NullCoalescingExpression] -> String -> String
Show)

_NullCoalescingExpression :: Name
_NullCoalescingExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NullCoalescingExpression")

_NullCoalescingExpression_simple :: Name
_NullCoalescingExpression_simple = (String -> Name
Core.Name String
"simple")

_NullCoalescingExpression_binary :: Name
_NullCoalescingExpression_binary = (String -> Name
Core.Name String
"binary")

_NullCoalescingExpression_throw :: Name
_NullCoalescingExpression_throw = (String -> Name
Core.Name String
"throw")

data BinaryNullCoalescingExpression = 
  BinaryNullCoalescingExpression {
    BinaryNullCoalescingExpression -> ConditionalOrExpression
binaryNullCoalescingExpressionLeft :: ConditionalOrExpression,
    BinaryNullCoalescingExpression -> NullCoalescingExpression
binaryNullCoalescingExpressionRight :: NullCoalescingExpression}
  deriving (BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
(BinaryNullCoalescingExpression
 -> BinaryNullCoalescingExpression -> Bool)
-> (BinaryNullCoalescingExpression
    -> BinaryNullCoalescingExpression -> Bool)
-> Eq BinaryNullCoalescingExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
== :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
$c/= :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
/= :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
Eq, Eq BinaryNullCoalescingExpression
Eq BinaryNullCoalescingExpression =>
(BinaryNullCoalescingExpression
 -> BinaryNullCoalescingExpression -> Ordering)
-> (BinaryNullCoalescingExpression
    -> BinaryNullCoalescingExpression -> Bool)
-> (BinaryNullCoalescingExpression
    -> BinaryNullCoalescingExpression -> Bool)
-> (BinaryNullCoalescingExpression
    -> BinaryNullCoalescingExpression -> Bool)
-> (BinaryNullCoalescingExpression
    -> BinaryNullCoalescingExpression -> Bool)
-> (BinaryNullCoalescingExpression
    -> BinaryNullCoalescingExpression
    -> BinaryNullCoalescingExpression)
-> (BinaryNullCoalescingExpression
    -> BinaryNullCoalescingExpression
    -> BinaryNullCoalescingExpression)
-> Ord BinaryNullCoalescingExpression
BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Ordering
BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> BinaryNullCoalescingExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Ordering
compare :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Ordering
$c< :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
< :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
$c<= :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
<= :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
$c> :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
> :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
$c>= :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
>= :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> Bool
$cmax :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> BinaryNullCoalescingExpression
max :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> BinaryNullCoalescingExpression
$cmin :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> BinaryNullCoalescingExpression
min :: BinaryNullCoalescingExpression
-> BinaryNullCoalescingExpression -> BinaryNullCoalescingExpression
Ord, ReadPrec [BinaryNullCoalescingExpression]
ReadPrec BinaryNullCoalescingExpression
Int -> ReadS BinaryNullCoalescingExpression
ReadS [BinaryNullCoalescingExpression]
(Int -> ReadS BinaryNullCoalescingExpression)
-> ReadS [BinaryNullCoalescingExpression]
-> ReadPrec BinaryNullCoalescingExpression
-> ReadPrec [BinaryNullCoalescingExpression]
-> Read BinaryNullCoalescingExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryNullCoalescingExpression
readsPrec :: Int -> ReadS BinaryNullCoalescingExpression
$creadList :: ReadS [BinaryNullCoalescingExpression]
readList :: ReadS [BinaryNullCoalescingExpression]
$creadPrec :: ReadPrec BinaryNullCoalescingExpression
readPrec :: ReadPrec BinaryNullCoalescingExpression
$creadListPrec :: ReadPrec [BinaryNullCoalescingExpression]
readListPrec :: ReadPrec [BinaryNullCoalescingExpression]
Read, Int -> BinaryNullCoalescingExpression -> String -> String
[BinaryNullCoalescingExpression] -> String -> String
BinaryNullCoalescingExpression -> String
(Int -> BinaryNullCoalescingExpression -> String -> String)
-> (BinaryNullCoalescingExpression -> String)
-> ([BinaryNullCoalescingExpression] -> String -> String)
-> Show BinaryNullCoalescingExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryNullCoalescingExpression -> String -> String
showsPrec :: Int -> BinaryNullCoalescingExpression -> String -> String
$cshow :: BinaryNullCoalescingExpression -> String
show :: BinaryNullCoalescingExpression -> String
$cshowList :: [BinaryNullCoalescingExpression] -> String -> String
showList :: [BinaryNullCoalescingExpression] -> String -> String
Show)

_BinaryNullCoalescingExpression :: Name
_BinaryNullCoalescingExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryNullCoalescingExpression")

_BinaryNullCoalescingExpression_left :: Name
_BinaryNullCoalescingExpression_left = (String -> Name
Core.Name String
"left")

_BinaryNullCoalescingExpression_right :: Name
_BinaryNullCoalescingExpression_right = (String -> Name
Core.Name String
"right")

data DeclarationExpression = 
  DeclarationExpression {
    DeclarationExpression -> LocalVariableType
declarationExpressionType :: LocalVariableType,
    DeclarationExpression -> Identifier
declarationExpressionIdentifier :: Identifier}
  deriving (DeclarationExpression -> DeclarationExpression -> Bool
(DeclarationExpression -> DeclarationExpression -> Bool)
-> (DeclarationExpression -> DeclarationExpression -> Bool)
-> Eq DeclarationExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeclarationExpression -> DeclarationExpression -> Bool
== :: DeclarationExpression -> DeclarationExpression -> Bool
$c/= :: DeclarationExpression -> DeclarationExpression -> Bool
/= :: DeclarationExpression -> DeclarationExpression -> Bool
Eq, Eq DeclarationExpression
Eq DeclarationExpression =>
(DeclarationExpression -> DeclarationExpression -> Ordering)
-> (DeclarationExpression -> DeclarationExpression -> Bool)
-> (DeclarationExpression -> DeclarationExpression -> Bool)
-> (DeclarationExpression -> DeclarationExpression -> Bool)
-> (DeclarationExpression -> DeclarationExpression -> Bool)
-> (DeclarationExpression
    -> DeclarationExpression -> DeclarationExpression)
-> (DeclarationExpression
    -> DeclarationExpression -> DeclarationExpression)
-> Ord DeclarationExpression
DeclarationExpression -> DeclarationExpression -> Bool
DeclarationExpression -> DeclarationExpression -> Ordering
DeclarationExpression
-> DeclarationExpression -> DeclarationExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DeclarationExpression -> DeclarationExpression -> Ordering
compare :: DeclarationExpression -> DeclarationExpression -> Ordering
$c< :: DeclarationExpression -> DeclarationExpression -> Bool
< :: DeclarationExpression -> DeclarationExpression -> Bool
$c<= :: DeclarationExpression -> DeclarationExpression -> Bool
<= :: DeclarationExpression -> DeclarationExpression -> Bool
$c> :: DeclarationExpression -> DeclarationExpression -> Bool
> :: DeclarationExpression -> DeclarationExpression -> Bool
$c>= :: DeclarationExpression -> DeclarationExpression -> Bool
>= :: DeclarationExpression -> DeclarationExpression -> Bool
$cmax :: DeclarationExpression
-> DeclarationExpression -> DeclarationExpression
max :: DeclarationExpression
-> DeclarationExpression -> DeclarationExpression
$cmin :: DeclarationExpression
-> DeclarationExpression -> DeclarationExpression
min :: DeclarationExpression
-> DeclarationExpression -> DeclarationExpression
Ord, ReadPrec [DeclarationExpression]
ReadPrec DeclarationExpression
Int -> ReadS DeclarationExpression
ReadS [DeclarationExpression]
(Int -> ReadS DeclarationExpression)
-> ReadS [DeclarationExpression]
-> ReadPrec DeclarationExpression
-> ReadPrec [DeclarationExpression]
-> Read DeclarationExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DeclarationExpression
readsPrec :: Int -> ReadS DeclarationExpression
$creadList :: ReadS [DeclarationExpression]
readList :: ReadS [DeclarationExpression]
$creadPrec :: ReadPrec DeclarationExpression
readPrec :: ReadPrec DeclarationExpression
$creadListPrec :: ReadPrec [DeclarationExpression]
readListPrec :: ReadPrec [DeclarationExpression]
Read, Int -> DeclarationExpression -> String -> String
[DeclarationExpression] -> String -> String
DeclarationExpression -> String
(Int -> DeclarationExpression -> String -> String)
-> (DeclarationExpression -> String)
-> ([DeclarationExpression] -> String -> String)
-> Show DeclarationExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DeclarationExpression -> String -> String
showsPrec :: Int -> DeclarationExpression -> String -> String
$cshow :: DeclarationExpression -> String
show :: DeclarationExpression -> String
$cshowList :: [DeclarationExpression] -> String -> String
showList :: [DeclarationExpression] -> String -> String
Show)

_DeclarationExpression :: Name
_DeclarationExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DeclarationExpression")

_DeclarationExpression_type :: Name
_DeclarationExpression_type = (String -> Name
Core.Name String
"type")

_DeclarationExpression_identifier :: Name
_DeclarationExpression_identifier = (String -> Name
Core.Name String
"identifier")

data LocalVariableType = 
  LocalVariableTypeType Type |
  LocalVariableTypeVar 
  deriving (LocalVariableType -> LocalVariableType -> Bool
(LocalVariableType -> LocalVariableType -> Bool)
-> (LocalVariableType -> LocalVariableType -> Bool)
-> Eq LocalVariableType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalVariableType -> LocalVariableType -> Bool
== :: LocalVariableType -> LocalVariableType -> Bool
$c/= :: LocalVariableType -> LocalVariableType -> Bool
/= :: LocalVariableType -> LocalVariableType -> Bool
Eq, Eq LocalVariableType
Eq LocalVariableType =>
(LocalVariableType -> LocalVariableType -> Ordering)
-> (LocalVariableType -> LocalVariableType -> Bool)
-> (LocalVariableType -> LocalVariableType -> Bool)
-> (LocalVariableType -> LocalVariableType -> Bool)
-> (LocalVariableType -> LocalVariableType -> Bool)
-> (LocalVariableType -> LocalVariableType -> LocalVariableType)
-> (LocalVariableType -> LocalVariableType -> LocalVariableType)
-> Ord LocalVariableType
LocalVariableType -> LocalVariableType -> Bool
LocalVariableType -> LocalVariableType -> Ordering
LocalVariableType -> LocalVariableType -> LocalVariableType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LocalVariableType -> LocalVariableType -> Ordering
compare :: LocalVariableType -> LocalVariableType -> Ordering
$c< :: LocalVariableType -> LocalVariableType -> Bool
< :: LocalVariableType -> LocalVariableType -> Bool
$c<= :: LocalVariableType -> LocalVariableType -> Bool
<= :: LocalVariableType -> LocalVariableType -> Bool
$c> :: LocalVariableType -> LocalVariableType -> Bool
> :: LocalVariableType -> LocalVariableType -> Bool
$c>= :: LocalVariableType -> LocalVariableType -> Bool
>= :: LocalVariableType -> LocalVariableType -> Bool
$cmax :: LocalVariableType -> LocalVariableType -> LocalVariableType
max :: LocalVariableType -> LocalVariableType -> LocalVariableType
$cmin :: LocalVariableType -> LocalVariableType -> LocalVariableType
min :: LocalVariableType -> LocalVariableType -> LocalVariableType
Ord, ReadPrec [LocalVariableType]
ReadPrec LocalVariableType
Int -> ReadS LocalVariableType
ReadS [LocalVariableType]
(Int -> ReadS LocalVariableType)
-> ReadS [LocalVariableType]
-> ReadPrec LocalVariableType
-> ReadPrec [LocalVariableType]
-> Read LocalVariableType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LocalVariableType
readsPrec :: Int -> ReadS LocalVariableType
$creadList :: ReadS [LocalVariableType]
readList :: ReadS [LocalVariableType]
$creadPrec :: ReadPrec LocalVariableType
readPrec :: ReadPrec LocalVariableType
$creadListPrec :: ReadPrec [LocalVariableType]
readListPrec :: ReadPrec [LocalVariableType]
Read, Int -> LocalVariableType -> String -> String
[LocalVariableType] -> String -> String
LocalVariableType -> String
(Int -> LocalVariableType -> String -> String)
-> (LocalVariableType -> String)
-> ([LocalVariableType] -> String -> String)
-> Show LocalVariableType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LocalVariableType -> String -> String
showsPrec :: Int -> LocalVariableType -> String -> String
$cshow :: LocalVariableType -> String
show :: LocalVariableType -> String
$cshowList :: [LocalVariableType] -> String -> String
showList :: [LocalVariableType] -> String -> String
Show)

_LocalVariableType :: Name
_LocalVariableType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LocalVariableType")

_LocalVariableType_type :: Name
_LocalVariableType_type = (String -> Name
Core.Name String
"type")

_LocalVariableType_var :: Name
_LocalVariableType_var = (String -> Name
Core.Name String
"var")

data ConditionalExpression = 
  ConditionalExpressionSimple NullCoalescingExpression |
  ConditionalExpressionSimpleConditional SimpleConditionalExpression |
  ConditionalExpressionRefConditional RefConditionalExpression
  deriving (ConditionalExpression -> ConditionalExpression -> Bool
(ConditionalExpression -> ConditionalExpression -> Bool)
-> (ConditionalExpression -> ConditionalExpression -> Bool)
-> Eq ConditionalExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConditionalExpression -> ConditionalExpression -> Bool
== :: ConditionalExpression -> ConditionalExpression -> Bool
$c/= :: ConditionalExpression -> ConditionalExpression -> Bool
/= :: ConditionalExpression -> ConditionalExpression -> Bool
Eq, Eq ConditionalExpression
Eq ConditionalExpression =>
(ConditionalExpression -> ConditionalExpression -> Ordering)
-> (ConditionalExpression -> ConditionalExpression -> Bool)
-> (ConditionalExpression -> ConditionalExpression -> Bool)
-> (ConditionalExpression -> ConditionalExpression -> Bool)
-> (ConditionalExpression -> ConditionalExpression -> Bool)
-> (ConditionalExpression
    -> ConditionalExpression -> ConditionalExpression)
-> (ConditionalExpression
    -> ConditionalExpression -> ConditionalExpression)
-> Ord ConditionalExpression
ConditionalExpression -> ConditionalExpression -> Bool
ConditionalExpression -> ConditionalExpression -> Ordering
ConditionalExpression
-> ConditionalExpression -> ConditionalExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConditionalExpression -> ConditionalExpression -> Ordering
compare :: ConditionalExpression -> ConditionalExpression -> Ordering
$c< :: ConditionalExpression -> ConditionalExpression -> Bool
< :: ConditionalExpression -> ConditionalExpression -> Bool
$c<= :: ConditionalExpression -> ConditionalExpression -> Bool
<= :: ConditionalExpression -> ConditionalExpression -> Bool
$c> :: ConditionalExpression -> ConditionalExpression -> Bool
> :: ConditionalExpression -> ConditionalExpression -> Bool
$c>= :: ConditionalExpression -> ConditionalExpression -> Bool
>= :: ConditionalExpression -> ConditionalExpression -> Bool
$cmax :: ConditionalExpression
-> ConditionalExpression -> ConditionalExpression
max :: ConditionalExpression
-> ConditionalExpression -> ConditionalExpression
$cmin :: ConditionalExpression
-> ConditionalExpression -> ConditionalExpression
min :: ConditionalExpression
-> ConditionalExpression -> ConditionalExpression
Ord, ReadPrec [ConditionalExpression]
ReadPrec ConditionalExpression
Int -> ReadS ConditionalExpression
ReadS [ConditionalExpression]
(Int -> ReadS ConditionalExpression)
-> ReadS [ConditionalExpression]
-> ReadPrec ConditionalExpression
-> ReadPrec [ConditionalExpression]
-> Read ConditionalExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConditionalExpression
readsPrec :: Int -> ReadS ConditionalExpression
$creadList :: ReadS [ConditionalExpression]
readList :: ReadS [ConditionalExpression]
$creadPrec :: ReadPrec ConditionalExpression
readPrec :: ReadPrec ConditionalExpression
$creadListPrec :: ReadPrec [ConditionalExpression]
readListPrec :: ReadPrec [ConditionalExpression]
Read, Int -> ConditionalExpression -> String -> String
[ConditionalExpression] -> String -> String
ConditionalExpression -> String
(Int -> ConditionalExpression -> String -> String)
-> (ConditionalExpression -> String)
-> ([ConditionalExpression] -> String -> String)
-> Show ConditionalExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConditionalExpression -> String -> String
showsPrec :: Int -> ConditionalExpression -> String -> String
$cshow :: ConditionalExpression -> String
show :: ConditionalExpression -> String
$cshowList :: [ConditionalExpression] -> String -> String
showList :: [ConditionalExpression] -> String -> String
Show)

_ConditionalExpression :: Name
_ConditionalExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConditionalExpression")

_ConditionalExpression_simple :: Name
_ConditionalExpression_simple = (String -> Name
Core.Name String
"simple")

_ConditionalExpression_simpleConditional :: Name
_ConditionalExpression_simpleConditional = (String -> Name
Core.Name String
"simpleConditional")

_ConditionalExpression_refConditional :: Name
_ConditionalExpression_refConditional = (String -> Name
Core.Name String
"refConditional")

data SimpleConditionalExpression = 
  SimpleConditionalExpression {
    SimpleConditionalExpression -> NullCoalescingExpression
simpleConditionalExpressionCondition :: NullCoalescingExpression,
    SimpleConditionalExpression -> Expression
simpleConditionalExpressionTrue :: Expression,
    SimpleConditionalExpression -> Expression
simpleConditionalExpressionFalse :: Expression}
  deriving (SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
(SimpleConditionalExpression
 -> SimpleConditionalExpression -> Bool)
-> (SimpleConditionalExpression
    -> SimpleConditionalExpression -> Bool)
-> Eq SimpleConditionalExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
== :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
$c/= :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
/= :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
Eq, Eq SimpleConditionalExpression
Eq SimpleConditionalExpression =>
(SimpleConditionalExpression
 -> SimpleConditionalExpression -> Ordering)
-> (SimpleConditionalExpression
    -> SimpleConditionalExpression -> Bool)
-> (SimpleConditionalExpression
    -> SimpleConditionalExpression -> Bool)
-> (SimpleConditionalExpression
    -> SimpleConditionalExpression -> Bool)
-> (SimpleConditionalExpression
    -> SimpleConditionalExpression -> Bool)
-> (SimpleConditionalExpression
    -> SimpleConditionalExpression -> SimpleConditionalExpression)
-> (SimpleConditionalExpression
    -> SimpleConditionalExpression -> SimpleConditionalExpression)
-> Ord SimpleConditionalExpression
SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
SimpleConditionalExpression
-> SimpleConditionalExpression -> Ordering
SimpleConditionalExpression
-> SimpleConditionalExpression -> SimpleConditionalExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SimpleConditionalExpression
-> SimpleConditionalExpression -> Ordering
compare :: SimpleConditionalExpression
-> SimpleConditionalExpression -> Ordering
$c< :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
< :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
$c<= :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
<= :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
$c> :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
> :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
$c>= :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
>= :: SimpleConditionalExpression -> SimpleConditionalExpression -> Bool
$cmax :: SimpleConditionalExpression
-> SimpleConditionalExpression -> SimpleConditionalExpression
max :: SimpleConditionalExpression
-> SimpleConditionalExpression -> SimpleConditionalExpression
$cmin :: SimpleConditionalExpression
-> SimpleConditionalExpression -> SimpleConditionalExpression
min :: SimpleConditionalExpression
-> SimpleConditionalExpression -> SimpleConditionalExpression
Ord, ReadPrec [SimpleConditionalExpression]
ReadPrec SimpleConditionalExpression
Int -> ReadS SimpleConditionalExpression
ReadS [SimpleConditionalExpression]
(Int -> ReadS SimpleConditionalExpression)
-> ReadS [SimpleConditionalExpression]
-> ReadPrec SimpleConditionalExpression
-> ReadPrec [SimpleConditionalExpression]
-> Read SimpleConditionalExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SimpleConditionalExpression
readsPrec :: Int -> ReadS SimpleConditionalExpression
$creadList :: ReadS [SimpleConditionalExpression]
readList :: ReadS [SimpleConditionalExpression]
$creadPrec :: ReadPrec SimpleConditionalExpression
readPrec :: ReadPrec SimpleConditionalExpression
$creadListPrec :: ReadPrec [SimpleConditionalExpression]
readListPrec :: ReadPrec [SimpleConditionalExpression]
Read, Int -> SimpleConditionalExpression -> String -> String
[SimpleConditionalExpression] -> String -> String
SimpleConditionalExpression -> String
(Int -> SimpleConditionalExpression -> String -> String)
-> (SimpleConditionalExpression -> String)
-> ([SimpleConditionalExpression] -> String -> String)
-> Show SimpleConditionalExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SimpleConditionalExpression -> String -> String
showsPrec :: Int -> SimpleConditionalExpression -> String -> String
$cshow :: SimpleConditionalExpression -> String
show :: SimpleConditionalExpression -> String
$cshowList :: [SimpleConditionalExpression] -> String -> String
showList :: [SimpleConditionalExpression] -> String -> String
Show)

_SimpleConditionalExpression :: Name
_SimpleConditionalExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SimpleConditionalExpression")

_SimpleConditionalExpression_condition :: Name
_SimpleConditionalExpression_condition = (String -> Name
Core.Name String
"condition")

_SimpleConditionalExpression_true :: Name
_SimpleConditionalExpression_true = (String -> Name
Core.Name String
"true")

_SimpleConditionalExpression_false :: Name
_SimpleConditionalExpression_false = (String -> Name
Core.Name String
"false")

data RefConditionalExpression = 
  RefConditionalExpression {
    RefConditionalExpression -> NullCoalescingExpression
refConditionalExpressionCondition :: NullCoalescingExpression,
    RefConditionalExpression -> VariableReference
refConditionalExpressionTrue :: VariableReference,
    RefConditionalExpression -> VariableReference
refConditionalExpressionFalse :: VariableReference}
  deriving (RefConditionalExpression -> RefConditionalExpression -> Bool
(RefConditionalExpression -> RefConditionalExpression -> Bool)
-> (RefConditionalExpression -> RefConditionalExpression -> Bool)
-> Eq RefConditionalExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefConditionalExpression -> RefConditionalExpression -> Bool
== :: RefConditionalExpression -> RefConditionalExpression -> Bool
$c/= :: RefConditionalExpression -> RefConditionalExpression -> Bool
/= :: RefConditionalExpression -> RefConditionalExpression -> Bool
Eq, Eq RefConditionalExpression
Eq RefConditionalExpression =>
(RefConditionalExpression -> RefConditionalExpression -> Ordering)
-> (RefConditionalExpression -> RefConditionalExpression -> Bool)
-> (RefConditionalExpression -> RefConditionalExpression -> Bool)
-> (RefConditionalExpression -> RefConditionalExpression -> Bool)
-> (RefConditionalExpression -> RefConditionalExpression -> Bool)
-> (RefConditionalExpression
    -> RefConditionalExpression -> RefConditionalExpression)
-> (RefConditionalExpression
    -> RefConditionalExpression -> RefConditionalExpression)
-> Ord RefConditionalExpression
RefConditionalExpression -> RefConditionalExpression -> Bool
RefConditionalExpression -> RefConditionalExpression -> Ordering
RefConditionalExpression
-> RefConditionalExpression -> RefConditionalExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefConditionalExpression -> RefConditionalExpression -> Ordering
compare :: RefConditionalExpression -> RefConditionalExpression -> Ordering
$c< :: RefConditionalExpression -> RefConditionalExpression -> Bool
< :: RefConditionalExpression -> RefConditionalExpression -> Bool
$c<= :: RefConditionalExpression -> RefConditionalExpression -> Bool
<= :: RefConditionalExpression -> RefConditionalExpression -> Bool
$c> :: RefConditionalExpression -> RefConditionalExpression -> Bool
> :: RefConditionalExpression -> RefConditionalExpression -> Bool
$c>= :: RefConditionalExpression -> RefConditionalExpression -> Bool
>= :: RefConditionalExpression -> RefConditionalExpression -> Bool
$cmax :: RefConditionalExpression
-> RefConditionalExpression -> RefConditionalExpression
max :: RefConditionalExpression
-> RefConditionalExpression -> RefConditionalExpression
$cmin :: RefConditionalExpression
-> RefConditionalExpression -> RefConditionalExpression
min :: RefConditionalExpression
-> RefConditionalExpression -> RefConditionalExpression
Ord, ReadPrec [RefConditionalExpression]
ReadPrec RefConditionalExpression
Int -> ReadS RefConditionalExpression
ReadS [RefConditionalExpression]
(Int -> ReadS RefConditionalExpression)
-> ReadS [RefConditionalExpression]
-> ReadPrec RefConditionalExpression
-> ReadPrec [RefConditionalExpression]
-> Read RefConditionalExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefConditionalExpression
readsPrec :: Int -> ReadS RefConditionalExpression
$creadList :: ReadS [RefConditionalExpression]
readList :: ReadS [RefConditionalExpression]
$creadPrec :: ReadPrec RefConditionalExpression
readPrec :: ReadPrec RefConditionalExpression
$creadListPrec :: ReadPrec [RefConditionalExpression]
readListPrec :: ReadPrec [RefConditionalExpression]
Read, Int -> RefConditionalExpression -> String -> String
[RefConditionalExpression] -> String -> String
RefConditionalExpression -> String
(Int -> RefConditionalExpression -> String -> String)
-> (RefConditionalExpression -> String)
-> ([RefConditionalExpression] -> String -> String)
-> Show RefConditionalExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefConditionalExpression -> String -> String
showsPrec :: Int -> RefConditionalExpression -> String -> String
$cshow :: RefConditionalExpression -> String
show :: RefConditionalExpression -> String
$cshowList :: [RefConditionalExpression] -> String -> String
showList :: [RefConditionalExpression] -> String -> String
Show)

_RefConditionalExpression :: Name
_RefConditionalExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefConditionalExpression")

_RefConditionalExpression_condition :: Name
_RefConditionalExpression_condition = (String -> Name
Core.Name String
"condition")

_RefConditionalExpression_true :: Name
_RefConditionalExpression_true = (String -> Name
Core.Name String
"true")

_RefConditionalExpression_false :: Name
_RefConditionalExpression_false = (String -> Name
Core.Name String
"false")

data LambdaExpression = 
  LambdaExpression {
    LambdaExpression -> Bool
lambdaExpressionAsync :: Bool,
    LambdaExpression -> AnonymousFunctionSignature
lambdaExpressionSignature :: AnonymousFunctionSignature,
    LambdaExpression -> AnonymousFunctionBody
lambdaExpressionBody :: AnonymousFunctionBody}
  deriving (LambdaExpression -> LambdaExpression -> Bool
(LambdaExpression -> LambdaExpression -> Bool)
-> (LambdaExpression -> LambdaExpression -> Bool)
-> Eq LambdaExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LambdaExpression -> LambdaExpression -> Bool
== :: LambdaExpression -> LambdaExpression -> Bool
$c/= :: LambdaExpression -> LambdaExpression -> Bool
/= :: LambdaExpression -> LambdaExpression -> Bool
Eq, Eq LambdaExpression
Eq LambdaExpression =>
(LambdaExpression -> LambdaExpression -> Ordering)
-> (LambdaExpression -> LambdaExpression -> Bool)
-> (LambdaExpression -> LambdaExpression -> Bool)
-> (LambdaExpression -> LambdaExpression -> Bool)
-> (LambdaExpression -> LambdaExpression -> Bool)
-> (LambdaExpression -> LambdaExpression -> LambdaExpression)
-> (LambdaExpression -> LambdaExpression -> LambdaExpression)
-> Ord LambdaExpression
LambdaExpression -> LambdaExpression -> Bool
LambdaExpression -> LambdaExpression -> Ordering
LambdaExpression -> LambdaExpression -> LambdaExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LambdaExpression -> LambdaExpression -> Ordering
compare :: LambdaExpression -> LambdaExpression -> Ordering
$c< :: LambdaExpression -> LambdaExpression -> Bool
< :: LambdaExpression -> LambdaExpression -> Bool
$c<= :: LambdaExpression -> LambdaExpression -> Bool
<= :: LambdaExpression -> LambdaExpression -> Bool
$c> :: LambdaExpression -> LambdaExpression -> Bool
> :: LambdaExpression -> LambdaExpression -> Bool
$c>= :: LambdaExpression -> LambdaExpression -> Bool
>= :: LambdaExpression -> LambdaExpression -> Bool
$cmax :: LambdaExpression -> LambdaExpression -> LambdaExpression
max :: LambdaExpression -> LambdaExpression -> LambdaExpression
$cmin :: LambdaExpression -> LambdaExpression -> LambdaExpression
min :: LambdaExpression -> LambdaExpression -> LambdaExpression
Ord, ReadPrec [LambdaExpression]
ReadPrec LambdaExpression
Int -> ReadS LambdaExpression
ReadS [LambdaExpression]
(Int -> ReadS LambdaExpression)
-> ReadS [LambdaExpression]
-> ReadPrec LambdaExpression
-> ReadPrec [LambdaExpression]
-> Read LambdaExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LambdaExpression
readsPrec :: Int -> ReadS LambdaExpression
$creadList :: ReadS [LambdaExpression]
readList :: ReadS [LambdaExpression]
$creadPrec :: ReadPrec LambdaExpression
readPrec :: ReadPrec LambdaExpression
$creadListPrec :: ReadPrec [LambdaExpression]
readListPrec :: ReadPrec [LambdaExpression]
Read, Int -> LambdaExpression -> String -> String
[LambdaExpression] -> String -> String
LambdaExpression -> String
(Int -> LambdaExpression -> String -> String)
-> (LambdaExpression -> String)
-> ([LambdaExpression] -> String -> String)
-> Show LambdaExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LambdaExpression -> String -> String
showsPrec :: Int -> LambdaExpression -> String -> String
$cshow :: LambdaExpression -> String
show :: LambdaExpression -> String
$cshowList :: [LambdaExpression] -> String -> String
showList :: [LambdaExpression] -> String -> String
Show)

_LambdaExpression :: Name
_LambdaExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LambdaExpression")

_LambdaExpression_async :: Name
_LambdaExpression_async = (String -> Name
Core.Name String
"async")

_LambdaExpression_signature :: Name
_LambdaExpression_signature = (String -> Name
Core.Name String
"signature")

_LambdaExpression_body :: Name
_LambdaExpression_body = (String -> Name
Core.Name String
"body")

data AnonymousMethodExpression = 
  AnonymousMethodExpression {
    AnonymousMethodExpression -> Bool
anonymousMethodExpressionAsync :: Bool,
    AnonymousMethodExpression -> [ExplicitAnonymousFunctionParameter]
anonymousMethodExpressionSignature :: [ExplicitAnonymousFunctionParameter],
    AnonymousMethodExpression -> Block
anonymousMethodExpressionBody :: Block}
  deriving (AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
(AnonymousMethodExpression -> AnonymousMethodExpression -> Bool)
-> (AnonymousMethodExpression -> AnonymousMethodExpression -> Bool)
-> Eq AnonymousMethodExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
== :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
$c/= :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
/= :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
Eq, Eq AnonymousMethodExpression
Eq AnonymousMethodExpression =>
(AnonymousMethodExpression
 -> AnonymousMethodExpression -> Ordering)
-> (AnonymousMethodExpression -> AnonymousMethodExpression -> Bool)
-> (AnonymousMethodExpression -> AnonymousMethodExpression -> Bool)
-> (AnonymousMethodExpression -> AnonymousMethodExpression -> Bool)
-> (AnonymousMethodExpression -> AnonymousMethodExpression -> Bool)
-> (AnonymousMethodExpression
    -> AnonymousMethodExpression -> AnonymousMethodExpression)
-> (AnonymousMethodExpression
    -> AnonymousMethodExpression -> AnonymousMethodExpression)
-> Ord AnonymousMethodExpression
AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
AnonymousMethodExpression -> AnonymousMethodExpression -> Ordering
AnonymousMethodExpression
-> AnonymousMethodExpression -> AnonymousMethodExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AnonymousMethodExpression -> AnonymousMethodExpression -> Ordering
compare :: AnonymousMethodExpression -> AnonymousMethodExpression -> Ordering
$c< :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
< :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
$c<= :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
<= :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
$c> :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
> :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
$c>= :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
>= :: AnonymousMethodExpression -> AnonymousMethodExpression -> Bool
$cmax :: AnonymousMethodExpression
-> AnonymousMethodExpression -> AnonymousMethodExpression
max :: AnonymousMethodExpression
-> AnonymousMethodExpression -> AnonymousMethodExpression
$cmin :: AnonymousMethodExpression
-> AnonymousMethodExpression -> AnonymousMethodExpression
min :: AnonymousMethodExpression
-> AnonymousMethodExpression -> AnonymousMethodExpression
Ord, ReadPrec [AnonymousMethodExpression]
ReadPrec AnonymousMethodExpression
Int -> ReadS AnonymousMethodExpression
ReadS [AnonymousMethodExpression]
(Int -> ReadS AnonymousMethodExpression)
-> ReadS [AnonymousMethodExpression]
-> ReadPrec AnonymousMethodExpression
-> ReadPrec [AnonymousMethodExpression]
-> Read AnonymousMethodExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AnonymousMethodExpression
readsPrec :: Int -> ReadS AnonymousMethodExpression
$creadList :: ReadS [AnonymousMethodExpression]
readList :: ReadS [AnonymousMethodExpression]
$creadPrec :: ReadPrec AnonymousMethodExpression
readPrec :: ReadPrec AnonymousMethodExpression
$creadListPrec :: ReadPrec [AnonymousMethodExpression]
readListPrec :: ReadPrec [AnonymousMethodExpression]
Read, Int -> AnonymousMethodExpression -> String -> String
[AnonymousMethodExpression] -> String -> String
AnonymousMethodExpression -> String
(Int -> AnonymousMethodExpression -> String -> String)
-> (AnonymousMethodExpression -> String)
-> ([AnonymousMethodExpression] -> String -> String)
-> Show AnonymousMethodExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AnonymousMethodExpression -> String -> String
showsPrec :: Int -> AnonymousMethodExpression -> String -> String
$cshow :: AnonymousMethodExpression -> String
show :: AnonymousMethodExpression -> String
$cshowList :: [AnonymousMethodExpression] -> String -> String
showList :: [AnonymousMethodExpression] -> String -> String
Show)

_AnonymousMethodExpression :: Name
_AnonymousMethodExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AnonymousMethodExpression")

_AnonymousMethodExpression_async :: Name
_AnonymousMethodExpression_async = (String -> Name
Core.Name String
"async")

_AnonymousMethodExpression_signature :: Name
_AnonymousMethodExpression_signature = (String -> Name
Core.Name String
"signature")

_AnonymousMethodExpression_body :: Name
_AnonymousMethodExpression_body = (String -> Name
Core.Name String
"body")

data AnonymousFunctionSignature = 
  AnonymousFunctionSignatureExplicit [ExplicitAnonymousFunctionParameter] |
  AnonymousFunctionSignatureImplicit [Identifier]
  deriving (AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
(AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool)
-> (AnonymousFunctionSignature
    -> AnonymousFunctionSignature -> Bool)
-> Eq AnonymousFunctionSignature
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
== :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
$c/= :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
/= :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
Eq, Eq AnonymousFunctionSignature
Eq AnonymousFunctionSignature =>
(AnonymousFunctionSignature
 -> AnonymousFunctionSignature -> Ordering)
-> (AnonymousFunctionSignature
    -> AnonymousFunctionSignature -> Bool)
-> (AnonymousFunctionSignature
    -> AnonymousFunctionSignature -> Bool)
-> (AnonymousFunctionSignature
    -> AnonymousFunctionSignature -> Bool)
-> (AnonymousFunctionSignature
    -> AnonymousFunctionSignature -> Bool)
-> (AnonymousFunctionSignature
    -> AnonymousFunctionSignature -> AnonymousFunctionSignature)
-> (AnonymousFunctionSignature
    -> AnonymousFunctionSignature -> AnonymousFunctionSignature)
-> Ord AnonymousFunctionSignature
AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
AnonymousFunctionSignature
-> AnonymousFunctionSignature -> Ordering
AnonymousFunctionSignature
-> AnonymousFunctionSignature -> AnonymousFunctionSignature
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AnonymousFunctionSignature
-> AnonymousFunctionSignature -> Ordering
compare :: AnonymousFunctionSignature
-> AnonymousFunctionSignature -> Ordering
$c< :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
< :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
$c<= :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
<= :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
$c> :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
> :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
$c>= :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
>= :: AnonymousFunctionSignature -> AnonymousFunctionSignature -> Bool
$cmax :: AnonymousFunctionSignature
-> AnonymousFunctionSignature -> AnonymousFunctionSignature
max :: AnonymousFunctionSignature
-> AnonymousFunctionSignature -> AnonymousFunctionSignature
$cmin :: AnonymousFunctionSignature
-> AnonymousFunctionSignature -> AnonymousFunctionSignature
min :: AnonymousFunctionSignature
-> AnonymousFunctionSignature -> AnonymousFunctionSignature
Ord, ReadPrec [AnonymousFunctionSignature]
ReadPrec AnonymousFunctionSignature
Int -> ReadS AnonymousFunctionSignature
ReadS [AnonymousFunctionSignature]
(Int -> ReadS AnonymousFunctionSignature)
-> ReadS [AnonymousFunctionSignature]
-> ReadPrec AnonymousFunctionSignature
-> ReadPrec [AnonymousFunctionSignature]
-> Read AnonymousFunctionSignature
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AnonymousFunctionSignature
readsPrec :: Int -> ReadS AnonymousFunctionSignature
$creadList :: ReadS [AnonymousFunctionSignature]
readList :: ReadS [AnonymousFunctionSignature]
$creadPrec :: ReadPrec AnonymousFunctionSignature
readPrec :: ReadPrec AnonymousFunctionSignature
$creadListPrec :: ReadPrec [AnonymousFunctionSignature]
readListPrec :: ReadPrec [AnonymousFunctionSignature]
Read, Int -> AnonymousFunctionSignature -> String -> String
[AnonymousFunctionSignature] -> String -> String
AnonymousFunctionSignature -> String
(Int -> AnonymousFunctionSignature -> String -> String)
-> (AnonymousFunctionSignature -> String)
-> ([AnonymousFunctionSignature] -> String -> String)
-> Show AnonymousFunctionSignature
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AnonymousFunctionSignature -> String -> String
showsPrec :: Int -> AnonymousFunctionSignature -> String -> String
$cshow :: AnonymousFunctionSignature -> String
show :: AnonymousFunctionSignature -> String
$cshowList :: [AnonymousFunctionSignature] -> String -> String
showList :: [AnonymousFunctionSignature] -> String -> String
Show)

_AnonymousFunctionSignature :: Name
_AnonymousFunctionSignature = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AnonymousFunctionSignature")

_AnonymousFunctionSignature_explicit :: Name
_AnonymousFunctionSignature_explicit = (String -> Name
Core.Name String
"explicit")

_AnonymousFunctionSignature_implicit :: Name
_AnonymousFunctionSignature_implicit = (String -> Name
Core.Name String
"implicit")

data ExplicitAnonymousFunctionParameter = 
  ExplicitAnonymousFunctionParameter {
    ExplicitAnonymousFunctionParameter
-> Maybe AnonymousFunctionParameterModifier
explicitAnonymousFunctionParameterModifier :: (Maybe AnonymousFunctionParameterModifier),
    ExplicitAnonymousFunctionParameter -> Type
explicitAnonymousFunctionParameterType :: Type,
    ExplicitAnonymousFunctionParameter -> Identifier
explicitAnonymousFunctionParameterIdentifier :: Identifier}
  deriving (ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
(ExplicitAnonymousFunctionParameter
 -> ExplicitAnonymousFunctionParameter -> Bool)
-> (ExplicitAnonymousFunctionParameter
    -> ExplicitAnonymousFunctionParameter -> Bool)
-> Eq ExplicitAnonymousFunctionParameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
== :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
$c/= :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
/= :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
Eq, Eq ExplicitAnonymousFunctionParameter
Eq ExplicitAnonymousFunctionParameter =>
(ExplicitAnonymousFunctionParameter
 -> ExplicitAnonymousFunctionParameter -> Ordering)
-> (ExplicitAnonymousFunctionParameter
    -> ExplicitAnonymousFunctionParameter -> Bool)
-> (ExplicitAnonymousFunctionParameter
    -> ExplicitAnonymousFunctionParameter -> Bool)
-> (ExplicitAnonymousFunctionParameter
    -> ExplicitAnonymousFunctionParameter -> Bool)
-> (ExplicitAnonymousFunctionParameter
    -> ExplicitAnonymousFunctionParameter -> Bool)
-> (ExplicitAnonymousFunctionParameter
    -> ExplicitAnonymousFunctionParameter
    -> ExplicitAnonymousFunctionParameter)
-> (ExplicitAnonymousFunctionParameter
    -> ExplicitAnonymousFunctionParameter
    -> ExplicitAnonymousFunctionParameter)
-> Ord ExplicitAnonymousFunctionParameter
ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Ordering
ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Ordering
compare :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Ordering
$c< :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
< :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
$c<= :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
<= :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
$c> :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
> :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
$c>= :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
>= :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter -> Bool
$cmax :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter
max :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter
$cmin :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter
min :: ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter
-> ExplicitAnonymousFunctionParameter
Ord, ReadPrec [ExplicitAnonymousFunctionParameter]
ReadPrec ExplicitAnonymousFunctionParameter
Int -> ReadS ExplicitAnonymousFunctionParameter
ReadS [ExplicitAnonymousFunctionParameter]
(Int -> ReadS ExplicitAnonymousFunctionParameter)
-> ReadS [ExplicitAnonymousFunctionParameter]
-> ReadPrec ExplicitAnonymousFunctionParameter
-> ReadPrec [ExplicitAnonymousFunctionParameter]
-> Read ExplicitAnonymousFunctionParameter
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExplicitAnonymousFunctionParameter
readsPrec :: Int -> ReadS ExplicitAnonymousFunctionParameter
$creadList :: ReadS [ExplicitAnonymousFunctionParameter]
readList :: ReadS [ExplicitAnonymousFunctionParameter]
$creadPrec :: ReadPrec ExplicitAnonymousFunctionParameter
readPrec :: ReadPrec ExplicitAnonymousFunctionParameter
$creadListPrec :: ReadPrec [ExplicitAnonymousFunctionParameter]
readListPrec :: ReadPrec [ExplicitAnonymousFunctionParameter]
Read, Int -> ExplicitAnonymousFunctionParameter -> String -> String
[ExplicitAnonymousFunctionParameter] -> String -> String
ExplicitAnonymousFunctionParameter -> String
(Int -> ExplicitAnonymousFunctionParameter -> String -> String)
-> (ExplicitAnonymousFunctionParameter -> String)
-> ([ExplicitAnonymousFunctionParameter] -> String -> String)
-> Show ExplicitAnonymousFunctionParameter
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ExplicitAnonymousFunctionParameter -> String -> String
showsPrec :: Int -> ExplicitAnonymousFunctionParameter -> String -> String
$cshow :: ExplicitAnonymousFunctionParameter -> String
show :: ExplicitAnonymousFunctionParameter -> String
$cshowList :: [ExplicitAnonymousFunctionParameter] -> String -> String
showList :: [ExplicitAnonymousFunctionParameter] -> String -> String
Show)

_ExplicitAnonymousFunctionParameter :: Name
_ExplicitAnonymousFunctionParameter = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ExplicitAnonymousFunctionParameter")

_ExplicitAnonymousFunctionParameter_modifier :: Name
_ExplicitAnonymousFunctionParameter_modifier = (String -> Name
Core.Name String
"modifier")

_ExplicitAnonymousFunctionParameter_type :: Name
_ExplicitAnonymousFunctionParameter_type = (String -> Name
Core.Name String
"type")

_ExplicitAnonymousFunctionParameter_identifier :: Name
_ExplicitAnonymousFunctionParameter_identifier = (String -> Name
Core.Name String
"identifier")

data AnonymousFunctionParameterModifier = 
  AnonymousFunctionParameterModifierRef  |
  AnonymousFunctionParameterModifierOut  |
  AnonymousFunctionParameterModifierIn 
  deriving (AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
(AnonymousFunctionParameterModifier
 -> AnonymousFunctionParameterModifier -> Bool)
-> (AnonymousFunctionParameterModifier
    -> AnonymousFunctionParameterModifier -> Bool)
-> Eq AnonymousFunctionParameterModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
== :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
$c/= :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
/= :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
Eq, Eq AnonymousFunctionParameterModifier
Eq AnonymousFunctionParameterModifier =>
(AnonymousFunctionParameterModifier
 -> AnonymousFunctionParameterModifier -> Ordering)
-> (AnonymousFunctionParameterModifier
    -> AnonymousFunctionParameterModifier -> Bool)
-> (AnonymousFunctionParameterModifier
    -> AnonymousFunctionParameterModifier -> Bool)
-> (AnonymousFunctionParameterModifier
    -> AnonymousFunctionParameterModifier -> Bool)
-> (AnonymousFunctionParameterModifier
    -> AnonymousFunctionParameterModifier -> Bool)
-> (AnonymousFunctionParameterModifier
    -> AnonymousFunctionParameterModifier
    -> AnonymousFunctionParameterModifier)
-> (AnonymousFunctionParameterModifier
    -> AnonymousFunctionParameterModifier
    -> AnonymousFunctionParameterModifier)
-> Ord AnonymousFunctionParameterModifier
AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Ordering
AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Ordering
compare :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Ordering
$c< :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
< :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
$c<= :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
<= :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
$c> :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
> :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
$c>= :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
>= :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier -> Bool
$cmax :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier
max :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier
$cmin :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier
min :: AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier
-> AnonymousFunctionParameterModifier
Ord, ReadPrec [AnonymousFunctionParameterModifier]
ReadPrec AnonymousFunctionParameterModifier
Int -> ReadS AnonymousFunctionParameterModifier
ReadS [AnonymousFunctionParameterModifier]
(Int -> ReadS AnonymousFunctionParameterModifier)
-> ReadS [AnonymousFunctionParameterModifier]
-> ReadPrec AnonymousFunctionParameterModifier
-> ReadPrec [AnonymousFunctionParameterModifier]
-> Read AnonymousFunctionParameterModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AnonymousFunctionParameterModifier
readsPrec :: Int -> ReadS AnonymousFunctionParameterModifier
$creadList :: ReadS [AnonymousFunctionParameterModifier]
readList :: ReadS [AnonymousFunctionParameterModifier]
$creadPrec :: ReadPrec AnonymousFunctionParameterModifier
readPrec :: ReadPrec AnonymousFunctionParameterModifier
$creadListPrec :: ReadPrec [AnonymousFunctionParameterModifier]
readListPrec :: ReadPrec [AnonymousFunctionParameterModifier]
Read, Int -> AnonymousFunctionParameterModifier -> String -> String
[AnonymousFunctionParameterModifier] -> String -> String
AnonymousFunctionParameterModifier -> String
(Int -> AnonymousFunctionParameterModifier -> String -> String)
-> (AnonymousFunctionParameterModifier -> String)
-> ([AnonymousFunctionParameterModifier] -> String -> String)
-> Show AnonymousFunctionParameterModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AnonymousFunctionParameterModifier -> String -> String
showsPrec :: Int -> AnonymousFunctionParameterModifier -> String -> String
$cshow :: AnonymousFunctionParameterModifier -> String
show :: AnonymousFunctionParameterModifier -> String
$cshowList :: [AnonymousFunctionParameterModifier] -> String -> String
showList :: [AnonymousFunctionParameterModifier] -> String -> String
Show)

_AnonymousFunctionParameterModifier :: Name
_AnonymousFunctionParameterModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AnonymousFunctionParameterModifier")

_AnonymousFunctionParameterModifier_ref :: Name
_AnonymousFunctionParameterModifier_ref = (String -> Name
Core.Name String
"ref")

_AnonymousFunctionParameterModifier_out :: Name
_AnonymousFunctionParameterModifier_out = (String -> Name
Core.Name String
"out")

_AnonymousFunctionParameterModifier_in :: Name
_AnonymousFunctionParameterModifier_in = (String -> Name
Core.Name String
"in")

data AnonymousFunctionBody = 
  AnonymousFunctionBodyNullConditionalInvocation NullConditionalInvocationExpression |
  AnonymousFunctionBodyExpression Expression |
  AnonymousFunctionBodyRef VariableReference |
  AnonymousFunctionBodyBlock Block
  deriving (AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
(AnonymousFunctionBody -> AnonymousFunctionBody -> Bool)
-> (AnonymousFunctionBody -> AnonymousFunctionBody -> Bool)
-> Eq AnonymousFunctionBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
== :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
$c/= :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
/= :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
Eq, Eq AnonymousFunctionBody
Eq AnonymousFunctionBody =>
(AnonymousFunctionBody -> AnonymousFunctionBody -> Ordering)
-> (AnonymousFunctionBody -> AnonymousFunctionBody -> Bool)
-> (AnonymousFunctionBody -> AnonymousFunctionBody -> Bool)
-> (AnonymousFunctionBody -> AnonymousFunctionBody -> Bool)
-> (AnonymousFunctionBody -> AnonymousFunctionBody -> Bool)
-> (AnonymousFunctionBody
    -> AnonymousFunctionBody -> AnonymousFunctionBody)
-> (AnonymousFunctionBody
    -> AnonymousFunctionBody -> AnonymousFunctionBody)
-> Ord AnonymousFunctionBody
AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
AnonymousFunctionBody -> AnonymousFunctionBody -> Ordering
AnonymousFunctionBody
-> AnonymousFunctionBody -> AnonymousFunctionBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AnonymousFunctionBody -> AnonymousFunctionBody -> Ordering
compare :: AnonymousFunctionBody -> AnonymousFunctionBody -> Ordering
$c< :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
< :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
$c<= :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
<= :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
$c> :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
> :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
$c>= :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
>= :: AnonymousFunctionBody -> AnonymousFunctionBody -> Bool
$cmax :: AnonymousFunctionBody
-> AnonymousFunctionBody -> AnonymousFunctionBody
max :: AnonymousFunctionBody
-> AnonymousFunctionBody -> AnonymousFunctionBody
$cmin :: AnonymousFunctionBody
-> AnonymousFunctionBody -> AnonymousFunctionBody
min :: AnonymousFunctionBody
-> AnonymousFunctionBody -> AnonymousFunctionBody
Ord, ReadPrec [AnonymousFunctionBody]
ReadPrec AnonymousFunctionBody
Int -> ReadS AnonymousFunctionBody
ReadS [AnonymousFunctionBody]
(Int -> ReadS AnonymousFunctionBody)
-> ReadS [AnonymousFunctionBody]
-> ReadPrec AnonymousFunctionBody
-> ReadPrec [AnonymousFunctionBody]
-> Read AnonymousFunctionBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AnonymousFunctionBody
readsPrec :: Int -> ReadS AnonymousFunctionBody
$creadList :: ReadS [AnonymousFunctionBody]
readList :: ReadS [AnonymousFunctionBody]
$creadPrec :: ReadPrec AnonymousFunctionBody
readPrec :: ReadPrec AnonymousFunctionBody
$creadListPrec :: ReadPrec [AnonymousFunctionBody]
readListPrec :: ReadPrec [AnonymousFunctionBody]
Read, Int -> AnonymousFunctionBody -> String -> String
[AnonymousFunctionBody] -> String -> String
AnonymousFunctionBody -> String
(Int -> AnonymousFunctionBody -> String -> String)
-> (AnonymousFunctionBody -> String)
-> ([AnonymousFunctionBody] -> String -> String)
-> Show AnonymousFunctionBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AnonymousFunctionBody -> String -> String
showsPrec :: Int -> AnonymousFunctionBody -> String -> String
$cshow :: AnonymousFunctionBody -> String
show :: AnonymousFunctionBody -> String
$cshowList :: [AnonymousFunctionBody] -> String -> String
showList :: [AnonymousFunctionBody] -> String -> String
Show)

_AnonymousFunctionBody :: Name
_AnonymousFunctionBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AnonymousFunctionBody")

_AnonymousFunctionBody_nullConditionalInvocation :: Name
_AnonymousFunctionBody_nullConditionalInvocation = (String -> Name
Core.Name String
"nullConditionalInvocation")

_AnonymousFunctionBody_expression :: Name
_AnonymousFunctionBody_expression = (String -> Name
Core.Name String
"expression")

_AnonymousFunctionBody_ref :: Name
_AnonymousFunctionBody_ref = (String -> Name
Core.Name String
"ref")

_AnonymousFunctionBody_block :: Name
_AnonymousFunctionBody_block = (String -> Name
Core.Name String
"block")

data QueryExpression = 
  QueryExpression {
    QueryExpression -> FromClause
queryExpressionFrom :: FromClause,
    QueryExpression -> QueryBody
queryExpressionBody :: QueryBody}
  deriving (QueryExpression -> QueryExpression -> Bool
(QueryExpression -> QueryExpression -> Bool)
-> (QueryExpression -> QueryExpression -> Bool)
-> Eq QueryExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QueryExpression -> QueryExpression -> Bool
== :: QueryExpression -> QueryExpression -> Bool
$c/= :: QueryExpression -> QueryExpression -> Bool
/= :: QueryExpression -> QueryExpression -> Bool
Eq, Eq QueryExpression
Eq QueryExpression =>
(QueryExpression -> QueryExpression -> Ordering)
-> (QueryExpression -> QueryExpression -> Bool)
-> (QueryExpression -> QueryExpression -> Bool)
-> (QueryExpression -> QueryExpression -> Bool)
-> (QueryExpression -> QueryExpression -> Bool)
-> (QueryExpression -> QueryExpression -> QueryExpression)
-> (QueryExpression -> QueryExpression -> QueryExpression)
-> Ord QueryExpression
QueryExpression -> QueryExpression -> Bool
QueryExpression -> QueryExpression -> Ordering
QueryExpression -> QueryExpression -> QueryExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: QueryExpression -> QueryExpression -> Ordering
compare :: QueryExpression -> QueryExpression -> Ordering
$c< :: QueryExpression -> QueryExpression -> Bool
< :: QueryExpression -> QueryExpression -> Bool
$c<= :: QueryExpression -> QueryExpression -> Bool
<= :: QueryExpression -> QueryExpression -> Bool
$c> :: QueryExpression -> QueryExpression -> Bool
> :: QueryExpression -> QueryExpression -> Bool
$c>= :: QueryExpression -> QueryExpression -> Bool
>= :: QueryExpression -> QueryExpression -> Bool
$cmax :: QueryExpression -> QueryExpression -> QueryExpression
max :: QueryExpression -> QueryExpression -> QueryExpression
$cmin :: QueryExpression -> QueryExpression -> QueryExpression
min :: QueryExpression -> QueryExpression -> QueryExpression
Ord, ReadPrec [QueryExpression]
ReadPrec QueryExpression
Int -> ReadS QueryExpression
ReadS [QueryExpression]
(Int -> ReadS QueryExpression)
-> ReadS [QueryExpression]
-> ReadPrec QueryExpression
-> ReadPrec [QueryExpression]
-> Read QueryExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS QueryExpression
readsPrec :: Int -> ReadS QueryExpression
$creadList :: ReadS [QueryExpression]
readList :: ReadS [QueryExpression]
$creadPrec :: ReadPrec QueryExpression
readPrec :: ReadPrec QueryExpression
$creadListPrec :: ReadPrec [QueryExpression]
readListPrec :: ReadPrec [QueryExpression]
Read, Int -> QueryExpression -> String -> String
[QueryExpression] -> String -> String
QueryExpression -> String
(Int -> QueryExpression -> String -> String)
-> (QueryExpression -> String)
-> ([QueryExpression] -> String -> String)
-> Show QueryExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> QueryExpression -> String -> String
showsPrec :: Int -> QueryExpression -> String -> String
$cshow :: QueryExpression -> String
show :: QueryExpression -> String
$cshowList :: [QueryExpression] -> String -> String
showList :: [QueryExpression] -> String -> String
Show)

_QueryExpression :: Name
_QueryExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.QueryExpression")

_QueryExpression_from :: Name
_QueryExpression_from = (String -> Name
Core.Name String
"from")

_QueryExpression_body :: Name
_QueryExpression_body = (String -> Name
Core.Name String
"body")

data FromClause = 
  FromClause {
    FromClause -> Maybe Type
fromClauseType :: (Maybe Type),
    FromClause -> Identifier
fromClauseIdentifier :: Identifier,
    FromClause -> Expression
fromClauseIn :: Expression}
  deriving (FromClause -> FromClause -> Bool
(FromClause -> FromClause -> Bool)
-> (FromClause -> FromClause -> Bool) -> Eq FromClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FromClause -> FromClause -> Bool
== :: FromClause -> FromClause -> Bool
$c/= :: FromClause -> FromClause -> Bool
/= :: FromClause -> FromClause -> Bool
Eq, Eq FromClause
Eq FromClause =>
(FromClause -> FromClause -> Ordering)
-> (FromClause -> FromClause -> Bool)
-> (FromClause -> FromClause -> Bool)
-> (FromClause -> FromClause -> Bool)
-> (FromClause -> FromClause -> Bool)
-> (FromClause -> FromClause -> FromClause)
-> (FromClause -> FromClause -> FromClause)
-> Ord FromClause
FromClause -> FromClause -> Bool
FromClause -> FromClause -> Ordering
FromClause -> FromClause -> FromClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FromClause -> FromClause -> Ordering
compare :: FromClause -> FromClause -> Ordering
$c< :: FromClause -> FromClause -> Bool
< :: FromClause -> FromClause -> Bool
$c<= :: FromClause -> FromClause -> Bool
<= :: FromClause -> FromClause -> Bool
$c> :: FromClause -> FromClause -> Bool
> :: FromClause -> FromClause -> Bool
$c>= :: FromClause -> FromClause -> Bool
>= :: FromClause -> FromClause -> Bool
$cmax :: FromClause -> FromClause -> FromClause
max :: FromClause -> FromClause -> FromClause
$cmin :: FromClause -> FromClause -> FromClause
min :: FromClause -> FromClause -> FromClause
Ord, ReadPrec [FromClause]
ReadPrec FromClause
Int -> ReadS FromClause
ReadS [FromClause]
(Int -> ReadS FromClause)
-> ReadS [FromClause]
-> ReadPrec FromClause
-> ReadPrec [FromClause]
-> Read FromClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FromClause
readsPrec :: Int -> ReadS FromClause
$creadList :: ReadS [FromClause]
readList :: ReadS [FromClause]
$creadPrec :: ReadPrec FromClause
readPrec :: ReadPrec FromClause
$creadListPrec :: ReadPrec [FromClause]
readListPrec :: ReadPrec [FromClause]
Read, Int -> FromClause -> String -> String
[FromClause] -> String -> String
FromClause -> String
(Int -> FromClause -> String -> String)
-> (FromClause -> String)
-> ([FromClause] -> String -> String)
-> Show FromClause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FromClause -> String -> String
showsPrec :: Int -> FromClause -> String -> String
$cshow :: FromClause -> String
show :: FromClause -> String
$cshowList :: [FromClause] -> String -> String
showList :: [FromClause] -> String -> String
Show)

_FromClause :: Name
_FromClause = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FromClause")

_FromClause_type :: Name
_FromClause_type = (String -> Name
Core.Name String
"type")

_FromClause_identifier :: Name
_FromClause_identifier = (String -> Name
Core.Name String
"identifier")

_FromClause_in :: Name
_FromClause_in = (String -> Name
Core.Name String
"in")

data QueryBody = 
  QueryBody {
    QueryBody -> [QueryBodyClause]
queryBodyClauses :: [QueryBodyClause],
    QueryBody -> SelectOrGroupClause
queryBodySelectOrGroup :: SelectOrGroupClause,
    QueryBody -> Maybe QueryContinuation
queryBodyContinuation :: (Maybe QueryContinuation)}
  deriving (QueryBody -> QueryBody -> Bool
(QueryBody -> QueryBody -> Bool)
-> (QueryBody -> QueryBody -> Bool) -> Eq QueryBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QueryBody -> QueryBody -> Bool
== :: QueryBody -> QueryBody -> Bool
$c/= :: QueryBody -> QueryBody -> Bool
/= :: QueryBody -> QueryBody -> Bool
Eq, Eq QueryBody
Eq QueryBody =>
(QueryBody -> QueryBody -> Ordering)
-> (QueryBody -> QueryBody -> Bool)
-> (QueryBody -> QueryBody -> Bool)
-> (QueryBody -> QueryBody -> Bool)
-> (QueryBody -> QueryBody -> Bool)
-> (QueryBody -> QueryBody -> QueryBody)
-> (QueryBody -> QueryBody -> QueryBody)
-> Ord QueryBody
QueryBody -> QueryBody -> Bool
QueryBody -> QueryBody -> Ordering
QueryBody -> QueryBody -> QueryBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: QueryBody -> QueryBody -> Ordering
compare :: QueryBody -> QueryBody -> Ordering
$c< :: QueryBody -> QueryBody -> Bool
< :: QueryBody -> QueryBody -> Bool
$c<= :: QueryBody -> QueryBody -> Bool
<= :: QueryBody -> QueryBody -> Bool
$c> :: QueryBody -> QueryBody -> Bool
> :: QueryBody -> QueryBody -> Bool
$c>= :: QueryBody -> QueryBody -> Bool
>= :: QueryBody -> QueryBody -> Bool
$cmax :: QueryBody -> QueryBody -> QueryBody
max :: QueryBody -> QueryBody -> QueryBody
$cmin :: QueryBody -> QueryBody -> QueryBody
min :: QueryBody -> QueryBody -> QueryBody
Ord, ReadPrec [QueryBody]
ReadPrec QueryBody
Int -> ReadS QueryBody
ReadS [QueryBody]
(Int -> ReadS QueryBody)
-> ReadS [QueryBody]
-> ReadPrec QueryBody
-> ReadPrec [QueryBody]
-> Read QueryBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS QueryBody
readsPrec :: Int -> ReadS QueryBody
$creadList :: ReadS [QueryBody]
readList :: ReadS [QueryBody]
$creadPrec :: ReadPrec QueryBody
readPrec :: ReadPrec QueryBody
$creadListPrec :: ReadPrec [QueryBody]
readListPrec :: ReadPrec [QueryBody]
Read, Int -> QueryBody -> String -> String
[QueryBody] -> String -> String
QueryBody -> String
(Int -> QueryBody -> String -> String)
-> (QueryBody -> String)
-> ([QueryBody] -> String -> String)
-> Show QueryBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> QueryBody -> String -> String
showsPrec :: Int -> QueryBody -> String -> String
$cshow :: QueryBody -> String
show :: QueryBody -> String
$cshowList :: [QueryBody] -> String -> String
showList :: [QueryBody] -> String -> String
Show)

_QueryBody :: Name
_QueryBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.QueryBody")

_QueryBody_clauses :: Name
_QueryBody_clauses = (String -> Name
Core.Name String
"clauses")

_QueryBody_selectOrGroup :: Name
_QueryBody_selectOrGroup = (String -> Name
Core.Name String
"selectOrGroup")

_QueryBody_continuation :: Name
_QueryBody_continuation = (String -> Name
Core.Name String
"continuation")

data QueryBodyClause = 
  QueryBodyClauseFrom FromClause |
  QueryBodyClauseLet LetClause |
  QueryBodyClauseWhere BooleanExpression |
  QueryBodyClauseJoin JoinClause |
  QueryBodyClauseOrderby [Ordering_]
  deriving (QueryBodyClause -> QueryBodyClause -> Bool
(QueryBodyClause -> QueryBodyClause -> Bool)
-> (QueryBodyClause -> QueryBodyClause -> Bool)
-> Eq QueryBodyClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QueryBodyClause -> QueryBodyClause -> Bool
== :: QueryBodyClause -> QueryBodyClause -> Bool
$c/= :: QueryBodyClause -> QueryBodyClause -> Bool
/= :: QueryBodyClause -> QueryBodyClause -> Bool
Eq, Eq QueryBodyClause
Eq QueryBodyClause =>
(QueryBodyClause -> QueryBodyClause -> Ordering)
-> (QueryBodyClause -> QueryBodyClause -> Bool)
-> (QueryBodyClause -> QueryBodyClause -> Bool)
-> (QueryBodyClause -> QueryBodyClause -> Bool)
-> (QueryBodyClause -> QueryBodyClause -> Bool)
-> (QueryBodyClause -> QueryBodyClause -> QueryBodyClause)
-> (QueryBodyClause -> QueryBodyClause -> QueryBodyClause)
-> Ord QueryBodyClause
QueryBodyClause -> QueryBodyClause -> Bool
QueryBodyClause -> QueryBodyClause -> Ordering
QueryBodyClause -> QueryBodyClause -> QueryBodyClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: QueryBodyClause -> QueryBodyClause -> Ordering
compare :: QueryBodyClause -> QueryBodyClause -> Ordering
$c< :: QueryBodyClause -> QueryBodyClause -> Bool
< :: QueryBodyClause -> QueryBodyClause -> Bool
$c<= :: QueryBodyClause -> QueryBodyClause -> Bool
<= :: QueryBodyClause -> QueryBodyClause -> Bool
$c> :: QueryBodyClause -> QueryBodyClause -> Bool
> :: QueryBodyClause -> QueryBodyClause -> Bool
$c>= :: QueryBodyClause -> QueryBodyClause -> Bool
>= :: QueryBodyClause -> QueryBodyClause -> Bool
$cmax :: QueryBodyClause -> QueryBodyClause -> QueryBodyClause
max :: QueryBodyClause -> QueryBodyClause -> QueryBodyClause
$cmin :: QueryBodyClause -> QueryBodyClause -> QueryBodyClause
min :: QueryBodyClause -> QueryBodyClause -> QueryBodyClause
Ord, ReadPrec [QueryBodyClause]
ReadPrec QueryBodyClause
Int -> ReadS QueryBodyClause
ReadS [QueryBodyClause]
(Int -> ReadS QueryBodyClause)
-> ReadS [QueryBodyClause]
-> ReadPrec QueryBodyClause
-> ReadPrec [QueryBodyClause]
-> Read QueryBodyClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS QueryBodyClause
readsPrec :: Int -> ReadS QueryBodyClause
$creadList :: ReadS [QueryBodyClause]
readList :: ReadS [QueryBodyClause]
$creadPrec :: ReadPrec QueryBodyClause
readPrec :: ReadPrec QueryBodyClause
$creadListPrec :: ReadPrec [QueryBodyClause]
readListPrec :: ReadPrec [QueryBodyClause]
Read, Int -> QueryBodyClause -> String -> String
[QueryBodyClause] -> String -> String
QueryBodyClause -> String
(Int -> QueryBodyClause -> String -> String)
-> (QueryBodyClause -> String)
-> ([QueryBodyClause] -> String -> String)
-> Show QueryBodyClause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> QueryBodyClause -> String -> String
showsPrec :: Int -> QueryBodyClause -> String -> String
$cshow :: QueryBodyClause -> String
show :: QueryBodyClause -> String
$cshowList :: [QueryBodyClause] -> String -> String
showList :: [QueryBodyClause] -> String -> String
Show)

_QueryBodyClause :: Name
_QueryBodyClause = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.QueryBodyClause")

_QueryBodyClause_from :: Name
_QueryBodyClause_from = (String -> Name
Core.Name String
"from")

_QueryBodyClause_let :: Name
_QueryBodyClause_let = (String -> Name
Core.Name String
"let")

_QueryBodyClause_where :: Name
_QueryBodyClause_where = (String -> Name
Core.Name String
"where")

_QueryBodyClause_join :: Name
_QueryBodyClause_join = (String -> Name
Core.Name String
"join")

_QueryBodyClause_orderby :: Name
_QueryBodyClause_orderby = (String -> Name
Core.Name String
"orderby")

data LetClause = 
  LetClause {
    LetClause -> Identifier
letClauseLeft :: Identifier,
    LetClause -> Expression
letClauseRight :: Expression}
  deriving (LetClause -> LetClause -> Bool
(LetClause -> LetClause -> Bool)
-> (LetClause -> LetClause -> Bool) -> Eq LetClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LetClause -> LetClause -> Bool
== :: LetClause -> LetClause -> Bool
$c/= :: LetClause -> LetClause -> Bool
/= :: LetClause -> LetClause -> Bool
Eq, Eq LetClause
Eq LetClause =>
(LetClause -> LetClause -> Ordering)
-> (LetClause -> LetClause -> Bool)
-> (LetClause -> LetClause -> Bool)
-> (LetClause -> LetClause -> Bool)
-> (LetClause -> LetClause -> Bool)
-> (LetClause -> LetClause -> LetClause)
-> (LetClause -> LetClause -> LetClause)
-> Ord LetClause
LetClause -> LetClause -> Bool
LetClause -> LetClause -> Ordering
LetClause -> LetClause -> LetClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LetClause -> LetClause -> Ordering
compare :: LetClause -> LetClause -> Ordering
$c< :: LetClause -> LetClause -> Bool
< :: LetClause -> LetClause -> Bool
$c<= :: LetClause -> LetClause -> Bool
<= :: LetClause -> LetClause -> Bool
$c> :: LetClause -> LetClause -> Bool
> :: LetClause -> LetClause -> Bool
$c>= :: LetClause -> LetClause -> Bool
>= :: LetClause -> LetClause -> Bool
$cmax :: LetClause -> LetClause -> LetClause
max :: LetClause -> LetClause -> LetClause
$cmin :: LetClause -> LetClause -> LetClause
min :: LetClause -> LetClause -> LetClause
Ord, ReadPrec [LetClause]
ReadPrec LetClause
Int -> ReadS LetClause
ReadS [LetClause]
(Int -> ReadS LetClause)
-> ReadS [LetClause]
-> ReadPrec LetClause
-> ReadPrec [LetClause]
-> Read LetClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LetClause
readsPrec :: Int -> ReadS LetClause
$creadList :: ReadS [LetClause]
readList :: ReadS [LetClause]
$creadPrec :: ReadPrec LetClause
readPrec :: ReadPrec LetClause
$creadListPrec :: ReadPrec [LetClause]
readListPrec :: ReadPrec [LetClause]
Read, Int -> LetClause -> String -> String
[LetClause] -> String -> String
LetClause -> String
(Int -> LetClause -> String -> String)
-> (LetClause -> String)
-> ([LetClause] -> String -> String)
-> Show LetClause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LetClause -> String -> String
showsPrec :: Int -> LetClause -> String -> String
$cshow :: LetClause -> String
show :: LetClause -> String
$cshowList :: [LetClause] -> String -> String
showList :: [LetClause] -> String -> String
Show)

_LetClause :: Name
_LetClause = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LetClause")

_LetClause_left :: Name
_LetClause_left = (String -> Name
Core.Name String
"left")

_LetClause_right :: Name
_LetClause_right = (String -> Name
Core.Name String
"right")

data JoinClause = 
  JoinClause {
    JoinClause -> Maybe Type
joinClauseType :: (Maybe Type),
    JoinClause -> Identifier
joinClauseIdentifier :: Identifier,
    JoinClause -> Expression
joinClauseIn :: Expression,
    JoinClause -> Expression
joinClauseOn :: Expression,
    JoinClause -> Expression
joinClauseEquals :: Expression,
    JoinClause -> Maybe Identifier
joinClauseInto :: (Maybe Identifier)}
  deriving (JoinClause -> JoinClause -> Bool
(JoinClause -> JoinClause -> Bool)
-> (JoinClause -> JoinClause -> Bool) -> Eq JoinClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JoinClause -> JoinClause -> Bool
== :: JoinClause -> JoinClause -> Bool
$c/= :: JoinClause -> JoinClause -> Bool
/= :: JoinClause -> JoinClause -> Bool
Eq, Eq JoinClause
Eq JoinClause =>
(JoinClause -> JoinClause -> Ordering)
-> (JoinClause -> JoinClause -> Bool)
-> (JoinClause -> JoinClause -> Bool)
-> (JoinClause -> JoinClause -> Bool)
-> (JoinClause -> JoinClause -> Bool)
-> (JoinClause -> JoinClause -> JoinClause)
-> (JoinClause -> JoinClause -> JoinClause)
-> Ord JoinClause
JoinClause -> JoinClause -> Bool
JoinClause -> JoinClause -> Ordering
JoinClause -> JoinClause -> JoinClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: JoinClause -> JoinClause -> Ordering
compare :: JoinClause -> JoinClause -> Ordering
$c< :: JoinClause -> JoinClause -> Bool
< :: JoinClause -> JoinClause -> Bool
$c<= :: JoinClause -> JoinClause -> Bool
<= :: JoinClause -> JoinClause -> Bool
$c> :: JoinClause -> JoinClause -> Bool
> :: JoinClause -> JoinClause -> Bool
$c>= :: JoinClause -> JoinClause -> Bool
>= :: JoinClause -> JoinClause -> Bool
$cmax :: JoinClause -> JoinClause -> JoinClause
max :: JoinClause -> JoinClause -> JoinClause
$cmin :: JoinClause -> JoinClause -> JoinClause
min :: JoinClause -> JoinClause -> JoinClause
Ord, ReadPrec [JoinClause]
ReadPrec JoinClause
Int -> ReadS JoinClause
ReadS [JoinClause]
(Int -> ReadS JoinClause)
-> ReadS [JoinClause]
-> ReadPrec JoinClause
-> ReadPrec [JoinClause]
-> Read JoinClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS JoinClause
readsPrec :: Int -> ReadS JoinClause
$creadList :: ReadS [JoinClause]
readList :: ReadS [JoinClause]
$creadPrec :: ReadPrec JoinClause
readPrec :: ReadPrec JoinClause
$creadListPrec :: ReadPrec [JoinClause]
readListPrec :: ReadPrec [JoinClause]
Read, Int -> JoinClause -> String -> String
[JoinClause] -> String -> String
JoinClause -> String
(Int -> JoinClause -> String -> String)
-> (JoinClause -> String)
-> ([JoinClause] -> String -> String)
-> Show JoinClause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> JoinClause -> String -> String
showsPrec :: Int -> JoinClause -> String -> String
$cshow :: JoinClause -> String
show :: JoinClause -> String
$cshowList :: [JoinClause] -> String -> String
showList :: [JoinClause] -> String -> String
Show)

_JoinClause :: Name
_JoinClause = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.JoinClause")

_JoinClause_type :: Name
_JoinClause_type = (String -> Name
Core.Name String
"type")

_JoinClause_identifier :: Name
_JoinClause_identifier = (String -> Name
Core.Name String
"identifier")

_JoinClause_in :: Name
_JoinClause_in = (String -> Name
Core.Name String
"in")

_JoinClause_on :: Name
_JoinClause_on = (String -> Name
Core.Name String
"on")

_JoinClause_equals :: Name
_JoinClause_equals = (String -> Name
Core.Name String
"equals")

_JoinClause_into :: Name
_JoinClause_into = (String -> Name
Core.Name String
"into")

data Ordering_ = 
  Ordering_ {
    Ordering_ -> Expression
orderingExpression :: Expression,
    Ordering_ -> Maybe OrderingDirection
orderingDirection :: (Maybe OrderingDirection)}
  deriving (Ordering_ -> Ordering_ -> Bool
(Ordering_ -> Ordering_ -> Bool)
-> (Ordering_ -> Ordering_ -> Bool) -> Eq Ordering_
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ordering_ -> Ordering_ -> Bool
== :: Ordering_ -> Ordering_ -> Bool
$c/= :: Ordering_ -> Ordering_ -> Bool
/= :: Ordering_ -> Ordering_ -> Bool
Eq, Eq Ordering_
Eq Ordering_ =>
(Ordering_ -> Ordering_ -> Ordering)
-> (Ordering_ -> Ordering_ -> Bool)
-> (Ordering_ -> Ordering_ -> Bool)
-> (Ordering_ -> Ordering_ -> Bool)
-> (Ordering_ -> Ordering_ -> Bool)
-> (Ordering_ -> Ordering_ -> Ordering_)
-> (Ordering_ -> Ordering_ -> Ordering_)
-> Ord Ordering_
Ordering_ -> Ordering_ -> Bool
Ordering_ -> Ordering_ -> Ordering
Ordering_ -> Ordering_ -> Ordering_
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Ordering_ -> Ordering_ -> Ordering
compare :: Ordering_ -> Ordering_ -> Ordering
$c< :: Ordering_ -> Ordering_ -> Bool
< :: Ordering_ -> Ordering_ -> Bool
$c<= :: Ordering_ -> Ordering_ -> Bool
<= :: Ordering_ -> Ordering_ -> Bool
$c> :: Ordering_ -> Ordering_ -> Bool
> :: Ordering_ -> Ordering_ -> Bool
$c>= :: Ordering_ -> Ordering_ -> Bool
>= :: Ordering_ -> Ordering_ -> Bool
$cmax :: Ordering_ -> Ordering_ -> Ordering_
max :: Ordering_ -> Ordering_ -> Ordering_
$cmin :: Ordering_ -> Ordering_ -> Ordering_
min :: Ordering_ -> Ordering_ -> Ordering_
Ord, ReadPrec [Ordering_]
ReadPrec Ordering_
Int -> ReadS Ordering_
ReadS [Ordering_]
(Int -> ReadS Ordering_)
-> ReadS [Ordering_]
-> ReadPrec Ordering_
-> ReadPrec [Ordering_]
-> Read Ordering_
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Ordering_
readsPrec :: Int -> ReadS Ordering_
$creadList :: ReadS [Ordering_]
readList :: ReadS [Ordering_]
$creadPrec :: ReadPrec Ordering_
readPrec :: ReadPrec Ordering_
$creadListPrec :: ReadPrec [Ordering_]
readListPrec :: ReadPrec [Ordering_]
Read, Int -> Ordering_ -> String -> String
[Ordering_] -> String -> String
Ordering_ -> String
(Int -> Ordering_ -> String -> String)
-> (Ordering_ -> String)
-> ([Ordering_] -> String -> String)
-> Show Ordering_
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Ordering_ -> String -> String
showsPrec :: Int -> Ordering_ -> String -> String
$cshow :: Ordering_ -> String
show :: Ordering_ -> String
$cshowList :: [Ordering_] -> String -> String
showList :: [Ordering_] -> String -> String
Show)

_Ordering :: Name
_Ordering = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Ordering")

_Ordering_expression :: Name
_Ordering_expression = (String -> Name
Core.Name String
"expression")

_Ordering_direction :: Name
_Ordering_direction = (String -> Name
Core.Name String
"direction")

data OrderingDirection = 
  OrderingDirectionAscending  |
  OrderingDirectionDescending 
  deriving (OrderingDirection -> OrderingDirection -> Bool
(OrderingDirection -> OrderingDirection -> Bool)
-> (OrderingDirection -> OrderingDirection -> Bool)
-> Eq OrderingDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OrderingDirection -> OrderingDirection -> Bool
== :: OrderingDirection -> OrderingDirection -> Bool
$c/= :: OrderingDirection -> OrderingDirection -> Bool
/= :: OrderingDirection -> OrderingDirection -> Bool
Eq, Eq OrderingDirection
Eq OrderingDirection =>
(OrderingDirection -> OrderingDirection -> Ordering)
-> (OrderingDirection -> OrderingDirection -> Bool)
-> (OrderingDirection -> OrderingDirection -> Bool)
-> (OrderingDirection -> OrderingDirection -> Bool)
-> (OrderingDirection -> OrderingDirection -> Bool)
-> (OrderingDirection -> OrderingDirection -> OrderingDirection)
-> (OrderingDirection -> OrderingDirection -> OrderingDirection)
-> Ord OrderingDirection
OrderingDirection -> OrderingDirection -> Bool
OrderingDirection -> OrderingDirection -> Ordering
OrderingDirection -> OrderingDirection -> OrderingDirection
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: OrderingDirection -> OrderingDirection -> Ordering
compare :: OrderingDirection -> OrderingDirection -> Ordering
$c< :: OrderingDirection -> OrderingDirection -> Bool
< :: OrderingDirection -> OrderingDirection -> Bool
$c<= :: OrderingDirection -> OrderingDirection -> Bool
<= :: OrderingDirection -> OrderingDirection -> Bool
$c> :: OrderingDirection -> OrderingDirection -> Bool
> :: OrderingDirection -> OrderingDirection -> Bool
$c>= :: OrderingDirection -> OrderingDirection -> Bool
>= :: OrderingDirection -> OrderingDirection -> Bool
$cmax :: OrderingDirection -> OrderingDirection -> OrderingDirection
max :: OrderingDirection -> OrderingDirection -> OrderingDirection
$cmin :: OrderingDirection -> OrderingDirection -> OrderingDirection
min :: OrderingDirection -> OrderingDirection -> OrderingDirection
Ord, ReadPrec [OrderingDirection]
ReadPrec OrderingDirection
Int -> ReadS OrderingDirection
ReadS [OrderingDirection]
(Int -> ReadS OrderingDirection)
-> ReadS [OrderingDirection]
-> ReadPrec OrderingDirection
-> ReadPrec [OrderingDirection]
-> Read OrderingDirection
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OrderingDirection
readsPrec :: Int -> ReadS OrderingDirection
$creadList :: ReadS [OrderingDirection]
readList :: ReadS [OrderingDirection]
$creadPrec :: ReadPrec OrderingDirection
readPrec :: ReadPrec OrderingDirection
$creadListPrec :: ReadPrec [OrderingDirection]
readListPrec :: ReadPrec [OrderingDirection]
Read, Int -> OrderingDirection -> String -> String
[OrderingDirection] -> String -> String
OrderingDirection -> String
(Int -> OrderingDirection -> String -> String)
-> (OrderingDirection -> String)
-> ([OrderingDirection] -> String -> String)
-> Show OrderingDirection
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> OrderingDirection -> String -> String
showsPrec :: Int -> OrderingDirection -> String -> String
$cshow :: OrderingDirection -> String
show :: OrderingDirection -> String
$cshowList :: [OrderingDirection] -> String -> String
showList :: [OrderingDirection] -> String -> String
Show)

_OrderingDirection :: Name
_OrderingDirection = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.OrderingDirection")

_OrderingDirection_ascending :: Name
_OrderingDirection_ascending = (String -> Name
Core.Name String
"ascending")

_OrderingDirection_descending :: Name
_OrderingDirection_descending = (String -> Name
Core.Name String
"descending")

data SelectOrGroupClause = 
  SelectOrGroupClauseSelect Expression |
  SelectOrGroupClauseGroup GroupClause
  deriving (SelectOrGroupClause -> SelectOrGroupClause -> Bool
(SelectOrGroupClause -> SelectOrGroupClause -> Bool)
-> (SelectOrGroupClause -> SelectOrGroupClause -> Bool)
-> Eq SelectOrGroupClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
== :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
$c/= :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
/= :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
Eq, Eq SelectOrGroupClause
Eq SelectOrGroupClause =>
(SelectOrGroupClause -> SelectOrGroupClause -> Ordering)
-> (SelectOrGroupClause -> SelectOrGroupClause -> Bool)
-> (SelectOrGroupClause -> SelectOrGroupClause -> Bool)
-> (SelectOrGroupClause -> SelectOrGroupClause -> Bool)
-> (SelectOrGroupClause -> SelectOrGroupClause -> Bool)
-> (SelectOrGroupClause
    -> SelectOrGroupClause -> SelectOrGroupClause)
-> (SelectOrGroupClause
    -> SelectOrGroupClause -> SelectOrGroupClause)
-> Ord SelectOrGroupClause
SelectOrGroupClause -> SelectOrGroupClause -> Bool
SelectOrGroupClause -> SelectOrGroupClause -> Ordering
SelectOrGroupClause -> SelectOrGroupClause -> SelectOrGroupClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SelectOrGroupClause -> SelectOrGroupClause -> Ordering
compare :: SelectOrGroupClause -> SelectOrGroupClause -> Ordering
$c< :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
< :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
$c<= :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
<= :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
$c> :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
> :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
$c>= :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
>= :: SelectOrGroupClause -> SelectOrGroupClause -> Bool
$cmax :: SelectOrGroupClause -> SelectOrGroupClause -> SelectOrGroupClause
max :: SelectOrGroupClause -> SelectOrGroupClause -> SelectOrGroupClause
$cmin :: SelectOrGroupClause -> SelectOrGroupClause -> SelectOrGroupClause
min :: SelectOrGroupClause -> SelectOrGroupClause -> SelectOrGroupClause
Ord, ReadPrec [SelectOrGroupClause]
ReadPrec SelectOrGroupClause
Int -> ReadS SelectOrGroupClause
ReadS [SelectOrGroupClause]
(Int -> ReadS SelectOrGroupClause)
-> ReadS [SelectOrGroupClause]
-> ReadPrec SelectOrGroupClause
-> ReadPrec [SelectOrGroupClause]
-> Read SelectOrGroupClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SelectOrGroupClause
readsPrec :: Int -> ReadS SelectOrGroupClause
$creadList :: ReadS [SelectOrGroupClause]
readList :: ReadS [SelectOrGroupClause]
$creadPrec :: ReadPrec SelectOrGroupClause
readPrec :: ReadPrec SelectOrGroupClause
$creadListPrec :: ReadPrec [SelectOrGroupClause]
readListPrec :: ReadPrec [SelectOrGroupClause]
Read, Int -> SelectOrGroupClause -> String -> String
[SelectOrGroupClause] -> String -> String
SelectOrGroupClause -> String
(Int -> SelectOrGroupClause -> String -> String)
-> (SelectOrGroupClause -> String)
-> ([SelectOrGroupClause] -> String -> String)
-> Show SelectOrGroupClause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SelectOrGroupClause -> String -> String
showsPrec :: Int -> SelectOrGroupClause -> String -> String
$cshow :: SelectOrGroupClause -> String
show :: SelectOrGroupClause -> String
$cshowList :: [SelectOrGroupClause] -> String -> String
showList :: [SelectOrGroupClause] -> String -> String
Show)

_SelectOrGroupClause :: Name
_SelectOrGroupClause = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SelectOrGroupClause")

_SelectOrGroupClause_select :: Name
_SelectOrGroupClause_select = (String -> Name
Core.Name String
"select")

_SelectOrGroupClause_group :: Name
_SelectOrGroupClause_group = (String -> Name
Core.Name String
"group")

data GroupClause = 
  GroupClause {
    GroupClause -> Expression
groupClauseGrouped :: Expression,
    GroupClause -> Expression
groupClauseBy :: Expression}
  deriving (GroupClause -> GroupClause -> Bool
(GroupClause -> GroupClause -> Bool)
-> (GroupClause -> GroupClause -> Bool) -> Eq GroupClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GroupClause -> GroupClause -> Bool
== :: GroupClause -> GroupClause -> Bool
$c/= :: GroupClause -> GroupClause -> Bool
/= :: GroupClause -> GroupClause -> Bool
Eq, Eq GroupClause
Eq GroupClause =>
(GroupClause -> GroupClause -> Ordering)
-> (GroupClause -> GroupClause -> Bool)
-> (GroupClause -> GroupClause -> Bool)
-> (GroupClause -> GroupClause -> Bool)
-> (GroupClause -> GroupClause -> Bool)
-> (GroupClause -> GroupClause -> GroupClause)
-> (GroupClause -> GroupClause -> GroupClause)
-> Ord GroupClause
GroupClause -> GroupClause -> Bool
GroupClause -> GroupClause -> Ordering
GroupClause -> GroupClause -> GroupClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GroupClause -> GroupClause -> Ordering
compare :: GroupClause -> GroupClause -> Ordering
$c< :: GroupClause -> GroupClause -> Bool
< :: GroupClause -> GroupClause -> Bool
$c<= :: GroupClause -> GroupClause -> Bool
<= :: GroupClause -> GroupClause -> Bool
$c> :: GroupClause -> GroupClause -> Bool
> :: GroupClause -> GroupClause -> Bool
$c>= :: GroupClause -> GroupClause -> Bool
>= :: GroupClause -> GroupClause -> Bool
$cmax :: GroupClause -> GroupClause -> GroupClause
max :: GroupClause -> GroupClause -> GroupClause
$cmin :: GroupClause -> GroupClause -> GroupClause
min :: GroupClause -> GroupClause -> GroupClause
Ord, ReadPrec [GroupClause]
ReadPrec GroupClause
Int -> ReadS GroupClause
ReadS [GroupClause]
(Int -> ReadS GroupClause)
-> ReadS [GroupClause]
-> ReadPrec GroupClause
-> ReadPrec [GroupClause]
-> Read GroupClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GroupClause
readsPrec :: Int -> ReadS GroupClause
$creadList :: ReadS [GroupClause]
readList :: ReadS [GroupClause]
$creadPrec :: ReadPrec GroupClause
readPrec :: ReadPrec GroupClause
$creadListPrec :: ReadPrec [GroupClause]
readListPrec :: ReadPrec [GroupClause]
Read, Int -> GroupClause -> String -> String
[GroupClause] -> String -> String
GroupClause -> String
(Int -> GroupClause -> String -> String)
-> (GroupClause -> String)
-> ([GroupClause] -> String -> String)
-> Show GroupClause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> GroupClause -> String -> String
showsPrec :: Int -> GroupClause -> String -> String
$cshow :: GroupClause -> String
show :: GroupClause -> String
$cshowList :: [GroupClause] -> String -> String
showList :: [GroupClause] -> String -> String
Show)

_GroupClause :: Name
_GroupClause = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.GroupClause")

_GroupClause_grouped :: Name
_GroupClause_grouped = (String -> Name
Core.Name String
"grouped")

_GroupClause_by :: Name
_GroupClause_by = (String -> Name
Core.Name String
"by")

data QueryContinuation = 
  QueryContinuation {
    QueryContinuation -> Identifier
queryContinuationInto :: Identifier,
    QueryContinuation -> QueryBody
queryContinuationBody :: QueryBody}
  deriving (QueryContinuation -> QueryContinuation -> Bool
(QueryContinuation -> QueryContinuation -> Bool)
-> (QueryContinuation -> QueryContinuation -> Bool)
-> Eq QueryContinuation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QueryContinuation -> QueryContinuation -> Bool
== :: QueryContinuation -> QueryContinuation -> Bool
$c/= :: QueryContinuation -> QueryContinuation -> Bool
/= :: QueryContinuation -> QueryContinuation -> Bool
Eq, Eq QueryContinuation
Eq QueryContinuation =>
(QueryContinuation -> QueryContinuation -> Ordering)
-> (QueryContinuation -> QueryContinuation -> Bool)
-> (QueryContinuation -> QueryContinuation -> Bool)
-> (QueryContinuation -> QueryContinuation -> Bool)
-> (QueryContinuation -> QueryContinuation -> Bool)
-> (QueryContinuation -> QueryContinuation -> QueryContinuation)
-> (QueryContinuation -> QueryContinuation -> QueryContinuation)
-> Ord QueryContinuation
QueryContinuation -> QueryContinuation -> Bool
QueryContinuation -> QueryContinuation -> Ordering
QueryContinuation -> QueryContinuation -> QueryContinuation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: QueryContinuation -> QueryContinuation -> Ordering
compare :: QueryContinuation -> QueryContinuation -> Ordering
$c< :: QueryContinuation -> QueryContinuation -> Bool
< :: QueryContinuation -> QueryContinuation -> Bool
$c<= :: QueryContinuation -> QueryContinuation -> Bool
<= :: QueryContinuation -> QueryContinuation -> Bool
$c> :: QueryContinuation -> QueryContinuation -> Bool
> :: QueryContinuation -> QueryContinuation -> Bool
$c>= :: QueryContinuation -> QueryContinuation -> Bool
>= :: QueryContinuation -> QueryContinuation -> Bool
$cmax :: QueryContinuation -> QueryContinuation -> QueryContinuation
max :: QueryContinuation -> QueryContinuation -> QueryContinuation
$cmin :: QueryContinuation -> QueryContinuation -> QueryContinuation
min :: QueryContinuation -> QueryContinuation -> QueryContinuation
Ord, ReadPrec [QueryContinuation]
ReadPrec QueryContinuation
Int -> ReadS QueryContinuation
ReadS [QueryContinuation]
(Int -> ReadS QueryContinuation)
-> ReadS [QueryContinuation]
-> ReadPrec QueryContinuation
-> ReadPrec [QueryContinuation]
-> Read QueryContinuation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS QueryContinuation
readsPrec :: Int -> ReadS QueryContinuation
$creadList :: ReadS [QueryContinuation]
readList :: ReadS [QueryContinuation]
$creadPrec :: ReadPrec QueryContinuation
readPrec :: ReadPrec QueryContinuation
$creadListPrec :: ReadPrec [QueryContinuation]
readListPrec :: ReadPrec [QueryContinuation]
Read, Int -> QueryContinuation -> String -> String
[QueryContinuation] -> String -> String
QueryContinuation -> String
(Int -> QueryContinuation -> String -> String)
-> (QueryContinuation -> String)
-> ([QueryContinuation] -> String -> String)
-> Show QueryContinuation
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> QueryContinuation -> String -> String
showsPrec :: Int -> QueryContinuation -> String -> String
$cshow :: QueryContinuation -> String
show :: QueryContinuation -> String
$cshowList :: [QueryContinuation] -> String -> String
showList :: [QueryContinuation] -> String -> String
Show)

_QueryContinuation :: Name
_QueryContinuation = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.QueryContinuation")

_QueryContinuation_into :: Name
_QueryContinuation_into = (String -> Name
Core.Name String
"into")

_QueryContinuation_body :: Name
_QueryContinuation_body = (String -> Name
Core.Name String
"body")

data Assignment = 
  Assignment {
    Assignment -> UnaryExpression
assignmentLeft :: UnaryExpression,
    Assignment -> AssignmentOperator
assignmentOperator :: AssignmentOperator,
    Assignment -> Expression
assignmentRight :: Expression}
  deriving (Assignment -> Assignment -> Bool
(Assignment -> Assignment -> Bool)
-> (Assignment -> Assignment -> Bool) -> Eq Assignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Assignment -> Assignment -> Bool
== :: Assignment -> Assignment -> Bool
$c/= :: Assignment -> Assignment -> Bool
/= :: Assignment -> Assignment -> Bool
Eq, Eq Assignment
Eq Assignment =>
(Assignment -> Assignment -> Ordering)
-> (Assignment -> Assignment -> Bool)
-> (Assignment -> Assignment -> Bool)
-> (Assignment -> Assignment -> Bool)
-> (Assignment -> Assignment -> Bool)
-> (Assignment -> Assignment -> Assignment)
-> (Assignment -> Assignment -> Assignment)
-> Ord Assignment
Assignment -> Assignment -> Bool
Assignment -> Assignment -> Ordering
Assignment -> Assignment -> Assignment
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Assignment -> Assignment -> Ordering
compare :: Assignment -> Assignment -> Ordering
$c< :: Assignment -> Assignment -> Bool
< :: Assignment -> Assignment -> Bool
$c<= :: Assignment -> Assignment -> Bool
<= :: Assignment -> Assignment -> Bool
$c> :: Assignment -> Assignment -> Bool
> :: Assignment -> Assignment -> Bool
$c>= :: Assignment -> Assignment -> Bool
>= :: Assignment -> Assignment -> Bool
$cmax :: Assignment -> Assignment -> Assignment
max :: Assignment -> Assignment -> Assignment
$cmin :: Assignment -> Assignment -> Assignment
min :: Assignment -> Assignment -> Assignment
Ord, ReadPrec [Assignment]
ReadPrec Assignment
Int -> ReadS Assignment
ReadS [Assignment]
(Int -> ReadS Assignment)
-> ReadS [Assignment]
-> ReadPrec Assignment
-> ReadPrec [Assignment]
-> Read Assignment
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Assignment
readsPrec :: Int -> ReadS Assignment
$creadList :: ReadS [Assignment]
readList :: ReadS [Assignment]
$creadPrec :: ReadPrec Assignment
readPrec :: ReadPrec Assignment
$creadListPrec :: ReadPrec [Assignment]
readListPrec :: ReadPrec [Assignment]
Read, Int -> Assignment -> String -> String
[Assignment] -> String -> String
Assignment -> String
(Int -> Assignment -> String -> String)
-> (Assignment -> String)
-> ([Assignment] -> String -> String)
-> Show Assignment
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Assignment -> String -> String
showsPrec :: Int -> Assignment -> String -> String
$cshow :: Assignment -> String
show :: Assignment -> String
$cshowList :: [Assignment] -> String -> String
showList :: [Assignment] -> String -> String
Show)

_Assignment :: Name
_Assignment = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Assignment")

_Assignment_left :: Name
_Assignment_left = (String -> Name
Core.Name String
"left")

_Assignment_operator :: Name
_Assignment_operator = (String -> Name
Core.Name String
"operator")

_Assignment_right :: Name
_Assignment_right = (String -> Name
Core.Name String
"right")

data AssignmentOperator = 
  AssignmentOperatorSimple Bool |
  AssignmentOperatorPlusEquals  |
  AssignmentOperatorMinusEquals  |
  AssignmentOperatorTimesEquals  |
  AssignmentOperatorDivideEquals  |
  AssignmentOperatorModEquals  |
  AssignmentOperatorAndEquals  |
  AssignmentOperatorOrEquals  |
  AssignmentOperatorXorEquals  |
  AssignmentOperatorLeftShiftEquals  |
  AssignmentOperatorRightShiftEquals 
  deriving (AssignmentOperator -> AssignmentOperator -> Bool
(AssignmentOperator -> AssignmentOperator -> Bool)
-> (AssignmentOperator -> AssignmentOperator -> Bool)
-> Eq AssignmentOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AssignmentOperator -> AssignmentOperator -> Bool
== :: AssignmentOperator -> AssignmentOperator -> Bool
$c/= :: AssignmentOperator -> AssignmentOperator -> Bool
/= :: AssignmentOperator -> AssignmentOperator -> Bool
Eq, Eq AssignmentOperator
Eq AssignmentOperator =>
(AssignmentOperator -> AssignmentOperator -> Ordering)
-> (AssignmentOperator -> AssignmentOperator -> Bool)
-> (AssignmentOperator -> AssignmentOperator -> Bool)
-> (AssignmentOperator -> AssignmentOperator -> Bool)
-> (AssignmentOperator -> AssignmentOperator -> Bool)
-> (AssignmentOperator -> AssignmentOperator -> AssignmentOperator)
-> (AssignmentOperator -> AssignmentOperator -> AssignmentOperator)
-> Ord AssignmentOperator
AssignmentOperator -> AssignmentOperator -> Bool
AssignmentOperator -> AssignmentOperator -> Ordering
AssignmentOperator -> AssignmentOperator -> AssignmentOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AssignmentOperator -> AssignmentOperator -> Ordering
compare :: AssignmentOperator -> AssignmentOperator -> Ordering
$c< :: AssignmentOperator -> AssignmentOperator -> Bool
< :: AssignmentOperator -> AssignmentOperator -> Bool
$c<= :: AssignmentOperator -> AssignmentOperator -> Bool
<= :: AssignmentOperator -> AssignmentOperator -> Bool
$c> :: AssignmentOperator -> AssignmentOperator -> Bool
> :: AssignmentOperator -> AssignmentOperator -> Bool
$c>= :: AssignmentOperator -> AssignmentOperator -> Bool
>= :: AssignmentOperator -> AssignmentOperator -> Bool
$cmax :: AssignmentOperator -> AssignmentOperator -> AssignmentOperator
max :: AssignmentOperator -> AssignmentOperator -> AssignmentOperator
$cmin :: AssignmentOperator -> AssignmentOperator -> AssignmentOperator
min :: AssignmentOperator -> AssignmentOperator -> AssignmentOperator
Ord, ReadPrec [AssignmentOperator]
ReadPrec AssignmentOperator
Int -> ReadS AssignmentOperator
ReadS [AssignmentOperator]
(Int -> ReadS AssignmentOperator)
-> ReadS [AssignmentOperator]
-> ReadPrec AssignmentOperator
-> ReadPrec [AssignmentOperator]
-> Read AssignmentOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AssignmentOperator
readsPrec :: Int -> ReadS AssignmentOperator
$creadList :: ReadS [AssignmentOperator]
readList :: ReadS [AssignmentOperator]
$creadPrec :: ReadPrec AssignmentOperator
readPrec :: ReadPrec AssignmentOperator
$creadListPrec :: ReadPrec [AssignmentOperator]
readListPrec :: ReadPrec [AssignmentOperator]
Read, Int -> AssignmentOperator -> String -> String
[AssignmentOperator] -> String -> String
AssignmentOperator -> String
(Int -> AssignmentOperator -> String -> String)
-> (AssignmentOperator -> String)
-> ([AssignmentOperator] -> String -> String)
-> Show AssignmentOperator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AssignmentOperator -> String -> String
showsPrec :: Int -> AssignmentOperator -> String -> String
$cshow :: AssignmentOperator -> String
show :: AssignmentOperator -> String
$cshowList :: [AssignmentOperator] -> String -> String
showList :: [AssignmentOperator] -> String -> String
Show)

_AssignmentOperator :: Name
_AssignmentOperator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AssignmentOperator")

_AssignmentOperator_simple :: Name
_AssignmentOperator_simple = (String -> Name
Core.Name String
"simple")

_AssignmentOperator_plusEquals :: Name
_AssignmentOperator_plusEquals = (String -> Name
Core.Name String
"plusEquals")

_AssignmentOperator_minusEquals :: Name
_AssignmentOperator_minusEquals = (String -> Name
Core.Name String
"minusEquals")

_AssignmentOperator_timesEquals :: Name
_AssignmentOperator_timesEquals = (String -> Name
Core.Name String
"timesEquals")

_AssignmentOperator_divideEquals :: Name
_AssignmentOperator_divideEquals = (String -> Name
Core.Name String
"divideEquals")

_AssignmentOperator_modEquals :: Name
_AssignmentOperator_modEquals = (String -> Name
Core.Name String
"modEquals")

_AssignmentOperator_andEquals :: Name
_AssignmentOperator_andEquals = (String -> Name
Core.Name String
"andEquals")

_AssignmentOperator_orEquals :: Name
_AssignmentOperator_orEquals = (String -> Name
Core.Name String
"orEquals")

_AssignmentOperator_xorEquals :: Name
_AssignmentOperator_xorEquals = (String -> Name
Core.Name String
"xorEquals")

_AssignmentOperator_leftShiftEquals :: Name
_AssignmentOperator_leftShiftEquals = (String -> Name
Core.Name String
"leftShiftEquals")

_AssignmentOperator_rightShiftEquals :: Name
_AssignmentOperator_rightShiftEquals = (String -> Name
Core.Name String
"rightShiftEquals")

data Expression = 
  ExpressionNonAssignment NonAssignmentExpression |
  ExpressionAssignment Assignment
  deriving (Expression -> Expression -> Bool
(Expression -> Expression -> Bool)
-> (Expression -> Expression -> Bool) -> Eq Expression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Expression -> Expression -> Bool
== :: Expression -> Expression -> Bool
$c/= :: Expression -> Expression -> Bool
/= :: Expression -> Expression -> Bool
Eq, Eq Expression
Eq Expression =>
(Expression -> Expression -> Ordering)
-> (Expression -> Expression -> Bool)
-> (Expression -> Expression -> Bool)
-> (Expression -> Expression -> Bool)
-> (Expression -> Expression -> Bool)
-> (Expression -> Expression -> Expression)
-> (Expression -> Expression -> Expression)
-> Ord Expression
Expression -> Expression -> Bool
Expression -> Expression -> Ordering
Expression -> Expression -> Expression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Expression -> Expression -> Ordering
compare :: Expression -> Expression -> Ordering
$c< :: Expression -> Expression -> Bool
< :: Expression -> Expression -> Bool
$c<= :: Expression -> Expression -> Bool
<= :: Expression -> Expression -> Bool
$c> :: Expression -> Expression -> Bool
> :: Expression -> Expression -> Bool
$c>= :: Expression -> Expression -> Bool
>= :: Expression -> Expression -> Bool
$cmax :: Expression -> Expression -> Expression
max :: Expression -> Expression -> Expression
$cmin :: Expression -> Expression -> Expression
min :: Expression -> Expression -> Expression
Ord, ReadPrec [Expression]
ReadPrec Expression
Int -> ReadS Expression
ReadS [Expression]
(Int -> ReadS Expression)
-> ReadS [Expression]
-> ReadPrec Expression
-> ReadPrec [Expression]
-> Read Expression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Expression
readsPrec :: Int -> ReadS Expression
$creadList :: ReadS [Expression]
readList :: ReadS [Expression]
$creadPrec :: ReadPrec Expression
readPrec :: ReadPrec Expression
$creadListPrec :: ReadPrec [Expression]
readListPrec :: ReadPrec [Expression]
Read, Int -> Expression -> String -> String
[Expression] -> String -> String
Expression -> String
(Int -> Expression -> String -> String)
-> (Expression -> String)
-> ([Expression] -> String -> String)
-> Show Expression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Expression -> String -> String
showsPrec :: Int -> Expression -> String -> String
$cshow :: Expression -> String
show :: Expression -> String
$cshowList :: [Expression] -> String -> String
showList :: [Expression] -> String -> String
Show)

_Expression :: Name
_Expression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Expression")

_Expression_nonAssignment :: Name
_Expression_nonAssignment = (String -> Name
Core.Name String
"nonAssignment")

_Expression_assignment :: Name
_Expression_assignment = (String -> Name
Core.Name String
"assignment")

data NonAssignmentExpression = 
  NonAssignmentExpressionDeclaration DeclarationExpression |
  NonAssignmentExpressionConditional ConditionalExpression |
  NonAssignmentExpressionLambda LambdaExpression |
  NonAssignmentExpressionQuery QueryExpression
  deriving (NonAssignmentExpression -> NonAssignmentExpression -> Bool
(NonAssignmentExpression -> NonAssignmentExpression -> Bool)
-> (NonAssignmentExpression -> NonAssignmentExpression -> Bool)
-> Eq NonAssignmentExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
== :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
$c/= :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
/= :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
Eq, Eq NonAssignmentExpression
Eq NonAssignmentExpression =>
(NonAssignmentExpression -> NonAssignmentExpression -> Ordering)
-> (NonAssignmentExpression -> NonAssignmentExpression -> Bool)
-> (NonAssignmentExpression -> NonAssignmentExpression -> Bool)
-> (NonAssignmentExpression -> NonAssignmentExpression -> Bool)
-> (NonAssignmentExpression -> NonAssignmentExpression -> Bool)
-> (NonAssignmentExpression
    -> NonAssignmentExpression -> NonAssignmentExpression)
-> (NonAssignmentExpression
    -> NonAssignmentExpression -> NonAssignmentExpression)
-> Ord NonAssignmentExpression
NonAssignmentExpression -> NonAssignmentExpression -> Bool
NonAssignmentExpression -> NonAssignmentExpression -> Ordering
NonAssignmentExpression
-> NonAssignmentExpression -> NonAssignmentExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NonAssignmentExpression -> NonAssignmentExpression -> Ordering
compare :: NonAssignmentExpression -> NonAssignmentExpression -> Ordering
$c< :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
< :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
$c<= :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
<= :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
$c> :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
> :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
$c>= :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
>= :: NonAssignmentExpression -> NonAssignmentExpression -> Bool
$cmax :: NonAssignmentExpression
-> NonAssignmentExpression -> NonAssignmentExpression
max :: NonAssignmentExpression
-> NonAssignmentExpression -> NonAssignmentExpression
$cmin :: NonAssignmentExpression
-> NonAssignmentExpression -> NonAssignmentExpression
min :: NonAssignmentExpression
-> NonAssignmentExpression -> NonAssignmentExpression
Ord, ReadPrec [NonAssignmentExpression]
ReadPrec NonAssignmentExpression
Int -> ReadS NonAssignmentExpression
ReadS [NonAssignmentExpression]
(Int -> ReadS NonAssignmentExpression)
-> ReadS [NonAssignmentExpression]
-> ReadPrec NonAssignmentExpression
-> ReadPrec [NonAssignmentExpression]
-> Read NonAssignmentExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NonAssignmentExpression
readsPrec :: Int -> ReadS NonAssignmentExpression
$creadList :: ReadS [NonAssignmentExpression]
readList :: ReadS [NonAssignmentExpression]
$creadPrec :: ReadPrec NonAssignmentExpression
readPrec :: ReadPrec NonAssignmentExpression
$creadListPrec :: ReadPrec [NonAssignmentExpression]
readListPrec :: ReadPrec [NonAssignmentExpression]
Read, Int -> NonAssignmentExpression -> String -> String
[NonAssignmentExpression] -> String -> String
NonAssignmentExpression -> String
(Int -> NonAssignmentExpression -> String -> String)
-> (NonAssignmentExpression -> String)
-> ([NonAssignmentExpression] -> String -> String)
-> Show NonAssignmentExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NonAssignmentExpression -> String -> String
showsPrec :: Int -> NonAssignmentExpression -> String -> String
$cshow :: NonAssignmentExpression -> String
show :: NonAssignmentExpression -> String
$cshowList :: [NonAssignmentExpression] -> String -> String
showList :: [NonAssignmentExpression] -> String -> String
Show)

_NonAssignmentExpression :: Name
_NonAssignmentExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NonAssignmentExpression")

_NonAssignmentExpression_declaration :: Name
_NonAssignmentExpression_declaration = (String -> Name
Core.Name String
"declaration")

_NonAssignmentExpression_conditional :: Name
_NonAssignmentExpression_conditional = (String -> Name
Core.Name String
"conditional")

_NonAssignmentExpression_lambda :: Name
_NonAssignmentExpression_lambda = (String -> Name
Core.Name String
"lambda")

_NonAssignmentExpression_query :: Name
_NonAssignmentExpression_query = (String -> Name
Core.Name String
"query")

newtype ConstantExpression = 
  ConstantExpression {
    ConstantExpression -> Expression
unConstantExpression :: Expression}
  deriving (ConstantExpression -> ConstantExpression -> Bool
(ConstantExpression -> ConstantExpression -> Bool)
-> (ConstantExpression -> ConstantExpression -> Bool)
-> Eq ConstantExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstantExpression -> ConstantExpression -> Bool
== :: ConstantExpression -> ConstantExpression -> Bool
$c/= :: ConstantExpression -> ConstantExpression -> Bool
/= :: ConstantExpression -> ConstantExpression -> Bool
Eq, Eq ConstantExpression
Eq ConstantExpression =>
(ConstantExpression -> ConstantExpression -> Ordering)
-> (ConstantExpression -> ConstantExpression -> Bool)
-> (ConstantExpression -> ConstantExpression -> Bool)
-> (ConstantExpression -> ConstantExpression -> Bool)
-> (ConstantExpression -> ConstantExpression -> Bool)
-> (ConstantExpression -> ConstantExpression -> ConstantExpression)
-> (ConstantExpression -> ConstantExpression -> ConstantExpression)
-> Ord ConstantExpression
ConstantExpression -> ConstantExpression -> Bool
ConstantExpression -> ConstantExpression -> Ordering
ConstantExpression -> ConstantExpression -> ConstantExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstantExpression -> ConstantExpression -> Ordering
compare :: ConstantExpression -> ConstantExpression -> Ordering
$c< :: ConstantExpression -> ConstantExpression -> Bool
< :: ConstantExpression -> ConstantExpression -> Bool
$c<= :: ConstantExpression -> ConstantExpression -> Bool
<= :: ConstantExpression -> ConstantExpression -> Bool
$c> :: ConstantExpression -> ConstantExpression -> Bool
> :: ConstantExpression -> ConstantExpression -> Bool
$c>= :: ConstantExpression -> ConstantExpression -> Bool
>= :: ConstantExpression -> ConstantExpression -> Bool
$cmax :: ConstantExpression -> ConstantExpression -> ConstantExpression
max :: ConstantExpression -> ConstantExpression -> ConstantExpression
$cmin :: ConstantExpression -> ConstantExpression -> ConstantExpression
min :: ConstantExpression -> ConstantExpression -> ConstantExpression
Ord, ReadPrec [ConstantExpression]
ReadPrec ConstantExpression
Int -> ReadS ConstantExpression
ReadS [ConstantExpression]
(Int -> ReadS ConstantExpression)
-> ReadS [ConstantExpression]
-> ReadPrec ConstantExpression
-> ReadPrec [ConstantExpression]
-> Read ConstantExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConstantExpression
readsPrec :: Int -> ReadS ConstantExpression
$creadList :: ReadS [ConstantExpression]
readList :: ReadS [ConstantExpression]
$creadPrec :: ReadPrec ConstantExpression
readPrec :: ReadPrec ConstantExpression
$creadListPrec :: ReadPrec [ConstantExpression]
readListPrec :: ReadPrec [ConstantExpression]
Read, Int -> ConstantExpression -> String -> String
[ConstantExpression] -> String -> String
ConstantExpression -> String
(Int -> ConstantExpression -> String -> String)
-> (ConstantExpression -> String)
-> ([ConstantExpression] -> String -> String)
-> Show ConstantExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConstantExpression -> String -> String
showsPrec :: Int -> ConstantExpression -> String -> String
$cshow :: ConstantExpression -> String
show :: ConstantExpression -> String
$cshowList :: [ConstantExpression] -> String -> String
showList :: [ConstantExpression] -> String -> String
Show)

_ConstantExpression :: Name
_ConstantExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConstantExpression")

newtype BooleanExpression = 
  BooleanExpression {
    BooleanExpression -> Expression
unBooleanExpression :: Expression}
  deriving (BooleanExpression -> BooleanExpression -> Bool
(BooleanExpression -> BooleanExpression -> Bool)
-> (BooleanExpression -> BooleanExpression -> Bool)
-> Eq BooleanExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BooleanExpression -> BooleanExpression -> Bool
== :: BooleanExpression -> BooleanExpression -> Bool
$c/= :: BooleanExpression -> BooleanExpression -> Bool
/= :: BooleanExpression -> BooleanExpression -> Bool
Eq, Eq BooleanExpression
Eq BooleanExpression =>
(BooleanExpression -> BooleanExpression -> Ordering)
-> (BooleanExpression -> BooleanExpression -> Bool)
-> (BooleanExpression -> BooleanExpression -> Bool)
-> (BooleanExpression -> BooleanExpression -> Bool)
-> (BooleanExpression -> BooleanExpression -> Bool)
-> (BooleanExpression -> BooleanExpression -> BooleanExpression)
-> (BooleanExpression -> BooleanExpression -> BooleanExpression)
-> Ord BooleanExpression
BooleanExpression -> BooleanExpression -> Bool
BooleanExpression -> BooleanExpression -> Ordering
BooleanExpression -> BooleanExpression -> BooleanExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BooleanExpression -> BooleanExpression -> Ordering
compare :: BooleanExpression -> BooleanExpression -> Ordering
$c< :: BooleanExpression -> BooleanExpression -> Bool
< :: BooleanExpression -> BooleanExpression -> Bool
$c<= :: BooleanExpression -> BooleanExpression -> Bool
<= :: BooleanExpression -> BooleanExpression -> Bool
$c> :: BooleanExpression -> BooleanExpression -> Bool
> :: BooleanExpression -> BooleanExpression -> Bool
$c>= :: BooleanExpression -> BooleanExpression -> Bool
>= :: BooleanExpression -> BooleanExpression -> Bool
$cmax :: BooleanExpression -> BooleanExpression -> BooleanExpression
max :: BooleanExpression -> BooleanExpression -> BooleanExpression
$cmin :: BooleanExpression -> BooleanExpression -> BooleanExpression
min :: BooleanExpression -> BooleanExpression -> BooleanExpression
Ord, ReadPrec [BooleanExpression]
ReadPrec BooleanExpression
Int -> ReadS BooleanExpression
ReadS [BooleanExpression]
(Int -> ReadS BooleanExpression)
-> ReadS [BooleanExpression]
-> ReadPrec BooleanExpression
-> ReadPrec [BooleanExpression]
-> Read BooleanExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BooleanExpression
readsPrec :: Int -> ReadS BooleanExpression
$creadList :: ReadS [BooleanExpression]
readList :: ReadS [BooleanExpression]
$creadPrec :: ReadPrec BooleanExpression
readPrec :: ReadPrec BooleanExpression
$creadListPrec :: ReadPrec [BooleanExpression]
readListPrec :: ReadPrec [BooleanExpression]
Read, Int -> BooleanExpression -> String -> String
[BooleanExpression] -> String -> String
BooleanExpression -> String
(Int -> BooleanExpression -> String -> String)
-> (BooleanExpression -> String)
-> ([BooleanExpression] -> String -> String)
-> Show BooleanExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BooleanExpression -> String -> String
showsPrec :: Int -> BooleanExpression -> String -> String
$cshow :: BooleanExpression -> String
show :: BooleanExpression -> String
$cshowList :: [BooleanExpression] -> String -> String
showList :: [BooleanExpression] -> String -> String
Show)

_BooleanExpression :: Name
_BooleanExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BooleanExpression")

data Statement = 
  StatementLabeled LabeledStatement |
  StatementDeclaration DeclarationStatement |
  StatementEmbedded EmbeddedStatement
  deriving (Statement -> Statement -> Bool
(Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool) -> Eq Statement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Statement -> Statement -> Bool
== :: Statement -> Statement -> Bool
$c/= :: Statement -> Statement -> Bool
/= :: Statement -> Statement -> Bool
Eq, Eq Statement
Eq Statement =>
(Statement -> Statement -> Ordering)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Bool)
-> (Statement -> Statement -> Statement)
-> (Statement -> Statement -> Statement)
-> Ord Statement
Statement -> Statement -> Bool
Statement -> Statement -> Ordering
Statement -> Statement -> Statement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Statement -> Statement -> Ordering
compare :: Statement -> Statement -> Ordering
$c< :: Statement -> Statement -> Bool
< :: Statement -> Statement -> Bool
$c<= :: Statement -> Statement -> Bool
<= :: Statement -> Statement -> Bool
$c> :: Statement -> Statement -> Bool
> :: Statement -> Statement -> Bool
$c>= :: Statement -> Statement -> Bool
>= :: Statement -> Statement -> Bool
$cmax :: Statement -> Statement -> Statement
max :: Statement -> Statement -> Statement
$cmin :: Statement -> Statement -> Statement
min :: Statement -> Statement -> Statement
Ord, ReadPrec [Statement]
ReadPrec Statement
Int -> ReadS Statement
ReadS [Statement]
(Int -> ReadS Statement)
-> ReadS [Statement]
-> ReadPrec Statement
-> ReadPrec [Statement]
-> Read Statement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Statement
readsPrec :: Int -> ReadS Statement
$creadList :: ReadS [Statement]
readList :: ReadS [Statement]
$creadPrec :: ReadPrec Statement
readPrec :: ReadPrec Statement
$creadListPrec :: ReadPrec [Statement]
readListPrec :: ReadPrec [Statement]
Read, Int -> Statement -> String -> String
[Statement] -> String -> String
Statement -> String
(Int -> Statement -> String -> String)
-> (Statement -> String)
-> ([Statement] -> String -> String)
-> Show Statement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Statement -> String -> String
showsPrec :: Int -> Statement -> String -> String
$cshow :: Statement -> String
show :: Statement -> String
$cshowList :: [Statement] -> String -> String
showList :: [Statement] -> String -> String
Show)

_Statement :: Name
_Statement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Statement")

_Statement_labeled :: Name
_Statement_labeled = (String -> Name
Core.Name String
"labeled")

_Statement_declaration :: Name
_Statement_declaration = (String -> Name
Core.Name String
"declaration")

_Statement_embedded :: Name
_Statement_embedded = (String -> Name
Core.Name String
"embedded")

data EmbeddedStatement = 
  EmbeddedStatementBlock Block |
  EmbeddedStatementEmpty  |
  EmbeddedStatementExpression StatementExpression |
  EmbeddedStatementSelection SelectionStatement |
  EmbeddedStatementIteration IterationStatement |
  EmbeddedStatementJump JumpStatement |
  EmbeddedStatementTry TryStatement |
  EmbeddedStatementChecked Block |
  EmbeddedStatementUnchecked Block |
  EmbeddedStatementLock LockStatement |
  EmbeddedStatementUsing UsingStatement |
  EmbeddedStatementYield YieldStatement |
  EmbeddedStatementUnsafe Block |
  EmbeddedStatementFixed FixedStatement
  deriving (EmbeddedStatement -> EmbeddedStatement -> Bool
(EmbeddedStatement -> EmbeddedStatement -> Bool)
-> (EmbeddedStatement -> EmbeddedStatement -> Bool)
-> Eq EmbeddedStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EmbeddedStatement -> EmbeddedStatement -> Bool
== :: EmbeddedStatement -> EmbeddedStatement -> Bool
$c/= :: EmbeddedStatement -> EmbeddedStatement -> Bool
/= :: EmbeddedStatement -> EmbeddedStatement -> Bool
Eq, Eq EmbeddedStatement
Eq EmbeddedStatement =>
(EmbeddedStatement -> EmbeddedStatement -> Ordering)
-> (EmbeddedStatement -> EmbeddedStatement -> Bool)
-> (EmbeddedStatement -> EmbeddedStatement -> Bool)
-> (EmbeddedStatement -> EmbeddedStatement -> Bool)
-> (EmbeddedStatement -> EmbeddedStatement -> Bool)
-> (EmbeddedStatement -> EmbeddedStatement -> EmbeddedStatement)
-> (EmbeddedStatement -> EmbeddedStatement -> EmbeddedStatement)
-> Ord EmbeddedStatement
EmbeddedStatement -> EmbeddedStatement -> Bool
EmbeddedStatement -> EmbeddedStatement -> Ordering
EmbeddedStatement -> EmbeddedStatement -> EmbeddedStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EmbeddedStatement -> EmbeddedStatement -> Ordering
compare :: EmbeddedStatement -> EmbeddedStatement -> Ordering
$c< :: EmbeddedStatement -> EmbeddedStatement -> Bool
< :: EmbeddedStatement -> EmbeddedStatement -> Bool
$c<= :: EmbeddedStatement -> EmbeddedStatement -> Bool
<= :: EmbeddedStatement -> EmbeddedStatement -> Bool
$c> :: EmbeddedStatement -> EmbeddedStatement -> Bool
> :: EmbeddedStatement -> EmbeddedStatement -> Bool
$c>= :: EmbeddedStatement -> EmbeddedStatement -> Bool
>= :: EmbeddedStatement -> EmbeddedStatement -> Bool
$cmax :: EmbeddedStatement -> EmbeddedStatement -> EmbeddedStatement
max :: EmbeddedStatement -> EmbeddedStatement -> EmbeddedStatement
$cmin :: EmbeddedStatement -> EmbeddedStatement -> EmbeddedStatement
min :: EmbeddedStatement -> EmbeddedStatement -> EmbeddedStatement
Ord, ReadPrec [EmbeddedStatement]
ReadPrec EmbeddedStatement
Int -> ReadS EmbeddedStatement
ReadS [EmbeddedStatement]
(Int -> ReadS EmbeddedStatement)
-> ReadS [EmbeddedStatement]
-> ReadPrec EmbeddedStatement
-> ReadPrec [EmbeddedStatement]
-> Read EmbeddedStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EmbeddedStatement
readsPrec :: Int -> ReadS EmbeddedStatement
$creadList :: ReadS [EmbeddedStatement]
readList :: ReadS [EmbeddedStatement]
$creadPrec :: ReadPrec EmbeddedStatement
readPrec :: ReadPrec EmbeddedStatement
$creadListPrec :: ReadPrec [EmbeddedStatement]
readListPrec :: ReadPrec [EmbeddedStatement]
Read, Int -> EmbeddedStatement -> String -> String
[EmbeddedStatement] -> String -> String
EmbeddedStatement -> String
(Int -> EmbeddedStatement -> String -> String)
-> (EmbeddedStatement -> String)
-> ([EmbeddedStatement] -> String -> String)
-> Show EmbeddedStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EmbeddedStatement -> String -> String
showsPrec :: Int -> EmbeddedStatement -> String -> String
$cshow :: EmbeddedStatement -> String
show :: EmbeddedStatement -> String
$cshowList :: [EmbeddedStatement] -> String -> String
showList :: [EmbeddedStatement] -> String -> String
Show)

_EmbeddedStatement :: Name
_EmbeddedStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EmbeddedStatement")

_EmbeddedStatement_block :: Name
_EmbeddedStatement_block = (String -> Name
Core.Name String
"block")

_EmbeddedStatement_empty :: Name
_EmbeddedStatement_empty = (String -> Name
Core.Name String
"empty")

_EmbeddedStatement_expression :: Name
_EmbeddedStatement_expression = (String -> Name
Core.Name String
"expression")

_EmbeddedStatement_selection :: Name
_EmbeddedStatement_selection = (String -> Name
Core.Name String
"selection")

_EmbeddedStatement_iteration :: Name
_EmbeddedStatement_iteration = (String -> Name
Core.Name String
"iteration")

_EmbeddedStatement_jump :: Name
_EmbeddedStatement_jump = (String -> Name
Core.Name String
"jump")

_EmbeddedStatement_try :: Name
_EmbeddedStatement_try = (String -> Name
Core.Name String
"try")

_EmbeddedStatement_checked :: Name
_EmbeddedStatement_checked = (String -> Name
Core.Name String
"checked")

_EmbeddedStatement_unchecked :: Name
_EmbeddedStatement_unchecked = (String -> Name
Core.Name String
"unchecked")

_EmbeddedStatement_lock :: Name
_EmbeddedStatement_lock = (String -> Name
Core.Name String
"lock")

_EmbeddedStatement_using :: Name
_EmbeddedStatement_using = (String -> Name
Core.Name String
"using")

_EmbeddedStatement_yield :: Name
_EmbeddedStatement_yield = (String -> Name
Core.Name String
"yield")

_EmbeddedStatement_unsafe :: Name
_EmbeddedStatement_unsafe = (String -> Name
Core.Name String
"unsafe")

_EmbeddedStatement_fixed :: Name
_EmbeddedStatement_fixed = (String -> Name
Core.Name String
"fixed")

newtype Block = 
  Block {
    Block -> [Statement]
unBlock :: [Statement]}
  deriving (Block -> Block -> Bool
(Block -> Block -> Bool) -> (Block -> Block -> Bool) -> Eq Block
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Block -> Block -> Bool
== :: Block -> Block -> Bool
$c/= :: Block -> Block -> Bool
/= :: Block -> Block -> Bool
Eq, Eq Block
Eq Block =>
(Block -> Block -> Ordering)
-> (Block -> Block -> Bool)
-> (Block -> Block -> Bool)
-> (Block -> Block -> Bool)
-> (Block -> Block -> Bool)
-> (Block -> Block -> Block)
-> (Block -> Block -> Block)
-> Ord Block
Block -> Block -> Bool
Block -> Block -> Ordering
Block -> Block -> Block
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Block -> Block -> Ordering
compare :: Block -> Block -> Ordering
$c< :: Block -> Block -> Bool
< :: Block -> Block -> Bool
$c<= :: Block -> Block -> Bool
<= :: Block -> Block -> Bool
$c> :: Block -> Block -> Bool
> :: Block -> Block -> Bool
$c>= :: Block -> Block -> Bool
>= :: Block -> Block -> Bool
$cmax :: Block -> Block -> Block
max :: Block -> Block -> Block
$cmin :: Block -> Block -> Block
min :: Block -> Block -> Block
Ord, ReadPrec [Block]
ReadPrec Block
Int -> ReadS Block
ReadS [Block]
(Int -> ReadS Block)
-> ReadS [Block]
-> ReadPrec Block
-> ReadPrec [Block]
-> Read Block
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Block
readsPrec :: Int -> ReadS Block
$creadList :: ReadS [Block]
readList :: ReadS [Block]
$creadPrec :: ReadPrec Block
readPrec :: ReadPrec Block
$creadListPrec :: ReadPrec [Block]
readListPrec :: ReadPrec [Block]
Read, Int -> Block -> String -> String
[Block] -> String -> String
Block -> String
(Int -> Block -> String -> String)
-> (Block -> String) -> ([Block] -> String -> String) -> Show Block
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Block -> String -> String
showsPrec :: Int -> Block -> String -> String
$cshow :: Block -> String
show :: Block -> String
$cshowList :: [Block] -> String -> String
showList :: [Block] -> String -> String
Show)

_Block :: Name
_Block = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Block")

data LabeledStatement = 
  LabeledStatement {
    LabeledStatement -> Identifier
labeledStatementLabel :: Identifier,
    LabeledStatement -> Statement
labeledStatementStatement :: Statement}
  deriving (LabeledStatement -> LabeledStatement -> Bool
(LabeledStatement -> LabeledStatement -> Bool)
-> (LabeledStatement -> LabeledStatement -> Bool)
-> Eq LabeledStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LabeledStatement -> LabeledStatement -> Bool
== :: LabeledStatement -> LabeledStatement -> Bool
$c/= :: LabeledStatement -> LabeledStatement -> Bool
/= :: LabeledStatement -> LabeledStatement -> Bool
Eq, Eq LabeledStatement
Eq LabeledStatement =>
(LabeledStatement -> LabeledStatement -> Ordering)
-> (LabeledStatement -> LabeledStatement -> Bool)
-> (LabeledStatement -> LabeledStatement -> Bool)
-> (LabeledStatement -> LabeledStatement -> Bool)
-> (LabeledStatement -> LabeledStatement -> Bool)
-> (LabeledStatement -> LabeledStatement -> LabeledStatement)
-> (LabeledStatement -> LabeledStatement -> LabeledStatement)
-> Ord LabeledStatement
LabeledStatement -> LabeledStatement -> Bool
LabeledStatement -> LabeledStatement -> Ordering
LabeledStatement -> LabeledStatement -> LabeledStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LabeledStatement -> LabeledStatement -> Ordering
compare :: LabeledStatement -> LabeledStatement -> Ordering
$c< :: LabeledStatement -> LabeledStatement -> Bool
< :: LabeledStatement -> LabeledStatement -> Bool
$c<= :: LabeledStatement -> LabeledStatement -> Bool
<= :: LabeledStatement -> LabeledStatement -> Bool
$c> :: LabeledStatement -> LabeledStatement -> Bool
> :: LabeledStatement -> LabeledStatement -> Bool
$c>= :: LabeledStatement -> LabeledStatement -> Bool
>= :: LabeledStatement -> LabeledStatement -> Bool
$cmax :: LabeledStatement -> LabeledStatement -> LabeledStatement
max :: LabeledStatement -> LabeledStatement -> LabeledStatement
$cmin :: LabeledStatement -> LabeledStatement -> LabeledStatement
min :: LabeledStatement -> LabeledStatement -> LabeledStatement
Ord, ReadPrec [LabeledStatement]
ReadPrec LabeledStatement
Int -> ReadS LabeledStatement
ReadS [LabeledStatement]
(Int -> ReadS LabeledStatement)
-> ReadS [LabeledStatement]
-> ReadPrec LabeledStatement
-> ReadPrec [LabeledStatement]
-> Read LabeledStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LabeledStatement
readsPrec :: Int -> ReadS LabeledStatement
$creadList :: ReadS [LabeledStatement]
readList :: ReadS [LabeledStatement]
$creadPrec :: ReadPrec LabeledStatement
readPrec :: ReadPrec LabeledStatement
$creadListPrec :: ReadPrec [LabeledStatement]
readListPrec :: ReadPrec [LabeledStatement]
Read, Int -> LabeledStatement -> String -> String
[LabeledStatement] -> String -> String
LabeledStatement -> String
(Int -> LabeledStatement -> String -> String)
-> (LabeledStatement -> String)
-> ([LabeledStatement] -> String -> String)
-> Show LabeledStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LabeledStatement -> String -> String
showsPrec :: Int -> LabeledStatement -> String -> String
$cshow :: LabeledStatement -> String
show :: LabeledStatement -> String
$cshowList :: [LabeledStatement] -> String -> String
showList :: [LabeledStatement] -> String -> String
Show)

_LabeledStatement :: Name
_LabeledStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LabeledStatement")

_LabeledStatement_label :: Name
_LabeledStatement_label = (String -> Name
Core.Name String
"label")

_LabeledStatement_statement :: Name
_LabeledStatement_statement = (String -> Name
Core.Name String
"statement")

data DeclarationStatement = 
  DeclarationStatementVariable LocalVariableDeclaration |
  DeclarationStatementConstant LocalConstantDeclaration |
  DeclarationStatementFunction LocalFunctionDeclaration
  deriving (DeclarationStatement -> DeclarationStatement -> Bool
(DeclarationStatement -> DeclarationStatement -> Bool)
-> (DeclarationStatement -> DeclarationStatement -> Bool)
-> Eq DeclarationStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeclarationStatement -> DeclarationStatement -> Bool
== :: DeclarationStatement -> DeclarationStatement -> Bool
$c/= :: DeclarationStatement -> DeclarationStatement -> Bool
/= :: DeclarationStatement -> DeclarationStatement -> Bool
Eq, Eq DeclarationStatement
Eq DeclarationStatement =>
(DeclarationStatement -> DeclarationStatement -> Ordering)
-> (DeclarationStatement -> DeclarationStatement -> Bool)
-> (DeclarationStatement -> DeclarationStatement -> Bool)
-> (DeclarationStatement -> DeclarationStatement -> Bool)
-> (DeclarationStatement -> DeclarationStatement -> Bool)
-> (DeclarationStatement
    -> DeclarationStatement -> DeclarationStatement)
-> (DeclarationStatement
    -> DeclarationStatement -> DeclarationStatement)
-> Ord DeclarationStatement
DeclarationStatement -> DeclarationStatement -> Bool
DeclarationStatement -> DeclarationStatement -> Ordering
DeclarationStatement
-> DeclarationStatement -> DeclarationStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DeclarationStatement -> DeclarationStatement -> Ordering
compare :: DeclarationStatement -> DeclarationStatement -> Ordering
$c< :: DeclarationStatement -> DeclarationStatement -> Bool
< :: DeclarationStatement -> DeclarationStatement -> Bool
$c<= :: DeclarationStatement -> DeclarationStatement -> Bool
<= :: DeclarationStatement -> DeclarationStatement -> Bool
$c> :: DeclarationStatement -> DeclarationStatement -> Bool
> :: DeclarationStatement -> DeclarationStatement -> Bool
$c>= :: DeclarationStatement -> DeclarationStatement -> Bool
>= :: DeclarationStatement -> DeclarationStatement -> Bool
$cmax :: DeclarationStatement
-> DeclarationStatement -> DeclarationStatement
max :: DeclarationStatement
-> DeclarationStatement -> DeclarationStatement
$cmin :: DeclarationStatement
-> DeclarationStatement -> DeclarationStatement
min :: DeclarationStatement
-> DeclarationStatement -> DeclarationStatement
Ord, ReadPrec [DeclarationStatement]
ReadPrec DeclarationStatement
Int -> ReadS DeclarationStatement
ReadS [DeclarationStatement]
(Int -> ReadS DeclarationStatement)
-> ReadS [DeclarationStatement]
-> ReadPrec DeclarationStatement
-> ReadPrec [DeclarationStatement]
-> Read DeclarationStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DeclarationStatement
readsPrec :: Int -> ReadS DeclarationStatement
$creadList :: ReadS [DeclarationStatement]
readList :: ReadS [DeclarationStatement]
$creadPrec :: ReadPrec DeclarationStatement
readPrec :: ReadPrec DeclarationStatement
$creadListPrec :: ReadPrec [DeclarationStatement]
readListPrec :: ReadPrec [DeclarationStatement]
Read, Int -> DeclarationStatement -> String -> String
[DeclarationStatement] -> String -> String
DeclarationStatement -> String
(Int -> DeclarationStatement -> String -> String)
-> (DeclarationStatement -> String)
-> ([DeclarationStatement] -> String -> String)
-> Show DeclarationStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DeclarationStatement -> String -> String
showsPrec :: Int -> DeclarationStatement -> String -> String
$cshow :: DeclarationStatement -> String
show :: DeclarationStatement -> String
$cshowList :: [DeclarationStatement] -> String -> String
showList :: [DeclarationStatement] -> String -> String
Show)

_DeclarationStatement :: Name
_DeclarationStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DeclarationStatement")

_DeclarationStatement_variable :: Name
_DeclarationStatement_variable = (String -> Name
Core.Name String
"variable")

_DeclarationStatement_constant :: Name
_DeclarationStatement_constant = (String -> Name
Core.Name String
"constant")

_DeclarationStatement_function :: Name
_DeclarationStatement_function = (String -> Name
Core.Name String
"function")

data LocalVariableDeclaration = 
  LocalVariableDeclarationImplicitlyTyped ImplicitlyTypedLocalVariableDeclaration |
  LocalVariableDeclarationExplicitlyTyped ExplicitlyTypedLocalVariableDeclaration |
  LocalVariableDeclarationRef RefLocalVariableDeclaration
  deriving (LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
(LocalVariableDeclaration -> LocalVariableDeclaration -> Bool)
-> (LocalVariableDeclaration -> LocalVariableDeclaration -> Bool)
-> Eq LocalVariableDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
== :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
$c/= :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
/= :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
Eq, Eq LocalVariableDeclaration
Eq LocalVariableDeclaration =>
(LocalVariableDeclaration -> LocalVariableDeclaration -> Ordering)
-> (LocalVariableDeclaration -> LocalVariableDeclaration -> Bool)
-> (LocalVariableDeclaration -> LocalVariableDeclaration -> Bool)
-> (LocalVariableDeclaration -> LocalVariableDeclaration -> Bool)
-> (LocalVariableDeclaration -> LocalVariableDeclaration -> Bool)
-> (LocalVariableDeclaration
    -> LocalVariableDeclaration -> LocalVariableDeclaration)
-> (LocalVariableDeclaration
    -> LocalVariableDeclaration -> LocalVariableDeclaration)
-> Ord LocalVariableDeclaration
LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
LocalVariableDeclaration -> LocalVariableDeclaration -> Ordering
LocalVariableDeclaration
-> LocalVariableDeclaration -> LocalVariableDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LocalVariableDeclaration -> LocalVariableDeclaration -> Ordering
compare :: LocalVariableDeclaration -> LocalVariableDeclaration -> Ordering
$c< :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
< :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
$c<= :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
<= :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
$c> :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
> :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
$c>= :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
>= :: LocalVariableDeclaration -> LocalVariableDeclaration -> Bool
$cmax :: LocalVariableDeclaration
-> LocalVariableDeclaration -> LocalVariableDeclaration
max :: LocalVariableDeclaration
-> LocalVariableDeclaration -> LocalVariableDeclaration
$cmin :: LocalVariableDeclaration
-> LocalVariableDeclaration -> LocalVariableDeclaration
min :: LocalVariableDeclaration
-> LocalVariableDeclaration -> LocalVariableDeclaration
Ord, ReadPrec [LocalVariableDeclaration]
ReadPrec LocalVariableDeclaration
Int -> ReadS LocalVariableDeclaration
ReadS [LocalVariableDeclaration]
(Int -> ReadS LocalVariableDeclaration)
-> ReadS [LocalVariableDeclaration]
-> ReadPrec LocalVariableDeclaration
-> ReadPrec [LocalVariableDeclaration]
-> Read LocalVariableDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LocalVariableDeclaration
readsPrec :: Int -> ReadS LocalVariableDeclaration
$creadList :: ReadS [LocalVariableDeclaration]
readList :: ReadS [LocalVariableDeclaration]
$creadPrec :: ReadPrec LocalVariableDeclaration
readPrec :: ReadPrec LocalVariableDeclaration
$creadListPrec :: ReadPrec [LocalVariableDeclaration]
readListPrec :: ReadPrec [LocalVariableDeclaration]
Read, Int -> LocalVariableDeclaration -> String -> String
[LocalVariableDeclaration] -> String -> String
LocalVariableDeclaration -> String
(Int -> LocalVariableDeclaration -> String -> String)
-> (LocalVariableDeclaration -> String)
-> ([LocalVariableDeclaration] -> String -> String)
-> Show LocalVariableDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LocalVariableDeclaration -> String -> String
showsPrec :: Int -> LocalVariableDeclaration -> String -> String
$cshow :: LocalVariableDeclaration -> String
show :: LocalVariableDeclaration -> String
$cshowList :: [LocalVariableDeclaration] -> String -> String
showList :: [LocalVariableDeclaration] -> String -> String
Show)

_LocalVariableDeclaration :: Name
_LocalVariableDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LocalVariableDeclaration")

_LocalVariableDeclaration_implicitlyTyped :: Name
_LocalVariableDeclaration_implicitlyTyped = (String -> Name
Core.Name String
"implicitlyTyped")

_LocalVariableDeclaration_explicitlyTyped :: Name
_LocalVariableDeclaration_explicitlyTyped = (String -> Name
Core.Name String
"explicitlyTyped")

_LocalVariableDeclaration_ref :: Name
_LocalVariableDeclaration_ref = (String -> Name
Core.Name String
"ref")

data ImplicitlyTypedLocalVariableDeclaration = 
  ImplicitlyTypedLocalVariableDeclarationVar ImplicitlyTypedLocalVariableDeclarator |
  ImplicitlyTypedLocalVariableDeclarationRefVar RefVarImplicitlyTypedLocalVariableDeclaration
  deriving (ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
(ImplicitlyTypedLocalVariableDeclaration
 -> ImplicitlyTypedLocalVariableDeclaration -> Bool)
-> (ImplicitlyTypedLocalVariableDeclaration
    -> ImplicitlyTypedLocalVariableDeclaration -> Bool)
-> Eq ImplicitlyTypedLocalVariableDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
== :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
$c/= :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
/= :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
Eq, Eq ImplicitlyTypedLocalVariableDeclaration
Eq ImplicitlyTypedLocalVariableDeclaration =>
(ImplicitlyTypedLocalVariableDeclaration
 -> ImplicitlyTypedLocalVariableDeclaration -> Ordering)
-> (ImplicitlyTypedLocalVariableDeclaration
    -> ImplicitlyTypedLocalVariableDeclaration -> Bool)
-> (ImplicitlyTypedLocalVariableDeclaration
    -> ImplicitlyTypedLocalVariableDeclaration -> Bool)
-> (ImplicitlyTypedLocalVariableDeclaration
    -> ImplicitlyTypedLocalVariableDeclaration -> Bool)
-> (ImplicitlyTypedLocalVariableDeclaration
    -> ImplicitlyTypedLocalVariableDeclaration -> Bool)
-> (ImplicitlyTypedLocalVariableDeclaration
    -> ImplicitlyTypedLocalVariableDeclaration
    -> ImplicitlyTypedLocalVariableDeclaration)
-> (ImplicitlyTypedLocalVariableDeclaration
    -> ImplicitlyTypedLocalVariableDeclaration
    -> ImplicitlyTypedLocalVariableDeclaration)
-> Ord ImplicitlyTypedLocalVariableDeclaration
ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Ordering
ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Ordering
compare :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Ordering
$c< :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
< :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
$c<= :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
<= :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
$c> :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
> :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
$c>= :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
>= :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration -> Bool
$cmax :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration
max :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration
$cmin :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration
min :: ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration
-> ImplicitlyTypedLocalVariableDeclaration
Ord, ReadPrec [ImplicitlyTypedLocalVariableDeclaration]
ReadPrec ImplicitlyTypedLocalVariableDeclaration
Int -> ReadS ImplicitlyTypedLocalVariableDeclaration
ReadS [ImplicitlyTypedLocalVariableDeclaration]
(Int -> ReadS ImplicitlyTypedLocalVariableDeclaration)
-> ReadS [ImplicitlyTypedLocalVariableDeclaration]
-> ReadPrec ImplicitlyTypedLocalVariableDeclaration
-> ReadPrec [ImplicitlyTypedLocalVariableDeclaration]
-> Read ImplicitlyTypedLocalVariableDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ImplicitlyTypedLocalVariableDeclaration
readsPrec :: Int -> ReadS ImplicitlyTypedLocalVariableDeclaration
$creadList :: ReadS [ImplicitlyTypedLocalVariableDeclaration]
readList :: ReadS [ImplicitlyTypedLocalVariableDeclaration]
$creadPrec :: ReadPrec ImplicitlyTypedLocalVariableDeclaration
readPrec :: ReadPrec ImplicitlyTypedLocalVariableDeclaration
$creadListPrec :: ReadPrec [ImplicitlyTypedLocalVariableDeclaration]
readListPrec :: ReadPrec [ImplicitlyTypedLocalVariableDeclaration]
Read, Int -> ImplicitlyTypedLocalVariableDeclaration -> String -> String
[ImplicitlyTypedLocalVariableDeclaration] -> String -> String
ImplicitlyTypedLocalVariableDeclaration -> String
(Int
 -> ImplicitlyTypedLocalVariableDeclaration -> String -> String)
-> (ImplicitlyTypedLocalVariableDeclaration -> String)
-> ([ImplicitlyTypedLocalVariableDeclaration] -> String -> String)
-> Show ImplicitlyTypedLocalVariableDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ImplicitlyTypedLocalVariableDeclaration -> String -> String
showsPrec :: Int -> ImplicitlyTypedLocalVariableDeclaration -> String -> String
$cshow :: ImplicitlyTypedLocalVariableDeclaration -> String
show :: ImplicitlyTypedLocalVariableDeclaration -> String
$cshowList :: [ImplicitlyTypedLocalVariableDeclaration] -> String -> String
showList :: [ImplicitlyTypedLocalVariableDeclaration] -> String -> String
Show)

_ImplicitlyTypedLocalVariableDeclaration :: Name
_ImplicitlyTypedLocalVariableDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ImplicitlyTypedLocalVariableDeclaration")

_ImplicitlyTypedLocalVariableDeclaration_var :: Name
_ImplicitlyTypedLocalVariableDeclaration_var = (String -> Name
Core.Name String
"var")

_ImplicitlyTypedLocalVariableDeclaration_refVar :: Name
_ImplicitlyTypedLocalVariableDeclaration_refVar = (String -> Name
Core.Name String
"refVar")

data RefVarImplicitlyTypedLocalVariableDeclaration = 
  RefVarImplicitlyTypedLocalVariableDeclaration {
    RefVarImplicitlyTypedLocalVariableDeclaration -> RefKind
refVarImplicitlyTypedLocalVariableDeclarationRefKind :: RefKind,
    RefVarImplicitlyTypedLocalVariableDeclaration
-> RefLocalVariableDeclarator
refVarImplicitlyTypedLocalVariableDeclarationDeclarator :: RefLocalVariableDeclarator}
  deriving (RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
(RefVarImplicitlyTypedLocalVariableDeclaration
 -> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool)
-> (RefVarImplicitlyTypedLocalVariableDeclaration
    -> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool)
-> Eq RefVarImplicitlyTypedLocalVariableDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
== :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
$c/= :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
/= :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
Eq, Eq RefVarImplicitlyTypedLocalVariableDeclaration
Eq RefVarImplicitlyTypedLocalVariableDeclaration =>
(RefVarImplicitlyTypedLocalVariableDeclaration
 -> RefVarImplicitlyTypedLocalVariableDeclaration -> Ordering)
-> (RefVarImplicitlyTypedLocalVariableDeclaration
    -> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool)
-> (RefVarImplicitlyTypedLocalVariableDeclaration
    -> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool)
-> (RefVarImplicitlyTypedLocalVariableDeclaration
    -> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool)
-> (RefVarImplicitlyTypedLocalVariableDeclaration
    -> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool)
-> (RefVarImplicitlyTypedLocalVariableDeclaration
    -> RefVarImplicitlyTypedLocalVariableDeclaration
    -> RefVarImplicitlyTypedLocalVariableDeclaration)
-> (RefVarImplicitlyTypedLocalVariableDeclaration
    -> RefVarImplicitlyTypedLocalVariableDeclaration
    -> RefVarImplicitlyTypedLocalVariableDeclaration)
-> Ord RefVarImplicitlyTypedLocalVariableDeclaration
RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Ordering
RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Ordering
compare :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Ordering
$c< :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
< :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
$c<= :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
<= :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
$c> :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
> :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
$c>= :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
>= :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration -> Bool
$cmax :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration
max :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration
$cmin :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration
min :: RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration
-> RefVarImplicitlyTypedLocalVariableDeclaration
Ord, ReadPrec [RefVarImplicitlyTypedLocalVariableDeclaration]
ReadPrec RefVarImplicitlyTypedLocalVariableDeclaration
Int -> ReadS RefVarImplicitlyTypedLocalVariableDeclaration
ReadS [RefVarImplicitlyTypedLocalVariableDeclaration]
(Int -> ReadS RefVarImplicitlyTypedLocalVariableDeclaration)
-> ReadS [RefVarImplicitlyTypedLocalVariableDeclaration]
-> ReadPrec RefVarImplicitlyTypedLocalVariableDeclaration
-> ReadPrec [RefVarImplicitlyTypedLocalVariableDeclaration]
-> Read RefVarImplicitlyTypedLocalVariableDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefVarImplicitlyTypedLocalVariableDeclaration
readsPrec :: Int -> ReadS RefVarImplicitlyTypedLocalVariableDeclaration
$creadList :: ReadS [RefVarImplicitlyTypedLocalVariableDeclaration]
readList :: ReadS [RefVarImplicitlyTypedLocalVariableDeclaration]
$creadPrec :: ReadPrec RefVarImplicitlyTypedLocalVariableDeclaration
readPrec :: ReadPrec RefVarImplicitlyTypedLocalVariableDeclaration
$creadListPrec :: ReadPrec [RefVarImplicitlyTypedLocalVariableDeclaration]
readListPrec :: ReadPrec [RefVarImplicitlyTypedLocalVariableDeclaration]
Read, Int
-> RefVarImplicitlyTypedLocalVariableDeclaration
-> String
-> String
[RefVarImplicitlyTypedLocalVariableDeclaration] -> String -> String
RefVarImplicitlyTypedLocalVariableDeclaration -> String
(Int
 -> RefVarImplicitlyTypedLocalVariableDeclaration
 -> String
 -> String)
-> (RefVarImplicitlyTypedLocalVariableDeclaration -> String)
-> ([RefVarImplicitlyTypedLocalVariableDeclaration]
    -> String -> String)
-> Show RefVarImplicitlyTypedLocalVariableDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int
-> RefVarImplicitlyTypedLocalVariableDeclaration
-> String
-> String
showsPrec :: Int
-> RefVarImplicitlyTypedLocalVariableDeclaration
-> String
-> String
$cshow :: RefVarImplicitlyTypedLocalVariableDeclaration -> String
show :: RefVarImplicitlyTypedLocalVariableDeclaration -> String
$cshowList :: [RefVarImplicitlyTypedLocalVariableDeclaration] -> String -> String
showList :: [RefVarImplicitlyTypedLocalVariableDeclaration] -> String -> String
Show)

_RefVarImplicitlyTypedLocalVariableDeclaration :: Name
_RefVarImplicitlyTypedLocalVariableDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefVarImplicitlyTypedLocalVariableDeclaration")

_RefVarImplicitlyTypedLocalVariableDeclaration_refKind :: Name
_RefVarImplicitlyTypedLocalVariableDeclaration_refKind = (String -> Name
Core.Name String
"refKind")

_RefVarImplicitlyTypedLocalVariableDeclaration_declarator :: Name
_RefVarImplicitlyTypedLocalVariableDeclaration_declarator = (String -> Name
Core.Name String
"declarator")

data ImplicitlyTypedLocalVariableDeclarator = 
  ImplicitlyTypedLocalVariableDeclarator {
    ImplicitlyTypedLocalVariableDeclarator -> Identifier
implicitlyTypedLocalVariableDeclaratorIdentifier :: Identifier,
    ImplicitlyTypedLocalVariableDeclarator -> Expression
implicitlyTypedLocalVariableDeclaratorExpression :: Expression}
  deriving (ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
(ImplicitlyTypedLocalVariableDeclarator
 -> ImplicitlyTypedLocalVariableDeclarator -> Bool)
-> (ImplicitlyTypedLocalVariableDeclarator
    -> ImplicitlyTypedLocalVariableDeclarator -> Bool)
-> Eq ImplicitlyTypedLocalVariableDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
== :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
$c/= :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
/= :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
Eq, Eq ImplicitlyTypedLocalVariableDeclarator
Eq ImplicitlyTypedLocalVariableDeclarator =>
(ImplicitlyTypedLocalVariableDeclarator
 -> ImplicitlyTypedLocalVariableDeclarator -> Ordering)
-> (ImplicitlyTypedLocalVariableDeclarator
    -> ImplicitlyTypedLocalVariableDeclarator -> Bool)
-> (ImplicitlyTypedLocalVariableDeclarator
    -> ImplicitlyTypedLocalVariableDeclarator -> Bool)
-> (ImplicitlyTypedLocalVariableDeclarator
    -> ImplicitlyTypedLocalVariableDeclarator -> Bool)
-> (ImplicitlyTypedLocalVariableDeclarator
    -> ImplicitlyTypedLocalVariableDeclarator -> Bool)
-> (ImplicitlyTypedLocalVariableDeclarator
    -> ImplicitlyTypedLocalVariableDeclarator
    -> ImplicitlyTypedLocalVariableDeclarator)
-> (ImplicitlyTypedLocalVariableDeclarator
    -> ImplicitlyTypedLocalVariableDeclarator
    -> ImplicitlyTypedLocalVariableDeclarator)
-> Ord ImplicitlyTypedLocalVariableDeclarator
ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Ordering
ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Ordering
compare :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Ordering
$c< :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
< :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
$c<= :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
<= :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
$c> :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
> :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
$c>= :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
>= :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator -> Bool
$cmax :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator
max :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator
$cmin :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator
min :: ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator
-> ImplicitlyTypedLocalVariableDeclarator
Ord, ReadPrec [ImplicitlyTypedLocalVariableDeclarator]
ReadPrec ImplicitlyTypedLocalVariableDeclarator
Int -> ReadS ImplicitlyTypedLocalVariableDeclarator
ReadS [ImplicitlyTypedLocalVariableDeclarator]
(Int -> ReadS ImplicitlyTypedLocalVariableDeclarator)
-> ReadS [ImplicitlyTypedLocalVariableDeclarator]
-> ReadPrec ImplicitlyTypedLocalVariableDeclarator
-> ReadPrec [ImplicitlyTypedLocalVariableDeclarator]
-> Read ImplicitlyTypedLocalVariableDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ImplicitlyTypedLocalVariableDeclarator
readsPrec :: Int -> ReadS ImplicitlyTypedLocalVariableDeclarator
$creadList :: ReadS [ImplicitlyTypedLocalVariableDeclarator]
readList :: ReadS [ImplicitlyTypedLocalVariableDeclarator]
$creadPrec :: ReadPrec ImplicitlyTypedLocalVariableDeclarator
readPrec :: ReadPrec ImplicitlyTypedLocalVariableDeclarator
$creadListPrec :: ReadPrec [ImplicitlyTypedLocalVariableDeclarator]
readListPrec :: ReadPrec [ImplicitlyTypedLocalVariableDeclarator]
Read, Int -> ImplicitlyTypedLocalVariableDeclarator -> String -> String
[ImplicitlyTypedLocalVariableDeclarator] -> String -> String
ImplicitlyTypedLocalVariableDeclarator -> String
(Int -> ImplicitlyTypedLocalVariableDeclarator -> String -> String)
-> (ImplicitlyTypedLocalVariableDeclarator -> String)
-> ([ImplicitlyTypedLocalVariableDeclarator] -> String -> String)
-> Show ImplicitlyTypedLocalVariableDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ImplicitlyTypedLocalVariableDeclarator -> String -> String
showsPrec :: Int -> ImplicitlyTypedLocalVariableDeclarator -> String -> String
$cshow :: ImplicitlyTypedLocalVariableDeclarator -> String
show :: ImplicitlyTypedLocalVariableDeclarator -> String
$cshowList :: [ImplicitlyTypedLocalVariableDeclarator] -> String -> String
showList :: [ImplicitlyTypedLocalVariableDeclarator] -> String -> String
Show)

_ImplicitlyTypedLocalVariableDeclarator :: Name
_ImplicitlyTypedLocalVariableDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ImplicitlyTypedLocalVariableDeclarator")

_ImplicitlyTypedLocalVariableDeclarator_identifier :: Name
_ImplicitlyTypedLocalVariableDeclarator_identifier = (String -> Name
Core.Name String
"identifier")

_ImplicitlyTypedLocalVariableDeclarator_expression :: Name
_ImplicitlyTypedLocalVariableDeclarator_expression = (String -> Name
Core.Name String
"expression")

data ExplicitlyTypedLocalVariableDeclaration = 
  ExplicitlyTypedLocalVariableDeclaration {
    ExplicitlyTypedLocalVariableDeclaration -> Type
explicitlyTypedLocalVariableDeclarationType :: Type,
    ExplicitlyTypedLocalVariableDeclaration
-> [ExplicitlyTypedLocalVariableDeclarator]
explicitlyTypedLocalVariableDeclarationDeclarators :: [ExplicitlyTypedLocalVariableDeclarator]}
  deriving (ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
(ExplicitlyTypedLocalVariableDeclaration
 -> ExplicitlyTypedLocalVariableDeclaration -> Bool)
-> (ExplicitlyTypedLocalVariableDeclaration
    -> ExplicitlyTypedLocalVariableDeclaration -> Bool)
-> Eq ExplicitlyTypedLocalVariableDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
== :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
$c/= :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
/= :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
Eq, Eq ExplicitlyTypedLocalVariableDeclaration
Eq ExplicitlyTypedLocalVariableDeclaration =>
(ExplicitlyTypedLocalVariableDeclaration
 -> ExplicitlyTypedLocalVariableDeclaration -> Ordering)
-> (ExplicitlyTypedLocalVariableDeclaration
    -> ExplicitlyTypedLocalVariableDeclaration -> Bool)
-> (ExplicitlyTypedLocalVariableDeclaration
    -> ExplicitlyTypedLocalVariableDeclaration -> Bool)
-> (ExplicitlyTypedLocalVariableDeclaration
    -> ExplicitlyTypedLocalVariableDeclaration -> Bool)
-> (ExplicitlyTypedLocalVariableDeclaration
    -> ExplicitlyTypedLocalVariableDeclaration -> Bool)
-> (ExplicitlyTypedLocalVariableDeclaration
    -> ExplicitlyTypedLocalVariableDeclaration
    -> ExplicitlyTypedLocalVariableDeclaration)
-> (ExplicitlyTypedLocalVariableDeclaration
    -> ExplicitlyTypedLocalVariableDeclaration
    -> ExplicitlyTypedLocalVariableDeclaration)
-> Ord ExplicitlyTypedLocalVariableDeclaration
ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Ordering
ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Ordering
compare :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Ordering
$c< :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
< :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
$c<= :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
<= :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
$c> :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
> :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
$c>= :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
>= :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration -> Bool
$cmax :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration
max :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration
$cmin :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration
min :: ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration
-> ExplicitlyTypedLocalVariableDeclaration
Ord, ReadPrec [ExplicitlyTypedLocalVariableDeclaration]
ReadPrec ExplicitlyTypedLocalVariableDeclaration
Int -> ReadS ExplicitlyTypedLocalVariableDeclaration
ReadS [ExplicitlyTypedLocalVariableDeclaration]
(Int -> ReadS ExplicitlyTypedLocalVariableDeclaration)
-> ReadS [ExplicitlyTypedLocalVariableDeclaration]
-> ReadPrec ExplicitlyTypedLocalVariableDeclaration
-> ReadPrec [ExplicitlyTypedLocalVariableDeclaration]
-> Read ExplicitlyTypedLocalVariableDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExplicitlyTypedLocalVariableDeclaration
readsPrec :: Int -> ReadS ExplicitlyTypedLocalVariableDeclaration
$creadList :: ReadS [ExplicitlyTypedLocalVariableDeclaration]
readList :: ReadS [ExplicitlyTypedLocalVariableDeclaration]
$creadPrec :: ReadPrec ExplicitlyTypedLocalVariableDeclaration
readPrec :: ReadPrec ExplicitlyTypedLocalVariableDeclaration
$creadListPrec :: ReadPrec [ExplicitlyTypedLocalVariableDeclaration]
readListPrec :: ReadPrec [ExplicitlyTypedLocalVariableDeclaration]
Read, Int -> ExplicitlyTypedLocalVariableDeclaration -> String -> String
[ExplicitlyTypedLocalVariableDeclaration] -> String -> String
ExplicitlyTypedLocalVariableDeclaration -> String
(Int
 -> ExplicitlyTypedLocalVariableDeclaration -> String -> String)
-> (ExplicitlyTypedLocalVariableDeclaration -> String)
-> ([ExplicitlyTypedLocalVariableDeclaration] -> String -> String)
-> Show ExplicitlyTypedLocalVariableDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ExplicitlyTypedLocalVariableDeclaration -> String -> String
showsPrec :: Int -> ExplicitlyTypedLocalVariableDeclaration -> String -> String
$cshow :: ExplicitlyTypedLocalVariableDeclaration -> String
show :: ExplicitlyTypedLocalVariableDeclaration -> String
$cshowList :: [ExplicitlyTypedLocalVariableDeclaration] -> String -> String
showList :: [ExplicitlyTypedLocalVariableDeclaration] -> String -> String
Show)

_ExplicitlyTypedLocalVariableDeclaration :: Name
_ExplicitlyTypedLocalVariableDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ExplicitlyTypedLocalVariableDeclaration")

_ExplicitlyTypedLocalVariableDeclaration_type :: Name
_ExplicitlyTypedLocalVariableDeclaration_type = (String -> Name
Core.Name String
"type")

_ExplicitlyTypedLocalVariableDeclaration_declarators :: Name
_ExplicitlyTypedLocalVariableDeclaration_declarators = (String -> Name
Core.Name String
"declarators")

data ExplicitlyTypedLocalVariableDeclarator = 
  ExplicitlyTypedLocalVariableDeclarator {
    ExplicitlyTypedLocalVariableDeclarator -> Identifier
explicitlyTypedLocalVariableDeclaratorIdentifier :: Identifier,
    ExplicitlyTypedLocalVariableDeclarator
-> Maybe LocalVariableInitializer
explicitlyTypedLocalVariableDeclaratorInitializer :: (Maybe LocalVariableInitializer)}
  deriving (ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
(ExplicitlyTypedLocalVariableDeclarator
 -> ExplicitlyTypedLocalVariableDeclarator -> Bool)
-> (ExplicitlyTypedLocalVariableDeclarator
    -> ExplicitlyTypedLocalVariableDeclarator -> Bool)
-> Eq ExplicitlyTypedLocalVariableDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
== :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
$c/= :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
/= :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
Eq, Eq ExplicitlyTypedLocalVariableDeclarator
Eq ExplicitlyTypedLocalVariableDeclarator =>
(ExplicitlyTypedLocalVariableDeclarator
 -> ExplicitlyTypedLocalVariableDeclarator -> Ordering)
-> (ExplicitlyTypedLocalVariableDeclarator
    -> ExplicitlyTypedLocalVariableDeclarator -> Bool)
-> (ExplicitlyTypedLocalVariableDeclarator
    -> ExplicitlyTypedLocalVariableDeclarator -> Bool)
-> (ExplicitlyTypedLocalVariableDeclarator
    -> ExplicitlyTypedLocalVariableDeclarator -> Bool)
-> (ExplicitlyTypedLocalVariableDeclarator
    -> ExplicitlyTypedLocalVariableDeclarator -> Bool)
-> (ExplicitlyTypedLocalVariableDeclarator
    -> ExplicitlyTypedLocalVariableDeclarator
    -> ExplicitlyTypedLocalVariableDeclarator)
-> (ExplicitlyTypedLocalVariableDeclarator
    -> ExplicitlyTypedLocalVariableDeclarator
    -> ExplicitlyTypedLocalVariableDeclarator)
-> Ord ExplicitlyTypedLocalVariableDeclarator
ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Ordering
ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Ordering
compare :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Ordering
$c< :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
< :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
$c<= :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
<= :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
$c> :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
> :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
$c>= :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
>= :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator -> Bool
$cmax :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator
max :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator
$cmin :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator
min :: ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator
-> ExplicitlyTypedLocalVariableDeclarator
Ord, ReadPrec [ExplicitlyTypedLocalVariableDeclarator]
ReadPrec ExplicitlyTypedLocalVariableDeclarator
Int -> ReadS ExplicitlyTypedLocalVariableDeclarator
ReadS [ExplicitlyTypedLocalVariableDeclarator]
(Int -> ReadS ExplicitlyTypedLocalVariableDeclarator)
-> ReadS [ExplicitlyTypedLocalVariableDeclarator]
-> ReadPrec ExplicitlyTypedLocalVariableDeclarator
-> ReadPrec [ExplicitlyTypedLocalVariableDeclarator]
-> Read ExplicitlyTypedLocalVariableDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExplicitlyTypedLocalVariableDeclarator
readsPrec :: Int -> ReadS ExplicitlyTypedLocalVariableDeclarator
$creadList :: ReadS [ExplicitlyTypedLocalVariableDeclarator]
readList :: ReadS [ExplicitlyTypedLocalVariableDeclarator]
$creadPrec :: ReadPrec ExplicitlyTypedLocalVariableDeclarator
readPrec :: ReadPrec ExplicitlyTypedLocalVariableDeclarator
$creadListPrec :: ReadPrec [ExplicitlyTypedLocalVariableDeclarator]
readListPrec :: ReadPrec [ExplicitlyTypedLocalVariableDeclarator]
Read, Int -> ExplicitlyTypedLocalVariableDeclarator -> String -> String
[ExplicitlyTypedLocalVariableDeclarator] -> String -> String
ExplicitlyTypedLocalVariableDeclarator -> String
(Int -> ExplicitlyTypedLocalVariableDeclarator -> String -> String)
-> (ExplicitlyTypedLocalVariableDeclarator -> String)
-> ([ExplicitlyTypedLocalVariableDeclarator] -> String -> String)
-> Show ExplicitlyTypedLocalVariableDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ExplicitlyTypedLocalVariableDeclarator -> String -> String
showsPrec :: Int -> ExplicitlyTypedLocalVariableDeclarator -> String -> String
$cshow :: ExplicitlyTypedLocalVariableDeclarator -> String
show :: ExplicitlyTypedLocalVariableDeclarator -> String
$cshowList :: [ExplicitlyTypedLocalVariableDeclarator] -> String -> String
showList :: [ExplicitlyTypedLocalVariableDeclarator] -> String -> String
Show)

_ExplicitlyTypedLocalVariableDeclarator :: Name
_ExplicitlyTypedLocalVariableDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ExplicitlyTypedLocalVariableDeclarator")

_ExplicitlyTypedLocalVariableDeclarator_identifier :: Name
_ExplicitlyTypedLocalVariableDeclarator_identifier = (String -> Name
Core.Name String
"identifier")

_ExplicitlyTypedLocalVariableDeclarator_initializer :: Name
_ExplicitlyTypedLocalVariableDeclarator_initializer = (String -> Name
Core.Name String
"initializer")

data LocalVariableInitializer = 
  LocalVariableInitializerExpression Expression |
  LocalVariableInitializerInitializer ArrayInitializer
  deriving (LocalVariableInitializer -> LocalVariableInitializer -> Bool
(LocalVariableInitializer -> LocalVariableInitializer -> Bool)
-> (LocalVariableInitializer -> LocalVariableInitializer -> Bool)
-> Eq LocalVariableInitializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
== :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
$c/= :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
/= :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
Eq, Eq LocalVariableInitializer
Eq LocalVariableInitializer =>
(LocalVariableInitializer -> LocalVariableInitializer -> Ordering)
-> (LocalVariableInitializer -> LocalVariableInitializer -> Bool)
-> (LocalVariableInitializer -> LocalVariableInitializer -> Bool)
-> (LocalVariableInitializer -> LocalVariableInitializer -> Bool)
-> (LocalVariableInitializer -> LocalVariableInitializer -> Bool)
-> (LocalVariableInitializer
    -> LocalVariableInitializer -> LocalVariableInitializer)
-> (LocalVariableInitializer
    -> LocalVariableInitializer -> LocalVariableInitializer)
-> Ord LocalVariableInitializer
LocalVariableInitializer -> LocalVariableInitializer -> Bool
LocalVariableInitializer -> LocalVariableInitializer -> Ordering
LocalVariableInitializer
-> LocalVariableInitializer -> LocalVariableInitializer
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LocalVariableInitializer -> LocalVariableInitializer -> Ordering
compare :: LocalVariableInitializer -> LocalVariableInitializer -> Ordering
$c< :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
< :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
$c<= :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
<= :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
$c> :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
> :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
$c>= :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
>= :: LocalVariableInitializer -> LocalVariableInitializer -> Bool
$cmax :: LocalVariableInitializer
-> LocalVariableInitializer -> LocalVariableInitializer
max :: LocalVariableInitializer
-> LocalVariableInitializer -> LocalVariableInitializer
$cmin :: LocalVariableInitializer
-> LocalVariableInitializer -> LocalVariableInitializer
min :: LocalVariableInitializer
-> LocalVariableInitializer -> LocalVariableInitializer
Ord, ReadPrec [LocalVariableInitializer]
ReadPrec LocalVariableInitializer
Int -> ReadS LocalVariableInitializer
ReadS [LocalVariableInitializer]
(Int -> ReadS LocalVariableInitializer)
-> ReadS [LocalVariableInitializer]
-> ReadPrec LocalVariableInitializer
-> ReadPrec [LocalVariableInitializer]
-> Read LocalVariableInitializer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LocalVariableInitializer
readsPrec :: Int -> ReadS LocalVariableInitializer
$creadList :: ReadS [LocalVariableInitializer]
readList :: ReadS [LocalVariableInitializer]
$creadPrec :: ReadPrec LocalVariableInitializer
readPrec :: ReadPrec LocalVariableInitializer
$creadListPrec :: ReadPrec [LocalVariableInitializer]
readListPrec :: ReadPrec [LocalVariableInitializer]
Read, Int -> LocalVariableInitializer -> String -> String
[LocalVariableInitializer] -> String -> String
LocalVariableInitializer -> String
(Int -> LocalVariableInitializer -> String -> String)
-> (LocalVariableInitializer -> String)
-> ([LocalVariableInitializer] -> String -> String)
-> Show LocalVariableInitializer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LocalVariableInitializer -> String -> String
showsPrec :: Int -> LocalVariableInitializer -> String -> String
$cshow :: LocalVariableInitializer -> String
show :: LocalVariableInitializer -> String
$cshowList :: [LocalVariableInitializer] -> String -> String
showList :: [LocalVariableInitializer] -> String -> String
Show)

_LocalVariableInitializer :: Name
_LocalVariableInitializer = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LocalVariableInitializer")

_LocalVariableInitializer_expression :: Name
_LocalVariableInitializer_expression = (String -> Name
Core.Name String
"expression")

_LocalVariableInitializer_initializer :: Name
_LocalVariableInitializer_initializer = (String -> Name
Core.Name String
"initializer")

data RefLocalVariableDeclaration = 
  RefLocalVariableDeclaration {
    RefLocalVariableDeclaration -> RefKind
refLocalVariableDeclarationRefKind :: RefKind,
    RefLocalVariableDeclaration -> Type
refLocalVariableDeclarationType :: Type,
    RefLocalVariableDeclaration -> [RefLocalVariableDeclarator]
refLocalVariableDeclarationDeclarators :: [RefLocalVariableDeclarator]}
  deriving (RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
(RefLocalVariableDeclaration
 -> RefLocalVariableDeclaration -> Bool)
-> (RefLocalVariableDeclaration
    -> RefLocalVariableDeclaration -> Bool)
-> Eq RefLocalVariableDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
== :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
$c/= :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
/= :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
Eq, Eq RefLocalVariableDeclaration
Eq RefLocalVariableDeclaration =>
(RefLocalVariableDeclaration
 -> RefLocalVariableDeclaration -> Ordering)
-> (RefLocalVariableDeclaration
    -> RefLocalVariableDeclaration -> Bool)
-> (RefLocalVariableDeclaration
    -> RefLocalVariableDeclaration -> Bool)
-> (RefLocalVariableDeclaration
    -> RefLocalVariableDeclaration -> Bool)
-> (RefLocalVariableDeclaration
    -> RefLocalVariableDeclaration -> Bool)
-> (RefLocalVariableDeclaration
    -> RefLocalVariableDeclaration -> RefLocalVariableDeclaration)
-> (RefLocalVariableDeclaration
    -> RefLocalVariableDeclaration -> RefLocalVariableDeclaration)
-> Ord RefLocalVariableDeclaration
RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
RefLocalVariableDeclaration
-> RefLocalVariableDeclaration -> Ordering
RefLocalVariableDeclaration
-> RefLocalVariableDeclaration -> RefLocalVariableDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefLocalVariableDeclaration
-> RefLocalVariableDeclaration -> Ordering
compare :: RefLocalVariableDeclaration
-> RefLocalVariableDeclaration -> Ordering
$c< :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
< :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
$c<= :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
<= :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
$c> :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
> :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
$c>= :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
>= :: RefLocalVariableDeclaration -> RefLocalVariableDeclaration -> Bool
$cmax :: RefLocalVariableDeclaration
-> RefLocalVariableDeclaration -> RefLocalVariableDeclaration
max :: RefLocalVariableDeclaration
-> RefLocalVariableDeclaration -> RefLocalVariableDeclaration
$cmin :: RefLocalVariableDeclaration
-> RefLocalVariableDeclaration -> RefLocalVariableDeclaration
min :: RefLocalVariableDeclaration
-> RefLocalVariableDeclaration -> RefLocalVariableDeclaration
Ord, ReadPrec [RefLocalVariableDeclaration]
ReadPrec RefLocalVariableDeclaration
Int -> ReadS RefLocalVariableDeclaration
ReadS [RefLocalVariableDeclaration]
(Int -> ReadS RefLocalVariableDeclaration)
-> ReadS [RefLocalVariableDeclaration]
-> ReadPrec RefLocalVariableDeclaration
-> ReadPrec [RefLocalVariableDeclaration]
-> Read RefLocalVariableDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefLocalVariableDeclaration
readsPrec :: Int -> ReadS RefLocalVariableDeclaration
$creadList :: ReadS [RefLocalVariableDeclaration]
readList :: ReadS [RefLocalVariableDeclaration]
$creadPrec :: ReadPrec RefLocalVariableDeclaration
readPrec :: ReadPrec RefLocalVariableDeclaration
$creadListPrec :: ReadPrec [RefLocalVariableDeclaration]
readListPrec :: ReadPrec [RefLocalVariableDeclaration]
Read, Int -> RefLocalVariableDeclaration -> String -> String
[RefLocalVariableDeclaration] -> String -> String
RefLocalVariableDeclaration -> String
(Int -> RefLocalVariableDeclaration -> String -> String)
-> (RefLocalVariableDeclaration -> String)
-> ([RefLocalVariableDeclaration] -> String -> String)
-> Show RefLocalVariableDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefLocalVariableDeclaration -> String -> String
showsPrec :: Int -> RefLocalVariableDeclaration -> String -> String
$cshow :: RefLocalVariableDeclaration -> String
show :: RefLocalVariableDeclaration -> String
$cshowList :: [RefLocalVariableDeclaration] -> String -> String
showList :: [RefLocalVariableDeclaration] -> String -> String
Show)

_RefLocalVariableDeclaration :: Name
_RefLocalVariableDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefLocalVariableDeclaration")

_RefLocalVariableDeclaration_refKind :: Name
_RefLocalVariableDeclaration_refKind = (String -> Name
Core.Name String
"refKind")

_RefLocalVariableDeclaration_type :: Name
_RefLocalVariableDeclaration_type = (String -> Name
Core.Name String
"type")

_RefLocalVariableDeclaration_declarators :: Name
_RefLocalVariableDeclaration_declarators = (String -> Name
Core.Name String
"declarators")

data RefLocalVariableDeclarator = 
  RefLocalVariableDeclarator {
    RefLocalVariableDeclarator -> Identifier
refLocalVariableDeclaratorLeft :: Identifier,
    RefLocalVariableDeclarator -> VariableReference
refLocalVariableDeclaratorRight :: VariableReference}
  deriving (RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
(RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool)
-> (RefLocalVariableDeclarator
    -> RefLocalVariableDeclarator -> Bool)
-> Eq RefLocalVariableDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
== :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
$c/= :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
/= :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
Eq, Eq RefLocalVariableDeclarator
Eq RefLocalVariableDeclarator =>
(RefLocalVariableDeclarator
 -> RefLocalVariableDeclarator -> Ordering)
-> (RefLocalVariableDeclarator
    -> RefLocalVariableDeclarator -> Bool)
-> (RefLocalVariableDeclarator
    -> RefLocalVariableDeclarator -> Bool)
-> (RefLocalVariableDeclarator
    -> RefLocalVariableDeclarator -> Bool)
-> (RefLocalVariableDeclarator
    -> RefLocalVariableDeclarator -> Bool)
-> (RefLocalVariableDeclarator
    -> RefLocalVariableDeclarator -> RefLocalVariableDeclarator)
-> (RefLocalVariableDeclarator
    -> RefLocalVariableDeclarator -> RefLocalVariableDeclarator)
-> Ord RefLocalVariableDeclarator
RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
RefLocalVariableDeclarator
-> RefLocalVariableDeclarator -> Ordering
RefLocalVariableDeclarator
-> RefLocalVariableDeclarator -> RefLocalVariableDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefLocalVariableDeclarator
-> RefLocalVariableDeclarator -> Ordering
compare :: RefLocalVariableDeclarator
-> RefLocalVariableDeclarator -> Ordering
$c< :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
< :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
$c<= :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
<= :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
$c> :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
> :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
$c>= :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
>= :: RefLocalVariableDeclarator -> RefLocalVariableDeclarator -> Bool
$cmax :: RefLocalVariableDeclarator
-> RefLocalVariableDeclarator -> RefLocalVariableDeclarator
max :: RefLocalVariableDeclarator
-> RefLocalVariableDeclarator -> RefLocalVariableDeclarator
$cmin :: RefLocalVariableDeclarator
-> RefLocalVariableDeclarator -> RefLocalVariableDeclarator
min :: RefLocalVariableDeclarator
-> RefLocalVariableDeclarator -> RefLocalVariableDeclarator
Ord, ReadPrec [RefLocalVariableDeclarator]
ReadPrec RefLocalVariableDeclarator
Int -> ReadS RefLocalVariableDeclarator
ReadS [RefLocalVariableDeclarator]
(Int -> ReadS RefLocalVariableDeclarator)
-> ReadS [RefLocalVariableDeclarator]
-> ReadPrec RefLocalVariableDeclarator
-> ReadPrec [RefLocalVariableDeclarator]
-> Read RefLocalVariableDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefLocalVariableDeclarator
readsPrec :: Int -> ReadS RefLocalVariableDeclarator
$creadList :: ReadS [RefLocalVariableDeclarator]
readList :: ReadS [RefLocalVariableDeclarator]
$creadPrec :: ReadPrec RefLocalVariableDeclarator
readPrec :: ReadPrec RefLocalVariableDeclarator
$creadListPrec :: ReadPrec [RefLocalVariableDeclarator]
readListPrec :: ReadPrec [RefLocalVariableDeclarator]
Read, Int -> RefLocalVariableDeclarator -> String -> String
[RefLocalVariableDeclarator] -> String -> String
RefLocalVariableDeclarator -> String
(Int -> RefLocalVariableDeclarator -> String -> String)
-> (RefLocalVariableDeclarator -> String)
-> ([RefLocalVariableDeclarator] -> String -> String)
-> Show RefLocalVariableDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefLocalVariableDeclarator -> String -> String
showsPrec :: Int -> RefLocalVariableDeclarator -> String -> String
$cshow :: RefLocalVariableDeclarator -> String
show :: RefLocalVariableDeclarator -> String
$cshowList :: [RefLocalVariableDeclarator] -> String -> String
showList :: [RefLocalVariableDeclarator] -> String -> String
Show)

_RefLocalVariableDeclarator :: Name
_RefLocalVariableDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefLocalVariableDeclarator")

_RefLocalVariableDeclarator_left :: Name
_RefLocalVariableDeclarator_left = (String -> Name
Core.Name String
"left")

_RefLocalVariableDeclarator_right :: Name
_RefLocalVariableDeclarator_right = (String -> Name
Core.Name String
"right")

data LocalConstantDeclaration = 
  LocalConstantDeclaration {
    LocalConstantDeclaration -> Type
localConstantDeclarationType :: Type,
    LocalConstantDeclaration -> [ConstantDeclarator]
localConstantDeclarationDeclarators :: [ConstantDeclarator]}
  deriving (LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
(LocalConstantDeclaration -> LocalConstantDeclaration -> Bool)
-> (LocalConstantDeclaration -> LocalConstantDeclaration -> Bool)
-> Eq LocalConstantDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
== :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
$c/= :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
/= :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
Eq, Eq LocalConstantDeclaration
Eq LocalConstantDeclaration =>
(LocalConstantDeclaration -> LocalConstantDeclaration -> Ordering)
-> (LocalConstantDeclaration -> LocalConstantDeclaration -> Bool)
-> (LocalConstantDeclaration -> LocalConstantDeclaration -> Bool)
-> (LocalConstantDeclaration -> LocalConstantDeclaration -> Bool)
-> (LocalConstantDeclaration -> LocalConstantDeclaration -> Bool)
-> (LocalConstantDeclaration
    -> LocalConstantDeclaration -> LocalConstantDeclaration)
-> (LocalConstantDeclaration
    -> LocalConstantDeclaration -> LocalConstantDeclaration)
-> Ord LocalConstantDeclaration
LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
LocalConstantDeclaration -> LocalConstantDeclaration -> Ordering
LocalConstantDeclaration
-> LocalConstantDeclaration -> LocalConstantDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LocalConstantDeclaration -> LocalConstantDeclaration -> Ordering
compare :: LocalConstantDeclaration -> LocalConstantDeclaration -> Ordering
$c< :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
< :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
$c<= :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
<= :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
$c> :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
> :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
$c>= :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
>= :: LocalConstantDeclaration -> LocalConstantDeclaration -> Bool
$cmax :: LocalConstantDeclaration
-> LocalConstantDeclaration -> LocalConstantDeclaration
max :: LocalConstantDeclaration
-> LocalConstantDeclaration -> LocalConstantDeclaration
$cmin :: LocalConstantDeclaration
-> LocalConstantDeclaration -> LocalConstantDeclaration
min :: LocalConstantDeclaration
-> LocalConstantDeclaration -> LocalConstantDeclaration
Ord, ReadPrec [LocalConstantDeclaration]
ReadPrec LocalConstantDeclaration
Int -> ReadS LocalConstantDeclaration
ReadS [LocalConstantDeclaration]
(Int -> ReadS LocalConstantDeclaration)
-> ReadS [LocalConstantDeclaration]
-> ReadPrec LocalConstantDeclaration
-> ReadPrec [LocalConstantDeclaration]
-> Read LocalConstantDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LocalConstantDeclaration
readsPrec :: Int -> ReadS LocalConstantDeclaration
$creadList :: ReadS [LocalConstantDeclaration]
readList :: ReadS [LocalConstantDeclaration]
$creadPrec :: ReadPrec LocalConstantDeclaration
readPrec :: ReadPrec LocalConstantDeclaration
$creadListPrec :: ReadPrec [LocalConstantDeclaration]
readListPrec :: ReadPrec [LocalConstantDeclaration]
Read, Int -> LocalConstantDeclaration -> String -> String
[LocalConstantDeclaration] -> String -> String
LocalConstantDeclaration -> String
(Int -> LocalConstantDeclaration -> String -> String)
-> (LocalConstantDeclaration -> String)
-> ([LocalConstantDeclaration] -> String -> String)
-> Show LocalConstantDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LocalConstantDeclaration -> String -> String
showsPrec :: Int -> LocalConstantDeclaration -> String -> String
$cshow :: LocalConstantDeclaration -> String
show :: LocalConstantDeclaration -> String
$cshowList :: [LocalConstantDeclaration] -> String -> String
showList :: [LocalConstantDeclaration] -> String -> String
Show)

_LocalConstantDeclaration :: Name
_LocalConstantDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LocalConstantDeclaration")

_LocalConstantDeclaration_type :: Name
_LocalConstantDeclaration_type = (String -> Name
Core.Name String
"type")

_LocalConstantDeclaration_declarators :: Name
_LocalConstantDeclaration_declarators = (String -> Name
Core.Name String
"declarators")

data ConstantDeclarator = 
  ConstantDeclarator {
    ConstantDeclarator -> Identifier
constantDeclaratorIdentifier :: Identifier,
    ConstantDeclarator -> ConstantExpression
constantDeclaratorExpression :: ConstantExpression}
  deriving (ConstantDeclarator -> ConstantDeclarator -> Bool
(ConstantDeclarator -> ConstantDeclarator -> Bool)
-> (ConstantDeclarator -> ConstantDeclarator -> Bool)
-> Eq ConstantDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstantDeclarator -> ConstantDeclarator -> Bool
== :: ConstantDeclarator -> ConstantDeclarator -> Bool
$c/= :: ConstantDeclarator -> ConstantDeclarator -> Bool
/= :: ConstantDeclarator -> ConstantDeclarator -> Bool
Eq, Eq ConstantDeclarator
Eq ConstantDeclarator =>
(ConstantDeclarator -> ConstantDeclarator -> Ordering)
-> (ConstantDeclarator -> ConstantDeclarator -> Bool)
-> (ConstantDeclarator -> ConstantDeclarator -> Bool)
-> (ConstantDeclarator -> ConstantDeclarator -> Bool)
-> (ConstantDeclarator -> ConstantDeclarator -> Bool)
-> (ConstantDeclarator -> ConstantDeclarator -> ConstantDeclarator)
-> (ConstantDeclarator -> ConstantDeclarator -> ConstantDeclarator)
-> Ord ConstantDeclarator
ConstantDeclarator -> ConstantDeclarator -> Bool
ConstantDeclarator -> ConstantDeclarator -> Ordering
ConstantDeclarator -> ConstantDeclarator -> ConstantDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstantDeclarator -> ConstantDeclarator -> Ordering
compare :: ConstantDeclarator -> ConstantDeclarator -> Ordering
$c< :: ConstantDeclarator -> ConstantDeclarator -> Bool
< :: ConstantDeclarator -> ConstantDeclarator -> Bool
$c<= :: ConstantDeclarator -> ConstantDeclarator -> Bool
<= :: ConstantDeclarator -> ConstantDeclarator -> Bool
$c> :: ConstantDeclarator -> ConstantDeclarator -> Bool
> :: ConstantDeclarator -> ConstantDeclarator -> Bool
$c>= :: ConstantDeclarator -> ConstantDeclarator -> Bool
>= :: ConstantDeclarator -> ConstantDeclarator -> Bool
$cmax :: ConstantDeclarator -> ConstantDeclarator -> ConstantDeclarator
max :: ConstantDeclarator -> ConstantDeclarator -> ConstantDeclarator
$cmin :: ConstantDeclarator -> ConstantDeclarator -> ConstantDeclarator
min :: ConstantDeclarator -> ConstantDeclarator -> ConstantDeclarator
Ord, ReadPrec [ConstantDeclarator]
ReadPrec ConstantDeclarator
Int -> ReadS ConstantDeclarator
ReadS [ConstantDeclarator]
(Int -> ReadS ConstantDeclarator)
-> ReadS [ConstantDeclarator]
-> ReadPrec ConstantDeclarator
-> ReadPrec [ConstantDeclarator]
-> Read ConstantDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConstantDeclarator
readsPrec :: Int -> ReadS ConstantDeclarator
$creadList :: ReadS [ConstantDeclarator]
readList :: ReadS [ConstantDeclarator]
$creadPrec :: ReadPrec ConstantDeclarator
readPrec :: ReadPrec ConstantDeclarator
$creadListPrec :: ReadPrec [ConstantDeclarator]
readListPrec :: ReadPrec [ConstantDeclarator]
Read, Int -> ConstantDeclarator -> String -> String
[ConstantDeclarator] -> String -> String
ConstantDeclarator -> String
(Int -> ConstantDeclarator -> String -> String)
-> (ConstantDeclarator -> String)
-> ([ConstantDeclarator] -> String -> String)
-> Show ConstantDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConstantDeclarator -> String -> String
showsPrec :: Int -> ConstantDeclarator -> String -> String
$cshow :: ConstantDeclarator -> String
show :: ConstantDeclarator -> String
$cshowList :: [ConstantDeclarator] -> String -> String
showList :: [ConstantDeclarator] -> String -> String
Show)

_ConstantDeclarator :: Name
_ConstantDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConstantDeclarator")

_ConstantDeclarator_identifier :: Name
_ConstantDeclarator_identifier = (String -> Name
Core.Name String
"identifier")

_ConstantDeclarator_expression :: Name
_ConstantDeclarator_expression = (String -> Name
Core.Name String
"expression")

data LocalFunctionDeclaration = 
  LocalFunctionDeclarationStandard StandardLocalFunctionDeclaration |
  LocalFunctionDeclarationRef RefLocalFunctionDeclaration
  deriving (LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
(LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool)
-> (LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool)
-> Eq LocalFunctionDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
== :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
$c/= :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
/= :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
Eq, Eq LocalFunctionDeclaration
Eq LocalFunctionDeclaration =>
(LocalFunctionDeclaration -> LocalFunctionDeclaration -> Ordering)
-> (LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool)
-> (LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool)
-> (LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool)
-> (LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool)
-> (LocalFunctionDeclaration
    -> LocalFunctionDeclaration -> LocalFunctionDeclaration)
-> (LocalFunctionDeclaration
    -> LocalFunctionDeclaration -> LocalFunctionDeclaration)
-> Ord LocalFunctionDeclaration
LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
LocalFunctionDeclaration -> LocalFunctionDeclaration -> Ordering
LocalFunctionDeclaration
-> LocalFunctionDeclaration -> LocalFunctionDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Ordering
compare :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Ordering
$c< :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
< :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
$c<= :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
<= :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
$c> :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
> :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
$c>= :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
>= :: LocalFunctionDeclaration -> LocalFunctionDeclaration -> Bool
$cmax :: LocalFunctionDeclaration
-> LocalFunctionDeclaration -> LocalFunctionDeclaration
max :: LocalFunctionDeclaration
-> LocalFunctionDeclaration -> LocalFunctionDeclaration
$cmin :: LocalFunctionDeclaration
-> LocalFunctionDeclaration -> LocalFunctionDeclaration
min :: LocalFunctionDeclaration
-> LocalFunctionDeclaration -> LocalFunctionDeclaration
Ord, ReadPrec [LocalFunctionDeclaration]
ReadPrec LocalFunctionDeclaration
Int -> ReadS LocalFunctionDeclaration
ReadS [LocalFunctionDeclaration]
(Int -> ReadS LocalFunctionDeclaration)
-> ReadS [LocalFunctionDeclaration]
-> ReadPrec LocalFunctionDeclaration
-> ReadPrec [LocalFunctionDeclaration]
-> Read LocalFunctionDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LocalFunctionDeclaration
readsPrec :: Int -> ReadS LocalFunctionDeclaration
$creadList :: ReadS [LocalFunctionDeclaration]
readList :: ReadS [LocalFunctionDeclaration]
$creadPrec :: ReadPrec LocalFunctionDeclaration
readPrec :: ReadPrec LocalFunctionDeclaration
$creadListPrec :: ReadPrec [LocalFunctionDeclaration]
readListPrec :: ReadPrec [LocalFunctionDeclaration]
Read, Int -> LocalFunctionDeclaration -> String -> String
[LocalFunctionDeclaration] -> String -> String
LocalFunctionDeclaration -> String
(Int -> LocalFunctionDeclaration -> String -> String)
-> (LocalFunctionDeclaration -> String)
-> ([LocalFunctionDeclaration] -> String -> String)
-> Show LocalFunctionDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LocalFunctionDeclaration -> String -> String
showsPrec :: Int -> LocalFunctionDeclaration -> String -> String
$cshow :: LocalFunctionDeclaration -> String
show :: LocalFunctionDeclaration -> String
$cshowList :: [LocalFunctionDeclaration] -> String -> String
showList :: [LocalFunctionDeclaration] -> String -> String
Show)

_LocalFunctionDeclaration :: Name
_LocalFunctionDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LocalFunctionDeclaration")

_LocalFunctionDeclaration_standard :: Name
_LocalFunctionDeclaration_standard = (String -> Name
Core.Name String
"standard")

_LocalFunctionDeclaration_ref :: Name
_LocalFunctionDeclaration_ref = (String -> Name
Core.Name String
"ref")

data StandardLocalFunctionDeclaration = 
  StandardLocalFunctionDeclaration {
    StandardLocalFunctionDeclaration -> [LocalFunctionModifier]
standardLocalFunctionDeclarationModifiers :: [LocalFunctionModifier],
    StandardLocalFunctionDeclaration -> ReturnType
standardLocalFunctionDeclarationReturnType :: ReturnType,
    StandardLocalFunctionDeclaration -> LocalFunctionHeader
standardLocalFunctionDeclarationHeader :: LocalFunctionHeader,
    StandardLocalFunctionDeclaration -> LocalFunctionBody
standardLocalFunctionDeclarationBody :: LocalFunctionBody}
  deriving (StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
(StandardLocalFunctionDeclaration
 -> StandardLocalFunctionDeclaration -> Bool)
-> (StandardLocalFunctionDeclaration
    -> StandardLocalFunctionDeclaration -> Bool)
-> Eq StandardLocalFunctionDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
== :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
$c/= :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
/= :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
Eq, Eq StandardLocalFunctionDeclaration
Eq StandardLocalFunctionDeclaration =>
(StandardLocalFunctionDeclaration
 -> StandardLocalFunctionDeclaration -> Ordering)
-> (StandardLocalFunctionDeclaration
    -> StandardLocalFunctionDeclaration -> Bool)
-> (StandardLocalFunctionDeclaration
    -> StandardLocalFunctionDeclaration -> Bool)
-> (StandardLocalFunctionDeclaration
    -> StandardLocalFunctionDeclaration -> Bool)
-> (StandardLocalFunctionDeclaration
    -> StandardLocalFunctionDeclaration -> Bool)
-> (StandardLocalFunctionDeclaration
    -> StandardLocalFunctionDeclaration
    -> StandardLocalFunctionDeclaration)
-> (StandardLocalFunctionDeclaration
    -> StandardLocalFunctionDeclaration
    -> StandardLocalFunctionDeclaration)
-> Ord StandardLocalFunctionDeclaration
StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Ordering
StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Ordering
compare :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Ordering
$c< :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
< :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
$c<= :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
<= :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
$c> :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
> :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
$c>= :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
>= :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration -> Bool
$cmax :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration
max :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration
$cmin :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration
min :: StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration
-> StandardLocalFunctionDeclaration
Ord, ReadPrec [StandardLocalFunctionDeclaration]
ReadPrec StandardLocalFunctionDeclaration
Int -> ReadS StandardLocalFunctionDeclaration
ReadS [StandardLocalFunctionDeclaration]
(Int -> ReadS StandardLocalFunctionDeclaration)
-> ReadS [StandardLocalFunctionDeclaration]
-> ReadPrec StandardLocalFunctionDeclaration
-> ReadPrec [StandardLocalFunctionDeclaration]
-> Read StandardLocalFunctionDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StandardLocalFunctionDeclaration
readsPrec :: Int -> ReadS StandardLocalFunctionDeclaration
$creadList :: ReadS [StandardLocalFunctionDeclaration]
readList :: ReadS [StandardLocalFunctionDeclaration]
$creadPrec :: ReadPrec StandardLocalFunctionDeclaration
readPrec :: ReadPrec StandardLocalFunctionDeclaration
$creadListPrec :: ReadPrec [StandardLocalFunctionDeclaration]
readListPrec :: ReadPrec [StandardLocalFunctionDeclaration]
Read, Int -> StandardLocalFunctionDeclaration -> String -> String
[StandardLocalFunctionDeclaration] -> String -> String
StandardLocalFunctionDeclaration -> String
(Int -> StandardLocalFunctionDeclaration -> String -> String)
-> (StandardLocalFunctionDeclaration -> String)
-> ([StandardLocalFunctionDeclaration] -> String -> String)
-> Show StandardLocalFunctionDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StandardLocalFunctionDeclaration -> String -> String
showsPrec :: Int -> StandardLocalFunctionDeclaration -> String -> String
$cshow :: StandardLocalFunctionDeclaration -> String
show :: StandardLocalFunctionDeclaration -> String
$cshowList :: [StandardLocalFunctionDeclaration] -> String -> String
showList :: [StandardLocalFunctionDeclaration] -> String -> String
Show)

_StandardLocalFunctionDeclaration :: Name
_StandardLocalFunctionDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StandardLocalFunctionDeclaration")

_StandardLocalFunctionDeclaration_modifiers :: Name
_StandardLocalFunctionDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_StandardLocalFunctionDeclaration_returnType :: Name
_StandardLocalFunctionDeclaration_returnType = (String -> Name
Core.Name String
"returnType")

_StandardLocalFunctionDeclaration_header :: Name
_StandardLocalFunctionDeclaration_header = (String -> Name
Core.Name String
"header")

_StandardLocalFunctionDeclaration_body :: Name
_StandardLocalFunctionDeclaration_body = (String -> Name
Core.Name String
"body")

data RefLocalFunctionDeclaration = 
  RefLocalFunctionDeclaration {
    RefLocalFunctionDeclaration -> [RefLocalFunctionModifier]
refLocalFunctionDeclarationModifiers :: [RefLocalFunctionModifier],
    RefLocalFunctionDeclaration -> RefKind
refLocalFunctionDeclarationRefKind :: RefKind,
    RefLocalFunctionDeclaration -> Type
refLocalFunctionDeclarationReturnType :: Type,
    RefLocalFunctionDeclaration -> LocalFunctionHeader
refLocalFunctionDeclarationHeader :: LocalFunctionHeader,
    RefLocalFunctionDeclaration -> RefLocalFunctionBody
refLocalFunctionDeclarationBody :: RefLocalFunctionBody}
  deriving (RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
(RefLocalFunctionDeclaration
 -> RefLocalFunctionDeclaration -> Bool)
-> (RefLocalFunctionDeclaration
    -> RefLocalFunctionDeclaration -> Bool)
-> Eq RefLocalFunctionDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
== :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
$c/= :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
/= :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
Eq, Eq RefLocalFunctionDeclaration
Eq RefLocalFunctionDeclaration =>
(RefLocalFunctionDeclaration
 -> RefLocalFunctionDeclaration -> Ordering)
-> (RefLocalFunctionDeclaration
    -> RefLocalFunctionDeclaration -> Bool)
-> (RefLocalFunctionDeclaration
    -> RefLocalFunctionDeclaration -> Bool)
-> (RefLocalFunctionDeclaration
    -> RefLocalFunctionDeclaration -> Bool)
-> (RefLocalFunctionDeclaration
    -> RefLocalFunctionDeclaration -> Bool)
-> (RefLocalFunctionDeclaration
    -> RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration)
-> (RefLocalFunctionDeclaration
    -> RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration)
-> Ord RefLocalFunctionDeclaration
RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
RefLocalFunctionDeclaration
-> RefLocalFunctionDeclaration -> Ordering
RefLocalFunctionDeclaration
-> RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefLocalFunctionDeclaration
-> RefLocalFunctionDeclaration -> Ordering
compare :: RefLocalFunctionDeclaration
-> RefLocalFunctionDeclaration -> Ordering
$c< :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
< :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
$c<= :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
<= :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
$c> :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
> :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
$c>= :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
>= :: RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration -> Bool
$cmax :: RefLocalFunctionDeclaration
-> RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration
max :: RefLocalFunctionDeclaration
-> RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration
$cmin :: RefLocalFunctionDeclaration
-> RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration
min :: RefLocalFunctionDeclaration
-> RefLocalFunctionDeclaration -> RefLocalFunctionDeclaration
Ord, ReadPrec [RefLocalFunctionDeclaration]
ReadPrec RefLocalFunctionDeclaration
Int -> ReadS RefLocalFunctionDeclaration
ReadS [RefLocalFunctionDeclaration]
(Int -> ReadS RefLocalFunctionDeclaration)
-> ReadS [RefLocalFunctionDeclaration]
-> ReadPrec RefLocalFunctionDeclaration
-> ReadPrec [RefLocalFunctionDeclaration]
-> Read RefLocalFunctionDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefLocalFunctionDeclaration
readsPrec :: Int -> ReadS RefLocalFunctionDeclaration
$creadList :: ReadS [RefLocalFunctionDeclaration]
readList :: ReadS [RefLocalFunctionDeclaration]
$creadPrec :: ReadPrec RefLocalFunctionDeclaration
readPrec :: ReadPrec RefLocalFunctionDeclaration
$creadListPrec :: ReadPrec [RefLocalFunctionDeclaration]
readListPrec :: ReadPrec [RefLocalFunctionDeclaration]
Read, Int -> RefLocalFunctionDeclaration -> String -> String
[RefLocalFunctionDeclaration] -> String -> String
RefLocalFunctionDeclaration -> String
(Int -> RefLocalFunctionDeclaration -> String -> String)
-> (RefLocalFunctionDeclaration -> String)
-> ([RefLocalFunctionDeclaration] -> String -> String)
-> Show RefLocalFunctionDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefLocalFunctionDeclaration -> String -> String
showsPrec :: Int -> RefLocalFunctionDeclaration -> String -> String
$cshow :: RefLocalFunctionDeclaration -> String
show :: RefLocalFunctionDeclaration -> String
$cshowList :: [RefLocalFunctionDeclaration] -> String -> String
showList :: [RefLocalFunctionDeclaration] -> String -> String
Show)

_RefLocalFunctionDeclaration :: Name
_RefLocalFunctionDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefLocalFunctionDeclaration")

_RefLocalFunctionDeclaration_modifiers :: Name
_RefLocalFunctionDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_RefLocalFunctionDeclaration_refKind :: Name
_RefLocalFunctionDeclaration_refKind = (String -> Name
Core.Name String
"refKind")

_RefLocalFunctionDeclaration_returnType :: Name
_RefLocalFunctionDeclaration_returnType = (String -> Name
Core.Name String
"returnType")

_RefLocalFunctionDeclaration_header :: Name
_RefLocalFunctionDeclaration_header = (String -> Name
Core.Name String
"header")

_RefLocalFunctionDeclaration_body :: Name
_RefLocalFunctionDeclaration_body = (String -> Name
Core.Name String
"body")

data LocalFunctionHeader = 
  LocalFunctionHeader {
    LocalFunctionHeader -> Identifier
localFunctionHeaderIdentifier :: Identifier,
    LocalFunctionHeader -> Maybe TypeParameterList
localFunctionHeaderTypeParameters :: (Maybe TypeParameterList),
    LocalFunctionHeader -> FormalParameterList
localFunctionHeaderParameters :: FormalParameterList,
    LocalFunctionHeader -> [TypeParameterConstraintsClause]
localFunctionHeaderConstraints :: [TypeParameterConstraintsClause]}
  deriving (LocalFunctionHeader -> LocalFunctionHeader -> Bool
(LocalFunctionHeader -> LocalFunctionHeader -> Bool)
-> (LocalFunctionHeader -> LocalFunctionHeader -> Bool)
-> Eq LocalFunctionHeader
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
== :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
$c/= :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
/= :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
Eq, Eq LocalFunctionHeader
Eq LocalFunctionHeader =>
(LocalFunctionHeader -> LocalFunctionHeader -> Ordering)
-> (LocalFunctionHeader -> LocalFunctionHeader -> Bool)
-> (LocalFunctionHeader -> LocalFunctionHeader -> Bool)
-> (LocalFunctionHeader -> LocalFunctionHeader -> Bool)
-> (LocalFunctionHeader -> LocalFunctionHeader -> Bool)
-> (LocalFunctionHeader
    -> LocalFunctionHeader -> LocalFunctionHeader)
-> (LocalFunctionHeader
    -> LocalFunctionHeader -> LocalFunctionHeader)
-> Ord LocalFunctionHeader
LocalFunctionHeader -> LocalFunctionHeader -> Bool
LocalFunctionHeader -> LocalFunctionHeader -> Ordering
LocalFunctionHeader -> LocalFunctionHeader -> LocalFunctionHeader
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LocalFunctionHeader -> LocalFunctionHeader -> Ordering
compare :: LocalFunctionHeader -> LocalFunctionHeader -> Ordering
$c< :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
< :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
$c<= :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
<= :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
$c> :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
> :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
$c>= :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
>= :: LocalFunctionHeader -> LocalFunctionHeader -> Bool
$cmax :: LocalFunctionHeader -> LocalFunctionHeader -> LocalFunctionHeader
max :: LocalFunctionHeader -> LocalFunctionHeader -> LocalFunctionHeader
$cmin :: LocalFunctionHeader -> LocalFunctionHeader -> LocalFunctionHeader
min :: LocalFunctionHeader -> LocalFunctionHeader -> LocalFunctionHeader
Ord, ReadPrec [LocalFunctionHeader]
ReadPrec LocalFunctionHeader
Int -> ReadS LocalFunctionHeader
ReadS [LocalFunctionHeader]
(Int -> ReadS LocalFunctionHeader)
-> ReadS [LocalFunctionHeader]
-> ReadPrec LocalFunctionHeader
-> ReadPrec [LocalFunctionHeader]
-> Read LocalFunctionHeader
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LocalFunctionHeader
readsPrec :: Int -> ReadS LocalFunctionHeader
$creadList :: ReadS [LocalFunctionHeader]
readList :: ReadS [LocalFunctionHeader]
$creadPrec :: ReadPrec LocalFunctionHeader
readPrec :: ReadPrec LocalFunctionHeader
$creadListPrec :: ReadPrec [LocalFunctionHeader]
readListPrec :: ReadPrec [LocalFunctionHeader]
Read, Int -> LocalFunctionHeader -> String -> String
[LocalFunctionHeader] -> String -> String
LocalFunctionHeader -> String
(Int -> LocalFunctionHeader -> String -> String)
-> (LocalFunctionHeader -> String)
-> ([LocalFunctionHeader] -> String -> String)
-> Show LocalFunctionHeader
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LocalFunctionHeader -> String -> String
showsPrec :: Int -> LocalFunctionHeader -> String -> String
$cshow :: LocalFunctionHeader -> String
show :: LocalFunctionHeader -> String
$cshowList :: [LocalFunctionHeader] -> String -> String
showList :: [LocalFunctionHeader] -> String -> String
Show)

_LocalFunctionHeader :: Name
_LocalFunctionHeader = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LocalFunctionHeader")

_LocalFunctionHeader_identifier :: Name
_LocalFunctionHeader_identifier = (String -> Name
Core.Name String
"identifier")

_LocalFunctionHeader_typeParameters :: Name
_LocalFunctionHeader_typeParameters = (String -> Name
Core.Name String
"typeParameters")

_LocalFunctionHeader_parameters :: Name
_LocalFunctionHeader_parameters = (String -> Name
Core.Name String
"parameters")

_LocalFunctionHeader_constraints :: Name
_LocalFunctionHeader_constraints = (String -> Name
Core.Name String
"constraints")

data LocalFunctionModifier = 
  LocalFunctionModifierRef RefLocalFunctionModifier |
  LocalFunctionModifierAsync 
  deriving (LocalFunctionModifier -> LocalFunctionModifier -> Bool
(LocalFunctionModifier -> LocalFunctionModifier -> Bool)
-> (LocalFunctionModifier -> LocalFunctionModifier -> Bool)
-> Eq LocalFunctionModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
== :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
$c/= :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
/= :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
Eq, Eq LocalFunctionModifier
Eq LocalFunctionModifier =>
(LocalFunctionModifier -> LocalFunctionModifier -> Ordering)
-> (LocalFunctionModifier -> LocalFunctionModifier -> Bool)
-> (LocalFunctionModifier -> LocalFunctionModifier -> Bool)
-> (LocalFunctionModifier -> LocalFunctionModifier -> Bool)
-> (LocalFunctionModifier -> LocalFunctionModifier -> Bool)
-> (LocalFunctionModifier
    -> LocalFunctionModifier -> LocalFunctionModifier)
-> (LocalFunctionModifier
    -> LocalFunctionModifier -> LocalFunctionModifier)
-> Ord LocalFunctionModifier
LocalFunctionModifier -> LocalFunctionModifier -> Bool
LocalFunctionModifier -> LocalFunctionModifier -> Ordering
LocalFunctionModifier
-> LocalFunctionModifier -> LocalFunctionModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LocalFunctionModifier -> LocalFunctionModifier -> Ordering
compare :: LocalFunctionModifier -> LocalFunctionModifier -> Ordering
$c< :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
< :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
$c<= :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
<= :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
$c> :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
> :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
$c>= :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
>= :: LocalFunctionModifier -> LocalFunctionModifier -> Bool
$cmax :: LocalFunctionModifier
-> LocalFunctionModifier -> LocalFunctionModifier
max :: LocalFunctionModifier
-> LocalFunctionModifier -> LocalFunctionModifier
$cmin :: LocalFunctionModifier
-> LocalFunctionModifier -> LocalFunctionModifier
min :: LocalFunctionModifier
-> LocalFunctionModifier -> LocalFunctionModifier
Ord, ReadPrec [LocalFunctionModifier]
ReadPrec LocalFunctionModifier
Int -> ReadS LocalFunctionModifier
ReadS [LocalFunctionModifier]
(Int -> ReadS LocalFunctionModifier)
-> ReadS [LocalFunctionModifier]
-> ReadPrec LocalFunctionModifier
-> ReadPrec [LocalFunctionModifier]
-> Read LocalFunctionModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LocalFunctionModifier
readsPrec :: Int -> ReadS LocalFunctionModifier
$creadList :: ReadS [LocalFunctionModifier]
readList :: ReadS [LocalFunctionModifier]
$creadPrec :: ReadPrec LocalFunctionModifier
readPrec :: ReadPrec LocalFunctionModifier
$creadListPrec :: ReadPrec [LocalFunctionModifier]
readListPrec :: ReadPrec [LocalFunctionModifier]
Read, Int -> LocalFunctionModifier -> String -> String
[LocalFunctionModifier] -> String -> String
LocalFunctionModifier -> String
(Int -> LocalFunctionModifier -> String -> String)
-> (LocalFunctionModifier -> String)
-> ([LocalFunctionModifier] -> String -> String)
-> Show LocalFunctionModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LocalFunctionModifier -> String -> String
showsPrec :: Int -> LocalFunctionModifier -> String -> String
$cshow :: LocalFunctionModifier -> String
show :: LocalFunctionModifier -> String
$cshowList :: [LocalFunctionModifier] -> String -> String
showList :: [LocalFunctionModifier] -> String -> String
Show)

_LocalFunctionModifier :: Name
_LocalFunctionModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LocalFunctionModifier")

_LocalFunctionModifier_ref :: Name
_LocalFunctionModifier_ref = (String -> Name
Core.Name String
"ref")

_LocalFunctionModifier_async :: Name
_LocalFunctionModifier_async = (String -> Name
Core.Name String
"async")

data RefLocalFunctionModifier = 
  RefLocalFunctionModifierStatic  |
  RefLocalFunctionModifierUnsafe 
  deriving (RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
(RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool)
-> (RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool)
-> Eq RefLocalFunctionModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
== :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
$c/= :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
/= :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
Eq, Eq RefLocalFunctionModifier
Eq RefLocalFunctionModifier =>
(RefLocalFunctionModifier -> RefLocalFunctionModifier -> Ordering)
-> (RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool)
-> (RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool)
-> (RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool)
-> (RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool)
-> (RefLocalFunctionModifier
    -> RefLocalFunctionModifier -> RefLocalFunctionModifier)
-> (RefLocalFunctionModifier
    -> RefLocalFunctionModifier -> RefLocalFunctionModifier)
-> Ord RefLocalFunctionModifier
RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
RefLocalFunctionModifier -> RefLocalFunctionModifier -> Ordering
RefLocalFunctionModifier
-> RefLocalFunctionModifier -> RefLocalFunctionModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Ordering
compare :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Ordering
$c< :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
< :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
$c<= :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
<= :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
$c> :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
> :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
$c>= :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
>= :: RefLocalFunctionModifier -> RefLocalFunctionModifier -> Bool
$cmax :: RefLocalFunctionModifier
-> RefLocalFunctionModifier -> RefLocalFunctionModifier
max :: RefLocalFunctionModifier
-> RefLocalFunctionModifier -> RefLocalFunctionModifier
$cmin :: RefLocalFunctionModifier
-> RefLocalFunctionModifier -> RefLocalFunctionModifier
min :: RefLocalFunctionModifier
-> RefLocalFunctionModifier -> RefLocalFunctionModifier
Ord, ReadPrec [RefLocalFunctionModifier]
ReadPrec RefLocalFunctionModifier
Int -> ReadS RefLocalFunctionModifier
ReadS [RefLocalFunctionModifier]
(Int -> ReadS RefLocalFunctionModifier)
-> ReadS [RefLocalFunctionModifier]
-> ReadPrec RefLocalFunctionModifier
-> ReadPrec [RefLocalFunctionModifier]
-> Read RefLocalFunctionModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefLocalFunctionModifier
readsPrec :: Int -> ReadS RefLocalFunctionModifier
$creadList :: ReadS [RefLocalFunctionModifier]
readList :: ReadS [RefLocalFunctionModifier]
$creadPrec :: ReadPrec RefLocalFunctionModifier
readPrec :: ReadPrec RefLocalFunctionModifier
$creadListPrec :: ReadPrec [RefLocalFunctionModifier]
readListPrec :: ReadPrec [RefLocalFunctionModifier]
Read, Int -> RefLocalFunctionModifier -> String -> String
[RefLocalFunctionModifier] -> String -> String
RefLocalFunctionModifier -> String
(Int -> RefLocalFunctionModifier -> String -> String)
-> (RefLocalFunctionModifier -> String)
-> ([RefLocalFunctionModifier] -> String -> String)
-> Show RefLocalFunctionModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefLocalFunctionModifier -> String -> String
showsPrec :: Int -> RefLocalFunctionModifier -> String -> String
$cshow :: RefLocalFunctionModifier -> String
show :: RefLocalFunctionModifier -> String
$cshowList :: [RefLocalFunctionModifier] -> String -> String
showList :: [RefLocalFunctionModifier] -> String -> String
Show)

_RefLocalFunctionModifier :: Name
_RefLocalFunctionModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefLocalFunctionModifier")

_RefLocalFunctionModifier_static :: Name
_RefLocalFunctionModifier_static = (String -> Name
Core.Name String
"static")

_RefLocalFunctionModifier_unsafe :: Name
_RefLocalFunctionModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

data LocalFunctionBody = 
  LocalFunctionBodyBlock Block |
  LocalFunctionBodyNullConditionalInvocation NullConditionalInvocationExpression |
  LocalFunctionBodyExpression Expression
  deriving (LocalFunctionBody -> LocalFunctionBody -> Bool
(LocalFunctionBody -> LocalFunctionBody -> Bool)
-> (LocalFunctionBody -> LocalFunctionBody -> Bool)
-> Eq LocalFunctionBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalFunctionBody -> LocalFunctionBody -> Bool
== :: LocalFunctionBody -> LocalFunctionBody -> Bool
$c/= :: LocalFunctionBody -> LocalFunctionBody -> Bool
/= :: LocalFunctionBody -> LocalFunctionBody -> Bool
Eq, Eq LocalFunctionBody
Eq LocalFunctionBody =>
(LocalFunctionBody -> LocalFunctionBody -> Ordering)
-> (LocalFunctionBody -> LocalFunctionBody -> Bool)
-> (LocalFunctionBody -> LocalFunctionBody -> Bool)
-> (LocalFunctionBody -> LocalFunctionBody -> Bool)
-> (LocalFunctionBody -> LocalFunctionBody -> Bool)
-> (LocalFunctionBody -> LocalFunctionBody -> LocalFunctionBody)
-> (LocalFunctionBody -> LocalFunctionBody -> LocalFunctionBody)
-> Ord LocalFunctionBody
LocalFunctionBody -> LocalFunctionBody -> Bool
LocalFunctionBody -> LocalFunctionBody -> Ordering
LocalFunctionBody -> LocalFunctionBody -> LocalFunctionBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LocalFunctionBody -> LocalFunctionBody -> Ordering
compare :: LocalFunctionBody -> LocalFunctionBody -> Ordering
$c< :: LocalFunctionBody -> LocalFunctionBody -> Bool
< :: LocalFunctionBody -> LocalFunctionBody -> Bool
$c<= :: LocalFunctionBody -> LocalFunctionBody -> Bool
<= :: LocalFunctionBody -> LocalFunctionBody -> Bool
$c> :: LocalFunctionBody -> LocalFunctionBody -> Bool
> :: LocalFunctionBody -> LocalFunctionBody -> Bool
$c>= :: LocalFunctionBody -> LocalFunctionBody -> Bool
>= :: LocalFunctionBody -> LocalFunctionBody -> Bool
$cmax :: LocalFunctionBody -> LocalFunctionBody -> LocalFunctionBody
max :: LocalFunctionBody -> LocalFunctionBody -> LocalFunctionBody
$cmin :: LocalFunctionBody -> LocalFunctionBody -> LocalFunctionBody
min :: LocalFunctionBody -> LocalFunctionBody -> LocalFunctionBody
Ord, ReadPrec [LocalFunctionBody]
ReadPrec LocalFunctionBody
Int -> ReadS LocalFunctionBody
ReadS [LocalFunctionBody]
(Int -> ReadS LocalFunctionBody)
-> ReadS [LocalFunctionBody]
-> ReadPrec LocalFunctionBody
-> ReadPrec [LocalFunctionBody]
-> Read LocalFunctionBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LocalFunctionBody
readsPrec :: Int -> ReadS LocalFunctionBody
$creadList :: ReadS [LocalFunctionBody]
readList :: ReadS [LocalFunctionBody]
$creadPrec :: ReadPrec LocalFunctionBody
readPrec :: ReadPrec LocalFunctionBody
$creadListPrec :: ReadPrec [LocalFunctionBody]
readListPrec :: ReadPrec [LocalFunctionBody]
Read, Int -> LocalFunctionBody -> String -> String
[LocalFunctionBody] -> String -> String
LocalFunctionBody -> String
(Int -> LocalFunctionBody -> String -> String)
-> (LocalFunctionBody -> String)
-> ([LocalFunctionBody] -> String -> String)
-> Show LocalFunctionBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LocalFunctionBody -> String -> String
showsPrec :: Int -> LocalFunctionBody -> String -> String
$cshow :: LocalFunctionBody -> String
show :: LocalFunctionBody -> String
$cshowList :: [LocalFunctionBody] -> String -> String
showList :: [LocalFunctionBody] -> String -> String
Show)

_LocalFunctionBody :: Name
_LocalFunctionBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LocalFunctionBody")

_LocalFunctionBody_block :: Name
_LocalFunctionBody_block = (String -> Name
Core.Name String
"block")

_LocalFunctionBody_nullConditionalInvocation :: Name
_LocalFunctionBody_nullConditionalInvocation = (String -> Name
Core.Name String
"nullConditionalInvocation")

_LocalFunctionBody_expression :: Name
_LocalFunctionBody_expression = (String -> Name
Core.Name String
"expression")

data RefLocalFunctionBody = 
  RefLocalFunctionBodyBlock Block |
  RefLocalFunctionBodyRef VariableReference
  deriving (RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
(RefLocalFunctionBody -> RefLocalFunctionBody -> Bool)
-> (RefLocalFunctionBody -> RefLocalFunctionBody -> Bool)
-> Eq RefLocalFunctionBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
== :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
$c/= :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
/= :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
Eq, Eq RefLocalFunctionBody
Eq RefLocalFunctionBody =>
(RefLocalFunctionBody -> RefLocalFunctionBody -> Ordering)
-> (RefLocalFunctionBody -> RefLocalFunctionBody -> Bool)
-> (RefLocalFunctionBody -> RefLocalFunctionBody -> Bool)
-> (RefLocalFunctionBody -> RefLocalFunctionBody -> Bool)
-> (RefLocalFunctionBody -> RefLocalFunctionBody -> Bool)
-> (RefLocalFunctionBody
    -> RefLocalFunctionBody -> RefLocalFunctionBody)
-> (RefLocalFunctionBody
    -> RefLocalFunctionBody -> RefLocalFunctionBody)
-> Ord RefLocalFunctionBody
RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
RefLocalFunctionBody -> RefLocalFunctionBody -> Ordering
RefLocalFunctionBody
-> RefLocalFunctionBody -> RefLocalFunctionBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefLocalFunctionBody -> RefLocalFunctionBody -> Ordering
compare :: RefLocalFunctionBody -> RefLocalFunctionBody -> Ordering
$c< :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
< :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
$c<= :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
<= :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
$c> :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
> :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
$c>= :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
>= :: RefLocalFunctionBody -> RefLocalFunctionBody -> Bool
$cmax :: RefLocalFunctionBody
-> RefLocalFunctionBody -> RefLocalFunctionBody
max :: RefLocalFunctionBody
-> RefLocalFunctionBody -> RefLocalFunctionBody
$cmin :: RefLocalFunctionBody
-> RefLocalFunctionBody -> RefLocalFunctionBody
min :: RefLocalFunctionBody
-> RefLocalFunctionBody -> RefLocalFunctionBody
Ord, ReadPrec [RefLocalFunctionBody]
ReadPrec RefLocalFunctionBody
Int -> ReadS RefLocalFunctionBody
ReadS [RefLocalFunctionBody]
(Int -> ReadS RefLocalFunctionBody)
-> ReadS [RefLocalFunctionBody]
-> ReadPrec RefLocalFunctionBody
-> ReadPrec [RefLocalFunctionBody]
-> Read RefLocalFunctionBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefLocalFunctionBody
readsPrec :: Int -> ReadS RefLocalFunctionBody
$creadList :: ReadS [RefLocalFunctionBody]
readList :: ReadS [RefLocalFunctionBody]
$creadPrec :: ReadPrec RefLocalFunctionBody
readPrec :: ReadPrec RefLocalFunctionBody
$creadListPrec :: ReadPrec [RefLocalFunctionBody]
readListPrec :: ReadPrec [RefLocalFunctionBody]
Read, Int -> RefLocalFunctionBody -> String -> String
[RefLocalFunctionBody] -> String -> String
RefLocalFunctionBody -> String
(Int -> RefLocalFunctionBody -> String -> String)
-> (RefLocalFunctionBody -> String)
-> ([RefLocalFunctionBody] -> String -> String)
-> Show RefLocalFunctionBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefLocalFunctionBody -> String -> String
showsPrec :: Int -> RefLocalFunctionBody -> String -> String
$cshow :: RefLocalFunctionBody -> String
show :: RefLocalFunctionBody -> String
$cshowList :: [RefLocalFunctionBody] -> String -> String
showList :: [RefLocalFunctionBody] -> String -> String
Show)

_RefLocalFunctionBody :: Name
_RefLocalFunctionBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefLocalFunctionBody")

_RefLocalFunctionBody_block :: Name
_RefLocalFunctionBody_block = (String -> Name
Core.Name String
"block")

_RefLocalFunctionBody_ref :: Name
_RefLocalFunctionBody_ref = (String -> Name
Core.Name String
"ref")

data StatementExpression = 
  StatementExpressionNullConditionalInvocation NullConditionalInvocationExpression |
  StatementExpressionInvocation InvocationExpression |
  StatementExpressionObjectCreation ObjectCreationExpression |
  StatementExpressionAssignment Assignment |
  StatementExpressionPostIncrement PrimaryExpression |
  StatementExpressionPostDecrement PrimaryExpression |
  StatementExpressionPreIncrement UnaryExpression |
  StatementExpressionPreDecrement UnaryExpression |
  StatementExpressionAwait UnaryExpression
  deriving (StatementExpression -> StatementExpression -> Bool
(StatementExpression -> StatementExpression -> Bool)
-> (StatementExpression -> StatementExpression -> Bool)
-> Eq StatementExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatementExpression -> StatementExpression -> Bool
== :: StatementExpression -> StatementExpression -> Bool
$c/= :: StatementExpression -> StatementExpression -> Bool
/= :: StatementExpression -> StatementExpression -> Bool
Eq, Eq StatementExpression
Eq StatementExpression =>
(StatementExpression -> StatementExpression -> Ordering)
-> (StatementExpression -> StatementExpression -> Bool)
-> (StatementExpression -> StatementExpression -> Bool)
-> (StatementExpression -> StatementExpression -> Bool)
-> (StatementExpression -> StatementExpression -> Bool)
-> (StatementExpression
    -> StatementExpression -> StatementExpression)
-> (StatementExpression
    -> StatementExpression -> StatementExpression)
-> Ord StatementExpression
StatementExpression -> StatementExpression -> Bool
StatementExpression -> StatementExpression -> Ordering
StatementExpression -> StatementExpression -> StatementExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StatementExpression -> StatementExpression -> Ordering
compare :: StatementExpression -> StatementExpression -> Ordering
$c< :: StatementExpression -> StatementExpression -> Bool
< :: StatementExpression -> StatementExpression -> Bool
$c<= :: StatementExpression -> StatementExpression -> Bool
<= :: StatementExpression -> StatementExpression -> Bool
$c> :: StatementExpression -> StatementExpression -> Bool
> :: StatementExpression -> StatementExpression -> Bool
$c>= :: StatementExpression -> StatementExpression -> Bool
>= :: StatementExpression -> StatementExpression -> Bool
$cmax :: StatementExpression -> StatementExpression -> StatementExpression
max :: StatementExpression -> StatementExpression -> StatementExpression
$cmin :: StatementExpression -> StatementExpression -> StatementExpression
min :: StatementExpression -> StatementExpression -> StatementExpression
Ord, ReadPrec [StatementExpression]
ReadPrec StatementExpression
Int -> ReadS StatementExpression
ReadS [StatementExpression]
(Int -> ReadS StatementExpression)
-> ReadS [StatementExpression]
-> ReadPrec StatementExpression
-> ReadPrec [StatementExpression]
-> Read StatementExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StatementExpression
readsPrec :: Int -> ReadS StatementExpression
$creadList :: ReadS [StatementExpression]
readList :: ReadS [StatementExpression]
$creadPrec :: ReadPrec StatementExpression
readPrec :: ReadPrec StatementExpression
$creadListPrec :: ReadPrec [StatementExpression]
readListPrec :: ReadPrec [StatementExpression]
Read, Int -> StatementExpression -> String -> String
[StatementExpression] -> String -> String
StatementExpression -> String
(Int -> StatementExpression -> String -> String)
-> (StatementExpression -> String)
-> ([StatementExpression] -> String -> String)
-> Show StatementExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StatementExpression -> String -> String
showsPrec :: Int -> StatementExpression -> String -> String
$cshow :: StatementExpression -> String
show :: StatementExpression -> String
$cshowList :: [StatementExpression] -> String -> String
showList :: [StatementExpression] -> String -> String
Show)

_StatementExpression :: Name
_StatementExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StatementExpression")

_StatementExpression_nullConditionalInvocation :: Name
_StatementExpression_nullConditionalInvocation = (String -> Name
Core.Name String
"nullConditionalInvocation")

_StatementExpression_invocation :: Name
_StatementExpression_invocation = (String -> Name
Core.Name String
"invocation")

_StatementExpression_objectCreation :: Name
_StatementExpression_objectCreation = (String -> Name
Core.Name String
"objectCreation")

_StatementExpression_assignment :: Name
_StatementExpression_assignment = (String -> Name
Core.Name String
"assignment")

_StatementExpression_postIncrement :: Name
_StatementExpression_postIncrement = (String -> Name
Core.Name String
"postIncrement")

_StatementExpression_postDecrement :: Name
_StatementExpression_postDecrement = (String -> Name
Core.Name String
"postDecrement")

_StatementExpression_preIncrement :: Name
_StatementExpression_preIncrement = (String -> Name
Core.Name String
"preIncrement")

_StatementExpression_preDecrement :: Name
_StatementExpression_preDecrement = (String -> Name
Core.Name String
"preDecrement")

_StatementExpression_await :: Name
_StatementExpression_await = (String -> Name
Core.Name String
"await")

data SelectionStatement = 
  SelectionStatementIf IfStatement |
  SelectionStatementSwitch SwitchStatement
  deriving (SelectionStatement -> SelectionStatement -> Bool
(SelectionStatement -> SelectionStatement -> Bool)
-> (SelectionStatement -> SelectionStatement -> Bool)
-> Eq SelectionStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectionStatement -> SelectionStatement -> Bool
== :: SelectionStatement -> SelectionStatement -> Bool
$c/= :: SelectionStatement -> SelectionStatement -> Bool
/= :: SelectionStatement -> SelectionStatement -> Bool
Eq, Eq SelectionStatement
Eq SelectionStatement =>
(SelectionStatement -> SelectionStatement -> Ordering)
-> (SelectionStatement -> SelectionStatement -> Bool)
-> (SelectionStatement -> SelectionStatement -> Bool)
-> (SelectionStatement -> SelectionStatement -> Bool)
-> (SelectionStatement -> SelectionStatement -> Bool)
-> (SelectionStatement -> SelectionStatement -> SelectionStatement)
-> (SelectionStatement -> SelectionStatement -> SelectionStatement)
-> Ord SelectionStatement
SelectionStatement -> SelectionStatement -> Bool
SelectionStatement -> SelectionStatement -> Ordering
SelectionStatement -> SelectionStatement -> SelectionStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SelectionStatement -> SelectionStatement -> Ordering
compare :: SelectionStatement -> SelectionStatement -> Ordering
$c< :: SelectionStatement -> SelectionStatement -> Bool
< :: SelectionStatement -> SelectionStatement -> Bool
$c<= :: SelectionStatement -> SelectionStatement -> Bool
<= :: SelectionStatement -> SelectionStatement -> Bool
$c> :: SelectionStatement -> SelectionStatement -> Bool
> :: SelectionStatement -> SelectionStatement -> Bool
$c>= :: SelectionStatement -> SelectionStatement -> Bool
>= :: SelectionStatement -> SelectionStatement -> Bool
$cmax :: SelectionStatement -> SelectionStatement -> SelectionStatement
max :: SelectionStatement -> SelectionStatement -> SelectionStatement
$cmin :: SelectionStatement -> SelectionStatement -> SelectionStatement
min :: SelectionStatement -> SelectionStatement -> SelectionStatement
Ord, ReadPrec [SelectionStatement]
ReadPrec SelectionStatement
Int -> ReadS SelectionStatement
ReadS [SelectionStatement]
(Int -> ReadS SelectionStatement)
-> ReadS [SelectionStatement]
-> ReadPrec SelectionStatement
-> ReadPrec [SelectionStatement]
-> Read SelectionStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SelectionStatement
readsPrec :: Int -> ReadS SelectionStatement
$creadList :: ReadS [SelectionStatement]
readList :: ReadS [SelectionStatement]
$creadPrec :: ReadPrec SelectionStatement
readPrec :: ReadPrec SelectionStatement
$creadListPrec :: ReadPrec [SelectionStatement]
readListPrec :: ReadPrec [SelectionStatement]
Read, Int -> SelectionStatement -> String -> String
[SelectionStatement] -> String -> String
SelectionStatement -> String
(Int -> SelectionStatement -> String -> String)
-> (SelectionStatement -> String)
-> ([SelectionStatement] -> String -> String)
-> Show SelectionStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SelectionStatement -> String -> String
showsPrec :: Int -> SelectionStatement -> String -> String
$cshow :: SelectionStatement -> String
show :: SelectionStatement -> String
$cshowList :: [SelectionStatement] -> String -> String
showList :: [SelectionStatement] -> String -> String
Show)

_SelectionStatement :: Name
_SelectionStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SelectionStatement")

_SelectionStatement_if :: Name
_SelectionStatement_if = (String -> Name
Core.Name String
"if")

_SelectionStatement_switch :: Name
_SelectionStatement_switch = (String -> Name
Core.Name String
"switch")

data IfStatement = 
  IfStatement {
    IfStatement -> BooleanExpression
ifStatementCondition :: BooleanExpression,
    IfStatement -> EmbeddedStatement
ifStatementIfBranch :: EmbeddedStatement,
    IfStatement -> EmbeddedStatement
ifStatementElseBranch :: EmbeddedStatement}
  deriving (IfStatement -> IfStatement -> Bool
(IfStatement -> IfStatement -> Bool)
-> (IfStatement -> IfStatement -> Bool) -> Eq IfStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IfStatement -> IfStatement -> Bool
== :: IfStatement -> IfStatement -> Bool
$c/= :: IfStatement -> IfStatement -> Bool
/= :: IfStatement -> IfStatement -> Bool
Eq, Eq IfStatement
Eq IfStatement =>
(IfStatement -> IfStatement -> Ordering)
-> (IfStatement -> IfStatement -> Bool)
-> (IfStatement -> IfStatement -> Bool)
-> (IfStatement -> IfStatement -> Bool)
-> (IfStatement -> IfStatement -> Bool)
-> (IfStatement -> IfStatement -> IfStatement)
-> (IfStatement -> IfStatement -> IfStatement)
-> Ord IfStatement
IfStatement -> IfStatement -> Bool
IfStatement -> IfStatement -> Ordering
IfStatement -> IfStatement -> IfStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IfStatement -> IfStatement -> Ordering
compare :: IfStatement -> IfStatement -> Ordering
$c< :: IfStatement -> IfStatement -> Bool
< :: IfStatement -> IfStatement -> Bool
$c<= :: IfStatement -> IfStatement -> Bool
<= :: IfStatement -> IfStatement -> Bool
$c> :: IfStatement -> IfStatement -> Bool
> :: IfStatement -> IfStatement -> Bool
$c>= :: IfStatement -> IfStatement -> Bool
>= :: IfStatement -> IfStatement -> Bool
$cmax :: IfStatement -> IfStatement -> IfStatement
max :: IfStatement -> IfStatement -> IfStatement
$cmin :: IfStatement -> IfStatement -> IfStatement
min :: IfStatement -> IfStatement -> IfStatement
Ord, ReadPrec [IfStatement]
ReadPrec IfStatement
Int -> ReadS IfStatement
ReadS [IfStatement]
(Int -> ReadS IfStatement)
-> ReadS [IfStatement]
-> ReadPrec IfStatement
-> ReadPrec [IfStatement]
-> Read IfStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IfStatement
readsPrec :: Int -> ReadS IfStatement
$creadList :: ReadS [IfStatement]
readList :: ReadS [IfStatement]
$creadPrec :: ReadPrec IfStatement
readPrec :: ReadPrec IfStatement
$creadListPrec :: ReadPrec [IfStatement]
readListPrec :: ReadPrec [IfStatement]
Read, Int -> IfStatement -> String -> String
[IfStatement] -> String -> String
IfStatement -> String
(Int -> IfStatement -> String -> String)
-> (IfStatement -> String)
-> ([IfStatement] -> String -> String)
-> Show IfStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IfStatement -> String -> String
showsPrec :: Int -> IfStatement -> String -> String
$cshow :: IfStatement -> String
show :: IfStatement -> String
$cshowList :: [IfStatement] -> String -> String
showList :: [IfStatement] -> String -> String
Show)

_IfStatement :: Name
_IfStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IfStatement")

_IfStatement_condition :: Name
_IfStatement_condition = (String -> Name
Core.Name String
"condition")

_IfStatement_ifBranch :: Name
_IfStatement_ifBranch = (String -> Name
Core.Name String
"ifBranch")

_IfStatement_elseBranch :: Name
_IfStatement_elseBranch = (String -> Name
Core.Name String
"elseBranch")

data SwitchStatement = 
  SwitchStatement {
    SwitchStatement -> Expression
switchStatementExpression :: Expression,
    SwitchStatement -> [SwitchSection]
switchStatementBranches :: [SwitchSection]}
  deriving (SwitchStatement -> SwitchStatement -> Bool
(SwitchStatement -> SwitchStatement -> Bool)
-> (SwitchStatement -> SwitchStatement -> Bool)
-> Eq SwitchStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SwitchStatement -> SwitchStatement -> Bool
== :: SwitchStatement -> SwitchStatement -> Bool
$c/= :: SwitchStatement -> SwitchStatement -> Bool
/= :: SwitchStatement -> SwitchStatement -> Bool
Eq, Eq SwitchStatement
Eq SwitchStatement =>
(SwitchStatement -> SwitchStatement -> Ordering)
-> (SwitchStatement -> SwitchStatement -> Bool)
-> (SwitchStatement -> SwitchStatement -> Bool)
-> (SwitchStatement -> SwitchStatement -> Bool)
-> (SwitchStatement -> SwitchStatement -> Bool)
-> (SwitchStatement -> SwitchStatement -> SwitchStatement)
-> (SwitchStatement -> SwitchStatement -> SwitchStatement)
-> Ord SwitchStatement
SwitchStatement -> SwitchStatement -> Bool
SwitchStatement -> SwitchStatement -> Ordering
SwitchStatement -> SwitchStatement -> SwitchStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SwitchStatement -> SwitchStatement -> Ordering
compare :: SwitchStatement -> SwitchStatement -> Ordering
$c< :: SwitchStatement -> SwitchStatement -> Bool
< :: SwitchStatement -> SwitchStatement -> Bool
$c<= :: SwitchStatement -> SwitchStatement -> Bool
<= :: SwitchStatement -> SwitchStatement -> Bool
$c> :: SwitchStatement -> SwitchStatement -> Bool
> :: SwitchStatement -> SwitchStatement -> Bool
$c>= :: SwitchStatement -> SwitchStatement -> Bool
>= :: SwitchStatement -> SwitchStatement -> Bool
$cmax :: SwitchStatement -> SwitchStatement -> SwitchStatement
max :: SwitchStatement -> SwitchStatement -> SwitchStatement
$cmin :: SwitchStatement -> SwitchStatement -> SwitchStatement
min :: SwitchStatement -> SwitchStatement -> SwitchStatement
Ord, ReadPrec [SwitchStatement]
ReadPrec SwitchStatement
Int -> ReadS SwitchStatement
ReadS [SwitchStatement]
(Int -> ReadS SwitchStatement)
-> ReadS [SwitchStatement]
-> ReadPrec SwitchStatement
-> ReadPrec [SwitchStatement]
-> Read SwitchStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SwitchStatement
readsPrec :: Int -> ReadS SwitchStatement
$creadList :: ReadS [SwitchStatement]
readList :: ReadS [SwitchStatement]
$creadPrec :: ReadPrec SwitchStatement
readPrec :: ReadPrec SwitchStatement
$creadListPrec :: ReadPrec [SwitchStatement]
readListPrec :: ReadPrec [SwitchStatement]
Read, Int -> SwitchStatement -> String -> String
[SwitchStatement] -> String -> String
SwitchStatement -> String
(Int -> SwitchStatement -> String -> String)
-> (SwitchStatement -> String)
-> ([SwitchStatement] -> String -> String)
-> Show SwitchStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SwitchStatement -> String -> String
showsPrec :: Int -> SwitchStatement -> String -> String
$cshow :: SwitchStatement -> String
show :: SwitchStatement -> String
$cshowList :: [SwitchStatement] -> String -> String
showList :: [SwitchStatement] -> String -> String
Show)

_SwitchStatement :: Name
_SwitchStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SwitchStatement")

_SwitchStatement_expression :: Name
_SwitchStatement_expression = (String -> Name
Core.Name String
"expression")

_SwitchStatement_branches :: Name
_SwitchStatement_branches = (String -> Name
Core.Name String
"branches")

data SwitchSection = 
  SwitchSection {
    SwitchSection -> [SwitchLabel]
switchSectionLabels :: [SwitchLabel],
    SwitchSection -> [Statement]
switchSectionStatements :: [Statement]}
  deriving (SwitchSection -> SwitchSection -> Bool
(SwitchSection -> SwitchSection -> Bool)
-> (SwitchSection -> SwitchSection -> Bool) -> Eq SwitchSection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SwitchSection -> SwitchSection -> Bool
== :: SwitchSection -> SwitchSection -> Bool
$c/= :: SwitchSection -> SwitchSection -> Bool
/= :: SwitchSection -> SwitchSection -> Bool
Eq, Eq SwitchSection
Eq SwitchSection =>
(SwitchSection -> SwitchSection -> Ordering)
-> (SwitchSection -> SwitchSection -> Bool)
-> (SwitchSection -> SwitchSection -> Bool)
-> (SwitchSection -> SwitchSection -> Bool)
-> (SwitchSection -> SwitchSection -> Bool)
-> (SwitchSection -> SwitchSection -> SwitchSection)
-> (SwitchSection -> SwitchSection -> SwitchSection)
-> Ord SwitchSection
SwitchSection -> SwitchSection -> Bool
SwitchSection -> SwitchSection -> Ordering
SwitchSection -> SwitchSection -> SwitchSection
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SwitchSection -> SwitchSection -> Ordering
compare :: SwitchSection -> SwitchSection -> Ordering
$c< :: SwitchSection -> SwitchSection -> Bool
< :: SwitchSection -> SwitchSection -> Bool
$c<= :: SwitchSection -> SwitchSection -> Bool
<= :: SwitchSection -> SwitchSection -> Bool
$c> :: SwitchSection -> SwitchSection -> Bool
> :: SwitchSection -> SwitchSection -> Bool
$c>= :: SwitchSection -> SwitchSection -> Bool
>= :: SwitchSection -> SwitchSection -> Bool
$cmax :: SwitchSection -> SwitchSection -> SwitchSection
max :: SwitchSection -> SwitchSection -> SwitchSection
$cmin :: SwitchSection -> SwitchSection -> SwitchSection
min :: SwitchSection -> SwitchSection -> SwitchSection
Ord, ReadPrec [SwitchSection]
ReadPrec SwitchSection
Int -> ReadS SwitchSection
ReadS [SwitchSection]
(Int -> ReadS SwitchSection)
-> ReadS [SwitchSection]
-> ReadPrec SwitchSection
-> ReadPrec [SwitchSection]
-> Read SwitchSection
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SwitchSection
readsPrec :: Int -> ReadS SwitchSection
$creadList :: ReadS [SwitchSection]
readList :: ReadS [SwitchSection]
$creadPrec :: ReadPrec SwitchSection
readPrec :: ReadPrec SwitchSection
$creadListPrec :: ReadPrec [SwitchSection]
readListPrec :: ReadPrec [SwitchSection]
Read, Int -> SwitchSection -> String -> String
[SwitchSection] -> String -> String
SwitchSection -> String
(Int -> SwitchSection -> String -> String)
-> (SwitchSection -> String)
-> ([SwitchSection] -> String -> String)
-> Show SwitchSection
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SwitchSection -> String -> String
showsPrec :: Int -> SwitchSection -> String -> String
$cshow :: SwitchSection -> String
show :: SwitchSection -> String
$cshowList :: [SwitchSection] -> String -> String
showList :: [SwitchSection] -> String -> String
Show)

_SwitchSection :: Name
_SwitchSection = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SwitchSection")

_SwitchSection_labels :: Name
_SwitchSection_labels = (String -> Name
Core.Name String
"labels")

_SwitchSection_statements :: Name
_SwitchSection_statements = (String -> Name
Core.Name String
"statements")

data SwitchLabel = 
  SwitchLabelBranch SwitchBranch |
  SwitchLabelDefault 
  deriving (SwitchLabel -> SwitchLabel -> Bool
(SwitchLabel -> SwitchLabel -> Bool)
-> (SwitchLabel -> SwitchLabel -> Bool) -> Eq SwitchLabel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SwitchLabel -> SwitchLabel -> Bool
== :: SwitchLabel -> SwitchLabel -> Bool
$c/= :: SwitchLabel -> SwitchLabel -> Bool
/= :: SwitchLabel -> SwitchLabel -> Bool
Eq, Eq SwitchLabel
Eq SwitchLabel =>
(SwitchLabel -> SwitchLabel -> Ordering)
-> (SwitchLabel -> SwitchLabel -> Bool)
-> (SwitchLabel -> SwitchLabel -> Bool)
-> (SwitchLabel -> SwitchLabel -> Bool)
-> (SwitchLabel -> SwitchLabel -> Bool)
-> (SwitchLabel -> SwitchLabel -> SwitchLabel)
-> (SwitchLabel -> SwitchLabel -> SwitchLabel)
-> Ord SwitchLabel
SwitchLabel -> SwitchLabel -> Bool
SwitchLabel -> SwitchLabel -> Ordering
SwitchLabel -> SwitchLabel -> SwitchLabel
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SwitchLabel -> SwitchLabel -> Ordering
compare :: SwitchLabel -> SwitchLabel -> Ordering
$c< :: SwitchLabel -> SwitchLabel -> Bool
< :: SwitchLabel -> SwitchLabel -> Bool
$c<= :: SwitchLabel -> SwitchLabel -> Bool
<= :: SwitchLabel -> SwitchLabel -> Bool
$c> :: SwitchLabel -> SwitchLabel -> Bool
> :: SwitchLabel -> SwitchLabel -> Bool
$c>= :: SwitchLabel -> SwitchLabel -> Bool
>= :: SwitchLabel -> SwitchLabel -> Bool
$cmax :: SwitchLabel -> SwitchLabel -> SwitchLabel
max :: SwitchLabel -> SwitchLabel -> SwitchLabel
$cmin :: SwitchLabel -> SwitchLabel -> SwitchLabel
min :: SwitchLabel -> SwitchLabel -> SwitchLabel
Ord, ReadPrec [SwitchLabel]
ReadPrec SwitchLabel
Int -> ReadS SwitchLabel
ReadS [SwitchLabel]
(Int -> ReadS SwitchLabel)
-> ReadS [SwitchLabel]
-> ReadPrec SwitchLabel
-> ReadPrec [SwitchLabel]
-> Read SwitchLabel
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SwitchLabel
readsPrec :: Int -> ReadS SwitchLabel
$creadList :: ReadS [SwitchLabel]
readList :: ReadS [SwitchLabel]
$creadPrec :: ReadPrec SwitchLabel
readPrec :: ReadPrec SwitchLabel
$creadListPrec :: ReadPrec [SwitchLabel]
readListPrec :: ReadPrec [SwitchLabel]
Read, Int -> SwitchLabel -> String -> String
[SwitchLabel] -> String -> String
SwitchLabel -> String
(Int -> SwitchLabel -> String -> String)
-> (SwitchLabel -> String)
-> ([SwitchLabel] -> String -> String)
-> Show SwitchLabel
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SwitchLabel -> String -> String
showsPrec :: Int -> SwitchLabel -> String -> String
$cshow :: SwitchLabel -> String
show :: SwitchLabel -> String
$cshowList :: [SwitchLabel] -> String -> String
showList :: [SwitchLabel] -> String -> String
Show)

_SwitchLabel :: Name
_SwitchLabel = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SwitchLabel")

_SwitchLabel_branch :: Name
_SwitchLabel_branch = (String -> Name
Core.Name String
"branch")

_SwitchLabel_default :: Name
_SwitchLabel_default = (String -> Name
Core.Name String
"default")

data SwitchBranch = 
  SwitchBranch {
    SwitchBranch -> Pattern
switchBranchPattern :: Pattern,
    SwitchBranch -> Maybe Expression
switchBranchGuard :: (Maybe Expression)}
  deriving (SwitchBranch -> SwitchBranch -> Bool
(SwitchBranch -> SwitchBranch -> Bool)
-> (SwitchBranch -> SwitchBranch -> Bool) -> Eq SwitchBranch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SwitchBranch -> SwitchBranch -> Bool
== :: SwitchBranch -> SwitchBranch -> Bool
$c/= :: SwitchBranch -> SwitchBranch -> Bool
/= :: SwitchBranch -> SwitchBranch -> Bool
Eq, Eq SwitchBranch
Eq SwitchBranch =>
(SwitchBranch -> SwitchBranch -> Ordering)
-> (SwitchBranch -> SwitchBranch -> Bool)
-> (SwitchBranch -> SwitchBranch -> Bool)
-> (SwitchBranch -> SwitchBranch -> Bool)
-> (SwitchBranch -> SwitchBranch -> Bool)
-> (SwitchBranch -> SwitchBranch -> SwitchBranch)
-> (SwitchBranch -> SwitchBranch -> SwitchBranch)
-> Ord SwitchBranch
SwitchBranch -> SwitchBranch -> Bool
SwitchBranch -> SwitchBranch -> Ordering
SwitchBranch -> SwitchBranch -> SwitchBranch
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SwitchBranch -> SwitchBranch -> Ordering
compare :: SwitchBranch -> SwitchBranch -> Ordering
$c< :: SwitchBranch -> SwitchBranch -> Bool
< :: SwitchBranch -> SwitchBranch -> Bool
$c<= :: SwitchBranch -> SwitchBranch -> Bool
<= :: SwitchBranch -> SwitchBranch -> Bool
$c> :: SwitchBranch -> SwitchBranch -> Bool
> :: SwitchBranch -> SwitchBranch -> Bool
$c>= :: SwitchBranch -> SwitchBranch -> Bool
>= :: SwitchBranch -> SwitchBranch -> Bool
$cmax :: SwitchBranch -> SwitchBranch -> SwitchBranch
max :: SwitchBranch -> SwitchBranch -> SwitchBranch
$cmin :: SwitchBranch -> SwitchBranch -> SwitchBranch
min :: SwitchBranch -> SwitchBranch -> SwitchBranch
Ord, ReadPrec [SwitchBranch]
ReadPrec SwitchBranch
Int -> ReadS SwitchBranch
ReadS [SwitchBranch]
(Int -> ReadS SwitchBranch)
-> ReadS [SwitchBranch]
-> ReadPrec SwitchBranch
-> ReadPrec [SwitchBranch]
-> Read SwitchBranch
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SwitchBranch
readsPrec :: Int -> ReadS SwitchBranch
$creadList :: ReadS [SwitchBranch]
readList :: ReadS [SwitchBranch]
$creadPrec :: ReadPrec SwitchBranch
readPrec :: ReadPrec SwitchBranch
$creadListPrec :: ReadPrec [SwitchBranch]
readListPrec :: ReadPrec [SwitchBranch]
Read, Int -> SwitchBranch -> String -> String
[SwitchBranch] -> String -> String
SwitchBranch -> String
(Int -> SwitchBranch -> String -> String)
-> (SwitchBranch -> String)
-> ([SwitchBranch] -> String -> String)
-> Show SwitchBranch
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SwitchBranch -> String -> String
showsPrec :: Int -> SwitchBranch -> String -> String
$cshow :: SwitchBranch -> String
show :: SwitchBranch -> String
$cshowList :: [SwitchBranch] -> String -> String
showList :: [SwitchBranch] -> String -> String
Show)

_SwitchBranch :: Name
_SwitchBranch = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SwitchBranch")

_SwitchBranch_pattern :: Name
_SwitchBranch_pattern = (String -> Name
Core.Name String
"pattern")

_SwitchBranch_guard :: Name
_SwitchBranch_guard = (String -> Name
Core.Name String
"guard")

data IterationStatement = 
  IterationStatementWhile WhileStatement |
  IterationStatementDo DoStatement |
  IterationStatementFor ForStatement |
  IterationStatementForeach ForeachStatement
  deriving (IterationStatement -> IterationStatement -> Bool
(IterationStatement -> IterationStatement -> Bool)
-> (IterationStatement -> IterationStatement -> Bool)
-> Eq IterationStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IterationStatement -> IterationStatement -> Bool
== :: IterationStatement -> IterationStatement -> Bool
$c/= :: IterationStatement -> IterationStatement -> Bool
/= :: IterationStatement -> IterationStatement -> Bool
Eq, Eq IterationStatement
Eq IterationStatement =>
(IterationStatement -> IterationStatement -> Ordering)
-> (IterationStatement -> IterationStatement -> Bool)
-> (IterationStatement -> IterationStatement -> Bool)
-> (IterationStatement -> IterationStatement -> Bool)
-> (IterationStatement -> IterationStatement -> Bool)
-> (IterationStatement -> IterationStatement -> IterationStatement)
-> (IterationStatement -> IterationStatement -> IterationStatement)
-> Ord IterationStatement
IterationStatement -> IterationStatement -> Bool
IterationStatement -> IterationStatement -> Ordering
IterationStatement -> IterationStatement -> IterationStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IterationStatement -> IterationStatement -> Ordering
compare :: IterationStatement -> IterationStatement -> Ordering
$c< :: IterationStatement -> IterationStatement -> Bool
< :: IterationStatement -> IterationStatement -> Bool
$c<= :: IterationStatement -> IterationStatement -> Bool
<= :: IterationStatement -> IterationStatement -> Bool
$c> :: IterationStatement -> IterationStatement -> Bool
> :: IterationStatement -> IterationStatement -> Bool
$c>= :: IterationStatement -> IterationStatement -> Bool
>= :: IterationStatement -> IterationStatement -> Bool
$cmax :: IterationStatement -> IterationStatement -> IterationStatement
max :: IterationStatement -> IterationStatement -> IterationStatement
$cmin :: IterationStatement -> IterationStatement -> IterationStatement
min :: IterationStatement -> IterationStatement -> IterationStatement
Ord, ReadPrec [IterationStatement]
ReadPrec IterationStatement
Int -> ReadS IterationStatement
ReadS [IterationStatement]
(Int -> ReadS IterationStatement)
-> ReadS [IterationStatement]
-> ReadPrec IterationStatement
-> ReadPrec [IterationStatement]
-> Read IterationStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IterationStatement
readsPrec :: Int -> ReadS IterationStatement
$creadList :: ReadS [IterationStatement]
readList :: ReadS [IterationStatement]
$creadPrec :: ReadPrec IterationStatement
readPrec :: ReadPrec IterationStatement
$creadListPrec :: ReadPrec [IterationStatement]
readListPrec :: ReadPrec [IterationStatement]
Read, Int -> IterationStatement -> String -> String
[IterationStatement] -> String -> String
IterationStatement -> String
(Int -> IterationStatement -> String -> String)
-> (IterationStatement -> String)
-> ([IterationStatement] -> String -> String)
-> Show IterationStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IterationStatement -> String -> String
showsPrec :: Int -> IterationStatement -> String -> String
$cshow :: IterationStatement -> String
show :: IterationStatement -> String
$cshowList :: [IterationStatement] -> String -> String
showList :: [IterationStatement] -> String -> String
Show)

_IterationStatement :: Name
_IterationStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IterationStatement")

_IterationStatement_while :: Name
_IterationStatement_while = (String -> Name
Core.Name String
"while")

_IterationStatement_do :: Name
_IterationStatement_do = (String -> Name
Core.Name String
"do")

_IterationStatement_for :: Name
_IterationStatement_for = (String -> Name
Core.Name String
"for")

_IterationStatement_foreach :: Name
_IterationStatement_foreach = (String -> Name
Core.Name String
"foreach")

data WhileStatement = 
  WhileStatement {
    WhileStatement -> BooleanExpression
whileStatementCondition :: BooleanExpression,
    WhileStatement -> EmbeddedStatement
whileStatementBody :: EmbeddedStatement}
  deriving (WhileStatement -> WhileStatement -> Bool
(WhileStatement -> WhileStatement -> Bool)
-> (WhileStatement -> WhileStatement -> Bool) -> Eq WhileStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WhileStatement -> WhileStatement -> Bool
== :: WhileStatement -> WhileStatement -> Bool
$c/= :: WhileStatement -> WhileStatement -> Bool
/= :: WhileStatement -> WhileStatement -> Bool
Eq, Eq WhileStatement
Eq WhileStatement =>
(WhileStatement -> WhileStatement -> Ordering)
-> (WhileStatement -> WhileStatement -> Bool)
-> (WhileStatement -> WhileStatement -> Bool)
-> (WhileStatement -> WhileStatement -> Bool)
-> (WhileStatement -> WhileStatement -> Bool)
-> (WhileStatement -> WhileStatement -> WhileStatement)
-> (WhileStatement -> WhileStatement -> WhileStatement)
-> Ord WhileStatement
WhileStatement -> WhileStatement -> Bool
WhileStatement -> WhileStatement -> Ordering
WhileStatement -> WhileStatement -> WhileStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: WhileStatement -> WhileStatement -> Ordering
compare :: WhileStatement -> WhileStatement -> Ordering
$c< :: WhileStatement -> WhileStatement -> Bool
< :: WhileStatement -> WhileStatement -> Bool
$c<= :: WhileStatement -> WhileStatement -> Bool
<= :: WhileStatement -> WhileStatement -> Bool
$c> :: WhileStatement -> WhileStatement -> Bool
> :: WhileStatement -> WhileStatement -> Bool
$c>= :: WhileStatement -> WhileStatement -> Bool
>= :: WhileStatement -> WhileStatement -> Bool
$cmax :: WhileStatement -> WhileStatement -> WhileStatement
max :: WhileStatement -> WhileStatement -> WhileStatement
$cmin :: WhileStatement -> WhileStatement -> WhileStatement
min :: WhileStatement -> WhileStatement -> WhileStatement
Ord, ReadPrec [WhileStatement]
ReadPrec WhileStatement
Int -> ReadS WhileStatement
ReadS [WhileStatement]
(Int -> ReadS WhileStatement)
-> ReadS [WhileStatement]
-> ReadPrec WhileStatement
-> ReadPrec [WhileStatement]
-> Read WhileStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS WhileStatement
readsPrec :: Int -> ReadS WhileStatement
$creadList :: ReadS [WhileStatement]
readList :: ReadS [WhileStatement]
$creadPrec :: ReadPrec WhileStatement
readPrec :: ReadPrec WhileStatement
$creadListPrec :: ReadPrec [WhileStatement]
readListPrec :: ReadPrec [WhileStatement]
Read, Int -> WhileStatement -> String -> String
[WhileStatement] -> String -> String
WhileStatement -> String
(Int -> WhileStatement -> String -> String)
-> (WhileStatement -> String)
-> ([WhileStatement] -> String -> String)
-> Show WhileStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> WhileStatement -> String -> String
showsPrec :: Int -> WhileStatement -> String -> String
$cshow :: WhileStatement -> String
show :: WhileStatement -> String
$cshowList :: [WhileStatement] -> String -> String
showList :: [WhileStatement] -> String -> String
Show)

_WhileStatement :: Name
_WhileStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.WhileStatement")

_WhileStatement_condition :: Name
_WhileStatement_condition = (String -> Name
Core.Name String
"condition")

_WhileStatement_body :: Name
_WhileStatement_body = (String -> Name
Core.Name String
"body")

data DoStatement = 
  DoStatement {
    DoStatement -> EmbeddedStatement
doStatementBody :: EmbeddedStatement,
    DoStatement -> BooleanExpression
doStatementWhile :: BooleanExpression}
  deriving (DoStatement -> DoStatement -> Bool
(DoStatement -> DoStatement -> Bool)
-> (DoStatement -> DoStatement -> Bool) -> Eq DoStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DoStatement -> DoStatement -> Bool
== :: DoStatement -> DoStatement -> Bool
$c/= :: DoStatement -> DoStatement -> Bool
/= :: DoStatement -> DoStatement -> Bool
Eq, Eq DoStatement
Eq DoStatement =>
(DoStatement -> DoStatement -> Ordering)
-> (DoStatement -> DoStatement -> Bool)
-> (DoStatement -> DoStatement -> Bool)
-> (DoStatement -> DoStatement -> Bool)
-> (DoStatement -> DoStatement -> Bool)
-> (DoStatement -> DoStatement -> DoStatement)
-> (DoStatement -> DoStatement -> DoStatement)
-> Ord DoStatement
DoStatement -> DoStatement -> Bool
DoStatement -> DoStatement -> Ordering
DoStatement -> DoStatement -> DoStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DoStatement -> DoStatement -> Ordering
compare :: DoStatement -> DoStatement -> Ordering
$c< :: DoStatement -> DoStatement -> Bool
< :: DoStatement -> DoStatement -> Bool
$c<= :: DoStatement -> DoStatement -> Bool
<= :: DoStatement -> DoStatement -> Bool
$c> :: DoStatement -> DoStatement -> Bool
> :: DoStatement -> DoStatement -> Bool
$c>= :: DoStatement -> DoStatement -> Bool
>= :: DoStatement -> DoStatement -> Bool
$cmax :: DoStatement -> DoStatement -> DoStatement
max :: DoStatement -> DoStatement -> DoStatement
$cmin :: DoStatement -> DoStatement -> DoStatement
min :: DoStatement -> DoStatement -> DoStatement
Ord, ReadPrec [DoStatement]
ReadPrec DoStatement
Int -> ReadS DoStatement
ReadS [DoStatement]
(Int -> ReadS DoStatement)
-> ReadS [DoStatement]
-> ReadPrec DoStatement
-> ReadPrec [DoStatement]
-> Read DoStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DoStatement
readsPrec :: Int -> ReadS DoStatement
$creadList :: ReadS [DoStatement]
readList :: ReadS [DoStatement]
$creadPrec :: ReadPrec DoStatement
readPrec :: ReadPrec DoStatement
$creadListPrec :: ReadPrec [DoStatement]
readListPrec :: ReadPrec [DoStatement]
Read, Int -> DoStatement -> String -> String
[DoStatement] -> String -> String
DoStatement -> String
(Int -> DoStatement -> String -> String)
-> (DoStatement -> String)
-> ([DoStatement] -> String -> String)
-> Show DoStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DoStatement -> String -> String
showsPrec :: Int -> DoStatement -> String -> String
$cshow :: DoStatement -> String
show :: DoStatement -> String
$cshowList :: [DoStatement] -> String -> String
showList :: [DoStatement] -> String -> String
Show)

_DoStatement :: Name
_DoStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DoStatement")

_DoStatement_body :: Name
_DoStatement_body = (String -> Name
Core.Name String
"body")

_DoStatement_while :: Name
_DoStatement_while = (String -> Name
Core.Name String
"while")

data ForStatement = 
  ForStatement {
    ForStatement -> Maybe ForInitializer
forStatementInitializer :: (Maybe ForInitializer),
    ForStatement -> Maybe BooleanExpression
forStatementCondition :: (Maybe BooleanExpression),
    ForStatement -> Maybe StatementExpressionList
forStatementIterator :: (Maybe StatementExpressionList),
    ForStatement -> EmbeddedStatement
forStatementBody :: EmbeddedStatement}
  deriving (ForStatement -> ForStatement -> Bool
(ForStatement -> ForStatement -> Bool)
-> (ForStatement -> ForStatement -> Bool) -> Eq ForStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForStatement -> ForStatement -> Bool
== :: ForStatement -> ForStatement -> Bool
$c/= :: ForStatement -> ForStatement -> Bool
/= :: ForStatement -> ForStatement -> Bool
Eq, Eq ForStatement
Eq ForStatement =>
(ForStatement -> ForStatement -> Ordering)
-> (ForStatement -> ForStatement -> Bool)
-> (ForStatement -> ForStatement -> Bool)
-> (ForStatement -> ForStatement -> Bool)
-> (ForStatement -> ForStatement -> Bool)
-> (ForStatement -> ForStatement -> ForStatement)
-> (ForStatement -> ForStatement -> ForStatement)
-> Ord ForStatement
ForStatement -> ForStatement -> Bool
ForStatement -> ForStatement -> Ordering
ForStatement -> ForStatement -> ForStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ForStatement -> ForStatement -> Ordering
compare :: ForStatement -> ForStatement -> Ordering
$c< :: ForStatement -> ForStatement -> Bool
< :: ForStatement -> ForStatement -> Bool
$c<= :: ForStatement -> ForStatement -> Bool
<= :: ForStatement -> ForStatement -> Bool
$c> :: ForStatement -> ForStatement -> Bool
> :: ForStatement -> ForStatement -> Bool
$c>= :: ForStatement -> ForStatement -> Bool
>= :: ForStatement -> ForStatement -> Bool
$cmax :: ForStatement -> ForStatement -> ForStatement
max :: ForStatement -> ForStatement -> ForStatement
$cmin :: ForStatement -> ForStatement -> ForStatement
min :: ForStatement -> ForStatement -> ForStatement
Ord, ReadPrec [ForStatement]
ReadPrec ForStatement
Int -> ReadS ForStatement
ReadS [ForStatement]
(Int -> ReadS ForStatement)
-> ReadS [ForStatement]
-> ReadPrec ForStatement
-> ReadPrec [ForStatement]
-> Read ForStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ForStatement
readsPrec :: Int -> ReadS ForStatement
$creadList :: ReadS [ForStatement]
readList :: ReadS [ForStatement]
$creadPrec :: ReadPrec ForStatement
readPrec :: ReadPrec ForStatement
$creadListPrec :: ReadPrec [ForStatement]
readListPrec :: ReadPrec [ForStatement]
Read, Int -> ForStatement -> String -> String
[ForStatement] -> String -> String
ForStatement -> String
(Int -> ForStatement -> String -> String)
-> (ForStatement -> String)
-> ([ForStatement] -> String -> String)
-> Show ForStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ForStatement -> String -> String
showsPrec :: Int -> ForStatement -> String -> String
$cshow :: ForStatement -> String
show :: ForStatement -> String
$cshowList :: [ForStatement] -> String -> String
showList :: [ForStatement] -> String -> String
Show)

_ForStatement :: Name
_ForStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ForStatement")

_ForStatement_initializer :: Name
_ForStatement_initializer = (String -> Name
Core.Name String
"initializer")

_ForStatement_condition :: Name
_ForStatement_condition = (String -> Name
Core.Name String
"condition")

_ForStatement_iterator :: Name
_ForStatement_iterator = (String -> Name
Core.Name String
"iterator")

_ForStatement_body :: Name
_ForStatement_body = (String -> Name
Core.Name String
"body")

data ForInitializer = 
  ForInitializerVariable LocalVariableDeclaration |
  ForInitializerStatements StatementExpressionList
  deriving (ForInitializer -> ForInitializer -> Bool
(ForInitializer -> ForInitializer -> Bool)
-> (ForInitializer -> ForInitializer -> Bool) -> Eq ForInitializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForInitializer -> ForInitializer -> Bool
== :: ForInitializer -> ForInitializer -> Bool
$c/= :: ForInitializer -> ForInitializer -> Bool
/= :: ForInitializer -> ForInitializer -> Bool
Eq, Eq ForInitializer
Eq ForInitializer =>
(ForInitializer -> ForInitializer -> Ordering)
-> (ForInitializer -> ForInitializer -> Bool)
-> (ForInitializer -> ForInitializer -> Bool)
-> (ForInitializer -> ForInitializer -> Bool)
-> (ForInitializer -> ForInitializer -> Bool)
-> (ForInitializer -> ForInitializer -> ForInitializer)
-> (ForInitializer -> ForInitializer -> ForInitializer)
-> Ord ForInitializer
ForInitializer -> ForInitializer -> Bool
ForInitializer -> ForInitializer -> Ordering
ForInitializer -> ForInitializer -> ForInitializer
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ForInitializer -> ForInitializer -> Ordering
compare :: ForInitializer -> ForInitializer -> Ordering
$c< :: ForInitializer -> ForInitializer -> Bool
< :: ForInitializer -> ForInitializer -> Bool
$c<= :: ForInitializer -> ForInitializer -> Bool
<= :: ForInitializer -> ForInitializer -> Bool
$c> :: ForInitializer -> ForInitializer -> Bool
> :: ForInitializer -> ForInitializer -> Bool
$c>= :: ForInitializer -> ForInitializer -> Bool
>= :: ForInitializer -> ForInitializer -> Bool
$cmax :: ForInitializer -> ForInitializer -> ForInitializer
max :: ForInitializer -> ForInitializer -> ForInitializer
$cmin :: ForInitializer -> ForInitializer -> ForInitializer
min :: ForInitializer -> ForInitializer -> ForInitializer
Ord, ReadPrec [ForInitializer]
ReadPrec ForInitializer
Int -> ReadS ForInitializer
ReadS [ForInitializer]
(Int -> ReadS ForInitializer)
-> ReadS [ForInitializer]
-> ReadPrec ForInitializer
-> ReadPrec [ForInitializer]
-> Read ForInitializer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ForInitializer
readsPrec :: Int -> ReadS ForInitializer
$creadList :: ReadS [ForInitializer]
readList :: ReadS [ForInitializer]
$creadPrec :: ReadPrec ForInitializer
readPrec :: ReadPrec ForInitializer
$creadListPrec :: ReadPrec [ForInitializer]
readListPrec :: ReadPrec [ForInitializer]
Read, Int -> ForInitializer -> String -> String
[ForInitializer] -> String -> String
ForInitializer -> String
(Int -> ForInitializer -> String -> String)
-> (ForInitializer -> String)
-> ([ForInitializer] -> String -> String)
-> Show ForInitializer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ForInitializer -> String -> String
showsPrec :: Int -> ForInitializer -> String -> String
$cshow :: ForInitializer -> String
show :: ForInitializer -> String
$cshowList :: [ForInitializer] -> String -> String
showList :: [ForInitializer] -> String -> String
Show)

_ForInitializer :: Name
_ForInitializer = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ForInitializer")

_ForInitializer_variable :: Name
_ForInitializer_variable = (String -> Name
Core.Name String
"variable")

_ForInitializer_statements :: Name
_ForInitializer_statements = (String -> Name
Core.Name String
"statements")

newtype StatementExpressionList = 
  StatementExpressionList {
    StatementExpressionList -> [StatementExpression]
unStatementExpressionList :: [StatementExpression]}
  deriving (StatementExpressionList -> StatementExpressionList -> Bool
(StatementExpressionList -> StatementExpressionList -> Bool)
-> (StatementExpressionList -> StatementExpressionList -> Bool)
-> Eq StatementExpressionList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StatementExpressionList -> StatementExpressionList -> Bool
== :: StatementExpressionList -> StatementExpressionList -> Bool
$c/= :: StatementExpressionList -> StatementExpressionList -> Bool
/= :: StatementExpressionList -> StatementExpressionList -> Bool
Eq, Eq StatementExpressionList
Eq StatementExpressionList =>
(StatementExpressionList -> StatementExpressionList -> Ordering)
-> (StatementExpressionList -> StatementExpressionList -> Bool)
-> (StatementExpressionList -> StatementExpressionList -> Bool)
-> (StatementExpressionList -> StatementExpressionList -> Bool)
-> (StatementExpressionList -> StatementExpressionList -> Bool)
-> (StatementExpressionList
    -> StatementExpressionList -> StatementExpressionList)
-> (StatementExpressionList
    -> StatementExpressionList -> StatementExpressionList)
-> Ord StatementExpressionList
StatementExpressionList -> StatementExpressionList -> Bool
StatementExpressionList -> StatementExpressionList -> Ordering
StatementExpressionList
-> StatementExpressionList -> StatementExpressionList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StatementExpressionList -> StatementExpressionList -> Ordering
compare :: StatementExpressionList -> StatementExpressionList -> Ordering
$c< :: StatementExpressionList -> StatementExpressionList -> Bool
< :: StatementExpressionList -> StatementExpressionList -> Bool
$c<= :: StatementExpressionList -> StatementExpressionList -> Bool
<= :: StatementExpressionList -> StatementExpressionList -> Bool
$c> :: StatementExpressionList -> StatementExpressionList -> Bool
> :: StatementExpressionList -> StatementExpressionList -> Bool
$c>= :: StatementExpressionList -> StatementExpressionList -> Bool
>= :: StatementExpressionList -> StatementExpressionList -> Bool
$cmax :: StatementExpressionList
-> StatementExpressionList -> StatementExpressionList
max :: StatementExpressionList
-> StatementExpressionList -> StatementExpressionList
$cmin :: StatementExpressionList
-> StatementExpressionList -> StatementExpressionList
min :: StatementExpressionList
-> StatementExpressionList -> StatementExpressionList
Ord, ReadPrec [StatementExpressionList]
ReadPrec StatementExpressionList
Int -> ReadS StatementExpressionList
ReadS [StatementExpressionList]
(Int -> ReadS StatementExpressionList)
-> ReadS [StatementExpressionList]
-> ReadPrec StatementExpressionList
-> ReadPrec [StatementExpressionList]
-> Read StatementExpressionList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StatementExpressionList
readsPrec :: Int -> ReadS StatementExpressionList
$creadList :: ReadS [StatementExpressionList]
readList :: ReadS [StatementExpressionList]
$creadPrec :: ReadPrec StatementExpressionList
readPrec :: ReadPrec StatementExpressionList
$creadListPrec :: ReadPrec [StatementExpressionList]
readListPrec :: ReadPrec [StatementExpressionList]
Read, Int -> StatementExpressionList -> String -> String
[StatementExpressionList] -> String -> String
StatementExpressionList -> String
(Int -> StatementExpressionList -> String -> String)
-> (StatementExpressionList -> String)
-> ([StatementExpressionList] -> String -> String)
-> Show StatementExpressionList
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StatementExpressionList -> String -> String
showsPrec :: Int -> StatementExpressionList -> String -> String
$cshow :: StatementExpressionList -> String
show :: StatementExpressionList -> String
$cshowList :: [StatementExpressionList] -> String -> String
showList :: [StatementExpressionList] -> String -> String
Show)

_StatementExpressionList :: Name
_StatementExpressionList = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StatementExpressionList")

data ForeachStatement = 
  ForeachStatement {
    ForeachStatement -> Maybe RefKind
foreachStatementKind :: (Maybe RefKind),
    ForeachStatement -> LocalVariableType
foreachStatementType :: LocalVariableType,
    ForeachStatement -> Identifier
foreachStatementIdentifier :: Identifier,
    ForeachStatement -> Expression
foreachStatementExpression :: Expression,
    ForeachStatement -> EmbeddedStatement
foreachStatementBody :: EmbeddedStatement}
  deriving (ForeachStatement -> ForeachStatement -> Bool
(ForeachStatement -> ForeachStatement -> Bool)
-> (ForeachStatement -> ForeachStatement -> Bool)
-> Eq ForeachStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeachStatement -> ForeachStatement -> Bool
== :: ForeachStatement -> ForeachStatement -> Bool
$c/= :: ForeachStatement -> ForeachStatement -> Bool
/= :: ForeachStatement -> ForeachStatement -> Bool
Eq, Eq ForeachStatement
Eq ForeachStatement =>
(ForeachStatement -> ForeachStatement -> Ordering)
-> (ForeachStatement -> ForeachStatement -> Bool)
-> (ForeachStatement -> ForeachStatement -> Bool)
-> (ForeachStatement -> ForeachStatement -> Bool)
-> (ForeachStatement -> ForeachStatement -> Bool)
-> (ForeachStatement -> ForeachStatement -> ForeachStatement)
-> (ForeachStatement -> ForeachStatement -> ForeachStatement)
-> Ord ForeachStatement
ForeachStatement -> ForeachStatement -> Bool
ForeachStatement -> ForeachStatement -> Ordering
ForeachStatement -> ForeachStatement -> ForeachStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ForeachStatement -> ForeachStatement -> Ordering
compare :: ForeachStatement -> ForeachStatement -> Ordering
$c< :: ForeachStatement -> ForeachStatement -> Bool
< :: ForeachStatement -> ForeachStatement -> Bool
$c<= :: ForeachStatement -> ForeachStatement -> Bool
<= :: ForeachStatement -> ForeachStatement -> Bool
$c> :: ForeachStatement -> ForeachStatement -> Bool
> :: ForeachStatement -> ForeachStatement -> Bool
$c>= :: ForeachStatement -> ForeachStatement -> Bool
>= :: ForeachStatement -> ForeachStatement -> Bool
$cmax :: ForeachStatement -> ForeachStatement -> ForeachStatement
max :: ForeachStatement -> ForeachStatement -> ForeachStatement
$cmin :: ForeachStatement -> ForeachStatement -> ForeachStatement
min :: ForeachStatement -> ForeachStatement -> ForeachStatement
Ord, ReadPrec [ForeachStatement]
ReadPrec ForeachStatement
Int -> ReadS ForeachStatement
ReadS [ForeachStatement]
(Int -> ReadS ForeachStatement)
-> ReadS [ForeachStatement]
-> ReadPrec ForeachStatement
-> ReadPrec [ForeachStatement]
-> Read ForeachStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ForeachStatement
readsPrec :: Int -> ReadS ForeachStatement
$creadList :: ReadS [ForeachStatement]
readList :: ReadS [ForeachStatement]
$creadPrec :: ReadPrec ForeachStatement
readPrec :: ReadPrec ForeachStatement
$creadListPrec :: ReadPrec [ForeachStatement]
readListPrec :: ReadPrec [ForeachStatement]
Read, Int -> ForeachStatement -> String -> String
[ForeachStatement] -> String -> String
ForeachStatement -> String
(Int -> ForeachStatement -> String -> String)
-> (ForeachStatement -> String)
-> ([ForeachStatement] -> String -> String)
-> Show ForeachStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ForeachStatement -> String -> String
showsPrec :: Int -> ForeachStatement -> String -> String
$cshow :: ForeachStatement -> String
show :: ForeachStatement -> String
$cshowList :: [ForeachStatement] -> String -> String
showList :: [ForeachStatement] -> String -> String
Show)

_ForeachStatement :: Name
_ForeachStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ForeachStatement")

_ForeachStatement_kind :: Name
_ForeachStatement_kind = (String -> Name
Core.Name String
"kind")

_ForeachStatement_type :: Name
_ForeachStatement_type = (String -> Name
Core.Name String
"type")

_ForeachStatement_identifier :: Name
_ForeachStatement_identifier = (String -> Name
Core.Name String
"identifier")

_ForeachStatement_expression :: Name
_ForeachStatement_expression = (String -> Name
Core.Name String
"expression")

_ForeachStatement_body :: Name
_ForeachStatement_body = (String -> Name
Core.Name String
"body")

data JumpStatement = 
  JumpStatementBreak  |
  JumpStatementContinue  |
  JumpStatementGoto GotoStatement |
  JumpStatementReturn ReturnStatement |
  JumpStatementThrow (Maybe Expression)
  deriving (JumpStatement -> JumpStatement -> Bool
(JumpStatement -> JumpStatement -> Bool)
-> (JumpStatement -> JumpStatement -> Bool) -> Eq JumpStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: JumpStatement -> JumpStatement -> Bool
== :: JumpStatement -> JumpStatement -> Bool
$c/= :: JumpStatement -> JumpStatement -> Bool
/= :: JumpStatement -> JumpStatement -> Bool
Eq, Eq JumpStatement
Eq JumpStatement =>
(JumpStatement -> JumpStatement -> Ordering)
-> (JumpStatement -> JumpStatement -> Bool)
-> (JumpStatement -> JumpStatement -> Bool)
-> (JumpStatement -> JumpStatement -> Bool)
-> (JumpStatement -> JumpStatement -> Bool)
-> (JumpStatement -> JumpStatement -> JumpStatement)
-> (JumpStatement -> JumpStatement -> JumpStatement)
-> Ord JumpStatement
JumpStatement -> JumpStatement -> Bool
JumpStatement -> JumpStatement -> Ordering
JumpStatement -> JumpStatement -> JumpStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: JumpStatement -> JumpStatement -> Ordering
compare :: JumpStatement -> JumpStatement -> Ordering
$c< :: JumpStatement -> JumpStatement -> Bool
< :: JumpStatement -> JumpStatement -> Bool
$c<= :: JumpStatement -> JumpStatement -> Bool
<= :: JumpStatement -> JumpStatement -> Bool
$c> :: JumpStatement -> JumpStatement -> Bool
> :: JumpStatement -> JumpStatement -> Bool
$c>= :: JumpStatement -> JumpStatement -> Bool
>= :: JumpStatement -> JumpStatement -> Bool
$cmax :: JumpStatement -> JumpStatement -> JumpStatement
max :: JumpStatement -> JumpStatement -> JumpStatement
$cmin :: JumpStatement -> JumpStatement -> JumpStatement
min :: JumpStatement -> JumpStatement -> JumpStatement
Ord, ReadPrec [JumpStatement]
ReadPrec JumpStatement
Int -> ReadS JumpStatement
ReadS [JumpStatement]
(Int -> ReadS JumpStatement)
-> ReadS [JumpStatement]
-> ReadPrec JumpStatement
-> ReadPrec [JumpStatement]
-> Read JumpStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS JumpStatement
readsPrec :: Int -> ReadS JumpStatement
$creadList :: ReadS [JumpStatement]
readList :: ReadS [JumpStatement]
$creadPrec :: ReadPrec JumpStatement
readPrec :: ReadPrec JumpStatement
$creadListPrec :: ReadPrec [JumpStatement]
readListPrec :: ReadPrec [JumpStatement]
Read, Int -> JumpStatement -> String -> String
[JumpStatement] -> String -> String
JumpStatement -> String
(Int -> JumpStatement -> String -> String)
-> (JumpStatement -> String)
-> ([JumpStatement] -> String -> String)
-> Show JumpStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> JumpStatement -> String -> String
showsPrec :: Int -> JumpStatement -> String -> String
$cshow :: JumpStatement -> String
show :: JumpStatement -> String
$cshowList :: [JumpStatement] -> String -> String
showList :: [JumpStatement] -> String -> String
Show)

_JumpStatement :: Name
_JumpStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.JumpStatement")

_JumpStatement_break :: Name
_JumpStatement_break = (String -> Name
Core.Name String
"break")

_JumpStatement_continue :: Name
_JumpStatement_continue = (String -> Name
Core.Name String
"continue")

_JumpStatement_goto :: Name
_JumpStatement_goto = (String -> Name
Core.Name String
"goto")

_JumpStatement_return :: Name
_JumpStatement_return = (String -> Name
Core.Name String
"return")

_JumpStatement_throw :: Name
_JumpStatement_throw = (String -> Name
Core.Name String
"throw")

data GotoStatement = 
  GotoStatementIdentifier Identifier |
  GotoStatementCase ConstantExpression |
  GotoStatementDefault 
  deriving (GotoStatement -> GotoStatement -> Bool
(GotoStatement -> GotoStatement -> Bool)
-> (GotoStatement -> GotoStatement -> Bool) -> Eq GotoStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GotoStatement -> GotoStatement -> Bool
== :: GotoStatement -> GotoStatement -> Bool
$c/= :: GotoStatement -> GotoStatement -> Bool
/= :: GotoStatement -> GotoStatement -> Bool
Eq, Eq GotoStatement
Eq GotoStatement =>
(GotoStatement -> GotoStatement -> Ordering)
-> (GotoStatement -> GotoStatement -> Bool)
-> (GotoStatement -> GotoStatement -> Bool)
-> (GotoStatement -> GotoStatement -> Bool)
-> (GotoStatement -> GotoStatement -> Bool)
-> (GotoStatement -> GotoStatement -> GotoStatement)
-> (GotoStatement -> GotoStatement -> GotoStatement)
-> Ord GotoStatement
GotoStatement -> GotoStatement -> Bool
GotoStatement -> GotoStatement -> Ordering
GotoStatement -> GotoStatement -> GotoStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GotoStatement -> GotoStatement -> Ordering
compare :: GotoStatement -> GotoStatement -> Ordering
$c< :: GotoStatement -> GotoStatement -> Bool
< :: GotoStatement -> GotoStatement -> Bool
$c<= :: GotoStatement -> GotoStatement -> Bool
<= :: GotoStatement -> GotoStatement -> Bool
$c> :: GotoStatement -> GotoStatement -> Bool
> :: GotoStatement -> GotoStatement -> Bool
$c>= :: GotoStatement -> GotoStatement -> Bool
>= :: GotoStatement -> GotoStatement -> Bool
$cmax :: GotoStatement -> GotoStatement -> GotoStatement
max :: GotoStatement -> GotoStatement -> GotoStatement
$cmin :: GotoStatement -> GotoStatement -> GotoStatement
min :: GotoStatement -> GotoStatement -> GotoStatement
Ord, ReadPrec [GotoStatement]
ReadPrec GotoStatement
Int -> ReadS GotoStatement
ReadS [GotoStatement]
(Int -> ReadS GotoStatement)
-> ReadS [GotoStatement]
-> ReadPrec GotoStatement
-> ReadPrec [GotoStatement]
-> Read GotoStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GotoStatement
readsPrec :: Int -> ReadS GotoStatement
$creadList :: ReadS [GotoStatement]
readList :: ReadS [GotoStatement]
$creadPrec :: ReadPrec GotoStatement
readPrec :: ReadPrec GotoStatement
$creadListPrec :: ReadPrec [GotoStatement]
readListPrec :: ReadPrec [GotoStatement]
Read, Int -> GotoStatement -> String -> String
[GotoStatement] -> String -> String
GotoStatement -> String
(Int -> GotoStatement -> String -> String)
-> (GotoStatement -> String)
-> ([GotoStatement] -> String -> String)
-> Show GotoStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> GotoStatement -> String -> String
showsPrec :: Int -> GotoStatement -> String -> String
$cshow :: GotoStatement -> String
show :: GotoStatement -> String
$cshowList :: [GotoStatement] -> String -> String
showList :: [GotoStatement] -> String -> String
Show)

_GotoStatement :: Name
_GotoStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.GotoStatement")

_GotoStatement_identifier :: Name
_GotoStatement_identifier = (String -> Name
Core.Name String
"identifier")

_GotoStatement_case :: Name
_GotoStatement_case = (String -> Name
Core.Name String
"case")

_GotoStatement_default :: Name
_GotoStatement_default = (String -> Name
Core.Name String
"default")

data ReturnStatement = 
  ReturnStatementSimple  |
  ReturnStatementValue Expression |
  ReturnStatementRef VariableReference
  deriving (ReturnStatement -> ReturnStatement -> Bool
(ReturnStatement -> ReturnStatement -> Bool)
-> (ReturnStatement -> ReturnStatement -> Bool)
-> Eq ReturnStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReturnStatement -> ReturnStatement -> Bool
== :: ReturnStatement -> ReturnStatement -> Bool
$c/= :: ReturnStatement -> ReturnStatement -> Bool
/= :: ReturnStatement -> ReturnStatement -> Bool
Eq, Eq ReturnStatement
Eq ReturnStatement =>
(ReturnStatement -> ReturnStatement -> Ordering)
-> (ReturnStatement -> ReturnStatement -> Bool)
-> (ReturnStatement -> ReturnStatement -> Bool)
-> (ReturnStatement -> ReturnStatement -> Bool)
-> (ReturnStatement -> ReturnStatement -> Bool)
-> (ReturnStatement -> ReturnStatement -> ReturnStatement)
-> (ReturnStatement -> ReturnStatement -> ReturnStatement)
-> Ord ReturnStatement
ReturnStatement -> ReturnStatement -> Bool
ReturnStatement -> ReturnStatement -> Ordering
ReturnStatement -> ReturnStatement -> ReturnStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ReturnStatement -> ReturnStatement -> Ordering
compare :: ReturnStatement -> ReturnStatement -> Ordering
$c< :: ReturnStatement -> ReturnStatement -> Bool
< :: ReturnStatement -> ReturnStatement -> Bool
$c<= :: ReturnStatement -> ReturnStatement -> Bool
<= :: ReturnStatement -> ReturnStatement -> Bool
$c> :: ReturnStatement -> ReturnStatement -> Bool
> :: ReturnStatement -> ReturnStatement -> Bool
$c>= :: ReturnStatement -> ReturnStatement -> Bool
>= :: ReturnStatement -> ReturnStatement -> Bool
$cmax :: ReturnStatement -> ReturnStatement -> ReturnStatement
max :: ReturnStatement -> ReturnStatement -> ReturnStatement
$cmin :: ReturnStatement -> ReturnStatement -> ReturnStatement
min :: ReturnStatement -> ReturnStatement -> ReturnStatement
Ord, ReadPrec [ReturnStatement]
ReadPrec ReturnStatement
Int -> ReadS ReturnStatement
ReadS [ReturnStatement]
(Int -> ReadS ReturnStatement)
-> ReadS [ReturnStatement]
-> ReadPrec ReturnStatement
-> ReadPrec [ReturnStatement]
-> Read ReturnStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ReturnStatement
readsPrec :: Int -> ReadS ReturnStatement
$creadList :: ReadS [ReturnStatement]
readList :: ReadS [ReturnStatement]
$creadPrec :: ReadPrec ReturnStatement
readPrec :: ReadPrec ReturnStatement
$creadListPrec :: ReadPrec [ReturnStatement]
readListPrec :: ReadPrec [ReturnStatement]
Read, Int -> ReturnStatement -> String -> String
[ReturnStatement] -> String -> String
ReturnStatement -> String
(Int -> ReturnStatement -> String -> String)
-> (ReturnStatement -> String)
-> ([ReturnStatement] -> String -> String)
-> Show ReturnStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ReturnStatement -> String -> String
showsPrec :: Int -> ReturnStatement -> String -> String
$cshow :: ReturnStatement -> String
show :: ReturnStatement -> String
$cshowList :: [ReturnStatement] -> String -> String
showList :: [ReturnStatement] -> String -> String
Show)

_ReturnStatement :: Name
_ReturnStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ReturnStatement")

_ReturnStatement_simple :: Name
_ReturnStatement_simple = (String -> Name
Core.Name String
"simple")

_ReturnStatement_value :: Name
_ReturnStatement_value = (String -> Name
Core.Name String
"value")

_ReturnStatement_ref :: Name
_ReturnStatement_ref = (String -> Name
Core.Name String
"ref")

data TryStatement = 
  TryStatement {
    TryStatement -> Block
tryStatementBody :: Block,
    TryStatement -> CatchClauses
tryStatementCatches :: CatchClauses,
    TryStatement -> Maybe Block
tryStatementFinally :: (Maybe Block)}
  deriving (TryStatement -> TryStatement -> Bool
(TryStatement -> TryStatement -> Bool)
-> (TryStatement -> TryStatement -> Bool) -> Eq TryStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TryStatement -> TryStatement -> Bool
== :: TryStatement -> TryStatement -> Bool
$c/= :: TryStatement -> TryStatement -> Bool
/= :: TryStatement -> TryStatement -> Bool
Eq, Eq TryStatement
Eq TryStatement =>
(TryStatement -> TryStatement -> Ordering)
-> (TryStatement -> TryStatement -> Bool)
-> (TryStatement -> TryStatement -> Bool)
-> (TryStatement -> TryStatement -> Bool)
-> (TryStatement -> TryStatement -> Bool)
-> (TryStatement -> TryStatement -> TryStatement)
-> (TryStatement -> TryStatement -> TryStatement)
-> Ord TryStatement
TryStatement -> TryStatement -> Bool
TryStatement -> TryStatement -> Ordering
TryStatement -> TryStatement -> TryStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TryStatement -> TryStatement -> Ordering
compare :: TryStatement -> TryStatement -> Ordering
$c< :: TryStatement -> TryStatement -> Bool
< :: TryStatement -> TryStatement -> Bool
$c<= :: TryStatement -> TryStatement -> Bool
<= :: TryStatement -> TryStatement -> Bool
$c> :: TryStatement -> TryStatement -> Bool
> :: TryStatement -> TryStatement -> Bool
$c>= :: TryStatement -> TryStatement -> Bool
>= :: TryStatement -> TryStatement -> Bool
$cmax :: TryStatement -> TryStatement -> TryStatement
max :: TryStatement -> TryStatement -> TryStatement
$cmin :: TryStatement -> TryStatement -> TryStatement
min :: TryStatement -> TryStatement -> TryStatement
Ord, ReadPrec [TryStatement]
ReadPrec TryStatement
Int -> ReadS TryStatement
ReadS [TryStatement]
(Int -> ReadS TryStatement)
-> ReadS [TryStatement]
-> ReadPrec TryStatement
-> ReadPrec [TryStatement]
-> Read TryStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TryStatement
readsPrec :: Int -> ReadS TryStatement
$creadList :: ReadS [TryStatement]
readList :: ReadS [TryStatement]
$creadPrec :: ReadPrec TryStatement
readPrec :: ReadPrec TryStatement
$creadListPrec :: ReadPrec [TryStatement]
readListPrec :: ReadPrec [TryStatement]
Read, Int -> TryStatement -> String -> String
[TryStatement] -> String -> String
TryStatement -> String
(Int -> TryStatement -> String -> String)
-> (TryStatement -> String)
-> ([TryStatement] -> String -> String)
-> Show TryStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TryStatement -> String -> String
showsPrec :: Int -> TryStatement -> String -> String
$cshow :: TryStatement -> String
show :: TryStatement -> String
$cshowList :: [TryStatement] -> String -> String
showList :: [TryStatement] -> String -> String
Show)

_TryStatement :: Name
_TryStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TryStatement")

_TryStatement_body :: Name
_TryStatement_body = (String -> Name
Core.Name String
"body")

_TryStatement_catches :: Name
_TryStatement_catches = (String -> Name
Core.Name String
"catches")

_TryStatement_finally :: Name
_TryStatement_finally = (String -> Name
Core.Name String
"finally")

data CatchClauses = 
  CatchClausesSpecific [SpecificCatchClause] |
  CatchClausesGeneral Block
  deriving (CatchClauses -> CatchClauses -> Bool
(CatchClauses -> CatchClauses -> Bool)
-> (CatchClauses -> CatchClauses -> Bool) -> Eq CatchClauses
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CatchClauses -> CatchClauses -> Bool
== :: CatchClauses -> CatchClauses -> Bool
$c/= :: CatchClauses -> CatchClauses -> Bool
/= :: CatchClauses -> CatchClauses -> Bool
Eq, Eq CatchClauses
Eq CatchClauses =>
(CatchClauses -> CatchClauses -> Ordering)
-> (CatchClauses -> CatchClauses -> Bool)
-> (CatchClauses -> CatchClauses -> Bool)
-> (CatchClauses -> CatchClauses -> Bool)
-> (CatchClauses -> CatchClauses -> Bool)
-> (CatchClauses -> CatchClauses -> CatchClauses)
-> (CatchClauses -> CatchClauses -> CatchClauses)
-> Ord CatchClauses
CatchClauses -> CatchClauses -> Bool
CatchClauses -> CatchClauses -> Ordering
CatchClauses -> CatchClauses -> CatchClauses
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CatchClauses -> CatchClauses -> Ordering
compare :: CatchClauses -> CatchClauses -> Ordering
$c< :: CatchClauses -> CatchClauses -> Bool
< :: CatchClauses -> CatchClauses -> Bool
$c<= :: CatchClauses -> CatchClauses -> Bool
<= :: CatchClauses -> CatchClauses -> Bool
$c> :: CatchClauses -> CatchClauses -> Bool
> :: CatchClauses -> CatchClauses -> Bool
$c>= :: CatchClauses -> CatchClauses -> Bool
>= :: CatchClauses -> CatchClauses -> Bool
$cmax :: CatchClauses -> CatchClauses -> CatchClauses
max :: CatchClauses -> CatchClauses -> CatchClauses
$cmin :: CatchClauses -> CatchClauses -> CatchClauses
min :: CatchClauses -> CatchClauses -> CatchClauses
Ord, ReadPrec [CatchClauses]
ReadPrec CatchClauses
Int -> ReadS CatchClauses
ReadS [CatchClauses]
(Int -> ReadS CatchClauses)
-> ReadS [CatchClauses]
-> ReadPrec CatchClauses
-> ReadPrec [CatchClauses]
-> Read CatchClauses
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CatchClauses
readsPrec :: Int -> ReadS CatchClauses
$creadList :: ReadS [CatchClauses]
readList :: ReadS [CatchClauses]
$creadPrec :: ReadPrec CatchClauses
readPrec :: ReadPrec CatchClauses
$creadListPrec :: ReadPrec [CatchClauses]
readListPrec :: ReadPrec [CatchClauses]
Read, Int -> CatchClauses -> String -> String
[CatchClauses] -> String -> String
CatchClauses -> String
(Int -> CatchClauses -> String -> String)
-> (CatchClauses -> String)
-> ([CatchClauses] -> String -> String)
-> Show CatchClauses
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> CatchClauses -> String -> String
showsPrec :: Int -> CatchClauses -> String -> String
$cshow :: CatchClauses -> String
show :: CatchClauses -> String
$cshowList :: [CatchClauses] -> String -> String
showList :: [CatchClauses] -> String -> String
Show)

_CatchClauses :: Name
_CatchClauses = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.CatchClauses")

_CatchClauses_specific :: Name
_CatchClauses_specific = (String -> Name
Core.Name String
"specific")

_CatchClauses_general :: Name
_CatchClauses_general = (String -> Name
Core.Name String
"general")

data SpecificCatchClause = 
  SpecificCatchClause {
    SpecificCatchClause -> Maybe ExceptionSpecifier
specificCatchClauseSpecifier :: (Maybe ExceptionSpecifier),
    SpecificCatchClause -> Maybe BooleanExpression
specificCatchClauseFilter :: (Maybe BooleanExpression),
    SpecificCatchClause -> Block
specificCatchClauseBody :: Block}
  deriving (SpecificCatchClause -> SpecificCatchClause -> Bool
(SpecificCatchClause -> SpecificCatchClause -> Bool)
-> (SpecificCatchClause -> SpecificCatchClause -> Bool)
-> Eq SpecificCatchClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SpecificCatchClause -> SpecificCatchClause -> Bool
== :: SpecificCatchClause -> SpecificCatchClause -> Bool
$c/= :: SpecificCatchClause -> SpecificCatchClause -> Bool
/= :: SpecificCatchClause -> SpecificCatchClause -> Bool
Eq, Eq SpecificCatchClause
Eq SpecificCatchClause =>
(SpecificCatchClause -> SpecificCatchClause -> Ordering)
-> (SpecificCatchClause -> SpecificCatchClause -> Bool)
-> (SpecificCatchClause -> SpecificCatchClause -> Bool)
-> (SpecificCatchClause -> SpecificCatchClause -> Bool)
-> (SpecificCatchClause -> SpecificCatchClause -> Bool)
-> (SpecificCatchClause
    -> SpecificCatchClause -> SpecificCatchClause)
-> (SpecificCatchClause
    -> SpecificCatchClause -> SpecificCatchClause)
-> Ord SpecificCatchClause
SpecificCatchClause -> SpecificCatchClause -> Bool
SpecificCatchClause -> SpecificCatchClause -> Ordering
SpecificCatchClause -> SpecificCatchClause -> SpecificCatchClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SpecificCatchClause -> SpecificCatchClause -> Ordering
compare :: SpecificCatchClause -> SpecificCatchClause -> Ordering
$c< :: SpecificCatchClause -> SpecificCatchClause -> Bool
< :: SpecificCatchClause -> SpecificCatchClause -> Bool
$c<= :: SpecificCatchClause -> SpecificCatchClause -> Bool
<= :: SpecificCatchClause -> SpecificCatchClause -> Bool
$c> :: SpecificCatchClause -> SpecificCatchClause -> Bool
> :: SpecificCatchClause -> SpecificCatchClause -> Bool
$c>= :: SpecificCatchClause -> SpecificCatchClause -> Bool
>= :: SpecificCatchClause -> SpecificCatchClause -> Bool
$cmax :: SpecificCatchClause -> SpecificCatchClause -> SpecificCatchClause
max :: SpecificCatchClause -> SpecificCatchClause -> SpecificCatchClause
$cmin :: SpecificCatchClause -> SpecificCatchClause -> SpecificCatchClause
min :: SpecificCatchClause -> SpecificCatchClause -> SpecificCatchClause
Ord, ReadPrec [SpecificCatchClause]
ReadPrec SpecificCatchClause
Int -> ReadS SpecificCatchClause
ReadS [SpecificCatchClause]
(Int -> ReadS SpecificCatchClause)
-> ReadS [SpecificCatchClause]
-> ReadPrec SpecificCatchClause
-> ReadPrec [SpecificCatchClause]
-> Read SpecificCatchClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SpecificCatchClause
readsPrec :: Int -> ReadS SpecificCatchClause
$creadList :: ReadS [SpecificCatchClause]
readList :: ReadS [SpecificCatchClause]
$creadPrec :: ReadPrec SpecificCatchClause
readPrec :: ReadPrec SpecificCatchClause
$creadListPrec :: ReadPrec [SpecificCatchClause]
readListPrec :: ReadPrec [SpecificCatchClause]
Read, Int -> SpecificCatchClause -> String -> String
[SpecificCatchClause] -> String -> String
SpecificCatchClause -> String
(Int -> SpecificCatchClause -> String -> String)
-> (SpecificCatchClause -> String)
-> ([SpecificCatchClause] -> String -> String)
-> Show SpecificCatchClause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SpecificCatchClause -> String -> String
showsPrec :: Int -> SpecificCatchClause -> String -> String
$cshow :: SpecificCatchClause -> String
show :: SpecificCatchClause -> String
$cshowList :: [SpecificCatchClause] -> String -> String
showList :: [SpecificCatchClause] -> String -> String
Show)

_SpecificCatchClause :: Name
_SpecificCatchClause = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SpecificCatchClause")

_SpecificCatchClause_specifier :: Name
_SpecificCatchClause_specifier = (String -> Name
Core.Name String
"specifier")

_SpecificCatchClause_filter :: Name
_SpecificCatchClause_filter = (String -> Name
Core.Name String
"filter")

_SpecificCatchClause_body :: Name
_SpecificCatchClause_body = (String -> Name
Core.Name String
"body")

data ExceptionSpecifier = 
  ExceptionSpecifier {
    ExceptionSpecifier -> Type
exceptionSpecifierType :: Type,
    ExceptionSpecifier -> Maybe Identifier
exceptionSpecifierIdentifier :: (Maybe Identifier)}
  deriving (ExceptionSpecifier -> ExceptionSpecifier -> Bool
(ExceptionSpecifier -> ExceptionSpecifier -> Bool)
-> (ExceptionSpecifier -> ExceptionSpecifier -> Bool)
-> Eq ExceptionSpecifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
== :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
$c/= :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
/= :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
Eq, Eq ExceptionSpecifier
Eq ExceptionSpecifier =>
(ExceptionSpecifier -> ExceptionSpecifier -> Ordering)
-> (ExceptionSpecifier -> ExceptionSpecifier -> Bool)
-> (ExceptionSpecifier -> ExceptionSpecifier -> Bool)
-> (ExceptionSpecifier -> ExceptionSpecifier -> Bool)
-> (ExceptionSpecifier -> ExceptionSpecifier -> Bool)
-> (ExceptionSpecifier -> ExceptionSpecifier -> ExceptionSpecifier)
-> (ExceptionSpecifier -> ExceptionSpecifier -> ExceptionSpecifier)
-> Ord ExceptionSpecifier
ExceptionSpecifier -> ExceptionSpecifier -> Bool
ExceptionSpecifier -> ExceptionSpecifier -> Ordering
ExceptionSpecifier -> ExceptionSpecifier -> ExceptionSpecifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ExceptionSpecifier -> ExceptionSpecifier -> Ordering
compare :: ExceptionSpecifier -> ExceptionSpecifier -> Ordering
$c< :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
< :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
$c<= :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
<= :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
$c> :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
> :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
$c>= :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
>= :: ExceptionSpecifier -> ExceptionSpecifier -> Bool
$cmax :: ExceptionSpecifier -> ExceptionSpecifier -> ExceptionSpecifier
max :: ExceptionSpecifier -> ExceptionSpecifier -> ExceptionSpecifier
$cmin :: ExceptionSpecifier -> ExceptionSpecifier -> ExceptionSpecifier
min :: ExceptionSpecifier -> ExceptionSpecifier -> ExceptionSpecifier
Ord, ReadPrec [ExceptionSpecifier]
ReadPrec ExceptionSpecifier
Int -> ReadS ExceptionSpecifier
ReadS [ExceptionSpecifier]
(Int -> ReadS ExceptionSpecifier)
-> ReadS [ExceptionSpecifier]
-> ReadPrec ExceptionSpecifier
-> ReadPrec [ExceptionSpecifier]
-> Read ExceptionSpecifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExceptionSpecifier
readsPrec :: Int -> ReadS ExceptionSpecifier
$creadList :: ReadS [ExceptionSpecifier]
readList :: ReadS [ExceptionSpecifier]
$creadPrec :: ReadPrec ExceptionSpecifier
readPrec :: ReadPrec ExceptionSpecifier
$creadListPrec :: ReadPrec [ExceptionSpecifier]
readListPrec :: ReadPrec [ExceptionSpecifier]
Read, Int -> ExceptionSpecifier -> String -> String
[ExceptionSpecifier] -> String -> String
ExceptionSpecifier -> String
(Int -> ExceptionSpecifier -> String -> String)
-> (ExceptionSpecifier -> String)
-> ([ExceptionSpecifier] -> String -> String)
-> Show ExceptionSpecifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ExceptionSpecifier -> String -> String
showsPrec :: Int -> ExceptionSpecifier -> String -> String
$cshow :: ExceptionSpecifier -> String
show :: ExceptionSpecifier -> String
$cshowList :: [ExceptionSpecifier] -> String -> String
showList :: [ExceptionSpecifier] -> String -> String
Show)

_ExceptionSpecifier :: Name
_ExceptionSpecifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ExceptionSpecifier")

_ExceptionSpecifier_type :: Name
_ExceptionSpecifier_type = (String -> Name
Core.Name String
"type")

_ExceptionSpecifier_identifier :: Name
_ExceptionSpecifier_identifier = (String -> Name
Core.Name String
"identifier")

data LockStatement = 
  LockStatement {
    LockStatement -> Expression
lockStatementExpression :: Expression,
    LockStatement -> EmbeddedStatement
lockStatementBody :: EmbeddedStatement}
  deriving (LockStatement -> LockStatement -> Bool
(LockStatement -> LockStatement -> Bool)
-> (LockStatement -> LockStatement -> Bool) -> Eq LockStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LockStatement -> LockStatement -> Bool
== :: LockStatement -> LockStatement -> Bool
$c/= :: LockStatement -> LockStatement -> Bool
/= :: LockStatement -> LockStatement -> Bool
Eq, Eq LockStatement
Eq LockStatement =>
(LockStatement -> LockStatement -> Ordering)
-> (LockStatement -> LockStatement -> Bool)
-> (LockStatement -> LockStatement -> Bool)
-> (LockStatement -> LockStatement -> Bool)
-> (LockStatement -> LockStatement -> Bool)
-> (LockStatement -> LockStatement -> LockStatement)
-> (LockStatement -> LockStatement -> LockStatement)
-> Ord LockStatement
LockStatement -> LockStatement -> Bool
LockStatement -> LockStatement -> Ordering
LockStatement -> LockStatement -> LockStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LockStatement -> LockStatement -> Ordering
compare :: LockStatement -> LockStatement -> Ordering
$c< :: LockStatement -> LockStatement -> Bool
< :: LockStatement -> LockStatement -> Bool
$c<= :: LockStatement -> LockStatement -> Bool
<= :: LockStatement -> LockStatement -> Bool
$c> :: LockStatement -> LockStatement -> Bool
> :: LockStatement -> LockStatement -> Bool
$c>= :: LockStatement -> LockStatement -> Bool
>= :: LockStatement -> LockStatement -> Bool
$cmax :: LockStatement -> LockStatement -> LockStatement
max :: LockStatement -> LockStatement -> LockStatement
$cmin :: LockStatement -> LockStatement -> LockStatement
min :: LockStatement -> LockStatement -> LockStatement
Ord, ReadPrec [LockStatement]
ReadPrec LockStatement
Int -> ReadS LockStatement
ReadS [LockStatement]
(Int -> ReadS LockStatement)
-> ReadS [LockStatement]
-> ReadPrec LockStatement
-> ReadPrec [LockStatement]
-> Read LockStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS LockStatement
readsPrec :: Int -> ReadS LockStatement
$creadList :: ReadS [LockStatement]
readList :: ReadS [LockStatement]
$creadPrec :: ReadPrec LockStatement
readPrec :: ReadPrec LockStatement
$creadListPrec :: ReadPrec [LockStatement]
readListPrec :: ReadPrec [LockStatement]
Read, Int -> LockStatement -> String -> String
[LockStatement] -> String -> String
LockStatement -> String
(Int -> LockStatement -> String -> String)
-> (LockStatement -> String)
-> ([LockStatement] -> String -> String)
-> Show LockStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> LockStatement -> String -> String
showsPrec :: Int -> LockStatement -> String -> String
$cshow :: LockStatement -> String
show :: LockStatement -> String
$cshowList :: [LockStatement] -> String -> String
showList :: [LockStatement] -> String -> String
Show)

_LockStatement :: Name
_LockStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.LockStatement")

_LockStatement_expression :: Name
_LockStatement_expression = (String -> Name
Core.Name String
"expression")

_LockStatement_body :: Name
_LockStatement_body = (String -> Name
Core.Name String
"body")

data UsingStatement = 
  UsingStatement {
    UsingStatement -> ResourceAcquisition
usingStatementAcquisition :: ResourceAcquisition,
    UsingStatement -> EmbeddedStatement
usingStatementBody :: EmbeddedStatement}
  deriving (UsingStatement -> UsingStatement -> Bool
(UsingStatement -> UsingStatement -> Bool)
-> (UsingStatement -> UsingStatement -> Bool) -> Eq UsingStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UsingStatement -> UsingStatement -> Bool
== :: UsingStatement -> UsingStatement -> Bool
$c/= :: UsingStatement -> UsingStatement -> Bool
/= :: UsingStatement -> UsingStatement -> Bool
Eq, Eq UsingStatement
Eq UsingStatement =>
(UsingStatement -> UsingStatement -> Ordering)
-> (UsingStatement -> UsingStatement -> Bool)
-> (UsingStatement -> UsingStatement -> Bool)
-> (UsingStatement -> UsingStatement -> Bool)
-> (UsingStatement -> UsingStatement -> Bool)
-> (UsingStatement -> UsingStatement -> UsingStatement)
-> (UsingStatement -> UsingStatement -> UsingStatement)
-> Ord UsingStatement
UsingStatement -> UsingStatement -> Bool
UsingStatement -> UsingStatement -> Ordering
UsingStatement -> UsingStatement -> UsingStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UsingStatement -> UsingStatement -> Ordering
compare :: UsingStatement -> UsingStatement -> Ordering
$c< :: UsingStatement -> UsingStatement -> Bool
< :: UsingStatement -> UsingStatement -> Bool
$c<= :: UsingStatement -> UsingStatement -> Bool
<= :: UsingStatement -> UsingStatement -> Bool
$c> :: UsingStatement -> UsingStatement -> Bool
> :: UsingStatement -> UsingStatement -> Bool
$c>= :: UsingStatement -> UsingStatement -> Bool
>= :: UsingStatement -> UsingStatement -> Bool
$cmax :: UsingStatement -> UsingStatement -> UsingStatement
max :: UsingStatement -> UsingStatement -> UsingStatement
$cmin :: UsingStatement -> UsingStatement -> UsingStatement
min :: UsingStatement -> UsingStatement -> UsingStatement
Ord, ReadPrec [UsingStatement]
ReadPrec UsingStatement
Int -> ReadS UsingStatement
ReadS [UsingStatement]
(Int -> ReadS UsingStatement)
-> ReadS [UsingStatement]
-> ReadPrec UsingStatement
-> ReadPrec [UsingStatement]
-> Read UsingStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UsingStatement
readsPrec :: Int -> ReadS UsingStatement
$creadList :: ReadS [UsingStatement]
readList :: ReadS [UsingStatement]
$creadPrec :: ReadPrec UsingStatement
readPrec :: ReadPrec UsingStatement
$creadListPrec :: ReadPrec [UsingStatement]
readListPrec :: ReadPrec [UsingStatement]
Read, Int -> UsingStatement -> String -> String
[UsingStatement] -> String -> String
UsingStatement -> String
(Int -> UsingStatement -> String -> String)
-> (UsingStatement -> String)
-> ([UsingStatement] -> String -> String)
-> Show UsingStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UsingStatement -> String -> String
showsPrec :: Int -> UsingStatement -> String -> String
$cshow :: UsingStatement -> String
show :: UsingStatement -> String
$cshowList :: [UsingStatement] -> String -> String
showList :: [UsingStatement] -> String -> String
Show)

_UsingStatement :: Name
_UsingStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.UsingStatement")

_UsingStatement_acquisition :: Name
_UsingStatement_acquisition = (String -> Name
Core.Name String
"acquisition")

_UsingStatement_body :: Name
_UsingStatement_body = (String -> Name
Core.Name String
"body")

data ResourceAcquisition = 
  ResourceAcquisitionLocal LocalVariableDeclaration |
  ResourceAcquisitionExpression Expression
  deriving (ResourceAcquisition -> ResourceAcquisition -> Bool
(ResourceAcquisition -> ResourceAcquisition -> Bool)
-> (ResourceAcquisition -> ResourceAcquisition -> Bool)
-> Eq ResourceAcquisition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ResourceAcquisition -> ResourceAcquisition -> Bool
== :: ResourceAcquisition -> ResourceAcquisition -> Bool
$c/= :: ResourceAcquisition -> ResourceAcquisition -> Bool
/= :: ResourceAcquisition -> ResourceAcquisition -> Bool
Eq, Eq ResourceAcquisition
Eq ResourceAcquisition =>
(ResourceAcquisition -> ResourceAcquisition -> Ordering)
-> (ResourceAcquisition -> ResourceAcquisition -> Bool)
-> (ResourceAcquisition -> ResourceAcquisition -> Bool)
-> (ResourceAcquisition -> ResourceAcquisition -> Bool)
-> (ResourceAcquisition -> ResourceAcquisition -> Bool)
-> (ResourceAcquisition
    -> ResourceAcquisition -> ResourceAcquisition)
-> (ResourceAcquisition
    -> ResourceAcquisition -> ResourceAcquisition)
-> Ord ResourceAcquisition
ResourceAcquisition -> ResourceAcquisition -> Bool
ResourceAcquisition -> ResourceAcquisition -> Ordering
ResourceAcquisition -> ResourceAcquisition -> ResourceAcquisition
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ResourceAcquisition -> ResourceAcquisition -> Ordering
compare :: ResourceAcquisition -> ResourceAcquisition -> Ordering
$c< :: ResourceAcquisition -> ResourceAcquisition -> Bool
< :: ResourceAcquisition -> ResourceAcquisition -> Bool
$c<= :: ResourceAcquisition -> ResourceAcquisition -> Bool
<= :: ResourceAcquisition -> ResourceAcquisition -> Bool
$c> :: ResourceAcquisition -> ResourceAcquisition -> Bool
> :: ResourceAcquisition -> ResourceAcquisition -> Bool
$c>= :: ResourceAcquisition -> ResourceAcquisition -> Bool
>= :: ResourceAcquisition -> ResourceAcquisition -> Bool
$cmax :: ResourceAcquisition -> ResourceAcquisition -> ResourceAcquisition
max :: ResourceAcquisition -> ResourceAcquisition -> ResourceAcquisition
$cmin :: ResourceAcquisition -> ResourceAcquisition -> ResourceAcquisition
min :: ResourceAcquisition -> ResourceAcquisition -> ResourceAcquisition
Ord, ReadPrec [ResourceAcquisition]
ReadPrec ResourceAcquisition
Int -> ReadS ResourceAcquisition
ReadS [ResourceAcquisition]
(Int -> ReadS ResourceAcquisition)
-> ReadS [ResourceAcquisition]
-> ReadPrec ResourceAcquisition
-> ReadPrec [ResourceAcquisition]
-> Read ResourceAcquisition
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ResourceAcquisition
readsPrec :: Int -> ReadS ResourceAcquisition
$creadList :: ReadS [ResourceAcquisition]
readList :: ReadS [ResourceAcquisition]
$creadPrec :: ReadPrec ResourceAcquisition
readPrec :: ReadPrec ResourceAcquisition
$creadListPrec :: ReadPrec [ResourceAcquisition]
readListPrec :: ReadPrec [ResourceAcquisition]
Read, Int -> ResourceAcquisition -> String -> String
[ResourceAcquisition] -> String -> String
ResourceAcquisition -> String
(Int -> ResourceAcquisition -> String -> String)
-> (ResourceAcquisition -> String)
-> ([ResourceAcquisition] -> String -> String)
-> Show ResourceAcquisition
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ResourceAcquisition -> String -> String
showsPrec :: Int -> ResourceAcquisition -> String -> String
$cshow :: ResourceAcquisition -> String
show :: ResourceAcquisition -> String
$cshowList :: [ResourceAcquisition] -> String -> String
showList :: [ResourceAcquisition] -> String -> String
Show)

_ResourceAcquisition :: Name
_ResourceAcquisition = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ResourceAcquisition")

_ResourceAcquisition_local :: Name
_ResourceAcquisition_local = (String -> Name
Core.Name String
"local")

_ResourceAcquisition_expression :: Name
_ResourceAcquisition_expression = (String -> Name
Core.Name String
"expression")

data YieldStatement = 
  YieldStatementReturn Expression |
  YieldStatementBreak 
  deriving (YieldStatement -> YieldStatement -> Bool
(YieldStatement -> YieldStatement -> Bool)
-> (YieldStatement -> YieldStatement -> Bool) -> Eq YieldStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: YieldStatement -> YieldStatement -> Bool
== :: YieldStatement -> YieldStatement -> Bool
$c/= :: YieldStatement -> YieldStatement -> Bool
/= :: YieldStatement -> YieldStatement -> Bool
Eq, Eq YieldStatement
Eq YieldStatement =>
(YieldStatement -> YieldStatement -> Ordering)
-> (YieldStatement -> YieldStatement -> Bool)
-> (YieldStatement -> YieldStatement -> Bool)
-> (YieldStatement -> YieldStatement -> Bool)
-> (YieldStatement -> YieldStatement -> Bool)
-> (YieldStatement -> YieldStatement -> YieldStatement)
-> (YieldStatement -> YieldStatement -> YieldStatement)
-> Ord YieldStatement
YieldStatement -> YieldStatement -> Bool
YieldStatement -> YieldStatement -> Ordering
YieldStatement -> YieldStatement -> YieldStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: YieldStatement -> YieldStatement -> Ordering
compare :: YieldStatement -> YieldStatement -> Ordering
$c< :: YieldStatement -> YieldStatement -> Bool
< :: YieldStatement -> YieldStatement -> Bool
$c<= :: YieldStatement -> YieldStatement -> Bool
<= :: YieldStatement -> YieldStatement -> Bool
$c> :: YieldStatement -> YieldStatement -> Bool
> :: YieldStatement -> YieldStatement -> Bool
$c>= :: YieldStatement -> YieldStatement -> Bool
>= :: YieldStatement -> YieldStatement -> Bool
$cmax :: YieldStatement -> YieldStatement -> YieldStatement
max :: YieldStatement -> YieldStatement -> YieldStatement
$cmin :: YieldStatement -> YieldStatement -> YieldStatement
min :: YieldStatement -> YieldStatement -> YieldStatement
Ord, ReadPrec [YieldStatement]
ReadPrec YieldStatement
Int -> ReadS YieldStatement
ReadS [YieldStatement]
(Int -> ReadS YieldStatement)
-> ReadS [YieldStatement]
-> ReadPrec YieldStatement
-> ReadPrec [YieldStatement]
-> Read YieldStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS YieldStatement
readsPrec :: Int -> ReadS YieldStatement
$creadList :: ReadS [YieldStatement]
readList :: ReadS [YieldStatement]
$creadPrec :: ReadPrec YieldStatement
readPrec :: ReadPrec YieldStatement
$creadListPrec :: ReadPrec [YieldStatement]
readListPrec :: ReadPrec [YieldStatement]
Read, Int -> YieldStatement -> String -> String
[YieldStatement] -> String -> String
YieldStatement -> String
(Int -> YieldStatement -> String -> String)
-> (YieldStatement -> String)
-> ([YieldStatement] -> String -> String)
-> Show YieldStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> YieldStatement -> String -> String
showsPrec :: Int -> YieldStatement -> String -> String
$cshow :: YieldStatement -> String
show :: YieldStatement -> String
$cshowList :: [YieldStatement] -> String -> String
showList :: [YieldStatement] -> String -> String
Show)

_YieldStatement :: Name
_YieldStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.YieldStatement")

_YieldStatement_return :: Name
_YieldStatement_return = (String -> Name
Core.Name String
"return")

_YieldStatement_break :: Name
_YieldStatement_break = (String -> Name
Core.Name String
"break")

data CompilationUnit = 
  CompilationUnit {
    CompilationUnit -> [Identifier]
compilationUnitExterns :: [Identifier],
    CompilationUnit -> [UsingDirective]
compilationUnitUsings :: [UsingDirective],
    CompilationUnit -> [GlobalAttributeSection]
compilationUnitAttributes :: [GlobalAttributeSection],
    CompilationUnit -> [NamespaceMemberDeclaration]
compilationUnitMembers :: [NamespaceMemberDeclaration]}
  deriving (CompilationUnit -> CompilationUnit -> Bool
(CompilationUnit -> CompilationUnit -> Bool)
-> (CompilationUnit -> CompilationUnit -> Bool)
-> Eq CompilationUnit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CompilationUnit -> CompilationUnit -> Bool
== :: CompilationUnit -> CompilationUnit -> Bool
$c/= :: CompilationUnit -> CompilationUnit -> Bool
/= :: CompilationUnit -> CompilationUnit -> Bool
Eq, Eq CompilationUnit
Eq CompilationUnit =>
(CompilationUnit -> CompilationUnit -> Ordering)
-> (CompilationUnit -> CompilationUnit -> Bool)
-> (CompilationUnit -> CompilationUnit -> Bool)
-> (CompilationUnit -> CompilationUnit -> Bool)
-> (CompilationUnit -> CompilationUnit -> Bool)
-> (CompilationUnit -> CompilationUnit -> CompilationUnit)
-> (CompilationUnit -> CompilationUnit -> CompilationUnit)
-> Ord CompilationUnit
CompilationUnit -> CompilationUnit -> Bool
CompilationUnit -> CompilationUnit -> Ordering
CompilationUnit -> CompilationUnit -> CompilationUnit
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CompilationUnit -> CompilationUnit -> Ordering
compare :: CompilationUnit -> CompilationUnit -> Ordering
$c< :: CompilationUnit -> CompilationUnit -> Bool
< :: CompilationUnit -> CompilationUnit -> Bool
$c<= :: CompilationUnit -> CompilationUnit -> Bool
<= :: CompilationUnit -> CompilationUnit -> Bool
$c> :: CompilationUnit -> CompilationUnit -> Bool
> :: CompilationUnit -> CompilationUnit -> Bool
$c>= :: CompilationUnit -> CompilationUnit -> Bool
>= :: CompilationUnit -> CompilationUnit -> Bool
$cmax :: CompilationUnit -> CompilationUnit -> CompilationUnit
max :: CompilationUnit -> CompilationUnit -> CompilationUnit
$cmin :: CompilationUnit -> CompilationUnit -> CompilationUnit
min :: CompilationUnit -> CompilationUnit -> CompilationUnit
Ord, ReadPrec [CompilationUnit]
ReadPrec CompilationUnit
Int -> ReadS CompilationUnit
ReadS [CompilationUnit]
(Int -> ReadS CompilationUnit)
-> ReadS [CompilationUnit]
-> ReadPrec CompilationUnit
-> ReadPrec [CompilationUnit]
-> Read CompilationUnit
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CompilationUnit
readsPrec :: Int -> ReadS CompilationUnit
$creadList :: ReadS [CompilationUnit]
readList :: ReadS [CompilationUnit]
$creadPrec :: ReadPrec CompilationUnit
readPrec :: ReadPrec CompilationUnit
$creadListPrec :: ReadPrec [CompilationUnit]
readListPrec :: ReadPrec [CompilationUnit]
Read, Int -> CompilationUnit -> String -> String
[CompilationUnit] -> String -> String
CompilationUnit -> String
(Int -> CompilationUnit -> String -> String)
-> (CompilationUnit -> String)
-> ([CompilationUnit] -> String -> String)
-> Show CompilationUnit
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> CompilationUnit -> String -> String
showsPrec :: Int -> CompilationUnit -> String -> String
$cshow :: CompilationUnit -> String
show :: CompilationUnit -> String
$cshowList :: [CompilationUnit] -> String -> String
showList :: [CompilationUnit] -> String -> String
Show)

_CompilationUnit :: Name
_CompilationUnit = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.CompilationUnit")

_CompilationUnit_externs :: Name
_CompilationUnit_externs = (String -> Name
Core.Name String
"externs")

_CompilationUnit_usings :: Name
_CompilationUnit_usings = (String -> Name
Core.Name String
"usings")

_CompilationUnit_attributes :: Name
_CompilationUnit_attributes = (String -> Name
Core.Name String
"attributes")

_CompilationUnit_members :: Name
_CompilationUnit_members = (String -> Name
Core.Name String
"members")

data NamespaceDeclaration = 
  NamespaceDeclaration {
    NamespaceDeclaration -> [Identifier]
namespaceDeclarationName :: [Identifier],
    NamespaceDeclaration -> NamespaceBody
namespaceDeclarationBody :: NamespaceBody}
  deriving (NamespaceDeclaration -> NamespaceDeclaration -> Bool
(NamespaceDeclaration -> NamespaceDeclaration -> Bool)
-> (NamespaceDeclaration -> NamespaceDeclaration -> Bool)
-> Eq NamespaceDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
== :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
$c/= :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
/= :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
Eq, Eq NamespaceDeclaration
Eq NamespaceDeclaration =>
(NamespaceDeclaration -> NamespaceDeclaration -> Ordering)
-> (NamespaceDeclaration -> NamespaceDeclaration -> Bool)
-> (NamespaceDeclaration -> NamespaceDeclaration -> Bool)
-> (NamespaceDeclaration -> NamespaceDeclaration -> Bool)
-> (NamespaceDeclaration -> NamespaceDeclaration -> Bool)
-> (NamespaceDeclaration
    -> NamespaceDeclaration -> NamespaceDeclaration)
-> (NamespaceDeclaration
    -> NamespaceDeclaration -> NamespaceDeclaration)
-> Ord NamespaceDeclaration
NamespaceDeclaration -> NamespaceDeclaration -> Bool
NamespaceDeclaration -> NamespaceDeclaration -> Ordering
NamespaceDeclaration
-> NamespaceDeclaration -> NamespaceDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceDeclaration -> NamespaceDeclaration -> Ordering
compare :: NamespaceDeclaration -> NamespaceDeclaration -> Ordering
$c< :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
< :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
$c<= :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
<= :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
$c> :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
> :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
$c>= :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
>= :: NamespaceDeclaration -> NamespaceDeclaration -> Bool
$cmax :: NamespaceDeclaration
-> NamespaceDeclaration -> NamespaceDeclaration
max :: NamespaceDeclaration
-> NamespaceDeclaration -> NamespaceDeclaration
$cmin :: NamespaceDeclaration
-> NamespaceDeclaration -> NamespaceDeclaration
min :: NamespaceDeclaration
-> NamespaceDeclaration -> NamespaceDeclaration
Ord, ReadPrec [NamespaceDeclaration]
ReadPrec NamespaceDeclaration
Int -> ReadS NamespaceDeclaration
ReadS [NamespaceDeclaration]
(Int -> ReadS NamespaceDeclaration)
-> ReadS [NamespaceDeclaration]
-> ReadPrec NamespaceDeclaration
-> ReadPrec [NamespaceDeclaration]
-> Read NamespaceDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamespaceDeclaration
readsPrec :: Int -> ReadS NamespaceDeclaration
$creadList :: ReadS [NamespaceDeclaration]
readList :: ReadS [NamespaceDeclaration]
$creadPrec :: ReadPrec NamespaceDeclaration
readPrec :: ReadPrec NamespaceDeclaration
$creadListPrec :: ReadPrec [NamespaceDeclaration]
readListPrec :: ReadPrec [NamespaceDeclaration]
Read, Int -> NamespaceDeclaration -> String -> String
[NamespaceDeclaration] -> String -> String
NamespaceDeclaration -> String
(Int -> NamespaceDeclaration -> String -> String)
-> (NamespaceDeclaration -> String)
-> ([NamespaceDeclaration] -> String -> String)
-> Show NamespaceDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NamespaceDeclaration -> String -> String
showsPrec :: Int -> NamespaceDeclaration -> String -> String
$cshow :: NamespaceDeclaration -> String
show :: NamespaceDeclaration -> String
$cshowList :: [NamespaceDeclaration] -> String -> String
showList :: [NamespaceDeclaration] -> String -> String
Show)

_NamespaceDeclaration :: Name
_NamespaceDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NamespaceDeclaration")

_NamespaceDeclaration_name :: Name
_NamespaceDeclaration_name = (String -> Name
Core.Name String
"name")

_NamespaceDeclaration_body :: Name
_NamespaceDeclaration_body = (String -> Name
Core.Name String
"body")

data NamespaceBody = 
  NamespaceBody {
    NamespaceBody -> [Identifier]
namespaceBodyExterns :: [Identifier],
    NamespaceBody -> [UsingDirective]
namespaceBodyUsings :: [UsingDirective],
    NamespaceBody -> [NamespaceMemberDeclaration]
namespaceBodyMembers :: [NamespaceMemberDeclaration]}
  deriving (NamespaceBody -> NamespaceBody -> Bool
(NamespaceBody -> NamespaceBody -> Bool)
-> (NamespaceBody -> NamespaceBody -> Bool) -> Eq NamespaceBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceBody -> NamespaceBody -> Bool
== :: NamespaceBody -> NamespaceBody -> Bool
$c/= :: NamespaceBody -> NamespaceBody -> Bool
/= :: NamespaceBody -> NamespaceBody -> Bool
Eq, Eq NamespaceBody
Eq NamespaceBody =>
(NamespaceBody -> NamespaceBody -> Ordering)
-> (NamespaceBody -> NamespaceBody -> Bool)
-> (NamespaceBody -> NamespaceBody -> Bool)
-> (NamespaceBody -> NamespaceBody -> Bool)
-> (NamespaceBody -> NamespaceBody -> Bool)
-> (NamespaceBody -> NamespaceBody -> NamespaceBody)
-> (NamespaceBody -> NamespaceBody -> NamespaceBody)
-> Ord NamespaceBody
NamespaceBody -> NamespaceBody -> Bool
NamespaceBody -> NamespaceBody -> Ordering
NamespaceBody -> NamespaceBody -> NamespaceBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceBody -> NamespaceBody -> Ordering
compare :: NamespaceBody -> NamespaceBody -> Ordering
$c< :: NamespaceBody -> NamespaceBody -> Bool
< :: NamespaceBody -> NamespaceBody -> Bool
$c<= :: NamespaceBody -> NamespaceBody -> Bool
<= :: NamespaceBody -> NamespaceBody -> Bool
$c> :: NamespaceBody -> NamespaceBody -> Bool
> :: NamespaceBody -> NamespaceBody -> Bool
$c>= :: NamespaceBody -> NamespaceBody -> Bool
>= :: NamespaceBody -> NamespaceBody -> Bool
$cmax :: NamespaceBody -> NamespaceBody -> NamespaceBody
max :: NamespaceBody -> NamespaceBody -> NamespaceBody
$cmin :: NamespaceBody -> NamespaceBody -> NamespaceBody
min :: NamespaceBody -> NamespaceBody -> NamespaceBody
Ord, ReadPrec [NamespaceBody]
ReadPrec NamespaceBody
Int -> ReadS NamespaceBody
ReadS [NamespaceBody]
(Int -> ReadS NamespaceBody)
-> ReadS [NamespaceBody]
-> ReadPrec NamespaceBody
-> ReadPrec [NamespaceBody]
-> Read NamespaceBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamespaceBody
readsPrec :: Int -> ReadS NamespaceBody
$creadList :: ReadS [NamespaceBody]
readList :: ReadS [NamespaceBody]
$creadPrec :: ReadPrec NamespaceBody
readPrec :: ReadPrec NamespaceBody
$creadListPrec :: ReadPrec [NamespaceBody]
readListPrec :: ReadPrec [NamespaceBody]
Read, Int -> NamespaceBody -> String -> String
[NamespaceBody] -> String -> String
NamespaceBody -> String
(Int -> NamespaceBody -> String -> String)
-> (NamespaceBody -> String)
-> ([NamespaceBody] -> String -> String)
-> Show NamespaceBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NamespaceBody -> String -> String
showsPrec :: Int -> NamespaceBody -> String -> String
$cshow :: NamespaceBody -> String
show :: NamespaceBody -> String
$cshowList :: [NamespaceBody] -> String -> String
showList :: [NamespaceBody] -> String -> String
Show)

_NamespaceBody :: Name
_NamespaceBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NamespaceBody")

_NamespaceBody_externs :: Name
_NamespaceBody_externs = (String -> Name
Core.Name String
"externs")

_NamespaceBody_usings :: Name
_NamespaceBody_usings = (String -> Name
Core.Name String
"usings")

_NamespaceBody_members :: Name
_NamespaceBody_members = (String -> Name
Core.Name String
"members")

data UsingDirective = 
  UsingDirectiveAlias UsingAliasDirective |
  UsingDirectiveNamespace NamespaceName |
  UsingDirectiveStatic TypeName
  deriving (UsingDirective -> UsingDirective -> Bool
(UsingDirective -> UsingDirective -> Bool)
-> (UsingDirective -> UsingDirective -> Bool) -> Eq UsingDirective
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UsingDirective -> UsingDirective -> Bool
== :: UsingDirective -> UsingDirective -> Bool
$c/= :: UsingDirective -> UsingDirective -> Bool
/= :: UsingDirective -> UsingDirective -> Bool
Eq, Eq UsingDirective
Eq UsingDirective =>
(UsingDirective -> UsingDirective -> Ordering)
-> (UsingDirective -> UsingDirective -> Bool)
-> (UsingDirective -> UsingDirective -> Bool)
-> (UsingDirective -> UsingDirective -> Bool)
-> (UsingDirective -> UsingDirective -> Bool)
-> (UsingDirective -> UsingDirective -> UsingDirective)
-> (UsingDirective -> UsingDirective -> UsingDirective)
-> Ord UsingDirective
UsingDirective -> UsingDirective -> Bool
UsingDirective -> UsingDirective -> Ordering
UsingDirective -> UsingDirective -> UsingDirective
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UsingDirective -> UsingDirective -> Ordering
compare :: UsingDirective -> UsingDirective -> Ordering
$c< :: UsingDirective -> UsingDirective -> Bool
< :: UsingDirective -> UsingDirective -> Bool
$c<= :: UsingDirective -> UsingDirective -> Bool
<= :: UsingDirective -> UsingDirective -> Bool
$c> :: UsingDirective -> UsingDirective -> Bool
> :: UsingDirective -> UsingDirective -> Bool
$c>= :: UsingDirective -> UsingDirective -> Bool
>= :: UsingDirective -> UsingDirective -> Bool
$cmax :: UsingDirective -> UsingDirective -> UsingDirective
max :: UsingDirective -> UsingDirective -> UsingDirective
$cmin :: UsingDirective -> UsingDirective -> UsingDirective
min :: UsingDirective -> UsingDirective -> UsingDirective
Ord, ReadPrec [UsingDirective]
ReadPrec UsingDirective
Int -> ReadS UsingDirective
ReadS [UsingDirective]
(Int -> ReadS UsingDirective)
-> ReadS [UsingDirective]
-> ReadPrec UsingDirective
-> ReadPrec [UsingDirective]
-> Read UsingDirective
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UsingDirective
readsPrec :: Int -> ReadS UsingDirective
$creadList :: ReadS [UsingDirective]
readList :: ReadS [UsingDirective]
$creadPrec :: ReadPrec UsingDirective
readPrec :: ReadPrec UsingDirective
$creadListPrec :: ReadPrec [UsingDirective]
readListPrec :: ReadPrec [UsingDirective]
Read, Int -> UsingDirective -> String -> String
[UsingDirective] -> String -> String
UsingDirective -> String
(Int -> UsingDirective -> String -> String)
-> (UsingDirective -> String)
-> ([UsingDirective] -> String -> String)
-> Show UsingDirective
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UsingDirective -> String -> String
showsPrec :: Int -> UsingDirective -> String -> String
$cshow :: UsingDirective -> String
show :: UsingDirective -> String
$cshowList :: [UsingDirective] -> String -> String
showList :: [UsingDirective] -> String -> String
Show)

_UsingDirective :: Name
_UsingDirective = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.UsingDirective")

_UsingDirective_alias :: Name
_UsingDirective_alias = (String -> Name
Core.Name String
"alias")

_UsingDirective_namespace :: Name
_UsingDirective_namespace = (String -> Name
Core.Name String
"namespace")

_UsingDirective_static :: Name
_UsingDirective_static = (String -> Name
Core.Name String
"static")

data UsingAliasDirective = 
  UsingAliasDirective {
    UsingAliasDirective -> Identifier
usingAliasDirectiveAlias :: Identifier,
    UsingAliasDirective -> NamespaceOrTypeName
usingAliasDirectiveName :: NamespaceOrTypeName}
  deriving (UsingAliasDirective -> UsingAliasDirective -> Bool
(UsingAliasDirective -> UsingAliasDirective -> Bool)
-> (UsingAliasDirective -> UsingAliasDirective -> Bool)
-> Eq UsingAliasDirective
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UsingAliasDirective -> UsingAliasDirective -> Bool
== :: UsingAliasDirective -> UsingAliasDirective -> Bool
$c/= :: UsingAliasDirective -> UsingAliasDirective -> Bool
/= :: UsingAliasDirective -> UsingAliasDirective -> Bool
Eq, Eq UsingAliasDirective
Eq UsingAliasDirective =>
(UsingAliasDirective -> UsingAliasDirective -> Ordering)
-> (UsingAliasDirective -> UsingAliasDirective -> Bool)
-> (UsingAliasDirective -> UsingAliasDirective -> Bool)
-> (UsingAliasDirective -> UsingAliasDirective -> Bool)
-> (UsingAliasDirective -> UsingAliasDirective -> Bool)
-> (UsingAliasDirective
    -> UsingAliasDirective -> UsingAliasDirective)
-> (UsingAliasDirective
    -> UsingAliasDirective -> UsingAliasDirective)
-> Ord UsingAliasDirective
UsingAliasDirective -> UsingAliasDirective -> Bool
UsingAliasDirective -> UsingAliasDirective -> Ordering
UsingAliasDirective -> UsingAliasDirective -> UsingAliasDirective
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UsingAliasDirective -> UsingAliasDirective -> Ordering
compare :: UsingAliasDirective -> UsingAliasDirective -> Ordering
$c< :: UsingAliasDirective -> UsingAliasDirective -> Bool
< :: UsingAliasDirective -> UsingAliasDirective -> Bool
$c<= :: UsingAliasDirective -> UsingAliasDirective -> Bool
<= :: UsingAliasDirective -> UsingAliasDirective -> Bool
$c> :: UsingAliasDirective -> UsingAliasDirective -> Bool
> :: UsingAliasDirective -> UsingAliasDirective -> Bool
$c>= :: UsingAliasDirective -> UsingAliasDirective -> Bool
>= :: UsingAliasDirective -> UsingAliasDirective -> Bool
$cmax :: UsingAliasDirective -> UsingAliasDirective -> UsingAliasDirective
max :: UsingAliasDirective -> UsingAliasDirective -> UsingAliasDirective
$cmin :: UsingAliasDirective -> UsingAliasDirective -> UsingAliasDirective
min :: UsingAliasDirective -> UsingAliasDirective -> UsingAliasDirective
Ord, ReadPrec [UsingAliasDirective]
ReadPrec UsingAliasDirective
Int -> ReadS UsingAliasDirective
ReadS [UsingAliasDirective]
(Int -> ReadS UsingAliasDirective)
-> ReadS [UsingAliasDirective]
-> ReadPrec UsingAliasDirective
-> ReadPrec [UsingAliasDirective]
-> Read UsingAliasDirective
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UsingAliasDirective
readsPrec :: Int -> ReadS UsingAliasDirective
$creadList :: ReadS [UsingAliasDirective]
readList :: ReadS [UsingAliasDirective]
$creadPrec :: ReadPrec UsingAliasDirective
readPrec :: ReadPrec UsingAliasDirective
$creadListPrec :: ReadPrec [UsingAliasDirective]
readListPrec :: ReadPrec [UsingAliasDirective]
Read, Int -> UsingAliasDirective -> String -> String
[UsingAliasDirective] -> String -> String
UsingAliasDirective -> String
(Int -> UsingAliasDirective -> String -> String)
-> (UsingAliasDirective -> String)
-> ([UsingAliasDirective] -> String -> String)
-> Show UsingAliasDirective
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UsingAliasDirective -> String -> String
showsPrec :: Int -> UsingAliasDirective -> String -> String
$cshow :: UsingAliasDirective -> String
show :: UsingAliasDirective -> String
$cshowList :: [UsingAliasDirective] -> String -> String
showList :: [UsingAliasDirective] -> String -> String
Show)

_UsingAliasDirective :: Name
_UsingAliasDirective = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.UsingAliasDirective")

_UsingAliasDirective_alias :: Name
_UsingAliasDirective_alias = (String -> Name
Core.Name String
"alias")

_UsingAliasDirective_name :: Name
_UsingAliasDirective_name = (String -> Name
Core.Name String
"name")

data NamespaceMemberDeclaration = 
  NamespaceMemberDeclarationNamespace NamespaceDeclaration |
  NamespaceMemberDeclarationType TypeDeclaration
  deriving (NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
(NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool)
-> (NamespaceMemberDeclaration
    -> NamespaceMemberDeclaration -> Bool)
-> Eq NamespaceMemberDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
== :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
$c/= :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
/= :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
Eq, Eq NamespaceMemberDeclaration
Eq NamespaceMemberDeclaration =>
(NamespaceMemberDeclaration
 -> NamespaceMemberDeclaration -> Ordering)
-> (NamespaceMemberDeclaration
    -> NamespaceMemberDeclaration -> Bool)
-> (NamespaceMemberDeclaration
    -> NamespaceMemberDeclaration -> Bool)
-> (NamespaceMemberDeclaration
    -> NamespaceMemberDeclaration -> Bool)
-> (NamespaceMemberDeclaration
    -> NamespaceMemberDeclaration -> Bool)
-> (NamespaceMemberDeclaration
    -> NamespaceMemberDeclaration -> NamespaceMemberDeclaration)
-> (NamespaceMemberDeclaration
    -> NamespaceMemberDeclaration -> NamespaceMemberDeclaration)
-> Ord NamespaceMemberDeclaration
NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
NamespaceMemberDeclaration
-> NamespaceMemberDeclaration -> Ordering
NamespaceMemberDeclaration
-> NamespaceMemberDeclaration -> NamespaceMemberDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamespaceMemberDeclaration
-> NamespaceMemberDeclaration -> Ordering
compare :: NamespaceMemberDeclaration
-> NamespaceMemberDeclaration -> Ordering
$c< :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
< :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
$c<= :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
<= :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
$c> :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
> :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
$c>= :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
>= :: NamespaceMemberDeclaration -> NamespaceMemberDeclaration -> Bool
$cmax :: NamespaceMemberDeclaration
-> NamespaceMemberDeclaration -> NamespaceMemberDeclaration
max :: NamespaceMemberDeclaration
-> NamespaceMemberDeclaration -> NamespaceMemberDeclaration
$cmin :: NamespaceMemberDeclaration
-> NamespaceMemberDeclaration -> NamespaceMemberDeclaration
min :: NamespaceMemberDeclaration
-> NamespaceMemberDeclaration -> NamespaceMemberDeclaration
Ord, ReadPrec [NamespaceMemberDeclaration]
ReadPrec NamespaceMemberDeclaration
Int -> ReadS NamespaceMemberDeclaration
ReadS [NamespaceMemberDeclaration]
(Int -> ReadS NamespaceMemberDeclaration)
-> ReadS [NamespaceMemberDeclaration]
-> ReadPrec NamespaceMemberDeclaration
-> ReadPrec [NamespaceMemberDeclaration]
-> Read NamespaceMemberDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamespaceMemberDeclaration
readsPrec :: Int -> ReadS NamespaceMemberDeclaration
$creadList :: ReadS [NamespaceMemberDeclaration]
readList :: ReadS [NamespaceMemberDeclaration]
$creadPrec :: ReadPrec NamespaceMemberDeclaration
readPrec :: ReadPrec NamespaceMemberDeclaration
$creadListPrec :: ReadPrec [NamespaceMemberDeclaration]
readListPrec :: ReadPrec [NamespaceMemberDeclaration]
Read, Int -> NamespaceMemberDeclaration -> String -> String
[NamespaceMemberDeclaration] -> String -> String
NamespaceMemberDeclaration -> String
(Int -> NamespaceMemberDeclaration -> String -> String)
-> (NamespaceMemberDeclaration -> String)
-> ([NamespaceMemberDeclaration] -> String -> String)
-> Show NamespaceMemberDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NamespaceMemberDeclaration -> String -> String
showsPrec :: Int -> NamespaceMemberDeclaration -> String -> String
$cshow :: NamespaceMemberDeclaration -> String
show :: NamespaceMemberDeclaration -> String
$cshowList :: [NamespaceMemberDeclaration] -> String -> String
showList :: [NamespaceMemberDeclaration] -> String -> String
Show)

_NamespaceMemberDeclaration :: Name
_NamespaceMemberDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NamespaceMemberDeclaration")

_NamespaceMemberDeclaration_namespace :: Name
_NamespaceMemberDeclaration_namespace = (String -> Name
Core.Name String
"namespace")

_NamespaceMemberDeclaration_type :: Name
_NamespaceMemberDeclaration_type = (String -> Name
Core.Name String
"type")

data TypeDeclaration = 
  TypeDeclarationClass ClassDeclaration |
  TypeDeclarationStruct StructDeclaration |
  TypeDeclarationInterface InterfaceDeclaration |
  TypeDeclarationEnum EnumDeclaration |
  TypeDeclarationDelegate DelegateDeclaration
  deriving (TypeDeclaration -> TypeDeclaration -> Bool
(TypeDeclaration -> TypeDeclaration -> Bool)
-> (TypeDeclaration -> TypeDeclaration -> Bool)
-> Eq TypeDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeDeclaration -> TypeDeclaration -> Bool
== :: TypeDeclaration -> TypeDeclaration -> Bool
$c/= :: TypeDeclaration -> TypeDeclaration -> Bool
/= :: TypeDeclaration -> TypeDeclaration -> Bool
Eq, Eq TypeDeclaration
Eq TypeDeclaration =>
(TypeDeclaration -> TypeDeclaration -> Ordering)
-> (TypeDeclaration -> TypeDeclaration -> Bool)
-> (TypeDeclaration -> TypeDeclaration -> Bool)
-> (TypeDeclaration -> TypeDeclaration -> Bool)
-> (TypeDeclaration -> TypeDeclaration -> Bool)
-> (TypeDeclaration -> TypeDeclaration -> TypeDeclaration)
-> (TypeDeclaration -> TypeDeclaration -> TypeDeclaration)
-> Ord TypeDeclaration
TypeDeclaration -> TypeDeclaration -> Bool
TypeDeclaration -> TypeDeclaration -> Ordering
TypeDeclaration -> TypeDeclaration -> TypeDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TypeDeclaration -> TypeDeclaration -> Ordering
compare :: TypeDeclaration -> TypeDeclaration -> Ordering
$c< :: TypeDeclaration -> TypeDeclaration -> Bool
< :: TypeDeclaration -> TypeDeclaration -> Bool
$c<= :: TypeDeclaration -> TypeDeclaration -> Bool
<= :: TypeDeclaration -> TypeDeclaration -> Bool
$c> :: TypeDeclaration -> TypeDeclaration -> Bool
> :: TypeDeclaration -> TypeDeclaration -> Bool
$c>= :: TypeDeclaration -> TypeDeclaration -> Bool
>= :: TypeDeclaration -> TypeDeclaration -> Bool
$cmax :: TypeDeclaration -> TypeDeclaration -> TypeDeclaration
max :: TypeDeclaration -> TypeDeclaration -> TypeDeclaration
$cmin :: TypeDeclaration -> TypeDeclaration -> TypeDeclaration
min :: TypeDeclaration -> TypeDeclaration -> TypeDeclaration
Ord, ReadPrec [TypeDeclaration]
ReadPrec TypeDeclaration
Int -> ReadS TypeDeclaration
ReadS [TypeDeclaration]
(Int -> ReadS TypeDeclaration)
-> ReadS [TypeDeclaration]
-> ReadPrec TypeDeclaration
-> ReadPrec [TypeDeclaration]
-> Read TypeDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeDeclaration
readsPrec :: Int -> ReadS TypeDeclaration
$creadList :: ReadS [TypeDeclaration]
readList :: ReadS [TypeDeclaration]
$creadPrec :: ReadPrec TypeDeclaration
readPrec :: ReadPrec TypeDeclaration
$creadListPrec :: ReadPrec [TypeDeclaration]
readListPrec :: ReadPrec [TypeDeclaration]
Read, Int -> TypeDeclaration -> String -> String
[TypeDeclaration] -> String -> String
TypeDeclaration -> String
(Int -> TypeDeclaration -> String -> String)
-> (TypeDeclaration -> String)
-> ([TypeDeclaration] -> String -> String)
-> Show TypeDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TypeDeclaration -> String -> String
showsPrec :: Int -> TypeDeclaration -> String -> String
$cshow :: TypeDeclaration -> String
show :: TypeDeclaration -> String
$cshowList :: [TypeDeclaration] -> String -> String
showList :: [TypeDeclaration] -> String -> String
Show)

_TypeDeclaration :: Name
_TypeDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TypeDeclaration")

_TypeDeclaration_class :: Name
_TypeDeclaration_class = (String -> Name
Core.Name String
"class")

_TypeDeclaration_struct :: Name
_TypeDeclaration_struct = (String -> Name
Core.Name String
"struct")

_TypeDeclaration_interface :: Name
_TypeDeclaration_interface = (String -> Name
Core.Name String
"interface")

_TypeDeclaration_enum :: Name
_TypeDeclaration_enum = (String -> Name
Core.Name String
"enum")

_TypeDeclaration_delegate :: Name
_TypeDeclaration_delegate = (String -> Name
Core.Name String
"delegate")

data QualifiedAliasMember = 
  QualifiedAliasMember {
    QualifiedAliasMember -> Identifier
qualifiedAliasMemberAlias :: Identifier,
    QualifiedAliasMember -> Identifier
qualifiedAliasMemberMember :: Identifier,
    QualifiedAliasMember -> Maybe TypeArgumentList
qualifiedAliasMemberArguments :: (Maybe TypeArgumentList)}
  deriving (QualifiedAliasMember -> QualifiedAliasMember -> Bool
(QualifiedAliasMember -> QualifiedAliasMember -> Bool)
-> (QualifiedAliasMember -> QualifiedAliasMember -> Bool)
-> Eq QualifiedAliasMember
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
== :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
$c/= :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
/= :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
Eq, Eq QualifiedAliasMember
Eq QualifiedAliasMember =>
(QualifiedAliasMember -> QualifiedAliasMember -> Ordering)
-> (QualifiedAliasMember -> QualifiedAliasMember -> Bool)
-> (QualifiedAliasMember -> QualifiedAliasMember -> Bool)
-> (QualifiedAliasMember -> QualifiedAliasMember -> Bool)
-> (QualifiedAliasMember -> QualifiedAliasMember -> Bool)
-> (QualifiedAliasMember
    -> QualifiedAliasMember -> QualifiedAliasMember)
-> (QualifiedAliasMember
    -> QualifiedAliasMember -> QualifiedAliasMember)
-> Ord QualifiedAliasMember
QualifiedAliasMember -> QualifiedAliasMember -> Bool
QualifiedAliasMember -> QualifiedAliasMember -> Ordering
QualifiedAliasMember
-> QualifiedAliasMember -> QualifiedAliasMember
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: QualifiedAliasMember -> QualifiedAliasMember -> Ordering
compare :: QualifiedAliasMember -> QualifiedAliasMember -> Ordering
$c< :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
< :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
$c<= :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
<= :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
$c> :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
> :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
$c>= :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
>= :: QualifiedAliasMember -> QualifiedAliasMember -> Bool
$cmax :: QualifiedAliasMember
-> QualifiedAliasMember -> QualifiedAliasMember
max :: QualifiedAliasMember
-> QualifiedAliasMember -> QualifiedAliasMember
$cmin :: QualifiedAliasMember
-> QualifiedAliasMember -> QualifiedAliasMember
min :: QualifiedAliasMember
-> QualifiedAliasMember -> QualifiedAliasMember
Ord, ReadPrec [QualifiedAliasMember]
ReadPrec QualifiedAliasMember
Int -> ReadS QualifiedAliasMember
ReadS [QualifiedAliasMember]
(Int -> ReadS QualifiedAliasMember)
-> ReadS [QualifiedAliasMember]
-> ReadPrec QualifiedAliasMember
-> ReadPrec [QualifiedAliasMember]
-> Read QualifiedAliasMember
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS QualifiedAliasMember
readsPrec :: Int -> ReadS QualifiedAliasMember
$creadList :: ReadS [QualifiedAliasMember]
readList :: ReadS [QualifiedAliasMember]
$creadPrec :: ReadPrec QualifiedAliasMember
readPrec :: ReadPrec QualifiedAliasMember
$creadListPrec :: ReadPrec [QualifiedAliasMember]
readListPrec :: ReadPrec [QualifiedAliasMember]
Read, Int -> QualifiedAliasMember -> String -> String
[QualifiedAliasMember] -> String -> String
QualifiedAliasMember -> String
(Int -> QualifiedAliasMember -> String -> String)
-> (QualifiedAliasMember -> String)
-> ([QualifiedAliasMember] -> String -> String)
-> Show QualifiedAliasMember
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> QualifiedAliasMember -> String -> String
showsPrec :: Int -> QualifiedAliasMember -> String -> String
$cshow :: QualifiedAliasMember -> String
show :: QualifiedAliasMember -> String
$cshowList :: [QualifiedAliasMember] -> String -> String
showList :: [QualifiedAliasMember] -> String -> String
Show)

_QualifiedAliasMember :: Name
_QualifiedAliasMember = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.QualifiedAliasMember")

_QualifiedAliasMember_alias :: Name
_QualifiedAliasMember_alias = (String -> Name
Core.Name String
"alias")

_QualifiedAliasMember_member :: Name
_QualifiedAliasMember_member = (String -> Name
Core.Name String
"member")

_QualifiedAliasMember_arguments :: Name
_QualifiedAliasMember_arguments = (String -> Name
Core.Name String
"arguments")

data ClassDeclaration = 
  ClassDeclaration {
    ClassDeclaration -> Maybe Attributes
classDeclarationAttributes :: (Maybe Attributes),
    ClassDeclaration -> [ClassModifier]
classDeclarationModifiers :: [ClassModifier],
    ClassDeclaration -> ()
classDeclarationPartial :: (),
    ClassDeclaration -> Identifier
classDeclarationName :: Identifier,
    ClassDeclaration -> Maybe TypeParameterList
classDeclarationParameters :: (Maybe TypeParameterList),
    ClassDeclaration -> Maybe ClassBase
classDeclarationBase :: (Maybe ClassBase),
    ClassDeclaration -> [TypeParameterConstraintsClause]
classDeclarationConstraints :: [TypeParameterConstraintsClause],
    ClassDeclaration -> ClassBody
classDeclarationBody :: ClassBody}
  deriving (ClassDeclaration -> ClassDeclaration -> Bool
(ClassDeclaration -> ClassDeclaration -> Bool)
-> (ClassDeclaration -> ClassDeclaration -> Bool)
-> Eq ClassDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClassDeclaration -> ClassDeclaration -> Bool
== :: ClassDeclaration -> ClassDeclaration -> Bool
$c/= :: ClassDeclaration -> ClassDeclaration -> Bool
/= :: ClassDeclaration -> ClassDeclaration -> Bool
Eq, Eq ClassDeclaration
Eq ClassDeclaration =>
(ClassDeclaration -> ClassDeclaration -> Ordering)
-> (ClassDeclaration -> ClassDeclaration -> Bool)
-> (ClassDeclaration -> ClassDeclaration -> Bool)
-> (ClassDeclaration -> ClassDeclaration -> Bool)
-> (ClassDeclaration -> ClassDeclaration -> Bool)
-> (ClassDeclaration -> ClassDeclaration -> ClassDeclaration)
-> (ClassDeclaration -> ClassDeclaration -> ClassDeclaration)
-> Ord ClassDeclaration
ClassDeclaration -> ClassDeclaration -> Bool
ClassDeclaration -> ClassDeclaration -> Ordering
ClassDeclaration -> ClassDeclaration -> ClassDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ClassDeclaration -> ClassDeclaration -> Ordering
compare :: ClassDeclaration -> ClassDeclaration -> Ordering
$c< :: ClassDeclaration -> ClassDeclaration -> Bool
< :: ClassDeclaration -> ClassDeclaration -> Bool
$c<= :: ClassDeclaration -> ClassDeclaration -> Bool
<= :: ClassDeclaration -> ClassDeclaration -> Bool
$c> :: ClassDeclaration -> ClassDeclaration -> Bool
> :: ClassDeclaration -> ClassDeclaration -> Bool
$c>= :: ClassDeclaration -> ClassDeclaration -> Bool
>= :: ClassDeclaration -> ClassDeclaration -> Bool
$cmax :: ClassDeclaration -> ClassDeclaration -> ClassDeclaration
max :: ClassDeclaration -> ClassDeclaration -> ClassDeclaration
$cmin :: ClassDeclaration -> ClassDeclaration -> ClassDeclaration
min :: ClassDeclaration -> ClassDeclaration -> ClassDeclaration
Ord, ReadPrec [ClassDeclaration]
ReadPrec ClassDeclaration
Int -> ReadS ClassDeclaration
ReadS [ClassDeclaration]
(Int -> ReadS ClassDeclaration)
-> ReadS [ClassDeclaration]
-> ReadPrec ClassDeclaration
-> ReadPrec [ClassDeclaration]
-> Read ClassDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ClassDeclaration
readsPrec :: Int -> ReadS ClassDeclaration
$creadList :: ReadS [ClassDeclaration]
readList :: ReadS [ClassDeclaration]
$creadPrec :: ReadPrec ClassDeclaration
readPrec :: ReadPrec ClassDeclaration
$creadListPrec :: ReadPrec [ClassDeclaration]
readListPrec :: ReadPrec [ClassDeclaration]
Read, Int -> ClassDeclaration -> String -> String
[ClassDeclaration] -> String -> String
ClassDeclaration -> String
(Int -> ClassDeclaration -> String -> String)
-> (ClassDeclaration -> String)
-> ([ClassDeclaration] -> String -> String)
-> Show ClassDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ClassDeclaration -> String -> String
showsPrec :: Int -> ClassDeclaration -> String -> String
$cshow :: ClassDeclaration -> String
show :: ClassDeclaration -> String
$cshowList :: [ClassDeclaration] -> String -> String
showList :: [ClassDeclaration] -> String -> String
Show)

_ClassDeclaration :: Name
_ClassDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ClassDeclaration")

_ClassDeclaration_attributes :: Name
_ClassDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_ClassDeclaration_modifiers :: Name
_ClassDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_ClassDeclaration_partial :: Name
_ClassDeclaration_partial = (String -> Name
Core.Name String
"partial")

_ClassDeclaration_name :: Name
_ClassDeclaration_name = (String -> Name
Core.Name String
"name")

_ClassDeclaration_parameters :: Name
_ClassDeclaration_parameters = (String -> Name
Core.Name String
"parameters")

_ClassDeclaration_base :: Name
_ClassDeclaration_base = (String -> Name
Core.Name String
"base")

_ClassDeclaration_constraints :: Name
_ClassDeclaration_constraints = (String -> Name
Core.Name String
"constraints")

_ClassDeclaration_body :: Name
_ClassDeclaration_body = (String -> Name
Core.Name String
"body")

data ClassModifier = 
  ClassModifierNew  |
  ClassModifierPublic  |
  ClassModifierProtected  |
  ClassModifierInternal  |
  ClassModifierPrivate  |
  ClassModifierAbstract  |
  ClassModifierSealed  |
  ClassModifierStatic  |
  ClassModifierUnsafe 
  deriving (ClassModifier -> ClassModifier -> Bool
(ClassModifier -> ClassModifier -> Bool)
-> (ClassModifier -> ClassModifier -> Bool) -> Eq ClassModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClassModifier -> ClassModifier -> Bool
== :: ClassModifier -> ClassModifier -> Bool
$c/= :: ClassModifier -> ClassModifier -> Bool
/= :: ClassModifier -> ClassModifier -> Bool
Eq, Eq ClassModifier
Eq ClassModifier =>
(ClassModifier -> ClassModifier -> Ordering)
-> (ClassModifier -> ClassModifier -> Bool)
-> (ClassModifier -> ClassModifier -> Bool)
-> (ClassModifier -> ClassModifier -> Bool)
-> (ClassModifier -> ClassModifier -> Bool)
-> (ClassModifier -> ClassModifier -> ClassModifier)
-> (ClassModifier -> ClassModifier -> ClassModifier)
-> Ord ClassModifier
ClassModifier -> ClassModifier -> Bool
ClassModifier -> ClassModifier -> Ordering
ClassModifier -> ClassModifier -> ClassModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ClassModifier -> ClassModifier -> Ordering
compare :: ClassModifier -> ClassModifier -> Ordering
$c< :: ClassModifier -> ClassModifier -> Bool
< :: ClassModifier -> ClassModifier -> Bool
$c<= :: ClassModifier -> ClassModifier -> Bool
<= :: ClassModifier -> ClassModifier -> Bool
$c> :: ClassModifier -> ClassModifier -> Bool
> :: ClassModifier -> ClassModifier -> Bool
$c>= :: ClassModifier -> ClassModifier -> Bool
>= :: ClassModifier -> ClassModifier -> Bool
$cmax :: ClassModifier -> ClassModifier -> ClassModifier
max :: ClassModifier -> ClassModifier -> ClassModifier
$cmin :: ClassModifier -> ClassModifier -> ClassModifier
min :: ClassModifier -> ClassModifier -> ClassModifier
Ord, ReadPrec [ClassModifier]
ReadPrec ClassModifier
Int -> ReadS ClassModifier
ReadS [ClassModifier]
(Int -> ReadS ClassModifier)
-> ReadS [ClassModifier]
-> ReadPrec ClassModifier
-> ReadPrec [ClassModifier]
-> Read ClassModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ClassModifier
readsPrec :: Int -> ReadS ClassModifier
$creadList :: ReadS [ClassModifier]
readList :: ReadS [ClassModifier]
$creadPrec :: ReadPrec ClassModifier
readPrec :: ReadPrec ClassModifier
$creadListPrec :: ReadPrec [ClassModifier]
readListPrec :: ReadPrec [ClassModifier]
Read, Int -> ClassModifier -> String -> String
[ClassModifier] -> String -> String
ClassModifier -> String
(Int -> ClassModifier -> String -> String)
-> (ClassModifier -> String)
-> ([ClassModifier] -> String -> String)
-> Show ClassModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ClassModifier -> String -> String
showsPrec :: Int -> ClassModifier -> String -> String
$cshow :: ClassModifier -> String
show :: ClassModifier -> String
$cshowList :: [ClassModifier] -> String -> String
showList :: [ClassModifier] -> String -> String
Show)

_ClassModifier :: Name
_ClassModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ClassModifier")

_ClassModifier_new :: Name
_ClassModifier_new = (String -> Name
Core.Name String
"new")

_ClassModifier_public :: Name
_ClassModifier_public = (String -> Name
Core.Name String
"public")

_ClassModifier_protected :: Name
_ClassModifier_protected = (String -> Name
Core.Name String
"protected")

_ClassModifier_internal :: Name
_ClassModifier_internal = (String -> Name
Core.Name String
"internal")

_ClassModifier_private :: Name
_ClassModifier_private = (String -> Name
Core.Name String
"private")

_ClassModifier_abstract :: Name
_ClassModifier_abstract = (String -> Name
Core.Name String
"abstract")

_ClassModifier_sealed :: Name
_ClassModifier_sealed = (String -> Name
Core.Name String
"sealed")

_ClassModifier_static :: Name
_ClassModifier_static = (String -> Name
Core.Name String
"static")

_ClassModifier_unsafe :: Name
_ClassModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

newtype TypeParameterList = 
  TypeParameterList {
    TypeParameterList -> [TypeParameterPart]
unTypeParameterList :: [TypeParameterPart]}
  deriving (TypeParameterList -> TypeParameterList -> Bool
(TypeParameterList -> TypeParameterList -> Bool)
-> (TypeParameterList -> TypeParameterList -> Bool)
-> Eq TypeParameterList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeParameterList -> TypeParameterList -> Bool
== :: TypeParameterList -> TypeParameterList -> Bool
$c/= :: TypeParameterList -> TypeParameterList -> Bool
/= :: TypeParameterList -> TypeParameterList -> Bool
Eq, Eq TypeParameterList
Eq TypeParameterList =>
(TypeParameterList -> TypeParameterList -> Ordering)
-> (TypeParameterList -> TypeParameterList -> Bool)
-> (TypeParameterList -> TypeParameterList -> Bool)
-> (TypeParameterList -> TypeParameterList -> Bool)
-> (TypeParameterList -> TypeParameterList -> Bool)
-> (TypeParameterList -> TypeParameterList -> TypeParameterList)
-> (TypeParameterList -> TypeParameterList -> TypeParameterList)
-> Ord TypeParameterList
TypeParameterList -> TypeParameterList -> Bool
TypeParameterList -> TypeParameterList -> Ordering
TypeParameterList -> TypeParameterList -> TypeParameterList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TypeParameterList -> TypeParameterList -> Ordering
compare :: TypeParameterList -> TypeParameterList -> Ordering
$c< :: TypeParameterList -> TypeParameterList -> Bool
< :: TypeParameterList -> TypeParameterList -> Bool
$c<= :: TypeParameterList -> TypeParameterList -> Bool
<= :: TypeParameterList -> TypeParameterList -> Bool
$c> :: TypeParameterList -> TypeParameterList -> Bool
> :: TypeParameterList -> TypeParameterList -> Bool
$c>= :: TypeParameterList -> TypeParameterList -> Bool
>= :: TypeParameterList -> TypeParameterList -> Bool
$cmax :: TypeParameterList -> TypeParameterList -> TypeParameterList
max :: TypeParameterList -> TypeParameterList -> TypeParameterList
$cmin :: TypeParameterList -> TypeParameterList -> TypeParameterList
min :: TypeParameterList -> TypeParameterList -> TypeParameterList
Ord, ReadPrec [TypeParameterList]
ReadPrec TypeParameterList
Int -> ReadS TypeParameterList
ReadS [TypeParameterList]
(Int -> ReadS TypeParameterList)
-> ReadS [TypeParameterList]
-> ReadPrec TypeParameterList
-> ReadPrec [TypeParameterList]
-> Read TypeParameterList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeParameterList
readsPrec :: Int -> ReadS TypeParameterList
$creadList :: ReadS [TypeParameterList]
readList :: ReadS [TypeParameterList]
$creadPrec :: ReadPrec TypeParameterList
readPrec :: ReadPrec TypeParameterList
$creadListPrec :: ReadPrec [TypeParameterList]
readListPrec :: ReadPrec [TypeParameterList]
Read, Int -> TypeParameterList -> String -> String
[TypeParameterList] -> String -> String
TypeParameterList -> String
(Int -> TypeParameterList -> String -> String)
-> (TypeParameterList -> String)
-> ([TypeParameterList] -> String -> String)
-> Show TypeParameterList
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TypeParameterList -> String -> String
showsPrec :: Int -> TypeParameterList -> String -> String
$cshow :: TypeParameterList -> String
show :: TypeParameterList -> String
$cshowList :: [TypeParameterList] -> String -> String
showList :: [TypeParameterList] -> String -> String
Show)

_TypeParameterList :: Name
_TypeParameterList = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TypeParameterList")

data TypeParameterPart = 
  TypeParameterPart {
    TypeParameterPart -> Maybe Attributes
typeParameterPartAttributes :: (Maybe Attributes),
    TypeParameterPart -> TypeParameter
typeParameterPartName :: TypeParameter}
  deriving (TypeParameterPart -> TypeParameterPart -> Bool
(TypeParameterPart -> TypeParameterPart -> Bool)
-> (TypeParameterPart -> TypeParameterPart -> Bool)
-> Eq TypeParameterPart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeParameterPart -> TypeParameterPart -> Bool
== :: TypeParameterPart -> TypeParameterPart -> Bool
$c/= :: TypeParameterPart -> TypeParameterPart -> Bool
/= :: TypeParameterPart -> TypeParameterPart -> Bool
Eq, Eq TypeParameterPart
Eq TypeParameterPart =>
(TypeParameterPart -> TypeParameterPart -> Ordering)
-> (TypeParameterPart -> TypeParameterPart -> Bool)
-> (TypeParameterPart -> TypeParameterPart -> Bool)
-> (TypeParameterPart -> TypeParameterPart -> Bool)
-> (TypeParameterPart -> TypeParameterPart -> Bool)
-> (TypeParameterPart -> TypeParameterPart -> TypeParameterPart)
-> (TypeParameterPart -> TypeParameterPart -> TypeParameterPart)
-> Ord TypeParameterPart
TypeParameterPart -> TypeParameterPart -> Bool
TypeParameterPart -> TypeParameterPart -> Ordering
TypeParameterPart -> TypeParameterPart -> TypeParameterPart
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TypeParameterPart -> TypeParameterPart -> Ordering
compare :: TypeParameterPart -> TypeParameterPart -> Ordering
$c< :: TypeParameterPart -> TypeParameterPart -> Bool
< :: TypeParameterPart -> TypeParameterPart -> Bool
$c<= :: TypeParameterPart -> TypeParameterPart -> Bool
<= :: TypeParameterPart -> TypeParameterPart -> Bool
$c> :: TypeParameterPart -> TypeParameterPart -> Bool
> :: TypeParameterPart -> TypeParameterPart -> Bool
$c>= :: TypeParameterPart -> TypeParameterPart -> Bool
>= :: TypeParameterPart -> TypeParameterPart -> Bool
$cmax :: TypeParameterPart -> TypeParameterPart -> TypeParameterPart
max :: TypeParameterPart -> TypeParameterPart -> TypeParameterPart
$cmin :: TypeParameterPart -> TypeParameterPart -> TypeParameterPart
min :: TypeParameterPart -> TypeParameterPart -> TypeParameterPart
Ord, ReadPrec [TypeParameterPart]
ReadPrec TypeParameterPart
Int -> ReadS TypeParameterPart
ReadS [TypeParameterPart]
(Int -> ReadS TypeParameterPart)
-> ReadS [TypeParameterPart]
-> ReadPrec TypeParameterPart
-> ReadPrec [TypeParameterPart]
-> Read TypeParameterPart
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeParameterPart
readsPrec :: Int -> ReadS TypeParameterPart
$creadList :: ReadS [TypeParameterPart]
readList :: ReadS [TypeParameterPart]
$creadPrec :: ReadPrec TypeParameterPart
readPrec :: ReadPrec TypeParameterPart
$creadListPrec :: ReadPrec [TypeParameterPart]
readListPrec :: ReadPrec [TypeParameterPart]
Read, Int -> TypeParameterPart -> String -> String
[TypeParameterPart] -> String -> String
TypeParameterPart -> String
(Int -> TypeParameterPart -> String -> String)
-> (TypeParameterPart -> String)
-> ([TypeParameterPart] -> String -> String)
-> Show TypeParameterPart
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TypeParameterPart -> String -> String
showsPrec :: Int -> TypeParameterPart -> String -> String
$cshow :: TypeParameterPart -> String
show :: TypeParameterPart -> String
$cshowList :: [TypeParameterPart] -> String -> String
showList :: [TypeParameterPart] -> String -> String
Show)

_TypeParameterPart :: Name
_TypeParameterPart = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TypeParameterPart")

_TypeParameterPart_attributes :: Name
_TypeParameterPart_attributes = (String -> Name
Core.Name String
"attributes")

_TypeParameterPart_name :: Name
_TypeParameterPart_name = (String -> Name
Core.Name String
"name")

data ClassBase = 
  ClassBaseClass (Maybe ClassType) |
  ClassBaseInterfaces [InterfaceType]
  deriving (ClassBase -> ClassBase -> Bool
(ClassBase -> ClassBase -> Bool)
-> (ClassBase -> ClassBase -> Bool) -> Eq ClassBase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClassBase -> ClassBase -> Bool
== :: ClassBase -> ClassBase -> Bool
$c/= :: ClassBase -> ClassBase -> Bool
/= :: ClassBase -> ClassBase -> Bool
Eq, Eq ClassBase
Eq ClassBase =>
(ClassBase -> ClassBase -> Ordering)
-> (ClassBase -> ClassBase -> Bool)
-> (ClassBase -> ClassBase -> Bool)
-> (ClassBase -> ClassBase -> Bool)
-> (ClassBase -> ClassBase -> Bool)
-> (ClassBase -> ClassBase -> ClassBase)
-> (ClassBase -> ClassBase -> ClassBase)
-> Ord ClassBase
ClassBase -> ClassBase -> Bool
ClassBase -> ClassBase -> Ordering
ClassBase -> ClassBase -> ClassBase
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ClassBase -> ClassBase -> Ordering
compare :: ClassBase -> ClassBase -> Ordering
$c< :: ClassBase -> ClassBase -> Bool
< :: ClassBase -> ClassBase -> Bool
$c<= :: ClassBase -> ClassBase -> Bool
<= :: ClassBase -> ClassBase -> Bool
$c> :: ClassBase -> ClassBase -> Bool
> :: ClassBase -> ClassBase -> Bool
$c>= :: ClassBase -> ClassBase -> Bool
>= :: ClassBase -> ClassBase -> Bool
$cmax :: ClassBase -> ClassBase -> ClassBase
max :: ClassBase -> ClassBase -> ClassBase
$cmin :: ClassBase -> ClassBase -> ClassBase
min :: ClassBase -> ClassBase -> ClassBase
Ord, ReadPrec [ClassBase]
ReadPrec ClassBase
Int -> ReadS ClassBase
ReadS [ClassBase]
(Int -> ReadS ClassBase)
-> ReadS [ClassBase]
-> ReadPrec ClassBase
-> ReadPrec [ClassBase]
-> Read ClassBase
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ClassBase
readsPrec :: Int -> ReadS ClassBase
$creadList :: ReadS [ClassBase]
readList :: ReadS [ClassBase]
$creadPrec :: ReadPrec ClassBase
readPrec :: ReadPrec ClassBase
$creadListPrec :: ReadPrec [ClassBase]
readListPrec :: ReadPrec [ClassBase]
Read, Int -> ClassBase -> String -> String
[ClassBase] -> String -> String
ClassBase -> String
(Int -> ClassBase -> String -> String)
-> (ClassBase -> String)
-> ([ClassBase] -> String -> String)
-> Show ClassBase
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ClassBase -> String -> String
showsPrec :: Int -> ClassBase -> String -> String
$cshow :: ClassBase -> String
show :: ClassBase -> String
$cshowList :: [ClassBase] -> String -> String
showList :: [ClassBase] -> String -> String
Show)

_ClassBase :: Name
_ClassBase = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ClassBase")

_ClassBase_class :: Name
_ClassBase_class = (String -> Name
Core.Name String
"class")

_ClassBase_interfaces :: Name
_ClassBase_interfaces = (String -> Name
Core.Name String
"interfaces")

data TypeParameterConstraintsClause = 
  TypeParameterConstraintsClause {
    TypeParameterConstraintsClause -> TypeParameter
typeParameterConstraintsClauseParameter :: TypeParameter,
    TypeParameterConstraintsClause -> [TypeParameterConstraints]
typeParameterConstraintsClauseConstraints :: [TypeParameterConstraints]}
  deriving (TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
(TypeParameterConstraintsClause
 -> TypeParameterConstraintsClause -> Bool)
-> (TypeParameterConstraintsClause
    -> TypeParameterConstraintsClause -> Bool)
-> Eq TypeParameterConstraintsClause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
== :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
$c/= :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
/= :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
Eq, Eq TypeParameterConstraintsClause
Eq TypeParameterConstraintsClause =>
(TypeParameterConstraintsClause
 -> TypeParameterConstraintsClause -> Ordering)
-> (TypeParameterConstraintsClause
    -> TypeParameterConstraintsClause -> Bool)
-> (TypeParameterConstraintsClause
    -> TypeParameterConstraintsClause -> Bool)
-> (TypeParameterConstraintsClause
    -> TypeParameterConstraintsClause -> Bool)
-> (TypeParameterConstraintsClause
    -> TypeParameterConstraintsClause -> Bool)
-> (TypeParameterConstraintsClause
    -> TypeParameterConstraintsClause
    -> TypeParameterConstraintsClause)
-> (TypeParameterConstraintsClause
    -> TypeParameterConstraintsClause
    -> TypeParameterConstraintsClause)
-> Ord TypeParameterConstraintsClause
TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Ordering
TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> TypeParameterConstraintsClause
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Ordering
compare :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Ordering
$c< :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
< :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
$c<= :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
<= :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
$c> :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
> :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
$c>= :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
>= :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> Bool
$cmax :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> TypeParameterConstraintsClause
max :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> TypeParameterConstraintsClause
$cmin :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> TypeParameterConstraintsClause
min :: TypeParameterConstraintsClause
-> TypeParameterConstraintsClause -> TypeParameterConstraintsClause
Ord, ReadPrec [TypeParameterConstraintsClause]
ReadPrec TypeParameterConstraintsClause
Int -> ReadS TypeParameterConstraintsClause
ReadS [TypeParameterConstraintsClause]
(Int -> ReadS TypeParameterConstraintsClause)
-> ReadS [TypeParameterConstraintsClause]
-> ReadPrec TypeParameterConstraintsClause
-> ReadPrec [TypeParameterConstraintsClause]
-> Read TypeParameterConstraintsClause
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeParameterConstraintsClause
readsPrec :: Int -> ReadS TypeParameterConstraintsClause
$creadList :: ReadS [TypeParameterConstraintsClause]
readList :: ReadS [TypeParameterConstraintsClause]
$creadPrec :: ReadPrec TypeParameterConstraintsClause
readPrec :: ReadPrec TypeParameterConstraintsClause
$creadListPrec :: ReadPrec [TypeParameterConstraintsClause]
readListPrec :: ReadPrec [TypeParameterConstraintsClause]
Read, Int -> TypeParameterConstraintsClause -> String -> String
[TypeParameterConstraintsClause] -> String -> String
TypeParameterConstraintsClause -> String
(Int -> TypeParameterConstraintsClause -> String -> String)
-> (TypeParameterConstraintsClause -> String)
-> ([TypeParameterConstraintsClause] -> String -> String)
-> Show TypeParameterConstraintsClause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TypeParameterConstraintsClause -> String -> String
showsPrec :: Int -> TypeParameterConstraintsClause -> String -> String
$cshow :: TypeParameterConstraintsClause -> String
show :: TypeParameterConstraintsClause -> String
$cshowList :: [TypeParameterConstraintsClause] -> String -> String
showList :: [TypeParameterConstraintsClause] -> String -> String
Show)

_TypeParameterConstraintsClause :: Name
_TypeParameterConstraintsClause = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TypeParameterConstraintsClause")

_TypeParameterConstraintsClause_parameter :: Name
_TypeParameterConstraintsClause_parameter = (String -> Name
Core.Name String
"parameter")

_TypeParameterConstraintsClause_constraints :: Name
_TypeParameterConstraintsClause_constraints = (String -> Name
Core.Name String
"constraints")

data TypeParameterConstraints = 
  TypeParameterConstraints {
    TypeParameterConstraints -> Maybe PrimaryConstraint
typeParameterConstraintsPrimary :: (Maybe PrimaryConstraint),
    TypeParameterConstraints -> Maybe SecondaryConstraints
typeParameterConstraintsSecondary :: (Maybe SecondaryConstraints),
    TypeParameterConstraints -> Bool
typeParameterConstraintsConstructor :: Bool}
  deriving (TypeParameterConstraints -> TypeParameterConstraints -> Bool
(TypeParameterConstraints -> TypeParameterConstraints -> Bool)
-> (TypeParameterConstraints -> TypeParameterConstraints -> Bool)
-> Eq TypeParameterConstraints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
== :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
$c/= :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
/= :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
Eq, Eq TypeParameterConstraints
Eq TypeParameterConstraints =>
(TypeParameterConstraints -> TypeParameterConstraints -> Ordering)
-> (TypeParameterConstraints -> TypeParameterConstraints -> Bool)
-> (TypeParameterConstraints -> TypeParameterConstraints -> Bool)
-> (TypeParameterConstraints -> TypeParameterConstraints -> Bool)
-> (TypeParameterConstraints -> TypeParameterConstraints -> Bool)
-> (TypeParameterConstraints
    -> TypeParameterConstraints -> TypeParameterConstraints)
-> (TypeParameterConstraints
    -> TypeParameterConstraints -> TypeParameterConstraints)
-> Ord TypeParameterConstraints
TypeParameterConstraints -> TypeParameterConstraints -> Bool
TypeParameterConstraints -> TypeParameterConstraints -> Ordering
TypeParameterConstraints
-> TypeParameterConstraints -> TypeParameterConstraints
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TypeParameterConstraints -> TypeParameterConstraints -> Ordering
compare :: TypeParameterConstraints -> TypeParameterConstraints -> Ordering
$c< :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
< :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
$c<= :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
<= :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
$c> :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
> :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
$c>= :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
>= :: TypeParameterConstraints -> TypeParameterConstraints -> Bool
$cmax :: TypeParameterConstraints
-> TypeParameterConstraints -> TypeParameterConstraints
max :: TypeParameterConstraints
-> TypeParameterConstraints -> TypeParameterConstraints
$cmin :: TypeParameterConstraints
-> TypeParameterConstraints -> TypeParameterConstraints
min :: TypeParameterConstraints
-> TypeParameterConstraints -> TypeParameterConstraints
Ord, ReadPrec [TypeParameterConstraints]
ReadPrec TypeParameterConstraints
Int -> ReadS TypeParameterConstraints
ReadS [TypeParameterConstraints]
(Int -> ReadS TypeParameterConstraints)
-> ReadS [TypeParameterConstraints]
-> ReadPrec TypeParameterConstraints
-> ReadPrec [TypeParameterConstraints]
-> Read TypeParameterConstraints
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeParameterConstraints
readsPrec :: Int -> ReadS TypeParameterConstraints
$creadList :: ReadS [TypeParameterConstraints]
readList :: ReadS [TypeParameterConstraints]
$creadPrec :: ReadPrec TypeParameterConstraints
readPrec :: ReadPrec TypeParameterConstraints
$creadListPrec :: ReadPrec [TypeParameterConstraints]
readListPrec :: ReadPrec [TypeParameterConstraints]
Read, Int -> TypeParameterConstraints -> String -> String
[TypeParameterConstraints] -> String -> String
TypeParameterConstraints -> String
(Int -> TypeParameterConstraints -> String -> String)
-> (TypeParameterConstraints -> String)
-> ([TypeParameterConstraints] -> String -> String)
-> Show TypeParameterConstraints
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TypeParameterConstraints -> String -> String
showsPrec :: Int -> TypeParameterConstraints -> String -> String
$cshow :: TypeParameterConstraints -> String
show :: TypeParameterConstraints -> String
$cshowList :: [TypeParameterConstraints] -> String -> String
showList :: [TypeParameterConstraints] -> String -> String
Show)

_TypeParameterConstraints :: Name
_TypeParameterConstraints = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.TypeParameterConstraints")

_TypeParameterConstraints_primary :: Name
_TypeParameterConstraints_primary = (String -> Name
Core.Name String
"primary")

_TypeParameterConstraints_secondary :: Name
_TypeParameterConstraints_secondary = (String -> Name
Core.Name String
"secondary")

_TypeParameterConstraints_constructor :: Name
_TypeParameterConstraints_constructor = (String -> Name
Core.Name String
"constructor")

data PrimaryConstraint = 
  PrimaryConstraintClassType ClassType |
  PrimaryConstraintClass  |
  PrimaryConstraintStruct  |
  PrimaryConstraintUnmanaged 
  deriving (PrimaryConstraint -> PrimaryConstraint -> Bool
(PrimaryConstraint -> PrimaryConstraint -> Bool)
-> (PrimaryConstraint -> PrimaryConstraint -> Bool)
-> Eq PrimaryConstraint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrimaryConstraint -> PrimaryConstraint -> Bool
== :: PrimaryConstraint -> PrimaryConstraint -> Bool
$c/= :: PrimaryConstraint -> PrimaryConstraint -> Bool
/= :: PrimaryConstraint -> PrimaryConstraint -> Bool
Eq, Eq PrimaryConstraint
Eq PrimaryConstraint =>
(PrimaryConstraint -> PrimaryConstraint -> Ordering)
-> (PrimaryConstraint -> PrimaryConstraint -> Bool)
-> (PrimaryConstraint -> PrimaryConstraint -> Bool)
-> (PrimaryConstraint -> PrimaryConstraint -> Bool)
-> (PrimaryConstraint -> PrimaryConstraint -> Bool)
-> (PrimaryConstraint -> PrimaryConstraint -> PrimaryConstraint)
-> (PrimaryConstraint -> PrimaryConstraint -> PrimaryConstraint)
-> Ord PrimaryConstraint
PrimaryConstraint -> PrimaryConstraint -> Bool
PrimaryConstraint -> PrimaryConstraint -> Ordering
PrimaryConstraint -> PrimaryConstraint -> PrimaryConstraint
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PrimaryConstraint -> PrimaryConstraint -> Ordering
compare :: PrimaryConstraint -> PrimaryConstraint -> Ordering
$c< :: PrimaryConstraint -> PrimaryConstraint -> Bool
< :: PrimaryConstraint -> PrimaryConstraint -> Bool
$c<= :: PrimaryConstraint -> PrimaryConstraint -> Bool
<= :: PrimaryConstraint -> PrimaryConstraint -> Bool
$c> :: PrimaryConstraint -> PrimaryConstraint -> Bool
> :: PrimaryConstraint -> PrimaryConstraint -> Bool
$c>= :: PrimaryConstraint -> PrimaryConstraint -> Bool
>= :: PrimaryConstraint -> PrimaryConstraint -> Bool
$cmax :: PrimaryConstraint -> PrimaryConstraint -> PrimaryConstraint
max :: PrimaryConstraint -> PrimaryConstraint -> PrimaryConstraint
$cmin :: PrimaryConstraint -> PrimaryConstraint -> PrimaryConstraint
min :: PrimaryConstraint -> PrimaryConstraint -> PrimaryConstraint
Ord, ReadPrec [PrimaryConstraint]
ReadPrec PrimaryConstraint
Int -> ReadS PrimaryConstraint
ReadS [PrimaryConstraint]
(Int -> ReadS PrimaryConstraint)
-> ReadS [PrimaryConstraint]
-> ReadPrec PrimaryConstraint
-> ReadPrec [PrimaryConstraint]
-> Read PrimaryConstraint
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PrimaryConstraint
readsPrec :: Int -> ReadS PrimaryConstraint
$creadList :: ReadS [PrimaryConstraint]
readList :: ReadS [PrimaryConstraint]
$creadPrec :: ReadPrec PrimaryConstraint
readPrec :: ReadPrec PrimaryConstraint
$creadListPrec :: ReadPrec [PrimaryConstraint]
readListPrec :: ReadPrec [PrimaryConstraint]
Read, Int -> PrimaryConstraint -> String -> String
[PrimaryConstraint] -> String -> String
PrimaryConstraint -> String
(Int -> PrimaryConstraint -> String -> String)
-> (PrimaryConstraint -> String)
-> ([PrimaryConstraint] -> String -> String)
-> Show PrimaryConstraint
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PrimaryConstraint -> String -> String
showsPrec :: Int -> PrimaryConstraint -> String -> String
$cshow :: PrimaryConstraint -> String
show :: PrimaryConstraint -> String
$cshowList :: [PrimaryConstraint] -> String -> String
showList :: [PrimaryConstraint] -> String -> String
Show)

_PrimaryConstraint :: Name
_PrimaryConstraint = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PrimaryConstraint")

_PrimaryConstraint_classType :: Name
_PrimaryConstraint_classType = (String -> Name
Core.Name String
"classType")

_PrimaryConstraint_class :: Name
_PrimaryConstraint_class = (String -> Name
Core.Name String
"class")

_PrimaryConstraint_struct :: Name
_PrimaryConstraint_struct = (String -> Name
Core.Name String
"struct")

_PrimaryConstraint_unmanaged :: Name
_PrimaryConstraint_unmanaged = (String -> Name
Core.Name String
"unmanaged")

newtype SecondaryConstraints = 
  SecondaryConstraints {
    SecondaryConstraints -> [SecondaryConstraint]
unSecondaryConstraints :: [SecondaryConstraint]}
  deriving (SecondaryConstraints -> SecondaryConstraints -> Bool
(SecondaryConstraints -> SecondaryConstraints -> Bool)
-> (SecondaryConstraints -> SecondaryConstraints -> Bool)
-> Eq SecondaryConstraints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SecondaryConstraints -> SecondaryConstraints -> Bool
== :: SecondaryConstraints -> SecondaryConstraints -> Bool
$c/= :: SecondaryConstraints -> SecondaryConstraints -> Bool
/= :: SecondaryConstraints -> SecondaryConstraints -> Bool
Eq, Eq SecondaryConstraints
Eq SecondaryConstraints =>
(SecondaryConstraints -> SecondaryConstraints -> Ordering)
-> (SecondaryConstraints -> SecondaryConstraints -> Bool)
-> (SecondaryConstraints -> SecondaryConstraints -> Bool)
-> (SecondaryConstraints -> SecondaryConstraints -> Bool)
-> (SecondaryConstraints -> SecondaryConstraints -> Bool)
-> (SecondaryConstraints
    -> SecondaryConstraints -> SecondaryConstraints)
-> (SecondaryConstraints
    -> SecondaryConstraints -> SecondaryConstraints)
-> Ord SecondaryConstraints
SecondaryConstraints -> SecondaryConstraints -> Bool
SecondaryConstraints -> SecondaryConstraints -> Ordering
SecondaryConstraints
-> SecondaryConstraints -> SecondaryConstraints
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SecondaryConstraints -> SecondaryConstraints -> Ordering
compare :: SecondaryConstraints -> SecondaryConstraints -> Ordering
$c< :: SecondaryConstraints -> SecondaryConstraints -> Bool
< :: SecondaryConstraints -> SecondaryConstraints -> Bool
$c<= :: SecondaryConstraints -> SecondaryConstraints -> Bool
<= :: SecondaryConstraints -> SecondaryConstraints -> Bool
$c> :: SecondaryConstraints -> SecondaryConstraints -> Bool
> :: SecondaryConstraints -> SecondaryConstraints -> Bool
$c>= :: SecondaryConstraints -> SecondaryConstraints -> Bool
>= :: SecondaryConstraints -> SecondaryConstraints -> Bool
$cmax :: SecondaryConstraints
-> SecondaryConstraints -> SecondaryConstraints
max :: SecondaryConstraints
-> SecondaryConstraints -> SecondaryConstraints
$cmin :: SecondaryConstraints
-> SecondaryConstraints -> SecondaryConstraints
min :: SecondaryConstraints
-> SecondaryConstraints -> SecondaryConstraints
Ord, ReadPrec [SecondaryConstraints]
ReadPrec SecondaryConstraints
Int -> ReadS SecondaryConstraints
ReadS [SecondaryConstraints]
(Int -> ReadS SecondaryConstraints)
-> ReadS [SecondaryConstraints]
-> ReadPrec SecondaryConstraints
-> ReadPrec [SecondaryConstraints]
-> Read SecondaryConstraints
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SecondaryConstraints
readsPrec :: Int -> ReadS SecondaryConstraints
$creadList :: ReadS [SecondaryConstraints]
readList :: ReadS [SecondaryConstraints]
$creadPrec :: ReadPrec SecondaryConstraints
readPrec :: ReadPrec SecondaryConstraints
$creadListPrec :: ReadPrec [SecondaryConstraints]
readListPrec :: ReadPrec [SecondaryConstraints]
Read, Int -> SecondaryConstraints -> String -> String
[SecondaryConstraints] -> String -> String
SecondaryConstraints -> String
(Int -> SecondaryConstraints -> String -> String)
-> (SecondaryConstraints -> String)
-> ([SecondaryConstraints] -> String -> String)
-> Show SecondaryConstraints
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SecondaryConstraints -> String -> String
showsPrec :: Int -> SecondaryConstraints -> String -> String
$cshow :: SecondaryConstraints -> String
show :: SecondaryConstraints -> String
$cshowList :: [SecondaryConstraints] -> String -> String
showList :: [SecondaryConstraints] -> String -> String
Show)

_SecondaryConstraints :: Name
_SecondaryConstraints = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SecondaryConstraints")

data SecondaryConstraint = 
  SecondaryConstraintInterface InterfaceType |
  SecondaryConstraintParameter TypeParameter
  deriving (SecondaryConstraint -> SecondaryConstraint -> Bool
(SecondaryConstraint -> SecondaryConstraint -> Bool)
-> (SecondaryConstraint -> SecondaryConstraint -> Bool)
-> Eq SecondaryConstraint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SecondaryConstraint -> SecondaryConstraint -> Bool
== :: SecondaryConstraint -> SecondaryConstraint -> Bool
$c/= :: SecondaryConstraint -> SecondaryConstraint -> Bool
/= :: SecondaryConstraint -> SecondaryConstraint -> Bool
Eq, Eq SecondaryConstraint
Eq SecondaryConstraint =>
(SecondaryConstraint -> SecondaryConstraint -> Ordering)
-> (SecondaryConstraint -> SecondaryConstraint -> Bool)
-> (SecondaryConstraint -> SecondaryConstraint -> Bool)
-> (SecondaryConstraint -> SecondaryConstraint -> Bool)
-> (SecondaryConstraint -> SecondaryConstraint -> Bool)
-> (SecondaryConstraint
    -> SecondaryConstraint -> SecondaryConstraint)
-> (SecondaryConstraint
    -> SecondaryConstraint -> SecondaryConstraint)
-> Ord SecondaryConstraint
SecondaryConstraint -> SecondaryConstraint -> Bool
SecondaryConstraint -> SecondaryConstraint -> Ordering
SecondaryConstraint -> SecondaryConstraint -> SecondaryConstraint
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SecondaryConstraint -> SecondaryConstraint -> Ordering
compare :: SecondaryConstraint -> SecondaryConstraint -> Ordering
$c< :: SecondaryConstraint -> SecondaryConstraint -> Bool
< :: SecondaryConstraint -> SecondaryConstraint -> Bool
$c<= :: SecondaryConstraint -> SecondaryConstraint -> Bool
<= :: SecondaryConstraint -> SecondaryConstraint -> Bool
$c> :: SecondaryConstraint -> SecondaryConstraint -> Bool
> :: SecondaryConstraint -> SecondaryConstraint -> Bool
$c>= :: SecondaryConstraint -> SecondaryConstraint -> Bool
>= :: SecondaryConstraint -> SecondaryConstraint -> Bool
$cmax :: SecondaryConstraint -> SecondaryConstraint -> SecondaryConstraint
max :: SecondaryConstraint -> SecondaryConstraint -> SecondaryConstraint
$cmin :: SecondaryConstraint -> SecondaryConstraint -> SecondaryConstraint
min :: SecondaryConstraint -> SecondaryConstraint -> SecondaryConstraint
Ord, ReadPrec [SecondaryConstraint]
ReadPrec SecondaryConstraint
Int -> ReadS SecondaryConstraint
ReadS [SecondaryConstraint]
(Int -> ReadS SecondaryConstraint)
-> ReadS [SecondaryConstraint]
-> ReadPrec SecondaryConstraint
-> ReadPrec [SecondaryConstraint]
-> Read SecondaryConstraint
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SecondaryConstraint
readsPrec :: Int -> ReadS SecondaryConstraint
$creadList :: ReadS [SecondaryConstraint]
readList :: ReadS [SecondaryConstraint]
$creadPrec :: ReadPrec SecondaryConstraint
readPrec :: ReadPrec SecondaryConstraint
$creadListPrec :: ReadPrec [SecondaryConstraint]
readListPrec :: ReadPrec [SecondaryConstraint]
Read, Int -> SecondaryConstraint -> String -> String
[SecondaryConstraint] -> String -> String
SecondaryConstraint -> String
(Int -> SecondaryConstraint -> String -> String)
-> (SecondaryConstraint -> String)
-> ([SecondaryConstraint] -> String -> String)
-> Show SecondaryConstraint
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> SecondaryConstraint -> String -> String
showsPrec :: Int -> SecondaryConstraint -> String -> String
$cshow :: SecondaryConstraint -> String
show :: SecondaryConstraint -> String
$cshowList :: [SecondaryConstraint] -> String -> String
showList :: [SecondaryConstraint] -> String -> String
Show)

_SecondaryConstraint :: Name
_SecondaryConstraint = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.SecondaryConstraint")

_SecondaryConstraint_interface :: Name
_SecondaryConstraint_interface = (String -> Name
Core.Name String
"interface")

_SecondaryConstraint_parameter :: Name
_SecondaryConstraint_parameter = (String -> Name
Core.Name String
"parameter")

newtype ClassBody = 
  ClassBody {
    ClassBody -> [ClassMemberDeclaration]
unClassBody :: [ClassMemberDeclaration]}
  deriving (ClassBody -> ClassBody -> Bool
(ClassBody -> ClassBody -> Bool)
-> (ClassBody -> ClassBody -> Bool) -> Eq ClassBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClassBody -> ClassBody -> Bool
== :: ClassBody -> ClassBody -> Bool
$c/= :: ClassBody -> ClassBody -> Bool
/= :: ClassBody -> ClassBody -> Bool
Eq, Eq ClassBody
Eq ClassBody =>
(ClassBody -> ClassBody -> Ordering)
-> (ClassBody -> ClassBody -> Bool)
-> (ClassBody -> ClassBody -> Bool)
-> (ClassBody -> ClassBody -> Bool)
-> (ClassBody -> ClassBody -> Bool)
-> (ClassBody -> ClassBody -> ClassBody)
-> (ClassBody -> ClassBody -> ClassBody)
-> Ord ClassBody
ClassBody -> ClassBody -> Bool
ClassBody -> ClassBody -> Ordering
ClassBody -> ClassBody -> ClassBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ClassBody -> ClassBody -> Ordering
compare :: ClassBody -> ClassBody -> Ordering
$c< :: ClassBody -> ClassBody -> Bool
< :: ClassBody -> ClassBody -> Bool
$c<= :: ClassBody -> ClassBody -> Bool
<= :: ClassBody -> ClassBody -> Bool
$c> :: ClassBody -> ClassBody -> Bool
> :: ClassBody -> ClassBody -> Bool
$c>= :: ClassBody -> ClassBody -> Bool
>= :: ClassBody -> ClassBody -> Bool
$cmax :: ClassBody -> ClassBody -> ClassBody
max :: ClassBody -> ClassBody -> ClassBody
$cmin :: ClassBody -> ClassBody -> ClassBody
min :: ClassBody -> ClassBody -> ClassBody
Ord, ReadPrec [ClassBody]
ReadPrec ClassBody
Int -> ReadS ClassBody
ReadS [ClassBody]
(Int -> ReadS ClassBody)
-> ReadS [ClassBody]
-> ReadPrec ClassBody
-> ReadPrec [ClassBody]
-> Read ClassBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ClassBody
readsPrec :: Int -> ReadS ClassBody
$creadList :: ReadS [ClassBody]
readList :: ReadS [ClassBody]
$creadPrec :: ReadPrec ClassBody
readPrec :: ReadPrec ClassBody
$creadListPrec :: ReadPrec [ClassBody]
readListPrec :: ReadPrec [ClassBody]
Read, Int -> ClassBody -> String -> String
[ClassBody] -> String -> String
ClassBody -> String
(Int -> ClassBody -> String -> String)
-> (ClassBody -> String)
-> ([ClassBody] -> String -> String)
-> Show ClassBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ClassBody -> String -> String
showsPrec :: Int -> ClassBody -> String -> String
$cshow :: ClassBody -> String
show :: ClassBody -> String
$cshowList :: [ClassBody] -> String -> String
showList :: [ClassBody] -> String -> String
Show)

_ClassBody :: Name
_ClassBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ClassBody")

data ClassMemberDeclaration = 
  ClassMemberDeclarationConstant ConstantDeclaration |
  ClassMemberDeclarationField FieldDeclaration |
  ClassMemberDeclarationMethod MethodDeclaration |
  ClassMemberDeclarationProperty PropertyDeclaration |
  ClassMemberDeclarationEvent EventDeclaration |
  ClassMemberDeclarationIndexer IndexerDeclaration |
  ClassMemberDeclarationOperator OperatorDeclaration |
  ClassMemberDeclarationConstructor ConstructorDeclaration |
  ClassMemberDeclarationFinalizer FinalizerDeclaration |
  ClassMemberDeclarationStaticConstructor StaticConstructorDeclaration |
  ClassMemberDeclarationType TypeDeclaration
  deriving (ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
(ClassMemberDeclaration -> ClassMemberDeclaration -> Bool)
-> (ClassMemberDeclaration -> ClassMemberDeclaration -> Bool)
-> Eq ClassMemberDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
== :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
$c/= :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
/= :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
Eq, Eq ClassMemberDeclaration
Eq ClassMemberDeclaration =>
(ClassMemberDeclaration -> ClassMemberDeclaration -> Ordering)
-> (ClassMemberDeclaration -> ClassMemberDeclaration -> Bool)
-> (ClassMemberDeclaration -> ClassMemberDeclaration -> Bool)
-> (ClassMemberDeclaration -> ClassMemberDeclaration -> Bool)
-> (ClassMemberDeclaration -> ClassMemberDeclaration -> Bool)
-> (ClassMemberDeclaration
    -> ClassMemberDeclaration -> ClassMemberDeclaration)
-> (ClassMemberDeclaration
    -> ClassMemberDeclaration -> ClassMemberDeclaration)
-> Ord ClassMemberDeclaration
ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
ClassMemberDeclaration -> ClassMemberDeclaration -> Ordering
ClassMemberDeclaration
-> ClassMemberDeclaration -> ClassMemberDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ClassMemberDeclaration -> ClassMemberDeclaration -> Ordering
compare :: ClassMemberDeclaration -> ClassMemberDeclaration -> Ordering
$c< :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
< :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
$c<= :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
<= :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
$c> :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
> :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
$c>= :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
>= :: ClassMemberDeclaration -> ClassMemberDeclaration -> Bool
$cmax :: ClassMemberDeclaration
-> ClassMemberDeclaration -> ClassMemberDeclaration
max :: ClassMemberDeclaration
-> ClassMemberDeclaration -> ClassMemberDeclaration
$cmin :: ClassMemberDeclaration
-> ClassMemberDeclaration -> ClassMemberDeclaration
min :: ClassMemberDeclaration
-> ClassMemberDeclaration -> ClassMemberDeclaration
Ord, ReadPrec [ClassMemberDeclaration]
ReadPrec ClassMemberDeclaration
Int -> ReadS ClassMemberDeclaration
ReadS [ClassMemberDeclaration]
(Int -> ReadS ClassMemberDeclaration)
-> ReadS [ClassMemberDeclaration]
-> ReadPrec ClassMemberDeclaration
-> ReadPrec [ClassMemberDeclaration]
-> Read ClassMemberDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ClassMemberDeclaration
readsPrec :: Int -> ReadS ClassMemberDeclaration
$creadList :: ReadS [ClassMemberDeclaration]
readList :: ReadS [ClassMemberDeclaration]
$creadPrec :: ReadPrec ClassMemberDeclaration
readPrec :: ReadPrec ClassMemberDeclaration
$creadListPrec :: ReadPrec [ClassMemberDeclaration]
readListPrec :: ReadPrec [ClassMemberDeclaration]
Read, Int -> ClassMemberDeclaration -> String -> String
[ClassMemberDeclaration] -> String -> String
ClassMemberDeclaration -> String
(Int -> ClassMemberDeclaration -> String -> String)
-> (ClassMemberDeclaration -> String)
-> ([ClassMemberDeclaration] -> String -> String)
-> Show ClassMemberDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ClassMemberDeclaration -> String -> String
showsPrec :: Int -> ClassMemberDeclaration -> String -> String
$cshow :: ClassMemberDeclaration -> String
show :: ClassMemberDeclaration -> String
$cshowList :: [ClassMemberDeclaration] -> String -> String
showList :: [ClassMemberDeclaration] -> String -> String
Show)

_ClassMemberDeclaration :: Name
_ClassMemberDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ClassMemberDeclaration")

_ClassMemberDeclaration_constant :: Name
_ClassMemberDeclaration_constant = (String -> Name
Core.Name String
"constant")

_ClassMemberDeclaration_field :: Name
_ClassMemberDeclaration_field = (String -> Name
Core.Name String
"field")

_ClassMemberDeclaration_method :: Name
_ClassMemberDeclaration_method = (String -> Name
Core.Name String
"method")

_ClassMemberDeclaration_property :: Name
_ClassMemberDeclaration_property = (String -> Name
Core.Name String
"property")

_ClassMemberDeclaration_event :: Name
_ClassMemberDeclaration_event = (String -> Name
Core.Name String
"event")

_ClassMemberDeclaration_indexer :: Name
_ClassMemberDeclaration_indexer = (String -> Name
Core.Name String
"indexer")

_ClassMemberDeclaration_operator :: Name
_ClassMemberDeclaration_operator = (String -> Name
Core.Name String
"operator")

_ClassMemberDeclaration_constructor :: Name
_ClassMemberDeclaration_constructor = (String -> Name
Core.Name String
"constructor")

_ClassMemberDeclaration_finalizer :: Name
_ClassMemberDeclaration_finalizer = (String -> Name
Core.Name String
"finalizer")

_ClassMemberDeclaration_staticConstructor :: Name
_ClassMemberDeclaration_staticConstructor = (String -> Name
Core.Name String
"staticConstructor")

_ClassMemberDeclaration_type :: Name
_ClassMemberDeclaration_type = (String -> Name
Core.Name String
"type")

data ConstantDeclaration = 
  ConstantDeclaration {
    ConstantDeclaration -> Maybe Attributes
constantDeclarationAttributes :: (Maybe Attributes),
    ConstantDeclaration -> [ConstantModifier]
constantDeclarationModifiers :: [ConstantModifier],
    ConstantDeclaration -> Type
constantDeclarationType :: Type,
    ConstantDeclaration -> [ConstantDeclarator]
constantDeclarationDeclarators :: [ConstantDeclarator]}
  deriving (ConstantDeclaration -> ConstantDeclaration -> Bool
(ConstantDeclaration -> ConstantDeclaration -> Bool)
-> (ConstantDeclaration -> ConstantDeclaration -> Bool)
-> Eq ConstantDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstantDeclaration -> ConstantDeclaration -> Bool
== :: ConstantDeclaration -> ConstantDeclaration -> Bool
$c/= :: ConstantDeclaration -> ConstantDeclaration -> Bool
/= :: ConstantDeclaration -> ConstantDeclaration -> Bool
Eq, Eq ConstantDeclaration
Eq ConstantDeclaration =>
(ConstantDeclaration -> ConstantDeclaration -> Ordering)
-> (ConstantDeclaration -> ConstantDeclaration -> Bool)
-> (ConstantDeclaration -> ConstantDeclaration -> Bool)
-> (ConstantDeclaration -> ConstantDeclaration -> Bool)
-> (ConstantDeclaration -> ConstantDeclaration -> Bool)
-> (ConstantDeclaration
    -> ConstantDeclaration -> ConstantDeclaration)
-> (ConstantDeclaration
    -> ConstantDeclaration -> ConstantDeclaration)
-> Ord ConstantDeclaration
ConstantDeclaration -> ConstantDeclaration -> Bool
ConstantDeclaration -> ConstantDeclaration -> Ordering
ConstantDeclaration -> ConstantDeclaration -> ConstantDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstantDeclaration -> ConstantDeclaration -> Ordering
compare :: ConstantDeclaration -> ConstantDeclaration -> Ordering
$c< :: ConstantDeclaration -> ConstantDeclaration -> Bool
< :: ConstantDeclaration -> ConstantDeclaration -> Bool
$c<= :: ConstantDeclaration -> ConstantDeclaration -> Bool
<= :: ConstantDeclaration -> ConstantDeclaration -> Bool
$c> :: ConstantDeclaration -> ConstantDeclaration -> Bool
> :: ConstantDeclaration -> ConstantDeclaration -> Bool
$c>= :: ConstantDeclaration -> ConstantDeclaration -> Bool
>= :: ConstantDeclaration -> ConstantDeclaration -> Bool
$cmax :: ConstantDeclaration -> ConstantDeclaration -> ConstantDeclaration
max :: ConstantDeclaration -> ConstantDeclaration -> ConstantDeclaration
$cmin :: ConstantDeclaration -> ConstantDeclaration -> ConstantDeclaration
min :: ConstantDeclaration -> ConstantDeclaration -> ConstantDeclaration
Ord, ReadPrec [ConstantDeclaration]
ReadPrec ConstantDeclaration
Int -> ReadS ConstantDeclaration
ReadS [ConstantDeclaration]
(Int -> ReadS ConstantDeclaration)
-> ReadS [ConstantDeclaration]
-> ReadPrec ConstantDeclaration
-> ReadPrec [ConstantDeclaration]
-> Read ConstantDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConstantDeclaration
readsPrec :: Int -> ReadS ConstantDeclaration
$creadList :: ReadS [ConstantDeclaration]
readList :: ReadS [ConstantDeclaration]
$creadPrec :: ReadPrec ConstantDeclaration
readPrec :: ReadPrec ConstantDeclaration
$creadListPrec :: ReadPrec [ConstantDeclaration]
readListPrec :: ReadPrec [ConstantDeclaration]
Read, Int -> ConstantDeclaration -> String -> String
[ConstantDeclaration] -> String -> String
ConstantDeclaration -> String
(Int -> ConstantDeclaration -> String -> String)
-> (ConstantDeclaration -> String)
-> ([ConstantDeclaration] -> String -> String)
-> Show ConstantDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConstantDeclaration -> String -> String
showsPrec :: Int -> ConstantDeclaration -> String -> String
$cshow :: ConstantDeclaration -> String
show :: ConstantDeclaration -> String
$cshowList :: [ConstantDeclaration] -> String -> String
showList :: [ConstantDeclaration] -> String -> String
Show)

_ConstantDeclaration :: Name
_ConstantDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConstantDeclaration")

_ConstantDeclaration_attributes :: Name
_ConstantDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_ConstantDeclaration_modifiers :: Name
_ConstantDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_ConstantDeclaration_type :: Name
_ConstantDeclaration_type = (String -> Name
Core.Name String
"type")

_ConstantDeclaration_declarators :: Name
_ConstantDeclaration_declarators = (String -> Name
Core.Name String
"declarators")

data ConstantModifier = 
  ConstantModifierNew  |
  ConstantModifierPublic  |
  ConstantModifierProtected  |
  ConstantModifierInternal  |
  ConstantModifierPrivate 
  deriving (ConstantModifier -> ConstantModifier -> Bool
(ConstantModifier -> ConstantModifier -> Bool)
-> (ConstantModifier -> ConstantModifier -> Bool)
-> Eq ConstantModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstantModifier -> ConstantModifier -> Bool
== :: ConstantModifier -> ConstantModifier -> Bool
$c/= :: ConstantModifier -> ConstantModifier -> Bool
/= :: ConstantModifier -> ConstantModifier -> Bool
Eq, Eq ConstantModifier
Eq ConstantModifier =>
(ConstantModifier -> ConstantModifier -> Ordering)
-> (ConstantModifier -> ConstantModifier -> Bool)
-> (ConstantModifier -> ConstantModifier -> Bool)
-> (ConstantModifier -> ConstantModifier -> Bool)
-> (ConstantModifier -> ConstantModifier -> Bool)
-> (ConstantModifier -> ConstantModifier -> ConstantModifier)
-> (ConstantModifier -> ConstantModifier -> ConstantModifier)
-> Ord ConstantModifier
ConstantModifier -> ConstantModifier -> Bool
ConstantModifier -> ConstantModifier -> Ordering
ConstantModifier -> ConstantModifier -> ConstantModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstantModifier -> ConstantModifier -> Ordering
compare :: ConstantModifier -> ConstantModifier -> Ordering
$c< :: ConstantModifier -> ConstantModifier -> Bool
< :: ConstantModifier -> ConstantModifier -> Bool
$c<= :: ConstantModifier -> ConstantModifier -> Bool
<= :: ConstantModifier -> ConstantModifier -> Bool
$c> :: ConstantModifier -> ConstantModifier -> Bool
> :: ConstantModifier -> ConstantModifier -> Bool
$c>= :: ConstantModifier -> ConstantModifier -> Bool
>= :: ConstantModifier -> ConstantModifier -> Bool
$cmax :: ConstantModifier -> ConstantModifier -> ConstantModifier
max :: ConstantModifier -> ConstantModifier -> ConstantModifier
$cmin :: ConstantModifier -> ConstantModifier -> ConstantModifier
min :: ConstantModifier -> ConstantModifier -> ConstantModifier
Ord, ReadPrec [ConstantModifier]
ReadPrec ConstantModifier
Int -> ReadS ConstantModifier
ReadS [ConstantModifier]
(Int -> ReadS ConstantModifier)
-> ReadS [ConstantModifier]
-> ReadPrec ConstantModifier
-> ReadPrec [ConstantModifier]
-> Read ConstantModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConstantModifier
readsPrec :: Int -> ReadS ConstantModifier
$creadList :: ReadS [ConstantModifier]
readList :: ReadS [ConstantModifier]
$creadPrec :: ReadPrec ConstantModifier
readPrec :: ReadPrec ConstantModifier
$creadListPrec :: ReadPrec [ConstantModifier]
readListPrec :: ReadPrec [ConstantModifier]
Read, Int -> ConstantModifier -> String -> String
[ConstantModifier] -> String -> String
ConstantModifier -> String
(Int -> ConstantModifier -> String -> String)
-> (ConstantModifier -> String)
-> ([ConstantModifier] -> String -> String)
-> Show ConstantModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConstantModifier -> String -> String
showsPrec :: Int -> ConstantModifier -> String -> String
$cshow :: ConstantModifier -> String
show :: ConstantModifier -> String
$cshowList :: [ConstantModifier] -> String -> String
showList :: [ConstantModifier] -> String -> String
Show)

_ConstantModifier :: Name
_ConstantModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConstantModifier")

_ConstantModifier_new :: Name
_ConstantModifier_new = (String -> Name
Core.Name String
"new")

_ConstantModifier_public :: Name
_ConstantModifier_public = (String -> Name
Core.Name String
"public")

_ConstantModifier_protected :: Name
_ConstantModifier_protected = (String -> Name
Core.Name String
"protected")

_ConstantModifier_internal :: Name
_ConstantModifier_internal = (String -> Name
Core.Name String
"internal")

_ConstantModifier_private :: Name
_ConstantModifier_private = (String -> Name
Core.Name String
"private")

data FieldDeclaration = 
  FieldDeclaration {
    FieldDeclaration -> Maybe Attributes
fieldDeclarationAttributes :: (Maybe Attributes),
    FieldDeclaration -> [FieldModifier]
fieldDeclarationModifiers :: [FieldModifier],
    FieldDeclaration -> Type
fieldDeclarationType :: Type,
    FieldDeclaration -> [VariableDeclarator]
fieldDeclarationDeclarators :: [VariableDeclarator]}
  deriving (FieldDeclaration -> FieldDeclaration -> Bool
(FieldDeclaration -> FieldDeclaration -> Bool)
-> (FieldDeclaration -> FieldDeclaration -> Bool)
-> Eq FieldDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldDeclaration -> FieldDeclaration -> Bool
== :: FieldDeclaration -> FieldDeclaration -> Bool
$c/= :: FieldDeclaration -> FieldDeclaration -> Bool
/= :: FieldDeclaration -> FieldDeclaration -> Bool
Eq, Eq FieldDeclaration
Eq FieldDeclaration =>
(FieldDeclaration -> FieldDeclaration -> Ordering)
-> (FieldDeclaration -> FieldDeclaration -> Bool)
-> (FieldDeclaration -> FieldDeclaration -> Bool)
-> (FieldDeclaration -> FieldDeclaration -> Bool)
-> (FieldDeclaration -> FieldDeclaration -> Bool)
-> (FieldDeclaration -> FieldDeclaration -> FieldDeclaration)
-> (FieldDeclaration -> FieldDeclaration -> FieldDeclaration)
-> Ord FieldDeclaration
FieldDeclaration -> FieldDeclaration -> Bool
FieldDeclaration -> FieldDeclaration -> Ordering
FieldDeclaration -> FieldDeclaration -> FieldDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FieldDeclaration -> FieldDeclaration -> Ordering
compare :: FieldDeclaration -> FieldDeclaration -> Ordering
$c< :: FieldDeclaration -> FieldDeclaration -> Bool
< :: FieldDeclaration -> FieldDeclaration -> Bool
$c<= :: FieldDeclaration -> FieldDeclaration -> Bool
<= :: FieldDeclaration -> FieldDeclaration -> Bool
$c> :: FieldDeclaration -> FieldDeclaration -> Bool
> :: FieldDeclaration -> FieldDeclaration -> Bool
$c>= :: FieldDeclaration -> FieldDeclaration -> Bool
>= :: FieldDeclaration -> FieldDeclaration -> Bool
$cmax :: FieldDeclaration -> FieldDeclaration -> FieldDeclaration
max :: FieldDeclaration -> FieldDeclaration -> FieldDeclaration
$cmin :: FieldDeclaration -> FieldDeclaration -> FieldDeclaration
min :: FieldDeclaration -> FieldDeclaration -> FieldDeclaration
Ord, ReadPrec [FieldDeclaration]
ReadPrec FieldDeclaration
Int -> ReadS FieldDeclaration
ReadS [FieldDeclaration]
(Int -> ReadS FieldDeclaration)
-> ReadS [FieldDeclaration]
-> ReadPrec FieldDeclaration
-> ReadPrec [FieldDeclaration]
-> Read FieldDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FieldDeclaration
readsPrec :: Int -> ReadS FieldDeclaration
$creadList :: ReadS [FieldDeclaration]
readList :: ReadS [FieldDeclaration]
$creadPrec :: ReadPrec FieldDeclaration
readPrec :: ReadPrec FieldDeclaration
$creadListPrec :: ReadPrec [FieldDeclaration]
readListPrec :: ReadPrec [FieldDeclaration]
Read, Int -> FieldDeclaration -> String -> String
[FieldDeclaration] -> String -> String
FieldDeclaration -> String
(Int -> FieldDeclaration -> String -> String)
-> (FieldDeclaration -> String)
-> ([FieldDeclaration] -> String -> String)
-> Show FieldDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FieldDeclaration -> String -> String
showsPrec :: Int -> FieldDeclaration -> String -> String
$cshow :: FieldDeclaration -> String
show :: FieldDeclaration -> String
$cshowList :: [FieldDeclaration] -> String -> String
showList :: [FieldDeclaration] -> String -> String
Show)

_FieldDeclaration :: Name
_FieldDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FieldDeclaration")

_FieldDeclaration_attributes :: Name
_FieldDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_FieldDeclaration_modifiers :: Name
_FieldDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_FieldDeclaration_type :: Name
_FieldDeclaration_type = (String -> Name
Core.Name String
"type")

_FieldDeclaration_declarators :: Name
_FieldDeclaration_declarators = (String -> Name
Core.Name String
"declarators")

data FieldModifier = 
  FieldModifierNew  |
  FieldModifierPublic  |
  FieldModifierProtected  |
  FieldModifierInternal  |
  FieldModifierPrivate  |
  FieldModifierStatic  |
  FieldModifierReadonly  |
  FieldModifierVolatile  |
  FieldModifierUnsafe 
  deriving (FieldModifier -> FieldModifier -> Bool
(FieldModifier -> FieldModifier -> Bool)
-> (FieldModifier -> FieldModifier -> Bool) -> Eq FieldModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FieldModifier -> FieldModifier -> Bool
== :: FieldModifier -> FieldModifier -> Bool
$c/= :: FieldModifier -> FieldModifier -> Bool
/= :: FieldModifier -> FieldModifier -> Bool
Eq, Eq FieldModifier
Eq FieldModifier =>
(FieldModifier -> FieldModifier -> Ordering)
-> (FieldModifier -> FieldModifier -> Bool)
-> (FieldModifier -> FieldModifier -> Bool)
-> (FieldModifier -> FieldModifier -> Bool)
-> (FieldModifier -> FieldModifier -> Bool)
-> (FieldModifier -> FieldModifier -> FieldModifier)
-> (FieldModifier -> FieldModifier -> FieldModifier)
-> Ord FieldModifier
FieldModifier -> FieldModifier -> Bool
FieldModifier -> FieldModifier -> Ordering
FieldModifier -> FieldModifier -> FieldModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FieldModifier -> FieldModifier -> Ordering
compare :: FieldModifier -> FieldModifier -> Ordering
$c< :: FieldModifier -> FieldModifier -> Bool
< :: FieldModifier -> FieldModifier -> Bool
$c<= :: FieldModifier -> FieldModifier -> Bool
<= :: FieldModifier -> FieldModifier -> Bool
$c> :: FieldModifier -> FieldModifier -> Bool
> :: FieldModifier -> FieldModifier -> Bool
$c>= :: FieldModifier -> FieldModifier -> Bool
>= :: FieldModifier -> FieldModifier -> Bool
$cmax :: FieldModifier -> FieldModifier -> FieldModifier
max :: FieldModifier -> FieldModifier -> FieldModifier
$cmin :: FieldModifier -> FieldModifier -> FieldModifier
min :: FieldModifier -> FieldModifier -> FieldModifier
Ord, ReadPrec [FieldModifier]
ReadPrec FieldModifier
Int -> ReadS FieldModifier
ReadS [FieldModifier]
(Int -> ReadS FieldModifier)
-> ReadS [FieldModifier]
-> ReadPrec FieldModifier
-> ReadPrec [FieldModifier]
-> Read FieldModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FieldModifier
readsPrec :: Int -> ReadS FieldModifier
$creadList :: ReadS [FieldModifier]
readList :: ReadS [FieldModifier]
$creadPrec :: ReadPrec FieldModifier
readPrec :: ReadPrec FieldModifier
$creadListPrec :: ReadPrec [FieldModifier]
readListPrec :: ReadPrec [FieldModifier]
Read, Int -> FieldModifier -> String -> String
[FieldModifier] -> String -> String
FieldModifier -> String
(Int -> FieldModifier -> String -> String)
-> (FieldModifier -> String)
-> ([FieldModifier] -> String -> String)
-> Show FieldModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FieldModifier -> String -> String
showsPrec :: Int -> FieldModifier -> String -> String
$cshow :: FieldModifier -> String
show :: FieldModifier -> String
$cshowList :: [FieldModifier] -> String -> String
showList :: [FieldModifier] -> String -> String
Show)

_FieldModifier :: Name
_FieldModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FieldModifier")

_FieldModifier_new :: Name
_FieldModifier_new = (String -> Name
Core.Name String
"new")

_FieldModifier_public :: Name
_FieldModifier_public = (String -> Name
Core.Name String
"public")

_FieldModifier_protected :: Name
_FieldModifier_protected = (String -> Name
Core.Name String
"protected")

_FieldModifier_internal :: Name
_FieldModifier_internal = (String -> Name
Core.Name String
"internal")

_FieldModifier_private :: Name
_FieldModifier_private = (String -> Name
Core.Name String
"private")

_FieldModifier_static :: Name
_FieldModifier_static = (String -> Name
Core.Name String
"static")

_FieldModifier_readonly :: Name
_FieldModifier_readonly = (String -> Name
Core.Name String
"readonly")

_FieldModifier_volatile :: Name
_FieldModifier_volatile = (String -> Name
Core.Name String
"volatile")

_FieldModifier_unsafe :: Name
_FieldModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

newtype VariableDeclarators = 
  VariableDeclarators {
    VariableDeclarators -> [VariableDeclarator]
unVariableDeclarators :: [VariableDeclarator]}
  deriving (VariableDeclarators -> VariableDeclarators -> Bool
(VariableDeclarators -> VariableDeclarators -> Bool)
-> (VariableDeclarators -> VariableDeclarators -> Bool)
-> Eq VariableDeclarators
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariableDeclarators -> VariableDeclarators -> Bool
== :: VariableDeclarators -> VariableDeclarators -> Bool
$c/= :: VariableDeclarators -> VariableDeclarators -> Bool
/= :: VariableDeclarators -> VariableDeclarators -> Bool
Eq, Eq VariableDeclarators
Eq VariableDeclarators =>
(VariableDeclarators -> VariableDeclarators -> Ordering)
-> (VariableDeclarators -> VariableDeclarators -> Bool)
-> (VariableDeclarators -> VariableDeclarators -> Bool)
-> (VariableDeclarators -> VariableDeclarators -> Bool)
-> (VariableDeclarators -> VariableDeclarators -> Bool)
-> (VariableDeclarators
    -> VariableDeclarators -> VariableDeclarators)
-> (VariableDeclarators
    -> VariableDeclarators -> VariableDeclarators)
-> Ord VariableDeclarators
VariableDeclarators -> VariableDeclarators -> Bool
VariableDeclarators -> VariableDeclarators -> Ordering
VariableDeclarators -> VariableDeclarators -> VariableDeclarators
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VariableDeclarators -> VariableDeclarators -> Ordering
compare :: VariableDeclarators -> VariableDeclarators -> Ordering
$c< :: VariableDeclarators -> VariableDeclarators -> Bool
< :: VariableDeclarators -> VariableDeclarators -> Bool
$c<= :: VariableDeclarators -> VariableDeclarators -> Bool
<= :: VariableDeclarators -> VariableDeclarators -> Bool
$c> :: VariableDeclarators -> VariableDeclarators -> Bool
> :: VariableDeclarators -> VariableDeclarators -> Bool
$c>= :: VariableDeclarators -> VariableDeclarators -> Bool
>= :: VariableDeclarators -> VariableDeclarators -> Bool
$cmax :: VariableDeclarators -> VariableDeclarators -> VariableDeclarators
max :: VariableDeclarators -> VariableDeclarators -> VariableDeclarators
$cmin :: VariableDeclarators -> VariableDeclarators -> VariableDeclarators
min :: VariableDeclarators -> VariableDeclarators -> VariableDeclarators
Ord, ReadPrec [VariableDeclarators]
ReadPrec VariableDeclarators
Int -> ReadS VariableDeclarators
ReadS [VariableDeclarators]
(Int -> ReadS VariableDeclarators)
-> ReadS [VariableDeclarators]
-> ReadPrec VariableDeclarators
-> ReadPrec [VariableDeclarators]
-> Read VariableDeclarators
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VariableDeclarators
readsPrec :: Int -> ReadS VariableDeclarators
$creadList :: ReadS [VariableDeclarators]
readList :: ReadS [VariableDeclarators]
$creadPrec :: ReadPrec VariableDeclarators
readPrec :: ReadPrec VariableDeclarators
$creadListPrec :: ReadPrec [VariableDeclarators]
readListPrec :: ReadPrec [VariableDeclarators]
Read, Int -> VariableDeclarators -> String -> String
[VariableDeclarators] -> String -> String
VariableDeclarators -> String
(Int -> VariableDeclarators -> String -> String)
-> (VariableDeclarators -> String)
-> ([VariableDeclarators] -> String -> String)
-> Show VariableDeclarators
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VariableDeclarators -> String -> String
showsPrec :: Int -> VariableDeclarators -> String -> String
$cshow :: VariableDeclarators -> String
show :: VariableDeclarators -> String
$cshowList :: [VariableDeclarators] -> String -> String
showList :: [VariableDeclarators] -> String -> String
Show)

_VariableDeclarators :: Name
_VariableDeclarators = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.VariableDeclarators")

data VariableDeclarator = 
  VariableDeclarator {
    VariableDeclarator -> Identifier
variableDeclaratorIdentifier :: Identifier,
    VariableDeclarator -> Maybe VariableInitializer
variableDeclaratorInitializer :: (Maybe VariableInitializer)}
  deriving (VariableDeclarator -> VariableDeclarator -> Bool
(VariableDeclarator -> VariableDeclarator -> Bool)
-> (VariableDeclarator -> VariableDeclarator -> Bool)
-> Eq VariableDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariableDeclarator -> VariableDeclarator -> Bool
== :: VariableDeclarator -> VariableDeclarator -> Bool
$c/= :: VariableDeclarator -> VariableDeclarator -> Bool
/= :: VariableDeclarator -> VariableDeclarator -> Bool
Eq, Eq VariableDeclarator
Eq VariableDeclarator =>
(VariableDeclarator -> VariableDeclarator -> Ordering)
-> (VariableDeclarator -> VariableDeclarator -> Bool)
-> (VariableDeclarator -> VariableDeclarator -> Bool)
-> (VariableDeclarator -> VariableDeclarator -> Bool)
-> (VariableDeclarator -> VariableDeclarator -> Bool)
-> (VariableDeclarator -> VariableDeclarator -> VariableDeclarator)
-> (VariableDeclarator -> VariableDeclarator -> VariableDeclarator)
-> Ord VariableDeclarator
VariableDeclarator -> VariableDeclarator -> Bool
VariableDeclarator -> VariableDeclarator -> Ordering
VariableDeclarator -> VariableDeclarator -> VariableDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VariableDeclarator -> VariableDeclarator -> Ordering
compare :: VariableDeclarator -> VariableDeclarator -> Ordering
$c< :: VariableDeclarator -> VariableDeclarator -> Bool
< :: VariableDeclarator -> VariableDeclarator -> Bool
$c<= :: VariableDeclarator -> VariableDeclarator -> Bool
<= :: VariableDeclarator -> VariableDeclarator -> Bool
$c> :: VariableDeclarator -> VariableDeclarator -> Bool
> :: VariableDeclarator -> VariableDeclarator -> Bool
$c>= :: VariableDeclarator -> VariableDeclarator -> Bool
>= :: VariableDeclarator -> VariableDeclarator -> Bool
$cmax :: VariableDeclarator -> VariableDeclarator -> VariableDeclarator
max :: VariableDeclarator -> VariableDeclarator -> VariableDeclarator
$cmin :: VariableDeclarator -> VariableDeclarator -> VariableDeclarator
min :: VariableDeclarator -> VariableDeclarator -> VariableDeclarator
Ord, ReadPrec [VariableDeclarator]
ReadPrec VariableDeclarator
Int -> ReadS VariableDeclarator
ReadS [VariableDeclarator]
(Int -> ReadS VariableDeclarator)
-> ReadS [VariableDeclarator]
-> ReadPrec VariableDeclarator
-> ReadPrec [VariableDeclarator]
-> Read VariableDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VariableDeclarator
readsPrec :: Int -> ReadS VariableDeclarator
$creadList :: ReadS [VariableDeclarator]
readList :: ReadS [VariableDeclarator]
$creadPrec :: ReadPrec VariableDeclarator
readPrec :: ReadPrec VariableDeclarator
$creadListPrec :: ReadPrec [VariableDeclarator]
readListPrec :: ReadPrec [VariableDeclarator]
Read, Int -> VariableDeclarator -> String -> String
[VariableDeclarator] -> String -> String
VariableDeclarator -> String
(Int -> VariableDeclarator -> String -> String)
-> (VariableDeclarator -> String)
-> ([VariableDeclarator] -> String -> String)
-> Show VariableDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VariableDeclarator -> String -> String
showsPrec :: Int -> VariableDeclarator -> String -> String
$cshow :: VariableDeclarator -> String
show :: VariableDeclarator -> String
$cshowList :: [VariableDeclarator] -> String -> String
showList :: [VariableDeclarator] -> String -> String
Show)

_VariableDeclarator :: Name
_VariableDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.VariableDeclarator")

_VariableDeclarator_identifier :: Name
_VariableDeclarator_identifier = (String -> Name
Core.Name String
"identifier")

_VariableDeclarator_initializer :: Name
_VariableDeclarator_initializer = (String -> Name
Core.Name String
"initializer")

data MethodDeclaration = 
  MethodDeclarationStandard StandardMethodDeclaration |
  MethodDeclarationRefReturn RefReturnMethodDeclaration
  deriving (MethodDeclaration -> MethodDeclaration -> Bool
(MethodDeclaration -> MethodDeclaration -> Bool)
-> (MethodDeclaration -> MethodDeclaration -> Bool)
-> Eq MethodDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MethodDeclaration -> MethodDeclaration -> Bool
== :: MethodDeclaration -> MethodDeclaration -> Bool
$c/= :: MethodDeclaration -> MethodDeclaration -> Bool
/= :: MethodDeclaration -> MethodDeclaration -> Bool
Eq, Eq MethodDeclaration
Eq MethodDeclaration =>
(MethodDeclaration -> MethodDeclaration -> Ordering)
-> (MethodDeclaration -> MethodDeclaration -> Bool)
-> (MethodDeclaration -> MethodDeclaration -> Bool)
-> (MethodDeclaration -> MethodDeclaration -> Bool)
-> (MethodDeclaration -> MethodDeclaration -> Bool)
-> (MethodDeclaration -> MethodDeclaration -> MethodDeclaration)
-> (MethodDeclaration -> MethodDeclaration -> MethodDeclaration)
-> Ord MethodDeclaration
MethodDeclaration -> MethodDeclaration -> Bool
MethodDeclaration -> MethodDeclaration -> Ordering
MethodDeclaration -> MethodDeclaration -> MethodDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MethodDeclaration -> MethodDeclaration -> Ordering
compare :: MethodDeclaration -> MethodDeclaration -> Ordering
$c< :: MethodDeclaration -> MethodDeclaration -> Bool
< :: MethodDeclaration -> MethodDeclaration -> Bool
$c<= :: MethodDeclaration -> MethodDeclaration -> Bool
<= :: MethodDeclaration -> MethodDeclaration -> Bool
$c> :: MethodDeclaration -> MethodDeclaration -> Bool
> :: MethodDeclaration -> MethodDeclaration -> Bool
$c>= :: MethodDeclaration -> MethodDeclaration -> Bool
>= :: MethodDeclaration -> MethodDeclaration -> Bool
$cmax :: MethodDeclaration -> MethodDeclaration -> MethodDeclaration
max :: MethodDeclaration -> MethodDeclaration -> MethodDeclaration
$cmin :: MethodDeclaration -> MethodDeclaration -> MethodDeclaration
min :: MethodDeclaration -> MethodDeclaration -> MethodDeclaration
Ord, ReadPrec [MethodDeclaration]
ReadPrec MethodDeclaration
Int -> ReadS MethodDeclaration
ReadS [MethodDeclaration]
(Int -> ReadS MethodDeclaration)
-> ReadS [MethodDeclaration]
-> ReadPrec MethodDeclaration
-> ReadPrec [MethodDeclaration]
-> Read MethodDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MethodDeclaration
readsPrec :: Int -> ReadS MethodDeclaration
$creadList :: ReadS [MethodDeclaration]
readList :: ReadS [MethodDeclaration]
$creadPrec :: ReadPrec MethodDeclaration
readPrec :: ReadPrec MethodDeclaration
$creadListPrec :: ReadPrec [MethodDeclaration]
readListPrec :: ReadPrec [MethodDeclaration]
Read, Int -> MethodDeclaration -> String -> String
[MethodDeclaration] -> String -> String
MethodDeclaration -> String
(Int -> MethodDeclaration -> String -> String)
-> (MethodDeclaration -> String)
-> ([MethodDeclaration] -> String -> String)
-> Show MethodDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MethodDeclaration -> String -> String
showsPrec :: Int -> MethodDeclaration -> String -> String
$cshow :: MethodDeclaration -> String
show :: MethodDeclaration -> String
$cshowList :: [MethodDeclaration] -> String -> String
showList :: [MethodDeclaration] -> String -> String
Show)

_MethodDeclaration :: Name
_MethodDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MethodDeclaration")

_MethodDeclaration_standard :: Name
_MethodDeclaration_standard = (String -> Name
Core.Name String
"standard")

_MethodDeclaration_refReturn :: Name
_MethodDeclaration_refReturn = (String -> Name
Core.Name String
"refReturn")

data StandardMethodDeclaration = 
  StandardMethodDeclaration {
    StandardMethodDeclaration -> Maybe Attributes
standardMethodDeclarationAttributes :: (Maybe Attributes),
    StandardMethodDeclaration -> [MethodModifier]
standardMethodDeclarationModifiers :: [MethodModifier],
    StandardMethodDeclaration -> ReturnType
standardMethodDeclarationReturnType :: ReturnType,
    StandardMethodDeclaration -> MethodHeader
standardMethodDeclarationHeader :: MethodHeader,
    StandardMethodDeclaration -> MethodBody
standardMethodDeclarationBody :: MethodBody}
  deriving (StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
(StandardMethodDeclaration -> StandardMethodDeclaration -> Bool)
-> (StandardMethodDeclaration -> StandardMethodDeclaration -> Bool)
-> Eq StandardMethodDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
== :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
$c/= :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
/= :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
Eq, Eq StandardMethodDeclaration
Eq StandardMethodDeclaration =>
(StandardMethodDeclaration
 -> StandardMethodDeclaration -> Ordering)
-> (StandardMethodDeclaration -> StandardMethodDeclaration -> Bool)
-> (StandardMethodDeclaration -> StandardMethodDeclaration -> Bool)
-> (StandardMethodDeclaration -> StandardMethodDeclaration -> Bool)
-> (StandardMethodDeclaration -> StandardMethodDeclaration -> Bool)
-> (StandardMethodDeclaration
    -> StandardMethodDeclaration -> StandardMethodDeclaration)
-> (StandardMethodDeclaration
    -> StandardMethodDeclaration -> StandardMethodDeclaration)
-> Ord StandardMethodDeclaration
StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
StandardMethodDeclaration -> StandardMethodDeclaration -> Ordering
StandardMethodDeclaration
-> StandardMethodDeclaration -> StandardMethodDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StandardMethodDeclaration -> StandardMethodDeclaration -> Ordering
compare :: StandardMethodDeclaration -> StandardMethodDeclaration -> Ordering
$c< :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
< :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
$c<= :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
<= :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
$c> :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
> :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
$c>= :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
>= :: StandardMethodDeclaration -> StandardMethodDeclaration -> Bool
$cmax :: StandardMethodDeclaration
-> StandardMethodDeclaration -> StandardMethodDeclaration
max :: StandardMethodDeclaration
-> StandardMethodDeclaration -> StandardMethodDeclaration
$cmin :: StandardMethodDeclaration
-> StandardMethodDeclaration -> StandardMethodDeclaration
min :: StandardMethodDeclaration
-> StandardMethodDeclaration -> StandardMethodDeclaration
Ord, ReadPrec [StandardMethodDeclaration]
ReadPrec StandardMethodDeclaration
Int -> ReadS StandardMethodDeclaration
ReadS [StandardMethodDeclaration]
(Int -> ReadS StandardMethodDeclaration)
-> ReadS [StandardMethodDeclaration]
-> ReadPrec StandardMethodDeclaration
-> ReadPrec [StandardMethodDeclaration]
-> Read StandardMethodDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StandardMethodDeclaration
readsPrec :: Int -> ReadS StandardMethodDeclaration
$creadList :: ReadS [StandardMethodDeclaration]
readList :: ReadS [StandardMethodDeclaration]
$creadPrec :: ReadPrec StandardMethodDeclaration
readPrec :: ReadPrec StandardMethodDeclaration
$creadListPrec :: ReadPrec [StandardMethodDeclaration]
readListPrec :: ReadPrec [StandardMethodDeclaration]
Read, Int -> StandardMethodDeclaration -> String -> String
[StandardMethodDeclaration] -> String -> String
StandardMethodDeclaration -> String
(Int -> StandardMethodDeclaration -> String -> String)
-> (StandardMethodDeclaration -> String)
-> ([StandardMethodDeclaration] -> String -> String)
-> Show StandardMethodDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StandardMethodDeclaration -> String -> String
showsPrec :: Int -> StandardMethodDeclaration -> String -> String
$cshow :: StandardMethodDeclaration -> String
show :: StandardMethodDeclaration -> String
$cshowList :: [StandardMethodDeclaration] -> String -> String
showList :: [StandardMethodDeclaration] -> String -> String
Show)

_StandardMethodDeclaration :: Name
_StandardMethodDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StandardMethodDeclaration")

_StandardMethodDeclaration_attributes :: Name
_StandardMethodDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_StandardMethodDeclaration_modifiers :: Name
_StandardMethodDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_StandardMethodDeclaration_returnType :: Name
_StandardMethodDeclaration_returnType = (String -> Name
Core.Name String
"returnType")

_StandardMethodDeclaration_header :: Name
_StandardMethodDeclaration_header = (String -> Name
Core.Name String
"header")

_StandardMethodDeclaration_body :: Name
_StandardMethodDeclaration_body = (String -> Name
Core.Name String
"body")

data RefReturnMethodDeclaration = 
  RefReturnMethodDeclaration {
    RefReturnMethodDeclaration -> Maybe Attributes
refReturnMethodDeclarationAttributes :: (Maybe Attributes),
    RefReturnMethodDeclaration -> [RefMethodModifier]
refReturnMethodDeclarationModifiers :: [RefMethodModifier],
    RefReturnMethodDeclaration -> RefKind
refReturnMethodDeclarationKind :: RefKind,
    RefReturnMethodDeclaration -> ReturnType
refReturnMethodDeclarationReturnType :: ReturnType,
    RefReturnMethodDeclaration -> MethodHeader
refReturnMethodDeclarationHeader :: MethodHeader,
    RefReturnMethodDeclaration -> RefMethodBody
refReturnMethodDeclarationBody :: RefMethodBody}
  deriving (RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
(RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool)
-> (RefReturnMethodDeclaration
    -> RefReturnMethodDeclaration -> Bool)
-> Eq RefReturnMethodDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
== :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
$c/= :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
/= :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
Eq, Eq RefReturnMethodDeclaration
Eq RefReturnMethodDeclaration =>
(RefReturnMethodDeclaration
 -> RefReturnMethodDeclaration -> Ordering)
-> (RefReturnMethodDeclaration
    -> RefReturnMethodDeclaration -> Bool)
-> (RefReturnMethodDeclaration
    -> RefReturnMethodDeclaration -> Bool)
-> (RefReturnMethodDeclaration
    -> RefReturnMethodDeclaration -> Bool)
-> (RefReturnMethodDeclaration
    -> RefReturnMethodDeclaration -> Bool)
-> (RefReturnMethodDeclaration
    -> RefReturnMethodDeclaration -> RefReturnMethodDeclaration)
-> (RefReturnMethodDeclaration
    -> RefReturnMethodDeclaration -> RefReturnMethodDeclaration)
-> Ord RefReturnMethodDeclaration
RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
RefReturnMethodDeclaration
-> RefReturnMethodDeclaration -> Ordering
RefReturnMethodDeclaration
-> RefReturnMethodDeclaration -> RefReturnMethodDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefReturnMethodDeclaration
-> RefReturnMethodDeclaration -> Ordering
compare :: RefReturnMethodDeclaration
-> RefReturnMethodDeclaration -> Ordering
$c< :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
< :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
$c<= :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
<= :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
$c> :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
> :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
$c>= :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
>= :: RefReturnMethodDeclaration -> RefReturnMethodDeclaration -> Bool
$cmax :: RefReturnMethodDeclaration
-> RefReturnMethodDeclaration -> RefReturnMethodDeclaration
max :: RefReturnMethodDeclaration
-> RefReturnMethodDeclaration -> RefReturnMethodDeclaration
$cmin :: RefReturnMethodDeclaration
-> RefReturnMethodDeclaration -> RefReturnMethodDeclaration
min :: RefReturnMethodDeclaration
-> RefReturnMethodDeclaration -> RefReturnMethodDeclaration
Ord, ReadPrec [RefReturnMethodDeclaration]
ReadPrec RefReturnMethodDeclaration
Int -> ReadS RefReturnMethodDeclaration
ReadS [RefReturnMethodDeclaration]
(Int -> ReadS RefReturnMethodDeclaration)
-> ReadS [RefReturnMethodDeclaration]
-> ReadPrec RefReturnMethodDeclaration
-> ReadPrec [RefReturnMethodDeclaration]
-> Read RefReturnMethodDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefReturnMethodDeclaration
readsPrec :: Int -> ReadS RefReturnMethodDeclaration
$creadList :: ReadS [RefReturnMethodDeclaration]
readList :: ReadS [RefReturnMethodDeclaration]
$creadPrec :: ReadPrec RefReturnMethodDeclaration
readPrec :: ReadPrec RefReturnMethodDeclaration
$creadListPrec :: ReadPrec [RefReturnMethodDeclaration]
readListPrec :: ReadPrec [RefReturnMethodDeclaration]
Read, Int -> RefReturnMethodDeclaration -> String -> String
[RefReturnMethodDeclaration] -> String -> String
RefReturnMethodDeclaration -> String
(Int -> RefReturnMethodDeclaration -> String -> String)
-> (RefReturnMethodDeclaration -> String)
-> ([RefReturnMethodDeclaration] -> String -> String)
-> Show RefReturnMethodDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefReturnMethodDeclaration -> String -> String
showsPrec :: Int -> RefReturnMethodDeclaration -> String -> String
$cshow :: RefReturnMethodDeclaration -> String
show :: RefReturnMethodDeclaration -> String
$cshowList :: [RefReturnMethodDeclaration] -> String -> String
showList :: [RefReturnMethodDeclaration] -> String -> String
Show)

_RefReturnMethodDeclaration :: Name
_RefReturnMethodDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefReturnMethodDeclaration")

_RefReturnMethodDeclaration_attributes :: Name
_RefReturnMethodDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_RefReturnMethodDeclaration_modifiers :: Name
_RefReturnMethodDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_RefReturnMethodDeclaration_kind :: Name
_RefReturnMethodDeclaration_kind = (String -> Name
Core.Name String
"kind")

_RefReturnMethodDeclaration_returnType :: Name
_RefReturnMethodDeclaration_returnType = (String -> Name
Core.Name String
"returnType")

_RefReturnMethodDeclaration_header :: Name
_RefReturnMethodDeclaration_header = (String -> Name
Core.Name String
"header")

_RefReturnMethodDeclaration_body :: Name
_RefReturnMethodDeclaration_body = (String -> Name
Core.Name String
"body")

data MethodModifiers = 
  MethodModifiers {
    MethodModifiers -> [MethodModifier]
methodModifiersModifiers :: [MethodModifier],
    MethodModifiers -> Bool
methodModifiersPartial :: Bool}
  deriving (MethodModifiers -> MethodModifiers -> Bool
(MethodModifiers -> MethodModifiers -> Bool)
-> (MethodModifiers -> MethodModifiers -> Bool)
-> Eq MethodModifiers
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MethodModifiers -> MethodModifiers -> Bool
== :: MethodModifiers -> MethodModifiers -> Bool
$c/= :: MethodModifiers -> MethodModifiers -> Bool
/= :: MethodModifiers -> MethodModifiers -> Bool
Eq, Eq MethodModifiers
Eq MethodModifiers =>
(MethodModifiers -> MethodModifiers -> Ordering)
-> (MethodModifiers -> MethodModifiers -> Bool)
-> (MethodModifiers -> MethodModifiers -> Bool)
-> (MethodModifiers -> MethodModifiers -> Bool)
-> (MethodModifiers -> MethodModifiers -> Bool)
-> (MethodModifiers -> MethodModifiers -> MethodModifiers)
-> (MethodModifiers -> MethodModifiers -> MethodModifiers)
-> Ord MethodModifiers
MethodModifiers -> MethodModifiers -> Bool
MethodModifiers -> MethodModifiers -> Ordering
MethodModifiers -> MethodModifiers -> MethodModifiers
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MethodModifiers -> MethodModifiers -> Ordering
compare :: MethodModifiers -> MethodModifiers -> Ordering
$c< :: MethodModifiers -> MethodModifiers -> Bool
< :: MethodModifiers -> MethodModifiers -> Bool
$c<= :: MethodModifiers -> MethodModifiers -> Bool
<= :: MethodModifiers -> MethodModifiers -> Bool
$c> :: MethodModifiers -> MethodModifiers -> Bool
> :: MethodModifiers -> MethodModifiers -> Bool
$c>= :: MethodModifiers -> MethodModifiers -> Bool
>= :: MethodModifiers -> MethodModifiers -> Bool
$cmax :: MethodModifiers -> MethodModifiers -> MethodModifiers
max :: MethodModifiers -> MethodModifiers -> MethodModifiers
$cmin :: MethodModifiers -> MethodModifiers -> MethodModifiers
min :: MethodModifiers -> MethodModifiers -> MethodModifiers
Ord, ReadPrec [MethodModifiers]
ReadPrec MethodModifiers
Int -> ReadS MethodModifiers
ReadS [MethodModifiers]
(Int -> ReadS MethodModifiers)
-> ReadS [MethodModifiers]
-> ReadPrec MethodModifiers
-> ReadPrec [MethodModifiers]
-> Read MethodModifiers
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MethodModifiers
readsPrec :: Int -> ReadS MethodModifiers
$creadList :: ReadS [MethodModifiers]
readList :: ReadS [MethodModifiers]
$creadPrec :: ReadPrec MethodModifiers
readPrec :: ReadPrec MethodModifiers
$creadListPrec :: ReadPrec [MethodModifiers]
readListPrec :: ReadPrec [MethodModifiers]
Read, Int -> MethodModifiers -> String -> String
[MethodModifiers] -> String -> String
MethodModifiers -> String
(Int -> MethodModifiers -> String -> String)
-> (MethodModifiers -> String)
-> ([MethodModifiers] -> String -> String)
-> Show MethodModifiers
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MethodModifiers -> String -> String
showsPrec :: Int -> MethodModifiers -> String -> String
$cshow :: MethodModifiers -> String
show :: MethodModifiers -> String
$cshowList :: [MethodModifiers] -> String -> String
showList :: [MethodModifiers] -> String -> String
Show)

_MethodModifiers :: Name
_MethodModifiers = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MethodModifiers")

_MethodModifiers_modifiers :: Name
_MethodModifiers_modifiers = (String -> Name
Core.Name String
"modifiers")

_MethodModifiers_partial :: Name
_MethodModifiers_partial = (String -> Name
Core.Name String
"partial")

data RefKind = 
  RefKindRef  |
  RefKindRefReadonly 
  deriving (RefKind -> RefKind -> Bool
(RefKind -> RefKind -> Bool)
-> (RefKind -> RefKind -> Bool) -> Eq RefKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefKind -> RefKind -> Bool
== :: RefKind -> RefKind -> Bool
$c/= :: RefKind -> RefKind -> Bool
/= :: RefKind -> RefKind -> Bool
Eq, Eq RefKind
Eq RefKind =>
(RefKind -> RefKind -> Ordering)
-> (RefKind -> RefKind -> Bool)
-> (RefKind -> RefKind -> Bool)
-> (RefKind -> RefKind -> Bool)
-> (RefKind -> RefKind -> Bool)
-> (RefKind -> RefKind -> RefKind)
-> (RefKind -> RefKind -> RefKind)
-> Ord RefKind
RefKind -> RefKind -> Bool
RefKind -> RefKind -> Ordering
RefKind -> RefKind -> RefKind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefKind -> RefKind -> Ordering
compare :: RefKind -> RefKind -> Ordering
$c< :: RefKind -> RefKind -> Bool
< :: RefKind -> RefKind -> Bool
$c<= :: RefKind -> RefKind -> Bool
<= :: RefKind -> RefKind -> Bool
$c> :: RefKind -> RefKind -> Bool
> :: RefKind -> RefKind -> Bool
$c>= :: RefKind -> RefKind -> Bool
>= :: RefKind -> RefKind -> Bool
$cmax :: RefKind -> RefKind -> RefKind
max :: RefKind -> RefKind -> RefKind
$cmin :: RefKind -> RefKind -> RefKind
min :: RefKind -> RefKind -> RefKind
Ord, ReadPrec [RefKind]
ReadPrec RefKind
Int -> ReadS RefKind
ReadS [RefKind]
(Int -> ReadS RefKind)
-> ReadS [RefKind]
-> ReadPrec RefKind
-> ReadPrec [RefKind]
-> Read RefKind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefKind
readsPrec :: Int -> ReadS RefKind
$creadList :: ReadS [RefKind]
readList :: ReadS [RefKind]
$creadPrec :: ReadPrec RefKind
readPrec :: ReadPrec RefKind
$creadListPrec :: ReadPrec [RefKind]
readListPrec :: ReadPrec [RefKind]
Read, Int -> RefKind -> String -> String
[RefKind] -> String -> String
RefKind -> String
(Int -> RefKind -> String -> String)
-> (RefKind -> String)
-> ([RefKind] -> String -> String)
-> Show RefKind
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefKind -> String -> String
showsPrec :: Int -> RefKind -> String -> String
$cshow :: RefKind -> String
show :: RefKind -> String
$cshowList :: [RefKind] -> String -> String
showList :: [RefKind] -> String -> String
Show)

_RefKind :: Name
_RefKind = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefKind")

_RefKind_ref :: Name
_RefKind_ref = (String -> Name
Core.Name String
"ref")

_RefKind_refReadonly :: Name
_RefKind_refReadonly = (String -> Name
Core.Name String
"refReadonly")

data MethodHeader = 
  MethodHeader {
    MethodHeader -> MemberName
methodHeaderName :: MemberName,
    MethodHeader -> Maybe TypeParameterList
methodHeaderTypeParameters :: (Maybe TypeParameterList),
    MethodHeader -> Maybe FormalParameterList
methodHeaderParameters :: (Maybe FormalParameterList),
    MethodHeader -> [TypeParameterConstraintsClause]
methodHeaderConstraints :: [TypeParameterConstraintsClause]}
  deriving (MethodHeader -> MethodHeader -> Bool
(MethodHeader -> MethodHeader -> Bool)
-> (MethodHeader -> MethodHeader -> Bool) -> Eq MethodHeader
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MethodHeader -> MethodHeader -> Bool
== :: MethodHeader -> MethodHeader -> Bool
$c/= :: MethodHeader -> MethodHeader -> Bool
/= :: MethodHeader -> MethodHeader -> Bool
Eq, Eq MethodHeader
Eq MethodHeader =>
(MethodHeader -> MethodHeader -> Ordering)
-> (MethodHeader -> MethodHeader -> Bool)
-> (MethodHeader -> MethodHeader -> Bool)
-> (MethodHeader -> MethodHeader -> Bool)
-> (MethodHeader -> MethodHeader -> Bool)
-> (MethodHeader -> MethodHeader -> MethodHeader)
-> (MethodHeader -> MethodHeader -> MethodHeader)
-> Ord MethodHeader
MethodHeader -> MethodHeader -> Bool
MethodHeader -> MethodHeader -> Ordering
MethodHeader -> MethodHeader -> MethodHeader
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MethodHeader -> MethodHeader -> Ordering
compare :: MethodHeader -> MethodHeader -> Ordering
$c< :: MethodHeader -> MethodHeader -> Bool
< :: MethodHeader -> MethodHeader -> Bool
$c<= :: MethodHeader -> MethodHeader -> Bool
<= :: MethodHeader -> MethodHeader -> Bool
$c> :: MethodHeader -> MethodHeader -> Bool
> :: MethodHeader -> MethodHeader -> Bool
$c>= :: MethodHeader -> MethodHeader -> Bool
>= :: MethodHeader -> MethodHeader -> Bool
$cmax :: MethodHeader -> MethodHeader -> MethodHeader
max :: MethodHeader -> MethodHeader -> MethodHeader
$cmin :: MethodHeader -> MethodHeader -> MethodHeader
min :: MethodHeader -> MethodHeader -> MethodHeader
Ord, ReadPrec [MethodHeader]
ReadPrec MethodHeader
Int -> ReadS MethodHeader
ReadS [MethodHeader]
(Int -> ReadS MethodHeader)
-> ReadS [MethodHeader]
-> ReadPrec MethodHeader
-> ReadPrec [MethodHeader]
-> Read MethodHeader
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MethodHeader
readsPrec :: Int -> ReadS MethodHeader
$creadList :: ReadS [MethodHeader]
readList :: ReadS [MethodHeader]
$creadPrec :: ReadPrec MethodHeader
readPrec :: ReadPrec MethodHeader
$creadListPrec :: ReadPrec [MethodHeader]
readListPrec :: ReadPrec [MethodHeader]
Read, Int -> MethodHeader -> String -> String
[MethodHeader] -> String -> String
MethodHeader -> String
(Int -> MethodHeader -> String -> String)
-> (MethodHeader -> String)
-> ([MethodHeader] -> String -> String)
-> Show MethodHeader
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MethodHeader -> String -> String
showsPrec :: Int -> MethodHeader -> String -> String
$cshow :: MethodHeader -> String
show :: MethodHeader -> String
$cshowList :: [MethodHeader] -> String -> String
showList :: [MethodHeader] -> String -> String
Show)

_MethodHeader :: Name
_MethodHeader = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MethodHeader")

_MethodHeader_name :: Name
_MethodHeader_name = (String -> Name
Core.Name String
"name")

_MethodHeader_typeParameters :: Name
_MethodHeader_typeParameters = (String -> Name
Core.Name String
"typeParameters")

_MethodHeader_parameters :: Name
_MethodHeader_parameters = (String -> Name
Core.Name String
"parameters")

_MethodHeader_constraints :: Name
_MethodHeader_constraints = (String -> Name
Core.Name String
"constraints")

data MethodModifier = 
  MethodModifierRef RefMethodModifier |
  MethodModifierAsync 
  deriving (MethodModifier -> MethodModifier -> Bool
(MethodModifier -> MethodModifier -> Bool)
-> (MethodModifier -> MethodModifier -> Bool) -> Eq MethodModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MethodModifier -> MethodModifier -> Bool
== :: MethodModifier -> MethodModifier -> Bool
$c/= :: MethodModifier -> MethodModifier -> Bool
/= :: MethodModifier -> MethodModifier -> Bool
Eq, Eq MethodModifier
Eq MethodModifier =>
(MethodModifier -> MethodModifier -> Ordering)
-> (MethodModifier -> MethodModifier -> Bool)
-> (MethodModifier -> MethodModifier -> Bool)
-> (MethodModifier -> MethodModifier -> Bool)
-> (MethodModifier -> MethodModifier -> Bool)
-> (MethodModifier -> MethodModifier -> MethodModifier)
-> (MethodModifier -> MethodModifier -> MethodModifier)
-> Ord MethodModifier
MethodModifier -> MethodModifier -> Bool
MethodModifier -> MethodModifier -> Ordering
MethodModifier -> MethodModifier -> MethodModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MethodModifier -> MethodModifier -> Ordering
compare :: MethodModifier -> MethodModifier -> Ordering
$c< :: MethodModifier -> MethodModifier -> Bool
< :: MethodModifier -> MethodModifier -> Bool
$c<= :: MethodModifier -> MethodModifier -> Bool
<= :: MethodModifier -> MethodModifier -> Bool
$c> :: MethodModifier -> MethodModifier -> Bool
> :: MethodModifier -> MethodModifier -> Bool
$c>= :: MethodModifier -> MethodModifier -> Bool
>= :: MethodModifier -> MethodModifier -> Bool
$cmax :: MethodModifier -> MethodModifier -> MethodModifier
max :: MethodModifier -> MethodModifier -> MethodModifier
$cmin :: MethodModifier -> MethodModifier -> MethodModifier
min :: MethodModifier -> MethodModifier -> MethodModifier
Ord, ReadPrec [MethodModifier]
ReadPrec MethodModifier
Int -> ReadS MethodModifier
ReadS [MethodModifier]
(Int -> ReadS MethodModifier)
-> ReadS [MethodModifier]
-> ReadPrec MethodModifier
-> ReadPrec [MethodModifier]
-> Read MethodModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MethodModifier
readsPrec :: Int -> ReadS MethodModifier
$creadList :: ReadS [MethodModifier]
readList :: ReadS [MethodModifier]
$creadPrec :: ReadPrec MethodModifier
readPrec :: ReadPrec MethodModifier
$creadListPrec :: ReadPrec [MethodModifier]
readListPrec :: ReadPrec [MethodModifier]
Read, Int -> MethodModifier -> String -> String
[MethodModifier] -> String -> String
MethodModifier -> String
(Int -> MethodModifier -> String -> String)
-> (MethodModifier -> String)
-> ([MethodModifier] -> String -> String)
-> Show MethodModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MethodModifier -> String -> String
showsPrec :: Int -> MethodModifier -> String -> String
$cshow :: MethodModifier -> String
show :: MethodModifier -> String
$cshowList :: [MethodModifier] -> String -> String
showList :: [MethodModifier] -> String -> String
Show)

_MethodModifier :: Name
_MethodModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MethodModifier")

_MethodModifier_ref :: Name
_MethodModifier_ref = (String -> Name
Core.Name String
"ref")

_MethodModifier_async :: Name
_MethodModifier_async = (String -> Name
Core.Name String
"async")

data RefMethodModifier = 
  RefMethodModifierNew  |
  RefMethodModifierPublic  |
  RefMethodModifierProtected  |
  RefMethodModifierInternal  |
  RefMethodModifierPrivate  |
  RefMethodModifierStatic  |
  RefMethodModifierVirtual  |
  RefMethodModifierSealed  |
  RefMethodModifierOverride  |
  RefMethodModifierAbstract  |
  RefMethodModifierExtern  |
  RefMethodModifierUnsafe 
  deriving (RefMethodModifier -> RefMethodModifier -> Bool
(RefMethodModifier -> RefMethodModifier -> Bool)
-> (RefMethodModifier -> RefMethodModifier -> Bool)
-> Eq RefMethodModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefMethodModifier -> RefMethodModifier -> Bool
== :: RefMethodModifier -> RefMethodModifier -> Bool
$c/= :: RefMethodModifier -> RefMethodModifier -> Bool
/= :: RefMethodModifier -> RefMethodModifier -> Bool
Eq, Eq RefMethodModifier
Eq RefMethodModifier =>
(RefMethodModifier -> RefMethodModifier -> Ordering)
-> (RefMethodModifier -> RefMethodModifier -> Bool)
-> (RefMethodModifier -> RefMethodModifier -> Bool)
-> (RefMethodModifier -> RefMethodModifier -> Bool)
-> (RefMethodModifier -> RefMethodModifier -> Bool)
-> (RefMethodModifier -> RefMethodModifier -> RefMethodModifier)
-> (RefMethodModifier -> RefMethodModifier -> RefMethodModifier)
-> Ord RefMethodModifier
RefMethodModifier -> RefMethodModifier -> Bool
RefMethodModifier -> RefMethodModifier -> Ordering
RefMethodModifier -> RefMethodModifier -> RefMethodModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefMethodModifier -> RefMethodModifier -> Ordering
compare :: RefMethodModifier -> RefMethodModifier -> Ordering
$c< :: RefMethodModifier -> RefMethodModifier -> Bool
< :: RefMethodModifier -> RefMethodModifier -> Bool
$c<= :: RefMethodModifier -> RefMethodModifier -> Bool
<= :: RefMethodModifier -> RefMethodModifier -> Bool
$c> :: RefMethodModifier -> RefMethodModifier -> Bool
> :: RefMethodModifier -> RefMethodModifier -> Bool
$c>= :: RefMethodModifier -> RefMethodModifier -> Bool
>= :: RefMethodModifier -> RefMethodModifier -> Bool
$cmax :: RefMethodModifier -> RefMethodModifier -> RefMethodModifier
max :: RefMethodModifier -> RefMethodModifier -> RefMethodModifier
$cmin :: RefMethodModifier -> RefMethodModifier -> RefMethodModifier
min :: RefMethodModifier -> RefMethodModifier -> RefMethodModifier
Ord, ReadPrec [RefMethodModifier]
ReadPrec RefMethodModifier
Int -> ReadS RefMethodModifier
ReadS [RefMethodModifier]
(Int -> ReadS RefMethodModifier)
-> ReadS [RefMethodModifier]
-> ReadPrec RefMethodModifier
-> ReadPrec [RefMethodModifier]
-> Read RefMethodModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefMethodModifier
readsPrec :: Int -> ReadS RefMethodModifier
$creadList :: ReadS [RefMethodModifier]
readList :: ReadS [RefMethodModifier]
$creadPrec :: ReadPrec RefMethodModifier
readPrec :: ReadPrec RefMethodModifier
$creadListPrec :: ReadPrec [RefMethodModifier]
readListPrec :: ReadPrec [RefMethodModifier]
Read, Int -> RefMethodModifier -> String -> String
[RefMethodModifier] -> String -> String
RefMethodModifier -> String
(Int -> RefMethodModifier -> String -> String)
-> (RefMethodModifier -> String)
-> ([RefMethodModifier] -> String -> String)
-> Show RefMethodModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefMethodModifier -> String -> String
showsPrec :: Int -> RefMethodModifier -> String -> String
$cshow :: RefMethodModifier -> String
show :: RefMethodModifier -> String
$cshowList :: [RefMethodModifier] -> String -> String
showList :: [RefMethodModifier] -> String -> String
Show)

_RefMethodModifier :: Name
_RefMethodModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefMethodModifier")

_RefMethodModifier_new :: Name
_RefMethodModifier_new = (String -> Name
Core.Name String
"new")

_RefMethodModifier_public :: Name
_RefMethodModifier_public = (String -> Name
Core.Name String
"public")

_RefMethodModifier_protected :: Name
_RefMethodModifier_protected = (String -> Name
Core.Name String
"protected")

_RefMethodModifier_internal :: Name
_RefMethodModifier_internal = (String -> Name
Core.Name String
"internal")

_RefMethodModifier_private :: Name
_RefMethodModifier_private = (String -> Name
Core.Name String
"private")

_RefMethodModifier_static :: Name
_RefMethodModifier_static = (String -> Name
Core.Name String
"static")

_RefMethodModifier_virtual :: Name
_RefMethodModifier_virtual = (String -> Name
Core.Name String
"virtual")

_RefMethodModifier_sealed :: Name
_RefMethodModifier_sealed = (String -> Name
Core.Name String
"sealed")

_RefMethodModifier_override :: Name
_RefMethodModifier_override = (String -> Name
Core.Name String
"override")

_RefMethodModifier_abstract :: Name
_RefMethodModifier_abstract = (String -> Name
Core.Name String
"abstract")

_RefMethodModifier_extern :: Name
_RefMethodModifier_extern = (String -> Name
Core.Name String
"extern")

_RefMethodModifier_unsafe :: Name
_RefMethodModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

data ReturnType = 
  ReturnTypeRef Type |
  ReturnTypeVoid 
  deriving (ReturnType -> ReturnType -> Bool
(ReturnType -> ReturnType -> Bool)
-> (ReturnType -> ReturnType -> Bool) -> Eq ReturnType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ReturnType -> ReturnType -> Bool
== :: ReturnType -> ReturnType -> Bool
$c/= :: ReturnType -> ReturnType -> Bool
/= :: ReturnType -> ReturnType -> Bool
Eq, Eq ReturnType
Eq ReturnType =>
(ReturnType -> ReturnType -> Ordering)
-> (ReturnType -> ReturnType -> Bool)
-> (ReturnType -> ReturnType -> Bool)
-> (ReturnType -> ReturnType -> Bool)
-> (ReturnType -> ReturnType -> Bool)
-> (ReturnType -> ReturnType -> ReturnType)
-> (ReturnType -> ReturnType -> ReturnType)
-> Ord ReturnType
ReturnType -> ReturnType -> Bool
ReturnType -> ReturnType -> Ordering
ReturnType -> ReturnType -> ReturnType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ReturnType -> ReturnType -> Ordering
compare :: ReturnType -> ReturnType -> Ordering
$c< :: ReturnType -> ReturnType -> Bool
< :: ReturnType -> ReturnType -> Bool
$c<= :: ReturnType -> ReturnType -> Bool
<= :: ReturnType -> ReturnType -> Bool
$c> :: ReturnType -> ReturnType -> Bool
> :: ReturnType -> ReturnType -> Bool
$c>= :: ReturnType -> ReturnType -> Bool
>= :: ReturnType -> ReturnType -> Bool
$cmax :: ReturnType -> ReturnType -> ReturnType
max :: ReturnType -> ReturnType -> ReturnType
$cmin :: ReturnType -> ReturnType -> ReturnType
min :: ReturnType -> ReturnType -> ReturnType
Ord, ReadPrec [ReturnType]
ReadPrec ReturnType
Int -> ReadS ReturnType
ReadS [ReturnType]
(Int -> ReadS ReturnType)
-> ReadS [ReturnType]
-> ReadPrec ReturnType
-> ReadPrec [ReturnType]
-> Read ReturnType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ReturnType
readsPrec :: Int -> ReadS ReturnType
$creadList :: ReadS [ReturnType]
readList :: ReadS [ReturnType]
$creadPrec :: ReadPrec ReturnType
readPrec :: ReadPrec ReturnType
$creadListPrec :: ReadPrec [ReturnType]
readListPrec :: ReadPrec [ReturnType]
Read, Int -> ReturnType -> String -> String
[ReturnType] -> String -> String
ReturnType -> String
(Int -> ReturnType -> String -> String)
-> (ReturnType -> String)
-> ([ReturnType] -> String -> String)
-> Show ReturnType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ReturnType -> String -> String
showsPrec :: Int -> ReturnType -> String -> String
$cshow :: ReturnType -> String
show :: ReturnType -> String
$cshowList :: [ReturnType] -> String -> String
showList :: [ReturnType] -> String -> String
Show)

_ReturnType :: Name
_ReturnType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ReturnType")

_ReturnType_ref :: Name
_ReturnType_ref = (String -> Name
Core.Name String
"ref")

_ReturnType_void :: Name
_ReturnType_void = (String -> Name
Core.Name String
"void")

data MemberName = 
  MemberName {
    MemberName -> Maybe TypeName
memberNameInterfaceType :: (Maybe TypeName),
    MemberName -> Identifier
memberNameIdentifier :: Identifier}
  deriving (MemberName -> MemberName -> Bool
(MemberName -> MemberName -> Bool)
-> (MemberName -> MemberName -> Bool) -> Eq MemberName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MemberName -> MemberName -> Bool
== :: MemberName -> MemberName -> Bool
$c/= :: MemberName -> MemberName -> Bool
/= :: MemberName -> MemberName -> Bool
Eq, Eq MemberName
Eq MemberName =>
(MemberName -> MemberName -> Ordering)
-> (MemberName -> MemberName -> Bool)
-> (MemberName -> MemberName -> Bool)
-> (MemberName -> MemberName -> Bool)
-> (MemberName -> MemberName -> Bool)
-> (MemberName -> MemberName -> MemberName)
-> (MemberName -> MemberName -> MemberName)
-> Ord MemberName
MemberName -> MemberName -> Bool
MemberName -> MemberName -> Ordering
MemberName -> MemberName -> MemberName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MemberName -> MemberName -> Ordering
compare :: MemberName -> MemberName -> Ordering
$c< :: MemberName -> MemberName -> Bool
< :: MemberName -> MemberName -> Bool
$c<= :: MemberName -> MemberName -> Bool
<= :: MemberName -> MemberName -> Bool
$c> :: MemberName -> MemberName -> Bool
> :: MemberName -> MemberName -> Bool
$c>= :: MemberName -> MemberName -> Bool
>= :: MemberName -> MemberName -> Bool
$cmax :: MemberName -> MemberName -> MemberName
max :: MemberName -> MemberName -> MemberName
$cmin :: MemberName -> MemberName -> MemberName
min :: MemberName -> MemberName -> MemberName
Ord, ReadPrec [MemberName]
ReadPrec MemberName
Int -> ReadS MemberName
ReadS [MemberName]
(Int -> ReadS MemberName)
-> ReadS [MemberName]
-> ReadPrec MemberName
-> ReadPrec [MemberName]
-> Read MemberName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MemberName
readsPrec :: Int -> ReadS MemberName
$creadList :: ReadS [MemberName]
readList :: ReadS [MemberName]
$creadPrec :: ReadPrec MemberName
readPrec :: ReadPrec MemberName
$creadListPrec :: ReadPrec [MemberName]
readListPrec :: ReadPrec [MemberName]
Read, Int -> MemberName -> String -> String
[MemberName] -> String -> String
MemberName -> String
(Int -> MemberName -> String -> String)
-> (MemberName -> String)
-> ([MemberName] -> String -> String)
-> Show MemberName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MemberName -> String -> String
showsPrec :: Int -> MemberName -> String -> String
$cshow :: MemberName -> String
show :: MemberName -> String
$cshowList :: [MemberName] -> String -> String
showList :: [MemberName] -> String -> String
Show)

_MemberName :: Name
_MemberName = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MemberName")

_MemberName_interfaceType :: Name
_MemberName_interfaceType = (String -> Name
Core.Name String
"interfaceType")

_MemberName_identifier :: Name
_MemberName_identifier = (String -> Name
Core.Name String
"identifier")

data MethodBody = 
  MethodBodyBlock Block |
  MethodBodyNullConditionalInvocation NullConditionalInvocationExpression |
  MethodBodyExpression Expression |
  MethodBodyEmpty 
  deriving (MethodBody -> MethodBody -> Bool
(MethodBody -> MethodBody -> Bool)
-> (MethodBody -> MethodBody -> Bool) -> Eq MethodBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MethodBody -> MethodBody -> Bool
== :: MethodBody -> MethodBody -> Bool
$c/= :: MethodBody -> MethodBody -> Bool
/= :: MethodBody -> MethodBody -> Bool
Eq, Eq MethodBody
Eq MethodBody =>
(MethodBody -> MethodBody -> Ordering)
-> (MethodBody -> MethodBody -> Bool)
-> (MethodBody -> MethodBody -> Bool)
-> (MethodBody -> MethodBody -> Bool)
-> (MethodBody -> MethodBody -> Bool)
-> (MethodBody -> MethodBody -> MethodBody)
-> (MethodBody -> MethodBody -> MethodBody)
-> Ord MethodBody
MethodBody -> MethodBody -> Bool
MethodBody -> MethodBody -> Ordering
MethodBody -> MethodBody -> MethodBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: MethodBody -> MethodBody -> Ordering
compare :: MethodBody -> MethodBody -> Ordering
$c< :: MethodBody -> MethodBody -> Bool
< :: MethodBody -> MethodBody -> Bool
$c<= :: MethodBody -> MethodBody -> Bool
<= :: MethodBody -> MethodBody -> Bool
$c> :: MethodBody -> MethodBody -> Bool
> :: MethodBody -> MethodBody -> Bool
$c>= :: MethodBody -> MethodBody -> Bool
>= :: MethodBody -> MethodBody -> Bool
$cmax :: MethodBody -> MethodBody -> MethodBody
max :: MethodBody -> MethodBody -> MethodBody
$cmin :: MethodBody -> MethodBody -> MethodBody
min :: MethodBody -> MethodBody -> MethodBody
Ord, ReadPrec [MethodBody]
ReadPrec MethodBody
Int -> ReadS MethodBody
ReadS [MethodBody]
(Int -> ReadS MethodBody)
-> ReadS [MethodBody]
-> ReadPrec MethodBody
-> ReadPrec [MethodBody]
-> Read MethodBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS MethodBody
readsPrec :: Int -> ReadS MethodBody
$creadList :: ReadS [MethodBody]
readList :: ReadS [MethodBody]
$creadPrec :: ReadPrec MethodBody
readPrec :: ReadPrec MethodBody
$creadListPrec :: ReadPrec [MethodBody]
readListPrec :: ReadPrec [MethodBody]
Read, Int -> MethodBody -> String -> String
[MethodBody] -> String -> String
MethodBody -> String
(Int -> MethodBody -> String -> String)
-> (MethodBody -> String)
-> ([MethodBody] -> String -> String)
-> Show MethodBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> MethodBody -> String -> String
showsPrec :: Int -> MethodBody -> String -> String
$cshow :: MethodBody -> String
show :: MethodBody -> String
$cshowList :: [MethodBody] -> String -> String
showList :: [MethodBody] -> String -> String
Show)

_MethodBody :: Name
_MethodBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.MethodBody")

_MethodBody_block :: Name
_MethodBody_block = (String -> Name
Core.Name String
"block")

_MethodBody_nullConditionalInvocation :: Name
_MethodBody_nullConditionalInvocation = (String -> Name
Core.Name String
"nullConditionalInvocation")

_MethodBody_expression :: Name
_MethodBody_expression = (String -> Name
Core.Name String
"expression")

_MethodBody_empty :: Name
_MethodBody_empty = (String -> Name
Core.Name String
"empty")

data RefMethodBody = 
  RefMethodBodyBlock Block |
  RefMethodBodyRef VariableReference |
  RefMethodBodyEmpty 
  deriving (RefMethodBody -> RefMethodBody -> Bool
(RefMethodBody -> RefMethodBody -> Bool)
-> (RefMethodBody -> RefMethodBody -> Bool) -> Eq RefMethodBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefMethodBody -> RefMethodBody -> Bool
== :: RefMethodBody -> RefMethodBody -> Bool
$c/= :: RefMethodBody -> RefMethodBody -> Bool
/= :: RefMethodBody -> RefMethodBody -> Bool
Eq, Eq RefMethodBody
Eq RefMethodBody =>
(RefMethodBody -> RefMethodBody -> Ordering)
-> (RefMethodBody -> RefMethodBody -> Bool)
-> (RefMethodBody -> RefMethodBody -> Bool)
-> (RefMethodBody -> RefMethodBody -> Bool)
-> (RefMethodBody -> RefMethodBody -> Bool)
-> (RefMethodBody -> RefMethodBody -> RefMethodBody)
-> (RefMethodBody -> RefMethodBody -> RefMethodBody)
-> Ord RefMethodBody
RefMethodBody -> RefMethodBody -> Bool
RefMethodBody -> RefMethodBody -> Ordering
RefMethodBody -> RefMethodBody -> RefMethodBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefMethodBody -> RefMethodBody -> Ordering
compare :: RefMethodBody -> RefMethodBody -> Ordering
$c< :: RefMethodBody -> RefMethodBody -> Bool
< :: RefMethodBody -> RefMethodBody -> Bool
$c<= :: RefMethodBody -> RefMethodBody -> Bool
<= :: RefMethodBody -> RefMethodBody -> Bool
$c> :: RefMethodBody -> RefMethodBody -> Bool
> :: RefMethodBody -> RefMethodBody -> Bool
$c>= :: RefMethodBody -> RefMethodBody -> Bool
>= :: RefMethodBody -> RefMethodBody -> Bool
$cmax :: RefMethodBody -> RefMethodBody -> RefMethodBody
max :: RefMethodBody -> RefMethodBody -> RefMethodBody
$cmin :: RefMethodBody -> RefMethodBody -> RefMethodBody
min :: RefMethodBody -> RefMethodBody -> RefMethodBody
Ord, ReadPrec [RefMethodBody]
ReadPrec RefMethodBody
Int -> ReadS RefMethodBody
ReadS [RefMethodBody]
(Int -> ReadS RefMethodBody)
-> ReadS [RefMethodBody]
-> ReadPrec RefMethodBody
-> ReadPrec [RefMethodBody]
-> Read RefMethodBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefMethodBody
readsPrec :: Int -> ReadS RefMethodBody
$creadList :: ReadS [RefMethodBody]
readList :: ReadS [RefMethodBody]
$creadPrec :: ReadPrec RefMethodBody
readPrec :: ReadPrec RefMethodBody
$creadListPrec :: ReadPrec [RefMethodBody]
readListPrec :: ReadPrec [RefMethodBody]
Read, Int -> RefMethodBody -> String -> String
[RefMethodBody] -> String -> String
RefMethodBody -> String
(Int -> RefMethodBody -> String -> String)
-> (RefMethodBody -> String)
-> ([RefMethodBody] -> String -> String)
-> Show RefMethodBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefMethodBody -> String -> String
showsPrec :: Int -> RefMethodBody -> String -> String
$cshow :: RefMethodBody -> String
show :: RefMethodBody -> String
$cshowList :: [RefMethodBody] -> String -> String
showList :: [RefMethodBody] -> String -> String
Show)

_RefMethodBody :: Name
_RefMethodBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefMethodBody")

_RefMethodBody_block :: Name
_RefMethodBody_block = (String -> Name
Core.Name String
"block")

_RefMethodBody_ref :: Name
_RefMethodBody_ref = (String -> Name
Core.Name String
"ref")

_RefMethodBody_empty :: Name
_RefMethodBody_empty = (String -> Name
Core.Name String
"empty")

data FormalParameterList = 
  FormalParameterList {
    FormalParameterList -> [FixedParameter]
formalParameterListFixed :: [FixedParameter],
    FormalParameterList -> Maybe ParameterArray
formalParameterListArray :: (Maybe ParameterArray)}
  deriving (FormalParameterList -> FormalParameterList -> Bool
(FormalParameterList -> FormalParameterList -> Bool)
-> (FormalParameterList -> FormalParameterList -> Bool)
-> Eq FormalParameterList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FormalParameterList -> FormalParameterList -> Bool
== :: FormalParameterList -> FormalParameterList -> Bool
$c/= :: FormalParameterList -> FormalParameterList -> Bool
/= :: FormalParameterList -> FormalParameterList -> Bool
Eq, Eq FormalParameterList
Eq FormalParameterList =>
(FormalParameterList -> FormalParameterList -> Ordering)
-> (FormalParameterList -> FormalParameterList -> Bool)
-> (FormalParameterList -> FormalParameterList -> Bool)
-> (FormalParameterList -> FormalParameterList -> Bool)
-> (FormalParameterList -> FormalParameterList -> Bool)
-> (FormalParameterList
    -> FormalParameterList -> FormalParameterList)
-> (FormalParameterList
    -> FormalParameterList -> FormalParameterList)
-> Ord FormalParameterList
FormalParameterList -> FormalParameterList -> Bool
FormalParameterList -> FormalParameterList -> Ordering
FormalParameterList -> FormalParameterList -> FormalParameterList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FormalParameterList -> FormalParameterList -> Ordering
compare :: FormalParameterList -> FormalParameterList -> Ordering
$c< :: FormalParameterList -> FormalParameterList -> Bool
< :: FormalParameterList -> FormalParameterList -> Bool
$c<= :: FormalParameterList -> FormalParameterList -> Bool
<= :: FormalParameterList -> FormalParameterList -> Bool
$c> :: FormalParameterList -> FormalParameterList -> Bool
> :: FormalParameterList -> FormalParameterList -> Bool
$c>= :: FormalParameterList -> FormalParameterList -> Bool
>= :: FormalParameterList -> FormalParameterList -> Bool
$cmax :: FormalParameterList -> FormalParameterList -> FormalParameterList
max :: FormalParameterList -> FormalParameterList -> FormalParameterList
$cmin :: FormalParameterList -> FormalParameterList -> FormalParameterList
min :: FormalParameterList -> FormalParameterList -> FormalParameterList
Ord, ReadPrec [FormalParameterList]
ReadPrec FormalParameterList
Int -> ReadS FormalParameterList
ReadS [FormalParameterList]
(Int -> ReadS FormalParameterList)
-> ReadS [FormalParameterList]
-> ReadPrec FormalParameterList
-> ReadPrec [FormalParameterList]
-> Read FormalParameterList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FormalParameterList
readsPrec :: Int -> ReadS FormalParameterList
$creadList :: ReadS [FormalParameterList]
readList :: ReadS [FormalParameterList]
$creadPrec :: ReadPrec FormalParameterList
readPrec :: ReadPrec FormalParameterList
$creadListPrec :: ReadPrec [FormalParameterList]
readListPrec :: ReadPrec [FormalParameterList]
Read, Int -> FormalParameterList -> String -> String
[FormalParameterList] -> String -> String
FormalParameterList -> String
(Int -> FormalParameterList -> String -> String)
-> (FormalParameterList -> String)
-> ([FormalParameterList] -> String -> String)
-> Show FormalParameterList
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FormalParameterList -> String -> String
showsPrec :: Int -> FormalParameterList -> String -> String
$cshow :: FormalParameterList -> String
show :: FormalParameterList -> String
$cshowList :: [FormalParameterList] -> String -> String
showList :: [FormalParameterList] -> String -> String
Show)

_FormalParameterList :: Name
_FormalParameterList = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FormalParameterList")

_FormalParameterList_fixed :: Name
_FormalParameterList_fixed = (String -> Name
Core.Name String
"fixed")

_FormalParameterList_array :: Name
_FormalParameterList_array = (String -> Name
Core.Name String
"array")

data FixedParameter = 
  FixedParameter {
    FixedParameter -> Maybe Attributes
fixedParameterAttributes :: (Maybe Attributes),
    FixedParameter -> Maybe ParameterModifier
fixedParameterModifier :: (Maybe ParameterModifier),
    FixedParameter -> Type
fixedParameterType :: Type,
    FixedParameter -> Identifier
fixedParameterIdentifier :: Identifier,
    FixedParameter -> Maybe Expression
fixedParameterDefaultArgument :: (Maybe Expression)}
  deriving (FixedParameter -> FixedParameter -> Bool
(FixedParameter -> FixedParameter -> Bool)
-> (FixedParameter -> FixedParameter -> Bool) -> Eq FixedParameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FixedParameter -> FixedParameter -> Bool
== :: FixedParameter -> FixedParameter -> Bool
$c/= :: FixedParameter -> FixedParameter -> Bool
/= :: FixedParameter -> FixedParameter -> Bool
Eq, Eq FixedParameter
Eq FixedParameter =>
(FixedParameter -> FixedParameter -> Ordering)
-> (FixedParameter -> FixedParameter -> Bool)
-> (FixedParameter -> FixedParameter -> Bool)
-> (FixedParameter -> FixedParameter -> Bool)
-> (FixedParameter -> FixedParameter -> Bool)
-> (FixedParameter -> FixedParameter -> FixedParameter)
-> (FixedParameter -> FixedParameter -> FixedParameter)
-> Ord FixedParameter
FixedParameter -> FixedParameter -> Bool
FixedParameter -> FixedParameter -> Ordering
FixedParameter -> FixedParameter -> FixedParameter
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FixedParameter -> FixedParameter -> Ordering
compare :: FixedParameter -> FixedParameter -> Ordering
$c< :: FixedParameter -> FixedParameter -> Bool
< :: FixedParameter -> FixedParameter -> Bool
$c<= :: FixedParameter -> FixedParameter -> Bool
<= :: FixedParameter -> FixedParameter -> Bool
$c> :: FixedParameter -> FixedParameter -> Bool
> :: FixedParameter -> FixedParameter -> Bool
$c>= :: FixedParameter -> FixedParameter -> Bool
>= :: FixedParameter -> FixedParameter -> Bool
$cmax :: FixedParameter -> FixedParameter -> FixedParameter
max :: FixedParameter -> FixedParameter -> FixedParameter
$cmin :: FixedParameter -> FixedParameter -> FixedParameter
min :: FixedParameter -> FixedParameter -> FixedParameter
Ord, ReadPrec [FixedParameter]
ReadPrec FixedParameter
Int -> ReadS FixedParameter
ReadS [FixedParameter]
(Int -> ReadS FixedParameter)
-> ReadS [FixedParameter]
-> ReadPrec FixedParameter
-> ReadPrec [FixedParameter]
-> Read FixedParameter
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FixedParameter
readsPrec :: Int -> ReadS FixedParameter
$creadList :: ReadS [FixedParameter]
readList :: ReadS [FixedParameter]
$creadPrec :: ReadPrec FixedParameter
readPrec :: ReadPrec FixedParameter
$creadListPrec :: ReadPrec [FixedParameter]
readListPrec :: ReadPrec [FixedParameter]
Read, Int -> FixedParameter -> String -> String
[FixedParameter] -> String -> String
FixedParameter -> String
(Int -> FixedParameter -> String -> String)
-> (FixedParameter -> String)
-> ([FixedParameter] -> String -> String)
-> Show FixedParameter
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FixedParameter -> String -> String
showsPrec :: Int -> FixedParameter -> String -> String
$cshow :: FixedParameter -> String
show :: FixedParameter -> String
$cshowList :: [FixedParameter] -> String -> String
showList :: [FixedParameter] -> String -> String
Show)

_FixedParameter :: Name
_FixedParameter = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FixedParameter")

_FixedParameter_attributes :: Name
_FixedParameter_attributes = (String -> Name
Core.Name String
"attributes")

_FixedParameter_modifier :: Name
_FixedParameter_modifier = (String -> Name
Core.Name String
"modifier")

_FixedParameter_type :: Name
_FixedParameter_type = (String -> Name
Core.Name String
"type")

_FixedParameter_identifier :: Name
_FixedParameter_identifier = (String -> Name
Core.Name String
"identifier")

_FixedParameter_defaultArgument :: Name
_FixedParameter_defaultArgument = (String -> Name
Core.Name String
"defaultArgument")

data ParameterModifier = 
  ParameterModifierMode ParameterModeModifier |
  ParameterModifierThis 
  deriving (ParameterModifier -> ParameterModifier -> Bool
(ParameterModifier -> ParameterModifier -> Bool)
-> (ParameterModifier -> ParameterModifier -> Bool)
-> Eq ParameterModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ParameterModifier -> ParameterModifier -> Bool
== :: ParameterModifier -> ParameterModifier -> Bool
$c/= :: ParameterModifier -> ParameterModifier -> Bool
/= :: ParameterModifier -> ParameterModifier -> Bool
Eq, Eq ParameterModifier
Eq ParameterModifier =>
(ParameterModifier -> ParameterModifier -> Ordering)
-> (ParameterModifier -> ParameterModifier -> Bool)
-> (ParameterModifier -> ParameterModifier -> Bool)
-> (ParameterModifier -> ParameterModifier -> Bool)
-> (ParameterModifier -> ParameterModifier -> Bool)
-> (ParameterModifier -> ParameterModifier -> ParameterModifier)
-> (ParameterModifier -> ParameterModifier -> ParameterModifier)
-> Ord ParameterModifier
ParameterModifier -> ParameterModifier -> Bool
ParameterModifier -> ParameterModifier -> Ordering
ParameterModifier -> ParameterModifier -> ParameterModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ParameterModifier -> ParameterModifier -> Ordering
compare :: ParameterModifier -> ParameterModifier -> Ordering
$c< :: ParameterModifier -> ParameterModifier -> Bool
< :: ParameterModifier -> ParameterModifier -> Bool
$c<= :: ParameterModifier -> ParameterModifier -> Bool
<= :: ParameterModifier -> ParameterModifier -> Bool
$c> :: ParameterModifier -> ParameterModifier -> Bool
> :: ParameterModifier -> ParameterModifier -> Bool
$c>= :: ParameterModifier -> ParameterModifier -> Bool
>= :: ParameterModifier -> ParameterModifier -> Bool
$cmax :: ParameterModifier -> ParameterModifier -> ParameterModifier
max :: ParameterModifier -> ParameterModifier -> ParameterModifier
$cmin :: ParameterModifier -> ParameterModifier -> ParameterModifier
min :: ParameterModifier -> ParameterModifier -> ParameterModifier
Ord, ReadPrec [ParameterModifier]
ReadPrec ParameterModifier
Int -> ReadS ParameterModifier
ReadS [ParameterModifier]
(Int -> ReadS ParameterModifier)
-> ReadS [ParameterModifier]
-> ReadPrec ParameterModifier
-> ReadPrec [ParameterModifier]
-> Read ParameterModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ParameterModifier
readsPrec :: Int -> ReadS ParameterModifier
$creadList :: ReadS [ParameterModifier]
readList :: ReadS [ParameterModifier]
$creadPrec :: ReadPrec ParameterModifier
readPrec :: ReadPrec ParameterModifier
$creadListPrec :: ReadPrec [ParameterModifier]
readListPrec :: ReadPrec [ParameterModifier]
Read, Int -> ParameterModifier -> String -> String
[ParameterModifier] -> String -> String
ParameterModifier -> String
(Int -> ParameterModifier -> String -> String)
-> (ParameterModifier -> String)
-> ([ParameterModifier] -> String -> String)
-> Show ParameterModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ParameterModifier -> String -> String
showsPrec :: Int -> ParameterModifier -> String -> String
$cshow :: ParameterModifier -> String
show :: ParameterModifier -> String
$cshowList :: [ParameterModifier] -> String -> String
showList :: [ParameterModifier] -> String -> String
Show)

_ParameterModifier :: Name
_ParameterModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ParameterModifier")

_ParameterModifier_mode :: Name
_ParameterModifier_mode = (String -> Name
Core.Name String
"mode")

_ParameterModifier_this :: Name
_ParameterModifier_this = (String -> Name
Core.Name String
"this")

data ParameterModeModifier = 
  ParameterModeModifierRef  |
  ParameterModeModifierOut  |
  ParameterModeModifierIn 
  deriving (ParameterModeModifier -> ParameterModeModifier -> Bool
(ParameterModeModifier -> ParameterModeModifier -> Bool)
-> (ParameterModeModifier -> ParameterModeModifier -> Bool)
-> Eq ParameterModeModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ParameterModeModifier -> ParameterModeModifier -> Bool
== :: ParameterModeModifier -> ParameterModeModifier -> Bool
$c/= :: ParameterModeModifier -> ParameterModeModifier -> Bool
/= :: ParameterModeModifier -> ParameterModeModifier -> Bool
Eq, Eq ParameterModeModifier
Eq ParameterModeModifier =>
(ParameterModeModifier -> ParameterModeModifier -> Ordering)
-> (ParameterModeModifier -> ParameterModeModifier -> Bool)
-> (ParameterModeModifier -> ParameterModeModifier -> Bool)
-> (ParameterModeModifier -> ParameterModeModifier -> Bool)
-> (ParameterModeModifier -> ParameterModeModifier -> Bool)
-> (ParameterModeModifier
    -> ParameterModeModifier -> ParameterModeModifier)
-> (ParameterModeModifier
    -> ParameterModeModifier -> ParameterModeModifier)
-> Ord ParameterModeModifier
ParameterModeModifier -> ParameterModeModifier -> Bool
ParameterModeModifier -> ParameterModeModifier -> Ordering
ParameterModeModifier
-> ParameterModeModifier -> ParameterModeModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ParameterModeModifier -> ParameterModeModifier -> Ordering
compare :: ParameterModeModifier -> ParameterModeModifier -> Ordering
$c< :: ParameterModeModifier -> ParameterModeModifier -> Bool
< :: ParameterModeModifier -> ParameterModeModifier -> Bool
$c<= :: ParameterModeModifier -> ParameterModeModifier -> Bool
<= :: ParameterModeModifier -> ParameterModeModifier -> Bool
$c> :: ParameterModeModifier -> ParameterModeModifier -> Bool
> :: ParameterModeModifier -> ParameterModeModifier -> Bool
$c>= :: ParameterModeModifier -> ParameterModeModifier -> Bool
>= :: ParameterModeModifier -> ParameterModeModifier -> Bool
$cmax :: ParameterModeModifier
-> ParameterModeModifier -> ParameterModeModifier
max :: ParameterModeModifier
-> ParameterModeModifier -> ParameterModeModifier
$cmin :: ParameterModeModifier
-> ParameterModeModifier -> ParameterModeModifier
min :: ParameterModeModifier
-> ParameterModeModifier -> ParameterModeModifier
Ord, ReadPrec [ParameterModeModifier]
ReadPrec ParameterModeModifier
Int -> ReadS ParameterModeModifier
ReadS [ParameterModeModifier]
(Int -> ReadS ParameterModeModifier)
-> ReadS [ParameterModeModifier]
-> ReadPrec ParameterModeModifier
-> ReadPrec [ParameterModeModifier]
-> Read ParameterModeModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ParameterModeModifier
readsPrec :: Int -> ReadS ParameterModeModifier
$creadList :: ReadS [ParameterModeModifier]
readList :: ReadS [ParameterModeModifier]
$creadPrec :: ReadPrec ParameterModeModifier
readPrec :: ReadPrec ParameterModeModifier
$creadListPrec :: ReadPrec [ParameterModeModifier]
readListPrec :: ReadPrec [ParameterModeModifier]
Read, Int -> ParameterModeModifier -> String -> String
[ParameterModeModifier] -> String -> String
ParameterModeModifier -> String
(Int -> ParameterModeModifier -> String -> String)
-> (ParameterModeModifier -> String)
-> ([ParameterModeModifier] -> String -> String)
-> Show ParameterModeModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ParameterModeModifier -> String -> String
showsPrec :: Int -> ParameterModeModifier -> String -> String
$cshow :: ParameterModeModifier -> String
show :: ParameterModeModifier -> String
$cshowList :: [ParameterModeModifier] -> String -> String
showList :: [ParameterModeModifier] -> String -> String
Show)

_ParameterModeModifier :: Name
_ParameterModeModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ParameterModeModifier")

_ParameterModeModifier_ref :: Name
_ParameterModeModifier_ref = (String -> Name
Core.Name String
"ref")

_ParameterModeModifier_out :: Name
_ParameterModeModifier_out = (String -> Name
Core.Name String
"out")

_ParameterModeModifier_in :: Name
_ParameterModeModifier_in = (String -> Name
Core.Name String
"in")

data ParameterArray = 
  ParameterArray {
    ParameterArray -> Maybe Attributes
parameterArrayAttributes :: (Maybe Attributes),
    ParameterArray -> ArrayType
parameterArrayType :: ArrayType,
    ParameterArray -> Identifier
parameterArrayIdentifier :: Identifier}
  deriving (ParameterArray -> ParameterArray -> Bool
(ParameterArray -> ParameterArray -> Bool)
-> (ParameterArray -> ParameterArray -> Bool) -> Eq ParameterArray
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ParameterArray -> ParameterArray -> Bool
== :: ParameterArray -> ParameterArray -> Bool
$c/= :: ParameterArray -> ParameterArray -> Bool
/= :: ParameterArray -> ParameterArray -> Bool
Eq, Eq ParameterArray
Eq ParameterArray =>
(ParameterArray -> ParameterArray -> Ordering)
-> (ParameterArray -> ParameterArray -> Bool)
-> (ParameterArray -> ParameterArray -> Bool)
-> (ParameterArray -> ParameterArray -> Bool)
-> (ParameterArray -> ParameterArray -> Bool)
-> (ParameterArray -> ParameterArray -> ParameterArray)
-> (ParameterArray -> ParameterArray -> ParameterArray)
-> Ord ParameterArray
ParameterArray -> ParameterArray -> Bool
ParameterArray -> ParameterArray -> Ordering
ParameterArray -> ParameterArray -> ParameterArray
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ParameterArray -> ParameterArray -> Ordering
compare :: ParameterArray -> ParameterArray -> Ordering
$c< :: ParameterArray -> ParameterArray -> Bool
< :: ParameterArray -> ParameterArray -> Bool
$c<= :: ParameterArray -> ParameterArray -> Bool
<= :: ParameterArray -> ParameterArray -> Bool
$c> :: ParameterArray -> ParameterArray -> Bool
> :: ParameterArray -> ParameterArray -> Bool
$c>= :: ParameterArray -> ParameterArray -> Bool
>= :: ParameterArray -> ParameterArray -> Bool
$cmax :: ParameterArray -> ParameterArray -> ParameterArray
max :: ParameterArray -> ParameterArray -> ParameterArray
$cmin :: ParameterArray -> ParameterArray -> ParameterArray
min :: ParameterArray -> ParameterArray -> ParameterArray
Ord, ReadPrec [ParameterArray]
ReadPrec ParameterArray
Int -> ReadS ParameterArray
ReadS [ParameterArray]
(Int -> ReadS ParameterArray)
-> ReadS [ParameterArray]
-> ReadPrec ParameterArray
-> ReadPrec [ParameterArray]
-> Read ParameterArray
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ParameterArray
readsPrec :: Int -> ReadS ParameterArray
$creadList :: ReadS [ParameterArray]
readList :: ReadS [ParameterArray]
$creadPrec :: ReadPrec ParameterArray
readPrec :: ReadPrec ParameterArray
$creadListPrec :: ReadPrec [ParameterArray]
readListPrec :: ReadPrec [ParameterArray]
Read, Int -> ParameterArray -> String -> String
[ParameterArray] -> String -> String
ParameterArray -> String
(Int -> ParameterArray -> String -> String)
-> (ParameterArray -> String)
-> ([ParameterArray] -> String -> String)
-> Show ParameterArray
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ParameterArray -> String -> String
showsPrec :: Int -> ParameterArray -> String -> String
$cshow :: ParameterArray -> String
show :: ParameterArray -> String
$cshowList :: [ParameterArray] -> String -> String
showList :: [ParameterArray] -> String -> String
Show)

_ParameterArray :: Name
_ParameterArray = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ParameterArray")

_ParameterArray_attributes :: Name
_ParameterArray_attributes = (String -> Name
Core.Name String
"attributes")

_ParameterArray_type :: Name
_ParameterArray_type = (String -> Name
Core.Name String
"type")

_ParameterArray_identifier :: Name
_ParameterArray_identifier = (String -> Name
Core.Name String
"identifier")

data PropertyDeclaration = 
  PropertyDeclarationStandard StandardPropertyDeclaration |
  PropertyDeclarationRefReturn RefReturnPropertyDeclaration
  deriving (PropertyDeclaration -> PropertyDeclaration -> Bool
(PropertyDeclaration -> PropertyDeclaration -> Bool)
-> (PropertyDeclaration -> PropertyDeclaration -> Bool)
-> Eq PropertyDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PropertyDeclaration -> PropertyDeclaration -> Bool
== :: PropertyDeclaration -> PropertyDeclaration -> Bool
$c/= :: PropertyDeclaration -> PropertyDeclaration -> Bool
/= :: PropertyDeclaration -> PropertyDeclaration -> Bool
Eq, Eq PropertyDeclaration
Eq PropertyDeclaration =>
(PropertyDeclaration -> PropertyDeclaration -> Ordering)
-> (PropertyDeclaration -> PropertyDeclaration -> Bool)
-> (PropertyDeclaration -> PropertyDeclaration -> Bool)
-> (PropertyDeclaration -> PropertyDeclaration -> Bool)
-> (PropertyDeclaration -> PropertyDeclaration -> Bool)
-> (PropertyDeclaration
    -> PropertyDeclaration -> PropertyDeclaration)
-> (PropertyDeclaration
    -> PropertyDeclaration -> PropertyDeclaration)
-> Ord PropertyDeclaration
PropertyDeclaration -> PropertyDeclaration -> Bool
PropertyDeclaration -> PropertyDeclaration -> Ordering
PropertyDeclaration -> PropertyDeclaration -> PropertyDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PropertyDeclaration -> PropertyDeclaration -> Ordering
compare :: PropertyDeclaration -> PropertyDeclaration -> Ordering
$c< :: PropertyDeclaration -> PropertyDeclaration -> Bool
< :: PropertyDeclaration -> PropertyDeclaration -> Bool
$c<= :: PropertyDeclaration -> PropertyDeclaration -> Bool
<= :: PropertyDeclaration -> PropertyDeclaration -> Bool
$c> :: PropertyDeclaration -> PropertyDeclaration -> Bool
> :: PropertyDeclaration -> PropertyDeclaration -> Bool
$c>= :: PropertyDeclaration -> PropertyDeclaration -> Bool
>= :: PropertyDeclaration -> PropertyDeclaration -> Bool
$cmax :: PropertyDeclaration -> PropertyDeclaration -> PropertyDeclaration
max :: PropertyDeclaration -> PropertyDeclaration -> PropertyDeclaration
$cmin :: PropertyDeclaration -> PropertyDeclaration -> PropertyDeclaration
min :: PropertyDeclaration -> PropertyDeclaration -> PropertyDeclaration
Ord, ReadPrec [PropertyDeclaration]
ReadPrec PropertyDeclaration
Int -> ReadS PropertyDeclaration
ReadS [PropertyDeclaration]
(Int -> ReadS PropertyDeclaration)
-> ReadS [PropertyDeclaration]
-> ReadPrec PropertyDeclaration
-> ReadPrec [PropertyDeclaration]
-> Read PropertyDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PropertyDeclaration
readsPrec :: Int -> ReadS PropertyDeclaration
$creadList :: ReadS [PropertyDeclaration]
readList :: ReadS [PropertyDeclaration]
$creadPrec :: ReadPrec PropertyDeclaration
readPrec :: ReadPrec PropertyDeclaration
$creadListPrec :: ReadPrec [PropertyDeclaration]
readListPrec :: ReadPrec [PropertyDeclaration]
Read, Int -> PropertyDeclaration -> String -> String
[PropertyDeclaration] -> String -> String
PropertyDeclaration -> String
(Int -> PropertyDeclaration -> String -> String)
-> (PropertyDeclaration -> String)
-> ([PropertyDeclaration] -> String -> String)
-> Show PropertyDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PropertyDeclaration -> String -> String
showsPrec :: Int -> PropertyDeclaration -> String -> String
$cshow :: PropertyDeclaration -> String
show :: PropertyDeclaration -> String
$cshowList :: [PropertyDeclaration] -> String -> String
showList :: [PropertyDeclaration] -> String -> String
Show)

_PropertyDeclaration :: Name
_PropertyDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PropertyDeclaration")

_PropertyDeclaration_standard :: Name
_PropertyDeclaration_standard = (String -> Name
Core.Name String
"standard")

_PropertyDeclaration_refReturn :: Name
_PropertyDeclaration_refReturn = (String -> Name
Core.Name String
"refReturn")

data StandardPropertyDeclaration = 
  StandardPropertyDeclaration {
    StandardPropertyDeclaration -> Maybe Attributes
standardPropertyDeclarationAttributes :: (Maybe Attributes),
    StandardPropertyDeclaration -> [PropertyModifier]
standardPropertyDeclarationModifiers :: [PropertyModifier],
    StandardPropertyDeclaration -> Type
standardPropertyDeclarationType :: Type,
    StandardPropertyDeclaration -> MemberName
standardPropertyDeclarationName :: MemberName,
    StandardPropertyDeclaration -> PropertyBody
standardPropertyDeclarationBody :: PropertyBody}
  deriving (StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
(StandardPropertyDeclaration
 -> StandardPropertyDeclaration -> Bool)
-> (StandardPropertyDeclaration
    -> StandardPropertyDeclaration -> Bool)
-> Eq StandardPropertyDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
== :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
$c/= :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
/= :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
Eq, Eq StandardPropertyDeclaration
Eq StandardPropertyDeclaration =>
(StandardPropertyDeclaration
 -> StandardPropertyDeclaration -> Ordering)
-> (StandardPropertyDeclaration
    -> StandardPropertyDeclaration -> Bool)
-> (StandardPropertyDeclaration
    -> StandardPropertyDeclaration -> Bool)
-> (StandardPropertyDeclaration
    -> StandardPropertyDeclaration -> Bool)
-> (StandardPropertyDeclaration
    -> StandardPropertyDeclaration -> Bool)
-> (StandardPropertyDeclaration
    -> StandardPropertyDeclaration -> StandardPropertyDeclaration)
-> (StandardPropertyDeclaration
    -> StandardPropertyDeclaration -> StandardPropertyDeclaration)
-> Ord StandardPropertyDeclaration
StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
StandardPropertyDeclaration
-> StandardPropertyDeclaration -> Ordering
StandardPropertyDeclaration
-> StandardPropertyDeclaration -> StandardPropertyDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StandardPropertyDeclaration
-> StandardPropertyDeclaration -> Ordering
compare :: StandardPropertyDeclaration
-> StandardPropertyDeclaration -> Ordering
$c< :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
< :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
$c<= :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
<= :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
$c> :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
> :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
$c>= :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
>= :: StandardPropertyDeclaration -> StandardPropertyDeclaration -> Bool
$cmax :: StandardPropertyDeclaration
-> StandardPropertyDeclaration -> StandardPropertyDeclaration
max :: StandardPropertyDeclaration
-> StandardPropertyDeclaration -> StandardPropertyDeclaration
$cmin :: StandardPropertyDeclaration
-> StandardPropertyDeclaration -> StandardPropertyDeclaration
min :: StandardPropertyDeclaration
-> StandardPropertyDeclaration -> StandardPropertyDeclaration
Ord, ReadPrec [StandardPropertyDeclaration]
ReadPrec StandardPropertyDeclaration
Int -> ReadS StandardPropertyDeclaration
ReadS [StandardPropertyDeclaration]
(Int -> ReadS StandardPropertyDeclaration)
-> ReadS [StandardPropertyDeclaration]
-> ReadPrec StandardPropertyDeclaration
-> ReadPrec [StandardPropertyDeclaration]
-> Read StandardPropertyDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StandardPropertyDeclaration
readsPrec :: Int -> ReadS StandardPropertyDeclaration
$creadList :: ReadS [StandardPropertyDeclaration]
readList :: ReadS [StandardPropertyDeclaration]
$creadPrec :: ReadPrec StandardPropertyDeclaration
readPrec :: ReadPrec StandardPropertyDeclaration
$creadListPrec :: ReadPrec [StandardPropertyDeclaration]
readListPrec :: ReadPrec [StandardPropertyDeclaration]
Read, Int -> StandardPropertyDeclaration -> String -> String
[StandardPropertyDeclaration] -> String -> String
StandardPropertyDeclaration -> String
(Int -> StandardPropertyDeclaration -> String -> String)
-> (StandardPropertyDeclaration -> String)
-> ([StandardPropertyDeclaration] -> String -> String)
-> Show StandardPropertyDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StandardPropertyDeclaration -> String -> String
showsPrec :: Int -> StandardPropertyDeclaration -> String -> String
$cshow :: StandardPropertyDeclaration -> String
show :: StandardPropertyDeclaration -> String
$cshowList :: [StandardPropertyDeclaration] -> String -> String
showList :: [StandardPropertyDeclaration] -> String -> String
Show)

_StandardPropertyDeclaration :: Name
_StandardPropertyDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StandardPropertyDeclaration")

_StandardPropertyDeclaration_attributes :: Name
_StandardPropertyDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_StandardPropertyDeclaration_modifiers :: Name
_StandardPropertyDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_StandardPropertyDeclaration_type :: Name
_StandardPropertyDeclaration_type = (String -> Name
Core.Name String
"type")

_StandardPropertyDeclaration_name :: Name
_StandardPropertyDeclaration_name = (String -> Name
Core.Name String
"name")

_StandardPropertyDeclaration_body :: Name
_StandardPropertyDeclaration_body = (String -> Name
Core.Name String
"body")

data RefReturnPropertyDeclaration = 
  RefReturnPropertyDeclaration {
    RefReturnPropertyDeclaration -> Maybe Attributes
refReturnPropertyDeclarationAttributes :: (Maybe Attributes),
    RefReturnPropertyDeclaration -> [PropertyModifier]
refReturnPropertyDeclarationModifiers :: [PropertyModifier],
    RefReturnPropertyDeclaration -> RefKind
refReturnPropertyDeclarationRefKind :: RefKind,
    RefReturnPropertyDeclaration -> Type
refReturnPropertyDeclarationType :: Type,
    RefReturnPropertyDeclaration -> MemberName
refReturnPropertyDeclarationName :: MemberName,
    RefReturnPropertyDeclaration -> RefPropertyBody
refReturnPropertyDeclarationBody :: RefPropertyBody}
  deriving (RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
(RefReturnPropertyDeclaration
 -> RefReturnPropertyDeclaration -> Bool)
-> (RefReturnPropertyDeclaration
    -> RefReturnPropertyDeclaration -> Bool)
-> Eq RefReturnPropertyDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
== :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
$c/= :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
/= :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
Eq, Eq RefReturnPropertyDeclaration
Eq RefReturnPropertyDeclaration =>
(RefReturnPropertyDeclaration
 -> RefReturnPropertyDeclaration -> Ordering)
-> (RefReturnPropertyDeclaration
    -> RefReturnPropertyDeclaration -> Bool)
-> (RefReturnPropertyDeclaration
    -> RefReturnPropertyDeclaration -> Bool)
-> (RefReturnPropertyDeclaration
    -> RefReturnPropertyDeclaration -> Bool)
-> (RefReturnPropertyDeclaration
    -> RefReturnPropertyDeclaration -> Bool)
-> (RefReturnPropertyDeclaration
    -> RefReturnPropertyDeclaration -> RefReturnPropertyDeclaration)
-> (RefReturnPropertyDeclaration
    -> RefReturnPropertyDeclaration -> RefReturnPropertyDeclaration)
-> Ord RefReturnPropertyDeclaration
RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Ordering
RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> RefReturnPropertyDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Ordering
compare :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Ordering
$c< :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
< :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
$c<= :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
<= :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
$c> :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
> :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
$c>= :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
>= :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> Bool
$cmax :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> RefReturnPropertyDeclaration
max :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> RefReturnPropertyDeclaration
$cmin :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> RefReturnPropertyDeclaration
min :: RefReturnPropertyDeclaration
-> RefReturnPropertyDeclaration -> RefReturnPropertyDeclaration
Ord, ReadPrec [RefReturnPropertyDeclaration]
ReadPrec RefReturnPropertyDeclaration
Int -> ReadS RefReturnPropertyDeclaration
ReadS [RefReturnPropertyDeclaration]
(Int -> ReadS RefReturnPropertyDeclaration)
-> ReadS [RefReturnPropertyDeclaration]
-> ReadPrec RefReturnPropertyDeclaration
-> ReadPrec [RefReturnPropertyDeclaration]
-> Read RefReturnPropertyDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefReturnPropertyDeclaration
readsPrec :: Int -> ReadS RefReturnPropertyDeclaration
$creadList :: ReadS [RefReturnPropertyDeclaration]
readList :: ReadS [RefReturnPropertyDeclaration]
$creadPrec :: ReadPrec RefReturnPropertyDeclaration
readPrec :: ReadPrec RefReturnPropertyDeclaration
$creadListPrec :: ReadPrec [RefReturnPropertyDeclaration]
readListPrec :: ReadPrec [RefReturnPropertyDeclaration]
Read, Int -> RefReturnPropertyDeclaration -> String -> String
[RefReturnPropertyDeclaration] -> String -> String
RefReturnPropertyDeclaration -> String
(Int -> RefReturnPropertyDeclaration -> String -> String)
-> (RefReturnPropertyDeclaration -> String)
-> ([RefReturnPropertyDeclaration] -> String -> String)
-> Show RefReturnPropertyDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefReturnPropertyDeclaration -> String -> String
showsPrec :: Int -> RefReturnPropertyDeclaration -> String -> String
$cshow :: RefReturnPropertyDeclaration -> String
show :: RefReturnPropertyDeclaration -> String
$cshowList :: [RefReturnPropertyDeclaration] -> String -> String
showList :: [RefReturnPropertyDeclaration] -> String -> String
Show)

_RefReturnPropertyDeclaration :: Name
_RefReturnPropertyDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefReturnPropertyDeclaration")

_RefReturnPropertyDeclaration_attributes :: Name
_RefReturnPropertyDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_RefReturnPropertyDeclaration_modifiers :: Name
_RefReturnPropertyDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_RefReturnPropertyDeclaration_refKind :: Name
_RefReturnPropertyDeclaration_refKind = (String -> Name
Core.Name String
"refKind")

_RefReturnPropertyDeclaration_type :: Name
_RefReturnPropertyDeclaration_type = (String -> Name
Core.Name String
"type")

_RefReturnPropertyDeclaration_name :: Name
_RefReturnPropertyDeclaration_name = (String -> Name
Core.Name String
"name")

_RefReturnPropertyDeclaration_body :: Name
_RefReturnPropertyDeclaration_body = (String -> Name
Core.Name String
"body")

data PropertyModifier = 
  PropertyModifierNew  |
  PropertyModifierPublic  |
  PropertyModifierProtected  |
  PropertyModifierInternal  |
  PropertyModifierPrivate  |
  PropertyModifierStatic  |
  PropertyModifierVirtual  |
  PropertyModifierSealed  |
  PropertyModifierOverride  |
  PropertyModifierAbstract  |
  PropertyModifierExtern  |
  PropertyModifierUnsafe 
  deriving (PropertyModifier -> PropertyModifier -> Bool
(PropertyModifier -> PropertyModifier -> Bool)
-> (PropertyModifier -> PropertyModifier -> Bool)
-> Eq PropertyModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PropertyModifier -> PropertyModifier -> Bool
== :: PropertyModifier -> PropertyModifier -> Bool
$c/= :: PropertyModifier -> PropertyModifier -> Bool
/= :: PropertyModifier -> PropertyModifier -> Bool
Eq, Eq PropertyModifier
Eq PropertyModifier =>
(PropertyModifier -> PropertyModifier -> Ordering)
-> (PropertyModifier -> PropertyModifier -> Bool)
-> (PropertyModifier -> PropertyModifier -> Bool)
-> (PropertyModifier -> PropertyModifier -> Bool)
-> (PropertyModifier -> PropertyModifier -> Bool)
-> (PropertyModifier -> PropertyModifier -> PropertyModifier)
-> (PropertyModifier -> PropertyModifier -> PropertyModifier)
-> Ord PropertyModifier
PropertyModifier -> PropertyModifier -> Bool
PropertyModifier -> PropertyModifier -> Ordering
PropertyModifier -> PropertyModifier -> PropertyModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PropertyModifier -> PropertyModifier -> Ordering
compare :: PropertyModifier -> PropertyModifier -> Ordering
$c< :: PropertyModifier -> PropertyModifier -> Bool
< :: PropertyModifier -> PropertyModifier -> Bool
$c<= :: PropertyModifier -> PropertyModifier -> Bool
<= :: PropertyModifier -> PropertyModifier -> Bool
$c> :: PropertyModifier -> PropertyModifier -> Bool
> :: PropertyModifier -> PropertyModifier -> Bool
$c>= :: PropertyModifier -> PropertyModifier -> Bool
>= :: PropertyModifier -> PropertyModifier -> Bool
$cmax :: PropertyModifier -> PropertyModifier -> PropertyModifier
max :: PropertyModifier -> PropertyModifier -> PropertyModifier
$cmin :: PropertyModifier -> PropertyModifier -> PropertyModifier
min :: PropertyModifier -> PropertyModifier -> PropertyModifier
Ord, ReadPrec [PropertyModifier]
ReadPrec PropertyModifier
Int -> ReadS PropertyModifier
ReadS [PropertyModifier]
(Int -> ReadS PropertyModifier)
-> ReadS [PropertyModifier]
-> ReadPrec PropertyModifier
-> ReadPrec [PropertyModifier]
-> Read PropertyModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PropertyModifier
readsPrec :: Int -> ReadS PropertyModifier
$creadList :: ReadS [PropertyModifier]
readList :: ReadS [PropertyModifier]
$creadPrec :: ReadPrec PropertyModifier
readPrec :: ReadPrec PropertyModifier
$creadListPrec :: ReadPrec [PropertyModifier]
readListPrec :: ReadPrec [PropertyModifier]
Read, Int -> PropertyModifier -> String -> String
[PropertyModifier] -> String -> String
PropertyModifier -> String
(Int -> PropertyModifier -> String -> String)
-> (PropertyModifier -> String)
-> ([PropertyModifier] -> String -> String)
-> Show PropertyModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PropertyModifier -> String -> String
showsPrec :: Int -> PropertyModifier -> String -> String
$cshow :: PropertyModifier -> String
show :: PropertyModifier -> String
$cshowList :: [PropertyModifier] -> String -> String
showList :: [PropertyModifier] -> String -> String
Show)

_PropertyModifier :: Name
_PropertyModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PropertyModifier")

_PropertyModifier_new :: Name
_PropertyModifier_new = (String -> Name
Core.Name String
"new")

_PropertyModifier_public :: Name
_PropertyModifier_public = (String -> Name
Core.Name String
"public")

_PropertyModifier_protected :: Name
_PropertyModifier_protected = (String -> Name
Core.Name String
"protected")

_PropertyModifier_internal :: Name
_PropertyModifier_internal = (String -> Name
Core.Name String
"internal")

_PropertyModifier_private :: Name
_PropertyModifier_private = (String -> Name
Core.Name String
"private")

_PropertyModifier_static :: Name
_PropertyModifier_static = (String -> Name
Core.Name String
"static")

_PropertyModifier_virtual :: Name
_PropertyModifier_virtual = (String -> Name
Core.Name String
"virtual")

_PropertyModifier_sealed :: Name
_PropertyModifier_sealed = (String -> Name
Core.Name String
"sealed")

_PropertyModifier_override :: Name
_PropertyModifier_override = (String -> Name
Core.Name String
"override")

_PropertyModifier_abstract :: Name
_PropertyModifier_abstract = (String -> Name
Core.Name String
"abstract")

_PropertyModifier_extern :: Name
_PropertyModifier_extern = (String -> Name
Core.Name String
"extern")

_PropertyModifier_unsafe :: Name
_PropertyModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

data PropertyBody = 
  PropertyBodyBlock BlockPropertyBody |
  PropertyBodyExpression Expression
  deriving (PropertyBody -> PropertyBody -> Bool
(PropertyBody -> PropertyBody -> Bool)
-> (PropertyBody -> PropertyBody -> Bool) -> Eq PropertyBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PropertyBody -> PropertyBody -> Bool
== :: PropertyBody -> PropertyBody -> Bool
$c/= :: PropertyBody -> PropertyBody -> Bool
/= :: PropertyBody -> PropertyBody -> Bool
Eq, Eq PropertyBody
Eq PropertyBody =>
(PropertyBody -> PropertyBody -> Ordering)
-> (PropertyBody -> PropertyBody -> Bool)
-> (PropertyBody -> PropertyBody -> Bool)
-> (PropertyBody -> PropertyBody -> Bool)
-> (PropertyBody -> PropertyBody -> Bool)
-> (PropertyBody -> PropertyBody -> PropertyBody)
-> (PropertyBody -> PropertyBody -> PropertyBody)
-> Ord PropertyBody
PropertyBody -> PropertyBody -> Bool
PropertyBody -> PropertyBody -> Ordering
PropertyBody -> PropertyBody -> PropertyBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PropertyBody -> PropertyBody -> Ordering
compare :: PropertyBody -> PropertyBody -> Ordering
$c< :: PropertyBody -> PropertyBody -> Bool
< :: PropertyBody -> PropertyBody -> Bool
$c<= :: PropertyBody -> PropertyBody -> Bool
<= :: PropertyBody -> PropertyBody -> Bool
$c> :: PropertyBody -> PropertyBody -> Bool
> :: PropertyBody -> PropertyBody -> Bool
$c>= :: PropertyBody -> PropertyBody -> Bool
>= :: PropertyBody -> PropertyBody -> Bool
$cmax :: PropertyBody -> PropertyBody -> PropertyBody
max :: PropertyBody -> PropertyBody -> PropertyBody
$cmin :: PropertyBody -> PropertyBody -> PropertyBody
min :: PropertyBody -> PropertyBody -> PropertyBody
Ord, ReadPrec [PropertyBody]
ReadPrec PropertyBody
Int -> ReadS PropertyBody
ReadS [PropertyBody]
(Int -> ReadS PropertyBody)
-> ReadS [PropertyBody]
-> ReadPrec PropertyBody
-> ReadPrec [PropertyBody]
-> Read PropertyBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PropertyBody
readsPrec :: Int -> ReadS PropertyBody
$creadList :: ReadS [PropertyBody]
readList :: ReadS [PropertyBody]
$creadPrec :: ReadPrec PropertyBody
readPrec :: ReadPrec PropertyBody
$creadListPrec :: ReadPrec [PropertyBody]
readListPrec :: ReadPrec [PropertyBody]
Read, Int -> PropertyBody -> String -> String
[PropertyBody] -> String -> String
PropertyBody -> String
(Int -> PropertyBody -> String -> String)
-> (PropertyBody -> String)
-> ([PropertyBody] -> String -> String)
-> Show PropertyBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PropertyBody -> String -> String
showsPrec :: Int -> PropertyBody -> String -> String
$cshow :: PropertyBody -> String
show :: PropertyBody -> String
$cshowList :: [PropertyBody] -> String -> String
showList :: [PropertyBody] -> String -> String
Show)

_PropertyBody :: Name
_PropertyBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PropertyBody")

_PropertyBody_block :: Name
_PropertyBody_block = (String -> Name
Core.Name String
"block")

_PropertyBody_expression :: Name
_PropertyBody_expression = (String -> Name
Core.Name String
"expression")

data BlockPropertyBody = 
  BlockPropertyBody {
    BlockPropertyBody -> AccessorDeclarations
blockPropertyBodyAccessors :: AccessorDeclarations,
    BlockPropertyBody -> Maybe VariableInitializer
blockPropertyBodyInitializer :: (Maybe VariableInitializer)}
  deriving (BlockPropertyBody -> BlockPropertyBody -> Bool
(BlockPropertyBody -> BlockPropertyBody -> Bool)
-> (BlockPropertyBody -> BlockPropertyBody -> Bool)
-> Eq BlockPropertyBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlockPropertyBody -> BlockPropertyBody -> Bool
== :: BlockPropertyBody -> BlockPropertyBody -> Bool
$c/= :: BlockPropertyBody -> BlockPropertyBody -> Bool
/= :: BlockPropertyBody -> BlockPropertyBody -> Bool
Eq, Eq BlockPropertyBody
Eq BlockPropertyBody =>
(BlockPropertyBody -> BlockPropertyBody -> Ordering)
-> (BlockPropertyBody -> BlockPropertyBody -> Bool)
-> (BlockPropertyBody -> BlockPropertyBody -> Bool)
-> (BlockPropertyBody -> BlockPropertyBody -> Bool)
-> (BlockPropertyBody -> BlockPropertyBody -> Bool)
-> (BlockPropertyBody -> BlockPropertyBody -> BlockPropertyBody)
-> (BlockPropertyBody -> BlockPropertyBody -> BlockPropertyBody)
-> Ord BlockPropertyBody
BlockPropertyBody -> BlockPropertyBody -> Bool
BlockPropertyBody -> BlockPropertyBody -> Ordering
BlockPropertyBody -> BlockPropertyBody -> BlockPropertyBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BlockPropertyBody -> BlockPropertyBody -> Ordering
compare :: BlockPropertyBody -> BlockPropertyBody -> Ordering
$c< :: BlockPropertyBody -> BlockPropertyBody -> Bool
< :: BlockPropertyBody -> BlockPropertyBody -> Bool
$c<= :: BlockPropertyBody -> BlockPropertyBody -> Bool
<= :: BlockPropertyBody -> BlockPropertyBody -> Bool
$c> :: BlockPropertyBody -> BlockPropertyBody -> Bool
> :: BlockPropertyBody -> BlockPropertyBody -> Bool
$c>= :: BlockPropertyBody -> BlockPropertyBody -> Bool
>= :: BlockPropertyBody -> BlockPropertyBody -> Bool
$cmax :: BlockPropertyBody -> BlockPropertyBody -> BlockPropertyBody
max :: BlockPropertyBody -> BlockPropertyBody -> BlockPropertyBody
$cmin :: BlockPropertyBody -> BlockPropertyBody -> BlockPropertyBody
min :: BlockPropertyBody -> BlockPropertyBody -> BlockPropertyBody
Ord, ReadPrec [BlockPropertyBody]
ReadPrec BlockPropertyBody
Int -> ReadS BlockPropertyBody
ReadS [BlockPropertyBody]
(Int -> ReadS BlockPropertyBody)
-> ReadS [BlockPropertyBody]
-> ReadPrec BlockPropertyBody
-> ReadPrec [BlockPropertyBody]
-> Read BlockPropertyBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BlockPropertyBody
readsPrec :: Int -> ReadS BlockPropertyBody
$creadList :: ReadS [BlockPropertyBody]
readList :: ReadS [BlockPropertyBody]
$creadPrec :: ReadPrec BlockPropertyBody
readPrec :: ReadPrec BlockPropertyBody
$creadListPrec :: ReadPrec [BlockPropertyBody]
readListPrec :: ReadPrec [BlockPropertyBody]
Read, Int -> BlockPropertyBody -> String -> String
[BlockPropertyBody] -> String -> String
BlockPropertyBody -> String
(Int -> BlockPropertyBody -> String -> String)
-> (BlockPropertyBody -> String)
-> ([BlockPropertyBody] -> String -> String)
-> Show BlockPropertyBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BlockPropertyBody -> String -> String
showsPrec :: Int -> BlockPropertyBody -> String -> String
$cshow :: BlockPropertyBody -> String
show :: BlockPropertyBody -> String
$cshowList :: [BlockPropertyBody] -> String -> String
showList :: [BlockPropertyBody] -> String -> String
Show)

_BlockPropertyBody :: Name
_BlockPropertyBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BlockPropertyBody")

_BlockPropertyBody_accessors :: Name
_BlockPropertyBody_accessors = (String -> Name
Core.Name String
"accessors")

_BlockPropertyBody_initializer :: Name
_BlockPropertyBody_initializer = (String -> Name
Core.Name String
"initializer")

data RefPropertyBody = 
  RefPropertyBodyBlock RefGetAccessorDeclaration |
  RefPropertyBodyRef VariableReference
  deriving (RefPropertyBody -> RefPropertyBody -> Bool
(RefPropertyBody -> RefPropertyBody -> Bool)
-> (RefPropertyBody -> RefPropertyBody -> Bool)
-> Eq RefPropertyBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefPropertyBody -> RefPropertyBody -> Bool
== :: RefPropertyBody -> RefPropertyBody -> Bool
$c/= :: RefPropertyBody -> RefPropertyBody -> Bool
/= :: RefPropertyBody -> RefPropertyBody -> Bool
Eq, Eq RefPropertyBody
Eq RefPropertyBody =>
(RefPropertyBody -> RefPropertyBody -> Ordering)
-> (RefPropertyBody -> RefPropertyBody -> Bool)
-> (RefPropertyBody -> RefPropertyBody -> Bool)
-> (RefPropertyBody -> RefPropertyBody -> Bool)
-> (RefPropertyBody -> RefPropertyBody -> Bool)
-> (RefPropertyBody -> RefPropertyBody -> RefPropertyBody)
-> (RefPropertyBody -> RefPropertyBody -> RefPropertyBody)
-> Ord RefPropertyBody
RefPropertyBody -> RefPropertyBody -> Bool
RefPropertyBody -> RefPropertyBody -> Ordering
RefPropertyBody -> RefPropertyBody -> RefPropertyBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefPropertyBody -> RefPropertyBody -> Ordering
compare :: RefPropertyBody -> RefPropertyBody -> Ordering
$c< :: RefPropertyBody -> RefPropertyBody -> Bool
< :: RefPropertyBody -> RefPropertyBody -> Bool
$c<= :: RefPropertyBody -> RefPropertyBody -> Bool
<= :: RefPropertyBody -> RefPropertyBody -> Bool
$c> :: RefPropertyBody -> RefPropertyBody -> Bool
> :: RefPropertyBody -> RefPropertyBody -> Bool
$c>= :: RefPropertyBody -> RefPropertyBody -> Bool
>= :: RefPropertyBody -> RefPropertyBody -> Bool
$cmax :: RefPropertyBody -> RefPropertyBody -> RefPropertyBody
max :: RefPropertyBody -> RefPropertyBody -> RefPropertyBody
$cmin :: RefPropertyBody -> RefPropertyBody -> RefPropertyBody
min :: RefPropertyBody -> RefPropertyBody -> RefPropertyBody
Ord, ReadPrec [RefPropertyBody]
ReadPrec RefPropertyBody
Int -> ReadS RefPropertyBody
ReadS [RefPropertyBody]
(Int -> ReadS RefPropertyBody)
-> ReadS [RefPropertyBody]
-> ReadPrec RefPropertyBody
-> ReadPrec [RefPropertyBody]
-> Read RefPropertyBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefPropertyBody
readsPrec :: Int -> ReadS RefPropertyBody
$creadList :: ReadS [RefPropertyBody]
readList :: ReadS [RefPropertyBody]
$creadPrec :: ReadPrec RefPropertyBody
readPrec :: ReadPrec RefPropertyBody
$creadListPrec :: ReadPrec [RefPropertyBody]
readListPrec :: ReadPrec [RefPropertyBody]
Read, Int -> RefPropertyBody -> String -> String
[RefPropertyBody] -> String -> String
RefPropertyBody -> String
(Int -> RefPropertyBody -> String -> String)
-> (RefPropertyBody -> String)
-> ([RefPropertyBody] -> String -> String)
-> Show RefPropertyBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefPropertyBody -> String -> String
showsPrec :: Int -> RefPropertyBody -> String -> String
$cshow :: RefPropertyBody -> String
show :: RefPropertyBody -> String
$cshowList :: [RefPropertyBody] -> String -> String
showList :: [RefPropertyBody] -> String -> String
Show)

_RefPropertyBody :: Name
_RefPropertyBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefPropertyBody")

_RefPropertyBody_block :: Name
_RefPropertyBody_block = (String -> Name
Core.Name String
"block")

_RefPropertyBody_ref :: Name
_RefPropertyBody_ref = (String -> Name
Core.Name String
"ref")

data AccessorDeclarations = 
  AccessorDeclarationsGet (Maybe AccessorDeclaration) |
  AccessorDeclarationsSet (Maybe AccessorDeclaration)
  deriving (AccessorDeclarations -> AccessorDeclarations -> Bool
(AccessorDeclarations -> AccessorDeclarations -> Bool)
-> (AccessorDeclarations -> AccessorDeclarations -> Bool)
-> Eq AccessorDeclarations
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AccessorDeclarations -> AccessorDeclarations -> Bool
== :: AccessorDeclarations -> AccessorDeclarations -> Bool
$c/= :: AccessorDeclarations -> AccessorDeclarations -> Bool
/= :: AccessorDeclarations -> AccessorDeclarations -> Bool
Eq, Eq AccessorDeclarations
Eq AccessorDeclarations =>
(AccessorDeclarations -> AccessorDeclarations -> Ordering)
-> (AccessorDeclarations -> AccessorDeclarations -> Bool)
-> (AccessorDeclarations -> AccessorDeclarations -> Bool)
-> (AccessorDeclarations -> AccessorDeclarations -> Bool)
-> (AccessorDeclarations -> AccessorDeclarations -> Bool)
-> (AccessorDeclarations
    -> AccessorDeclarations -> AccessorDeclarations)
-> (AccessorDeclarations
    -> AccessorDeclarations -> AccessorDeclarations)
-> Ord AccessorDeclarations
AccessorDeclarations -> AccessorDeclarations -> Bool
AccessorDeclarations -> AccessorDeclarations -> Ordering
AccessorDeclarations
-> AccessorDeclarations -> AccessorDeclarations
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AccessorDeclarations -> AccessorDeclarations -> Ordering
compare :: AccessorDeclarations -> AccessorDeclarations -> Ordering
$c< :: AccessorDeclarations -> AccessorDeclarations -> Bool
< :: AccessorDeclarations -> AccessorDeclarations -> Bool
$c<= :: AccessorDeclarations -> AccessorDeclarations -> Bool
<= :: AccessorDeclarations -> AccessorDeclarations -> Bool
$c> :: AccessorDeclarations -> AccessorDeclarations -> Bool
> :: AccessorDeclarations -> AccessorDeclarations -> Bool
$c>= :: AccessorDeclarations -> AccessorDeclarations -> Bool
>= :: AccessorDeclarations -> AccessorDeclarations -> Bool
$cmax :: AccessorDeclarations
-> AccessorDeclarations -> AccessorDeclarations
max :: AccessorDeclarations
-> AccessorDeclarations -> AccessorDeclarations
$cmin :: AccessorDeclarations
-> AccessorDeclarations -> AccessorDeclarations
min :: AccessorDeclarations
-> AccessorDeclarations -> AccessorDeclarations
Ord, ReadPrec [AccessorDeclarations]
ReadPrec AccessorDeclarations
Int -> ReadS AccessorDeclarations
ReadS [AccessorDeclarations]
(Int -> ReadS AccessorDeclarations)
-> ReadS [AccessorDeclarations]
-> ReadPrec AccessorDeclarations
-> ReadPrec [AccessorDeclarations]
-> Read AccessorDeclarations
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AccessorDeclarations
readsPrec :: Int -> ReadS AccessorDeclarations
$creadList :: ReadS [AccessorDeclarations]
readList :: ReadS [AccessorDeclarations]
$creadPrec :: ReadPrec AccessorDeclarations
readPrec :: ReadPrec AccessorDeclarations
$creadListPrec :: ReadPrec [AccessorDeclarations]
readListPrec :: ReadPrec [AccessorDeclarations]
Read, Int -> AccessorDeclarations -> String -> String
[AccessorDeclarations] -> String -> String
AccessorDeclarations -> String
(Int -> AccessorDeclarations -> String -> String)
-> (AccessorDeclarations -> String)
-> ([AccessorDeclarations] -> String -> String)
-> Show AccessorDeclarations
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AccessorDeclarations -> String -> String
showsPrec :: Int -> AccessorDeclarations -> String -> String
$cshow :: AccessorDeclarations -> String
show :: AccessorDeclarations -> String
$cshowList :: [AccessorDeclarations] -> String -> String
showList :: [AccessorDeclarations] -> String -> String
Show)

_AccessorDeclarations :: Name
_AccessorDeclarations = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AccessorDeclarations")

_AccessorDeclarations_get :: Name
_AccessorDeclarations_get = (String -> Name
Core.Name String
"get")

_AccessorDeclarations_set :: Name
_AccessorDeclarations_set = (String -> Name
Core.Name String
"set")

data AccessorDeclaration = 
  AccessorDeclaration {
    AccessorDeclaration -> Maybe Attributes
accessorDeclarationAttributes :: (Maybe Attributes),
    AccessorDeclaration -> Maybe AccessorModifier
accessorDeclarationModifier :: (Maybe AccessorModifier),
    AccessorDeclaration -> AccessorBody
accessorDeclarationBody :: AccessorBody}
  deriving (AccessorDeclaration -> AccessorDeclaration -> Bool
(AccessorDeclaration -> AccessorDeclaration -> Bool)
-> (AccessorDeclaration -> AccessorDeclaration -> Bool)
-> Eq AccessorDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AccessorDeclaration -> AccessorDeclaration -> Bool
== :: AccessorDeclaration -> AccessorDeclaration -> Bool
$c/= :: AccessorDeclaration -> AccessorDeclaration -> Bool
/= :: AccessorDeclaration -> AccessorDeclaration -> Bool
Eq, Eq AccessorDeclaration
Eq AccessorDeclaration =>
(AccessorDeclaration -> AccessorDeclaration -> Ordering)
-> (AccessorDeclaration -> AccessorDeclaration -> Bool)
-> (AccessorDeclaration -> AccessorDeclaration -> Bool)
-> (AccessorDeclaration -> AccessorDeclaration -> Bool)
-> (AccessorDeclaration -> AccessorDeclaration -> Bool)
-> (AccessorDeclaration
    -> AccessorDeclaration -> AccessorDeclaration)
-> (AccessorDeclaration
    -> AccessorDeclaration -> AccessorDeclaration)
-> Ord AccessorDeclaration
AccessorDeclaration -> AccessorDeclaration -> Bool
AccessorDeclaration -> AccessorDeclaration -> Ordering
AccessorDeclaration -> AccessorDeclaration -> AccessorDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AccessorDeclaration -> AccessorDeclaration -> Ordering
compare :: AccessorDeclaration -> AccessorDeclaration -> Ordering
$c< :: AccessorDeclaration -> AccessorDeclaration -> Bool
< :: AccessorDeclaration -> AccessorDeclaration -> Bool
$c<= :: AccessorDeclaration -> AccessorDeclaration -> Bool
<= :: AccessorDeclaration -> AccessorDeclaration -> Bool
$c> :: AccessorDeclaration -> AccessorDeclaration -> Bool
> :: AccessorDeclaration -> AccessorDeclaration -> Bool
$c>= :: AccessorDeclaration -> AccessorDeclaration -> Bool
>= :: AccessorDeclaration -> AccessorDeclaration -> Bool
$cmax :: AccessorDeclaration -> AccessorDeclaration -> AccessorDeclaration
max :: AccessorDeclaration -> AccessorDeclaration -> AccessorDeclaration
$cmin :: AccessorDeclaration -> AccessorDeclaration -> AccessorDeclaration
min :: AccessorDeclaration -> AccessorDeclaration -> AccessorDeclaration
Ord, ReadPrec [AccessorDeclaration]
ReadPrec AccessorDeclaration
Int -> ReadS AccessorDeclaration
ReadS [AccessorDeclaration]
(Int -> ReadS AccessorDeclaration)
-> ReadS [AccessorDeclaration]
-> ReadPrec AccessorDeclaration
-> ReadPrec [AccessorDeclaration]
-> Read AccessorDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AccessorDeclaration
readsPrec :: Int -> ReadS AccessorDeclaration
$creadList :: ReadS [AccessorDeclaration]
readList :: ReadS [AccessorDeclaration]
$creadPrec :: ReadPrec AccessorDeclaration
readPrec :: ReadPrec AccessorDeclaration
$creadListPrec :: ReadPrec [AccessorDeclaration]
readListPrec :: ReadPrec [AccessorDeclaration]
Read, Int -> AccessorDeclaration -> String -> String
[AccessorDeclaration] -> String -> String
AccessorDeclaration -> String
(Int -> AccessorDeclaration -> String -> String)
-> (AccessorDeclaration -> String)
-> ([AccessorDeclaration] -> String -> String)
-> Show AccessorDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AccessorDeclaration -> String -> String
showsPrec :: Int -> AccessorDeclaration -> String -> String
$cshow :: AccessorDeclaration -> String
show :: AccessorDeclaration -> String
$cshowList :: [AccessorDeclaration] -> String -> String
showList :: [AccessorDeclaration] -> String -> String
Show)

_AccessorDeclaration :: Name
_AccessorDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AccessorDeclaration")

_AccessorDeclaration_attributes :: Name
_AccessorDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_AccessorDeclaration_modifier :: Name
_AccessorDeclaration_modifier = (String -> Name
Core.Name String
"modifier")

_AccessorDeclaration_body :: Name
_AccessorDeclaration_body = (String -> Name
Core.Name String
"body")

data AccessorModifier = 
  AccessorModifierProtected  |
  AccessorModifierInternal  |
  AccessorModifierPrivate  |
  AccessorModifierProtectedInternal  |
  AccessorModifierInternalProtected  |
  AccessorModifierProtectedPrivate  |
  AccessorModifierPrivateProtected 
  deriving (AccessorModifier -> AccessorModifier -> Bool
(AccessorModifier -> AccessorModifier -> Bool)
-> (AccessorModifier -> AccessorModifier -> Bool)
-> Eq AccessorModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AccessorModifier -> AccessorModifier -> Bool
== :: AccessorModifier -> AccessorModifier -> Bool
$c/= :: AccessorModifier -> AccessorModifier -> Bool
/= :: AccessorModifier -> AccessorModifier -> Bool
Eq, Eq AccessorModifier
Eq AccessorModifier =>
(AccessorModifier -> AccessorModifier -> Ordering)
-> (AccessorModifier -> AccessorModifier -> Bool)
-> (AccessorModifier -> AccessorModifier -> Bool)
-> (AccessorModifier -> AccessorModifier -> Bool)
-> (AccessorModifier -> AccessorModifier -> Bool)
-> (AccessorModifier -> AccessorModifier -> AccessorModifier)
-> (AccessorModifier -> AccessorModifier -> AccessorModifier)
-> Ord AccessorModifier
AccessorModifier -> AccessorModifier -> Bool
AccessorModifier -> AccessorModifier -> Ordering
AccessorModifier -> AccessorModifier -> AccessorModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AccessorModifier -> AccessorModifier -> Ordering
compare :: AccessorModifier -> AccessorModifier -> Ordering
$c< :: AccessorModifier -> AccessorModifier -> Bool
< :: AccessorModifier -> AccessorModifier -> Bool
$c<= :: AccessorModifier -> AccessorModifier -> Bool
<= :: AccessorModifier -> AccessorModifier -> Bool
$c> :: AccessorModifier -> AccessorModifier -> Bool
> :: AccessorModifier -> AccessorModifier -> Bool
$c>= :: AccessorModifier -> AccessorModifier -> Bool
>= :: AccessorModifier -> AccessorModifier -> Bool
$cmax :: AccessorModifier -> AccessorModifier -> AccessorModifier
max :: AccessorModifier -> AccessorModifier -> AccessorModifier
$cmin :: AccessorModifier -> AccessorModifier -> AccessorModifier
min :: AccessorModifier -> AccessorModifier -> AccessorModifier
Ord, ReadPrec [AccessorModifier]
ReadPrec AccessorModifier
Int -> ReadS AccessorModifier
ReadS [AccessorModifier]
(Int -> ReadS AccessorModifier)
-> ReadS [AccessorModifier]
-> ReadPrec AccessorModifier
-> ReadPrec [AccessorModifier]
-> Read AccessorModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AccessorModifier
readsPrec :: Int -> ReadS AccessorModifier
$creadList :: ReadS [AccessorModifier]
readList :: ReadS [AccessorModifier]
$creadPrec :: ReadPrec AccessorModifier
readPrec :: ReadPrec AccessorModifier
$creadListPrec :: ReadPrec [AccessorModifier]
readListPrec :: ReadPrec [AccessorModifier]
Read, Int -> AccessorModifier -> String -> String
[AccessorModifier] -> String -> String
AccessorModifier -> String
(Int -> AccessorModifier -> String -> String)
-> (AccessorModifier -> String)
-> ([AccessorModifier] -> String -> String)
-> Show AccessorModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AccessorModifier -> String -> String
showsPrec :: Int -> AccessorModifier -> String -> String
$cshow :: AccessorModifier -> String
show :: AccessorModifier -> String
$cshowList :: [AccessorModifier] -> String -> String
showList :: [AccessorModifier] -> String -> String
Show)

_AccessorModifier :: Name
_AccessorModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AccessorModifier")

_AccessorModifier_protected :: Name
_AccessorModifier_protected = (String -> Name
Core.Name String
"protected")

_AccessorModifier_internal :: Name
_AccessorModifier_internal = (String -> Name
Core.Name String
"internal")

_AccessorModifier_private :: Name
_AccessorModifier_private = (String -> Name
Core.Name String
"private")

_AccessorModifier_protectedInternal :: Name
_AccessorModifier_protectedInternal = (String -> Name
Core.Name String
"protectedInternal")

_AccessorModifier_internalProtected :: Name
_AccessorModifier_internalProtected = (String -> Name
Core.Name String
"internalProtected")

_AccessorModifier_protectedPrivate :: Name
_AccessorModifier_protectedPrivate = (String -> Name
Core.Name String
"protectedPrivate")

_AccessorModifier_privateProtected :: Name
_AccessorModifier_privateProtected = (String -> Name
Core.Name String
"privateProtected")

data AccessorBody = 
  AccessorBodyBlock Block |
  AccessorBodyExpression Expression |
  AccessorBodyEmpty 
  deriving (AccessorBody -> AccessorBody -> Bool
(AccessorBody -> AccessorBody -> Bool)
-> (AccessorBody -> AccessorBody -> Bool) -> Eq AccessorBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AccessorBody -> AccessorBody -> Bool
== :: AccessorBody -> AccessorBody -> Bool
$c/= :: AccessorBody -> AccessorBody -> Bool
/= :: AccessorBody -> AccessorBody -> Bool
Eq, Eq AccessorBody
Eq AccessorBody =>
(AccessorBody -> AccessorBody -> Ordering)
-> (AccessorBody -> AccessorBody -> Bool)
-> (AccessorBody -> AccessorBody -> Bool)
-> (AccessorBody -> AccessorBody -> Bool)
-> (AccessorBody -> AccessorBody -> Bool)
-> (AccessorBody -> AccessorBody -> AccessorBody)
-> (AccessorBody -> AccessorBody -> AccessorBody)
-> Ord AccessorBody
AccessorBody -> AccessorBody -> Bool
AccessorBody -> AccessorBody -> Ordering
AccessorBody -> AccessorBody -> AccessorBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AccessorBody -> AccessorBody -> Ordering
compare :: AccessorBody -> AccessorBody -> Ordering
$c< :: AccessorBody -> AccessorBody -> Bool
< :: AccessorBody -> AccessorBody -> Bool
$c<= :: AccessorBody -> AccessorBody -> Bool
<= :: AccessorBody -> AccessorBody -> Bool
$c> :: AccessorBody -> AccessorBody -> Bool
> :: AccessorBody -> AccessorBody -> Bool
$c>= :: AccessorBody -> AccessorBody -> Bool
>= :: AccessorBody -> AccessorBody -> Bool
$cmax :: AccessorBody -> AccessorBody -> AccessorBody
max :: AccessorBody -> AccessorBody -> AccessorBody
$cmin :: AccessorBody -> AccessorBody -> AccessorBody
min :: AccessorBody -> AccessorBody -> AccessorBody
Ord, ReadPrec [AccessorBody]
ReadPrec AccessorBody
Int -> ReadS AccessorBody
ReadS [AccessorBody]
(Int -> ReadS AccessorBody)
-> ReadS [AccessorBody]
-> ReadPrec AccessorBody
-> ReadPrec [AccessorBody]
-> Read AccessorBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AccessorBody
readsPrec :: Int -> ReadS AccessorBody
$creadList :: ReadS [AccessorBody]
readList :: ReadS [AccessorBody]
$creadPrec :: ReadPrec AccessorBody
readPrec :: ReadPrec AccessorBody
$creadListPrec :: ReadPrec [AccessorBody]
readListPrec :: ReadPrec [AccessorBody]
Read, Int -> AccessorBody -> String -> String
[AccessorBody] -> String -> String
AccessorBody -> String
(Int -> AccessorBody -> String -> String)
-> (AccessorBody -> String)
-> ([AccessorBody] -> String -> String)
-> Show AccessorBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AccessorBody -> String -> String
showsPrec :: Int -> AccessorBody -> String -> String
$cshow :: AccessorBody -> String
show :: AccessorBody -> String
$cshowList :: [AccessorBody] -> String -> String
showList :: [AccessorBody] -> String -> String
Show)

_AccessorBody :: Name
_AccessorBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AccessorBody")

_AccessorBody_block :: Name
_AccessorBody_block = (String -> Name
Core.Name String
"block")

_AccessorBody_expression :: Name
_AccessorBody_expression = (String -> Name
Core.Name String
"expression")

_AccessorBody_empty :: Name
_AccessorBody_empty = (String -> Name
Core.Name String
"empty")

data RefGetAccessorDeclaration = 
  RefGetAccessorDeclaration {
    RefGetAccessorDeclaration -> Maybe Attributes
refGetAccessorDeclarationAttributes :: (Maybe Attributes),
    RefGetAccessorDeclaration -> Maybe AccessorModifier
refGetAccessorDeclarationModifier :: (Maybe AccessorModifier),
    RefGetAccessorDeclaration -> RefAccessorBody
refGetAccessorDeclarationBody :: RefAccessorBody}
  deriving (RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
(RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool)
-> (RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool)
-> Eq RefGetAccessorDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
== :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
$c/= :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
/= :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
Eq, Eq RefGetAccessorDeclaration
Eq RefGetAccessorDeclaration =>
(RefGetAccessorDeclaration
 -> RefGetAccessorDeclaration -> Ordering)
-> (RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool)
-> (RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool)
-> (RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool)
-> (RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool)
-> (RefGetAccessorDeclaration
    -> RefGetAccessorDeclaration -> RefGetAccessorDeclaration)
-> (RefGetAccessorDeclaration
    -> RefGetAccessorDeclaration -> RefGetAccessorDeclaration)
-> Ord RefGetAccessorDeclaration
RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Ordering
RefGetAccessorDeclaration
-> RefGetAccessorDeclaration -> RefGetAccessorDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Ordering
compare :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Ordering
$c< :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
< :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
$c<= :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
<= :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
$c> :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
> :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
$c>= :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
>= :: RefGetAccessorDeclaration -> RefGetAccessorDeclaration -> Bool
$cmax :: RefGetAccessorDeclaration
-> RefGetAccessorDeclaration -> RefGetAccessorDeclaration
max :: RefGetAccessorDeclaration
-> RefGetAccessorDeclaration -> RefGetAccessorDeclaration
$cmin :: RefGetAccessorDeclaration
-> RefGetAccessorDeclaration -> RefGetAccessorDeclaration
min :: RefGetAccessorDeclaration
-> RefGetAccessorDeclaration -> RefGetAccessorDeclaration
Ord, ReadPrec [RefGetAccessorDeclaration]
ReadPrec RefGetAccessorDeclaration
Int -> ReadS RefGetAccessorDeclaration
ReadS [RefGetAccessorDeclaration]
(Int -> ReadS RefGetAccessorDeclaration)
-> ReadS [RefGetAccessorDeclaration]
-> ReadPrec RefGetAccessorDeclaration
-> ReadPrec [RefGetAccessorDeclaration]
-> Read RefGetAccessorDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefGetAccessorDeclaration
readsPrec :: Int -> ReadS RefGetAccessorDeclaration
$creadList :: ReadS [RefGetAccessorDeclaration]
readList :: ReadS [RefGetAccessorDeclaration]
$creadPrec :: ReadPrec RefGetAccessorDeclaration
readPrec :: ReadPrec RefGetAccessorDeclaration
$creadListPrec :: ReadPrec [RefGetAccessorDeclaration]
readListPrec :: ReadPrec [RefGetAccessorDeclaration]
Read, Int -> RefGetAccessorDeclaration -> String -> String
[RefGetAccessorDeclaration] -> String -> String
RefGetAccessorDeclaration -> String
(Int -> RefGetAccessorDeclaration -> String -> String)
-> (RefGetAccessorDeclaration -> String)
-> ([RefGetAccessorDeclaration] -> String -> String)
-> Show RefGetAccessorDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefGetAccessorDeclaration -> String -> String
showsPrec :: Int -> RefGetAccessorDeclaration -> String -> String
$cshow :: RefGetAccessorDeclaration -> String
show :: RefGetAccessorDeclaration -> String
$cshowList :: [RefGetAccessorDeclaration] -> String -> String
showList :: [RefGetAccessorDeclaration] -> String -> String
Show)

_RefGetAccessorDeclaration :: Name
_RefGetAccessorDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefGetAccessorDeclaration")

_RefGetAccessorDeclaration_attributes :: Name
_RefGetAccessorDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_RefGetAccessorDeclaration_modifier :: Name
_RefGetAccessorDeclaration_modifier = (String -> Name
Core.Name String
"modifier")

_RefGetAccessorDeclaration_body :: Name
_RefGetAccessorDeclaration_body = (String -> Name
Core.Name String
"body")

data RefAccessorBody = 
  RefAccessorBodyBlock Block |
  RefAccessorBodyRef VariableReference |
  RefAccessorBodyEmpty 
  deriving (RefAccessorBody -> RefAccessorBody -> Bool
(RefAccessorBody -> RefAccessorBody -> Bool)
-> (RefAccessorBody -> RefAccessorBody -> Bool)
-> Eq RefAccessorBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefAccessorBody -> RefAccessorBody -> Bool
== :: RefAccessorBody -> RefAccessorBody -> Bool
$c/= :: RefAccessorBody -> RefAccessorBody -> Bool
/= :: RefAccessorBody -> RefAccessorBody -> Bool
Eq, Eq RefAccessorBody
Eq RefAccessorBody =>
(RefAccessorBody -> RefAccessorBody -> Ordering)
-> (RefAccessorBody -> RefAccessorBody -> Bool)
-> (RefAccessorBody -> RefAccessorBody -> Bool)
-> (RefAccessorBody -> RefAccessorBody -> Bool)
-> (RefAccessorBody -> RefAccessorBody -> Bool)
-> (RefAccessorBody -> RefAccessorBody -> RefAccessorBody)
-> (RefAccessorBody -> RefAccessorBody -> RefAccessorBody)
-> Ord RefAccessorBody
RefAccessorBody -> RefAccessorBody -> Bool
RefAccessorBody -> RefAccessorBody -> Ordering
RefAccessorBody -> RefAccessorBody -> RefAccessorBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefAccessorBody -> RefAccessorBody -> Ordering
compare :: RefAccessorBody -> RefAccessorBody -> Ordering
$c< :: RefAccessorBody -> RefAccessorBody -> Bool
< :: RefAccessorBody -> RefAccessorBody -> Bool
$c<= :: RefAccessorBody -> RefAccessorBody -> Bool
<= :: RefAccessorBody -> RefAccessorBody -> Bool
$c> :: RefAccessorBody -> RefAccessorBody -> Bool
> :: RefAccessorBody -> RefAccessorBody -> Bool
$c>= :: RefAccessorBody -> RefAccessorBody -> Bool
>= :: RefAccessorBody -> RefAccessorBody -> Bool
$cmax :: RefAccessorBody -> RefAccessorBody -> RefAccessorBody
max :: RefAccessorBody -> RefAccessorBody -> RefAccessorBody
$cmin :: RefAccessorBody -> RefAccessorBody -> RefAccessorBody
min :: RefAccessorBody -> RefAccessorBody -> RefAccessorBody
Ord, ReadPrec [RefAccessorBody]
ReadPrec RefAccessorBody
Int -> ReadS RefAccessorBody
ReadS [RefAccessorBody]
(Int -> ReadS RefAccessorBody)
-> ReadS [RefAccessorBody]
-> ReadPrec RefAccessorBody
-> ReadPrec [RefAccessorBody]
-> Read RefAccessorBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefAccessorBody
readsPrec :: Int -> ReadS RefAccessorBody
$creadList :: ReadS [RefAccessorBody]
readList :: ReadS [RefAccessorBody]
$creadPrec :: ReadPrec RefAccessorBody
readPrec :: ReadPrec RefAccessorBody
$creadListPrec :: ReadPrec [RefAccessorBody]
readListPrec :: ReadPrec [RefAccessorBody]
Read, Int -> RefAccessorBody -> String -> String
[RefAccessorBody] -> String -> String
RefAccessorBody -> String
(Int -> RefAccessorBody -> String -> String)
-> (RefAccessorBody -> String)
-> ([RefAccessorBody] -> String -> String)
-> Show RefAccessorBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefAccessorBody -> String -> String
showsPrec :: Int -> RefAccessorBody -> String -> String
$cshow :: RefAccessorBody -> String
show :: RefAccessorBody -> String
$cshowList :: [RefAccessorBody] -> String -> String
showList :: [RefAccessorBody] -> String -> String
Show)

_RefAccessorBody :: Name
_RefAccessorBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefAccessorBody")

_RefAccessorBody_block :: Name
_RefAccessorBody_block = (String -> Name
Core.Name String
"block")

_RefAccessorBody_ref :: Name
_RefAccessorBody_ref = (String -> Name
Core.Name String
"ref")

_RefAccessorBody_empty :: Name
_RefAccessorBody_empty = (String -> Name
Core.Name String
"empty")

data EventDeclaration = 
  EventDeclarationStandard StandardEventDeclaration |
  EventDeclarationAccessors AccessorsEventDeclaration
  deriving (EventDeclaration -> EventDeclaration -> Bool
(EventDeclaration -> EventDeclaration -> Bool)
-> (EventDeclaration -> EventDeclaration -> Bool)
-> Eq EventDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventDeclaration -> EventDeclaration -> Bool
== :: EventDeclaration -> EventDeclaration -> Bool
$c/= :: EventDeclaration -> EventDeclaration -> Bool
/= :: EventDeclaration -> EventDeclaration -> Bool
Eq, Eq EventDeclaration
Eq EventDeclaration =>
(EventDeclaration -> EventDeclaration -> Ordering)
-> (EventDeclaration -> EventDeclaration -> Bool)
-> (EventDeclaration -> EventDeclaration -> Bool)
-> (EventDeclaration -> EventDeclaration -> Bool)
-> (EventDeclaration -> EventDeclaration -> Bool)
-> (EventDeclaration -> EventDeclaration -> EventDeclaration)
-> (EventDeclaration -> EventDeclaration -> EventDeclaration)
-> Ord EventDeclaration
EventDeclaration -> EventDeclaration -> Bool
EventDeclaration -> EventDeclaration -> Ordering
EventDeclaration -> EventDeclaration -> EventDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EventDeclaration -> EventDeclaration -> Ordering
compare :: EventDeclaration -> EventDeclaration -> Ordering
$c< :: EventDeclaration -> EventDeclaration -> Bool
< :: EventDeclaration -> EventDeclaration -> Bool
$c<= :: EventDeclaration -> EventDeclaration -> Bool
<= :: EventDeclaration -> EventDeclaration -> Bool
$c> :: EventDeclaration -> EventDeclaration -> Bool
> :: EventDeclaration -> EventDeclaration -> Bool
$c>= :: EventDeclaration -> EventDeclaration -> Bool
>= :: EventDeclaration -> EventDeclaration -> Bool
$cmax :: EventDeclaration -> EventDeclaration -> EventDeclaration
max :: EventDeclaration -> EventDeclaration -> EventDeclaration
$cmin :: EventDeclaration -> EventDeclaration -> EventDeclaration
min :: EventDeclaration -> EventDeclaration -> EventDeclaration
Ord, ReadPrec [EventDeclaration]
ReadPrec EventDeclaration
Int -> ReadS EventDeclaration
ReadS [EventDeclaration]
(Int -> ReadS EventDeclaration)
-> ReadS [EventDeclaration]
-> ReadPrec EventDeclaration
-> ReadPrec [EventDeclaration]
-> Read EventDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EventDeclaration
readsPrec :: Int -> ReadS EventDeclaration
$creadList :: ReadS [EventDeclaration]
readList :: ReadS [EventDeclaration]
$creadPrec :: ReadPrec EventDeclaration
readPrec :: ReadPrec EventDeclaration
$creadListPrec :: ReadPrec [EventDeclaration]
readListPrec :: ReadPrec [EventDeclaration]
Read, Int -> EventDeclaration -> String -> String
[EventDeclaration] -> String -> String
EventDeclaration -> String
(Int -> EventDeclaration -> String -> String)
-> (EventDeclaration -> String)
-> ([EventDeclaration] -> String -> String)
-> Show EventDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EventDeclaration -> String -> String
showsPrec :: Int -> EventDeclaration -> String -> String
$cshow :: EventDeclaration -> String
show :: EventDeclaration -> String
$cshowList :: [EventDeclaration] -> String -> String
showList :: [EventDeclaration] -> String -> String
Show)

_EventDeclaration :: Name
_EventDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EventDeclaration")

_EventDeclaration_standard :: Name
_EventDeclaration_standard = (String -> Name
Core.Name String
"standard")

_EventDeclaration_accessors :: Name
_EventDeclaration_accessors = (String -> Name
Core.Name String
"accessors")

data StandardEventDeclaration = 
  StandardEventDeclaration {
    StandardEventDeclaration -> Maybe Attributes
standardEventDeclarationAttributes :: (Maybe Attributes),
    StandardEventDeclaration -> [EventModifier]
standardEventDeclarationModifiers :: [EventModifier],
    StandardEventDeclaration -> Type
standardEventDeclarationType :: Type,
    StandardEventDeclaration -> VariableDeclarators
standardEventDeclarationDeclarators :: VariableDeclarators}
  deriving (StandardEventDeclaration -> StandardEventDeclaration -> Bool
(StandardEventDeclaration -> StandardEventDeclaration -> Bool)
-> (StandardEventDeclaration -> StandardEventDeclaration -> Bool)
-> Eq StandardEventDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
== :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
$c/= :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
/= :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
Eq, Eq StandardEventDeclaration
Eq StandardEventDeclaration =>
(StandardEventDeclaration -> StandardEventDeclaration -> Ordering)
-> (StandardEventDeclaration -> StandardEventDeclaration -> Bool)
-> (StandardEventDeclaration -> StandardEventDeclaration -> Bool)
-> (StandardEventDeclaration -> StandardEventDeclaration -> Bool)
-> (StandardEventDeclaration -> StandardEventDeclaration -> Bool)
-> (StandardEventDeclaration
    -> StandardEventDeclaration -> StandardEventDeclaration)
-> (StandardEventDeclaration
    -> StandardEventDeclaration -> StandardEventDeclaration)
-> Ord StandardEventDeclaration
StandardEventDeclaration -> StandardEventDeclaration -> Bool
StandardEventDeclaration -> StandardEventDeclaration -> Ordering
StandardEventDeclaration
-> StandardEventDeclaration -> StandardEventDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StandardEventDeclaration -> StandardEventDeclaration -> Ordering
compare :: StandardEventDeclaration -> StandardEventDeclaration -> Ordering
$c< :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
< :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
$c<= :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
<= :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
$c> :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
> :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
$c>= :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
>= :: StandardEventDeclaration -> StandardEventDeclaration -> Bool
$cmax :: StandardEventDeclaration
-> StandardEventDeclaration -> StandardEventDeclaration
max :: StandardEventDeclaration
-> StandardEventDeclaration -> StandardEventDeclaration
$cmin :: StandardEventDeclaration
-> StandardEventDeclaration -> StandardEventDeclaration
min :: StandardEventDeclaration
-> StandardEventDeclaration -> StandardEventDeclaration
Ord, ReadPrec [StandardEventDeclaration]
ReadPrec StandardEventDeclaration
Int -> ReadS StandardEventDeclaration
ReadS [StandardEventDeclaration]
(Int -> ReadS StandardEventDeclaration)
-> ReadS [StandardEventDeclaration]
-> ReadPrec StandardEventDeclaration
-> ReadPrec [StandardEventDeclaration]
-> Read StandardEventDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StandardEventDeclaration
readsPrec :: Int -> ReadS StandardEventDeclaration
$creadList :: ReadS [StandardEventDeclaration]
readList :: ReadS [StandardEventDeclaration]
$creadPrec :: ReadPrec StandardEventDeclaration
readPrec :: ReadPrec StandardEventDeclaration
$creadListPrec :: ReadPrec [StandardEventDeclaration]
readListPrec :: ReadPrec [StandardEventDeclaration]
Read, Int -> StandardEventDeclaration -> String -> String
[StandardEventDeclaration] -> String -> String
StandardEventDeclaration -> String
(Int -> StandardEventDeclaration -> String -> String)
-> (StandardEventDeclaration -> String)
-> ([StandardEventDeclaration] -> String -> String)
-> Show StandardEventDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StandardEventDeclaration -> String -> String
showsPrec :: Int -> StandardEventDeclaration -> String -> String
$cshow :: StandardEventDeclaration -> String
show :: StandardEventDeclaration -> String
$cshowList :: [StandardEventDeclaration] -> String -> String
showList :: [StandardEventDeclaration] -> String -> String
Show)

_StandardEventDeclaration :: Name
_StandardEventDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StandardEventDeclaration")

_StandardEventDeclaration_attributes :: Name
_StandardEventDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_StandardEventDeclaration_modifiers :: Name
_StandardEventDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_StandardEventDeclaration_type :: Name
_StandardEventDeclaration_type = (String -> Name
Core.Name String
"type")

_StandardEventDeclaration_declarators :: Name
_StandardEventDeclaration_declarators = (String -> Name
Core.Name String
"declarators")

data AccessorsEventDeclaration = 
  AccessorsEventDeclaration {
    AccessorsEventDeclaration -> Maybe Attributes
accessorsEventDeclarationAttributes :: (Maybe Attributes),
    AccessorsEventDeclaration -> [EventModifier]
accessorsEventDeclarationModifiers :: [EventModifier],
    AccessorsEventDeclaration -> Type
accessorsEventDeclarationType :: Type,
    AccessorsEventDeclaration -> MemberName
accessorsEventDeclarationName :: MemberName,
    AccessorsEventDeclaration -> EventAccessorDeclarations
accessorsEventDeclarationAccessors :: EventAccessorDeclarations}
  deriving (AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
(AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool)
-> (AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool)
-> Eq AccessorsEventDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
== :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
$c/= :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
/= :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
Eq, Eq AccessorsEventDeclaration
Eq AccessorsEventDeclaration =>
(AccessorsEventDeclaration
 -> AccessorsEventDeclaration -> Ordering)
-> (AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool)
-> (AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool)
-> (AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool)
-> (AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool)
-> (AccessorsEventDeclaration
    -> AccessorsEventDeclaration -> AccessorsEventDeclaration)
-> (AccessorsEventDeclaration
    -> AccessorsEventDeclaration -> AccessorsEventDeclaration)
-> Ord AccessorsEventDeclaration
AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
AccessorsEventDeclaration -> AccessorsEventDeclaration -> Ordering
AccessorsEventDeclaration
-> AccessorsEventDeclaration -> AccessorsEventDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Ordering
compare :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Ordering
$c< :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
< :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
$c<= :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
<= :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
$c> :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
> :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
$c>= :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
>= :: AccessorsEventDeclaration -> AccessorsEventDeclaration -> Bool
$cmax :: AccessorsEventDeclaration
-> AccessorsEventDeclaration -> AccessorsEventDeclaration
max :: AccessorsEventDeclaration
-> AccessorsEventDeclaration -> AccessorsEventDeclaration
$cmin :: AccessorsEventDeclaration
-> AccessorsEventDeclaration -> AccessorsEventDeclaration
min :: AccessorsEventDeclaration
-> AccessorsEventDeclaration -> AccessorsEventDeclaration
Ord, ReadPrec [AccessorsEventDeclaration]
ReadPrec AccessorsEventDeclaration
Int -> ReadS AccessorsEventDeclaration
ReadS [AccessorsEventDeclaration]
(Int -> ReadS AccessorsEventDeclaration)
-> ReadS [AccessorsEventDeclaration]
-> ReadPrec AccessorsEventDeclaration
-> ReadPrec [AccessorsEventDeclaration]
-> Read AccessorsEventDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AccessorsEventDeclaration
readsPrec :: Int -> ReadS AccessorsEventDeclaration
$creadList :: ReadS [AccessorsEventDeclaration]
readList :: ReadS [AccessorsEventDeclaration]
$creadPrec :: ReadPrec AccessorsEventDeclaration
readPrec :: ReadPrec AccessorsEventDeclaration
$creadListPrec :: ReadPrec [AccessorsEventDeclaration]
readListPrec :: ReadPrec [AccessorsEventDeclaration]
Read, Int -> AccessorsEventDeclaration -> String -> String
[AccessorsEventDeclaration] -> String -> String
AccessorsEventDeclaration -> String
(Int -> AccessorsEventDeclaration -> String -> String)
-> (AccessorsEventDeclaration -> String)
-> ([AccessorsEventDeclaration] -> String -> String)
-> Show AccessorsEventDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AccessorsEventDeclaration -> String -> String
showsPrec :: Int -> AccessorsEventDeclaration -> String -> String
$cshow :: AccessorsEventDeclaration -> String
show :: AccessorsEventDeclaration -> String
$cshowList :: [AccessorsEventDeclaration] -> String -> String
showList :: [AccessorsEventDeclaration] -> String -> String
Show)

_AccessorsEventDeclaration :: Name
_AccessorsEventDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AccessorsEventDeclaration")

_AccessorsEventDeclaration_attributes :: Name
_AccessorsEventDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_AccessorsEventDeclaration_modifiers :: Name
_AccessorsEventDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_AccessorsEventDeclaration_type :: Name
_AccessorsEventDeclaration_type = (String -> Name
Core.Name String
"type")

_AccessorsEventDeclaration_name :: Name
_AccessorsEventDeclaration_name = (String -> Name
Core.Name String
"name")

_AccessorsEventDeclaration_accessors :: Name
_AccessorsEventDeclaration_accessors = (String -> Name
Core.Name String
"accessors")

data EventModifier = 
  EventModifierNew  |
  EventModifierPublic  |
  EventModifierProtected  |
  EventModifierInternal  |
  EventModifierPrivate  |
  EventModifierStatic  |
  EventModifierVirtual  |
  EventModifierSealed  |
  EventModifierOverride  |
  EventModifierAbstract  |
  EventModifierExtern  |
  EventModifierUnsafe 
  deriving (EventModifier -> EventModifier -> Bool
(EventModifier -> EventModifier -> Bool)
-> (EventModifier -> EventModifier -> Bool) -> Eq EventModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventModifier -> EventModifier -> Bool
== :: EventModifier -> EventModifier -> Bool
$c/= :: EventModifier -> EventModifier -> Bool
/= :: EventModifier -> EventModifier -> Bool
Eq, Eq EventModifier
Eq EventModifier =>
(EventModifier -> EventModifier -> Ordering)
-> (EventModifier -> EventModifier -> Bool)
-> (EventModifier -> EventModifier -> Bool)
-> (EventModifier -> EventModifier -> Bool)
-> (EventModifier -> EventModifier -> Bool)
-> (EventModifier -> EventModifier -> EventModifier)
-> (EventModifier -> EventModifier -> EventModifier)
-> Ord EventModifier
EventModifier -> EventModifier -> Bool
EventModifier -> EventModifier -> Ordering
EventModifier -> EventModifier -> EventModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EventModifier -> EventModifier -> Ordering
compare :: EventModifier -> EventModifier -> Ordering
$c< :: EventModifier -> EventModifier -> Bool
< :: EventModifier -> EventModifier -> Bool
$c<= :: EventModifier -> EventModifier -> Bool
<= :: EventModifier -> EventModifier -> Bool
$c> :: EventModifier -> EventModifier -> Bool
> :: EventModifier -> EventModifier -> Bool
$c>= :: EventModifier -> EventModifier -> Bool
>= :: EventModifier -> EventModifier -> Bool
$cmax :: EventModifier -> EventModifier -> EventModifier
max :: EventModifier -> EventModifier -> EventModifier
$cmin :: EventModifier -> EventModifier -> EventModifier
min :: EventModifier -> EventModifier -> EventModifier
Ord, ReadPrec [EventModifier]
ReadPrec EventModifier
Int -> ReadS EventModifier
ReadS [EventModifier]
(Int -> ReadS EventModifier)
-> ReadS [EventModifier]
-> ReadPrec EventModifier
-> ReadPrec [EventModifier]
-> Read EventModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EventModifier
readsPrec :: Int -> ReadS EventModifier
$creadList :: ReadS [EventModifier]
readList :: ReadS [EventModifier]
$creadPrec :: ReadPrec EventModifier
readPrec :: ReadPrec EventModifier
$creadListPrec :: ReadPrec [EventModifier]
readListPrec :: ReadPrec [EventModifier]
Read, Int -> EventModifier -> String -> String
[EventModifier] -> String -> String
EventModifier -> String
(Int -> EventModifier -> String -> String)
-> (EventModifier -> String)
-> ([EventModifier] -> String -> String)
-> Show EventModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EventModifier -> String -> String
showsPrec :: Int -> EventModifier -> String -> String
$cshow :: EventModifier -> String
show :: EventModifier -> String
$cshowList :: [EventModifier] -> String -> String
showList :: [EventModifier] -> String -> String
Show)

_EventModifier :: Name
_EventModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EventModifier")

_EventModifier_new :: Name
_EventModifier_new = (String -> Name
Core.Name String
"new")

_EventModifier_public :: Name
_EventModifier_public = (String -> Name
Core.Name String
"public")

_EventModifier_protected :: Name
_EventModifier_protected = (String -> Name
Core.Name String
"protected")

_EventModifier_internal :: Name
_EventModifier_internal = (String -> Name
Core.Name String
"internal")

_EventModifier_private :: Name
_EventModifier_private = (String -> Name
Core.Name String
"private")

_EventModifier_static :: Name
_EventModifier_static = (String -> Name
Core.Name String
"static")

_EventModifier_virtual :: Name
_EventModifier_virtual = (String -> Name
Core.Name String
"virtual")

_EventModifier_sealed :: Name
_EventModifier_sealed = (String -> Name
Core.Name String
"sealed")

_EventModifier_override :: Name
_EventModifier_override = (String -> Name
Core.Name String
"override")

_EventModifier_abstract :: Name
_EventModifier_abstract = (String -> Name
Core.Name String
"abstract")

_EventModifier_extern :: Name
_EventModifier_extern = (String -> Name
Core.Name String
"extern")

_EventModifier_unsafe :: Name
_EventModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

data EventAccessorDeclarations = 
  EventAccessorDeclarationsAdd AddRemoveAccessorDeclaration |
  EventAccessorDeclarationsRemove AddRemoveAccessorDeclaration
  deriving (EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
(EventAccessorDeclarations -> EventAccessorDeclarations -> Bool)
-> (EventAccessorDeclarations -> EventAccessorDeclarations -> Bool)
-> Eq EventAccessorDeclarations
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
== :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
$c/= :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
/= :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
Eq, Eq EventAccessorDeclarations
Eq EventAccessorDeclarations =>
(EventAccessorDeclarations
 -> EventAccessorDeclarations -> Ordering)
-> (EventAccessorDeclarations -> EventAccessorDeclarations -> Bool)
-> (EventAccessorDeclarations -> EventAccessorDeclarations -> Bool)
-> (EventAccessorDeclarations -> EventAccessorDeclarations -> Bool)
-> (EventAccessorDeclarations -> EventAccessorDeclarations -> Bool)
-> (EventAccessorDeclarations
    -> EventAccessorDeclarations -> EventAccessorDeclarations)
-> (EventAccessorDeclarations
    -> EventAccessorDeclarations -> EventAccessorDeclarations)
-> Ord EventAccessorDeclarations
EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
EventAccessorDeclarations -> EventAccessorDeclarations -> Ordering
EventAccessorDeclarations
-> EventAccessorDeclarations -> EventAccessorDeclarations
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EventAccessorDeclarations -> EventAccessorDeclarations -> Ordering
compare :: EventAccessorDeclarations -> EventAccessorDeclarations -> Ordering
$c< :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
< :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
$c<= :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
<= :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
$c> :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
> :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
$c>= :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
>= :: EventAccessorDeclarations -> EventAccessorDeclarations -> Bool
$cmax :: EventAccessorDeclarations
-> EventAccessorDeclarations -> EventAccessorDeclarations
max :: EventAccessorDeclarations
-> EventAccessorDeclarations -> EventAccessorDeclarations
$cmin :: EventAccessorDeclarations
-> EventAccessorDeclarations -> EventAccessorDeclarations
min :: EventAccessorDeclarations
-> EventAccessorDeclarations -> EventAccessorDeclarations
Ord, ReadPrec [EventAccessorDeclarations]
ReadPrec EventAccessorDeclarations
Int -> ReadS EventAccessorDeclarations
ReadS [EventAccessorDeclarations]
(Int -> ReadS EventAccessorDeclarations)
-> ReadS [EventAccessorDeclarations]
-> ReadPrec EventAccessorDeclarations
-> ReadPrec [EventAccessorDeclarations]
-> Read EventAccessorDeclarations
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EventAccessorDeclarations
readsPrec :: Int -> ReadS EventAccessorDeclarations
$creadList :: ReadS [EventAccessorDeclarations]
readList :: ReadS [EventAccessorDeclarations]
$creadPrec :: ReadPrec EventAccessorDeclarations
readPrec :: ReadPrec EventAccessorDeclarations
$creadListPrec :: ReadPrec [EventAccessorDeclarations]
readListPrec :: ReadPrec [EventAccessorDeclarations]
Read, Int -> EventAccessorDeclarations -> String -> String
[EventAccessorDeclarations] -> String -> String
EventAccessorDeclarations -> String
(Int -> EventAccessorDeclarations -> String -> String)
-> (EventAccessorDeclarations -> String)
-> ([EventAccessorDeclarations] -> String -> String)
-> Show EventAccessorDeclarations
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EventAccessorDeclarations -> String -> String
showsPrec :: Int -> EventAccessorDeclarations -> String -> String
$cshow :: EventAccessorDeclarations -> String
show :: EventAccessorDeclarations -> String
$cshowList :: [EventAccessorDeclarations] -> String -> String
showList :: [EventAccessorDeclarations] -> String -> String
Show)

_EventAccessorDeclarations :: Name
_EventAccessorDeclarations = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EventAccessorDeclarations")

_EventAccessorDeclarations_add :: Name
_EventAccessorDeclarations_add = (String -> Name
Core.Name String
"add")

_EventAccessorDeclarations_remove :: Name
_EventAccessorDeclarations_remove = (String -> Name
Core.Name String
"remove")

data AddRemoveAccessorDeclaration = 
  AddRemoveAccessorDeclaration {
    AddRemoveAccessorDeclaration -> Maybe Attributes
addRemoveAccessorDeclarationAttributes :: (Maybe Attributes),
    AddRemoveAccessorDeclaration -> Block
addRemoveAccessorDeclarationBody :: Block}
  deriving (AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
(AddRemoveAccessorDeclaration
 -> AddRemoveAccessorDeclaration -> Bool)
-> (AddRemoveAccessorDeclaration
    -> AddRemoveAccessorDeclaration -> Bool)
-> Eq AddRemoveAccessorDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
== :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
$c/= :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
/= :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
Eq, Eq AddRemoveAccessorDeclaration
Eq AddRemoveAccessorDeclaration =>
(AddRemoveAccessorDeclaration
 -> AddRemoveAccessorDeclaration -> Ordering)
-> (AddRemoveAccessorDeclaration
    -> AddRemoveAccessorDeclaration -> Bool)
-> (AddRemoveAccessorDeclaration
    -> AddRemoveAccessorDeclaration -> Bool)
-> (AddRemoveAccessorDeclaration
    -> AddRemoveAccessorDeclaration -> Bool)
-> (AddRemoveAccessorDeclaration
    -> AddRemoveAccessorDeclaration -> Bool)
-> (AddRemoveAccessorDeclaration
    -> AddRemoveAccessorDeclaration -> AddRemoveAccessorDeclaration)
-> (AddRemoveAccessorDeclaration
    -> AddRemoveAccessorDeclaration -> AddRemoveAccessorDeclaration)
-> Ord AddRemoveAccessorDeclaration
AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Ordering
AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> AddRemoveAccessorDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Ordering
compare :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Ordering
$c< :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
< :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
$c<= :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
<= :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
$c> :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
> :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
$c>= :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
>= :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> Bool
$cmax :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> AddRemoveAccessorDeclaration
max :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> AddRemoveAccessorDeclaration
$cmin :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> AddRemoveAccessorDeclaration
min :: AddRemoveAccessorDeclaration
-> AddRemoveAccessorDeclaration -> AddRemoveAccessorDeclaration
Ord, ReadPrec [AddRemoveAccessorDeclaration]
ReadPrec AddRemoveAccessorDeclaration
Int -> ReadS AddRemoveAccessorDeclaration
ReadS [AddRemoveAccessorDeclaration]
(Int -> ReadS AddRemoveAccessorDeclaration)
-> ReadS [AddRemoveAccessorDeclaration]
-> ReadPrec AddRemoveAccessorDeclaration
-> ReadPrec [AddRemoveAccessorDeclaration]
-> Read AddRemoveAccessorDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AddRemoveAccessorDeclaration
readsPrec :: Int -> ReadS AddRemoveAccessorDeclaration
$creadList :: ReadS [AddRemoveAccessorDeclaration]
readList :: ReadS [AddRemoveAccessorDeclaration]
$creadPrec :: ReadPrec AddRemoveAccessorDeclaration
readPrec :: ReadPrec AddRemoveAccessorDeclaration
$creadListPrec :: ReadPrec [AddRemoveAccessorDeclaration]
readListPrec :: ReadPrec [AddRemoveAccessorDeclaration]
Read, Int -> AddRemoveAccessorDeclaration -> String -> String
[AddRemoveAccessorDeclaration] -> String -> String
AddRemoveAccessorDeclaration -> String
(Int -> AddRemoveAccessorDeclaration -> String -> String)
-> (AddRemoveAccessorDeclaration -> String)
-> ([AddRemoveAccessorDeclaration] -> String -> String)
-> Show AddRemoveAccessorDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AddRemoveAccessorDeclaration -> String -> String
showsPrec :: Int -> AddRemoveAccessorDeclaration -> String -> String
$cshow :: AddRemoveAccessorDeclaration -> String
show :: AddRemoveAccessorDeclaration -> String
$cshowList :: [AddRemoveAccessorDeclaration] -> String -> String
showList :: [AddRemoveAccessorDeclaration] -> String -> String
Show)

_AddRemoveAccessorDeclaration :: Name
_AddRemoveAccessorDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AddRemoveAccessorDeclaration")

_AddRemoveAccessorDeclaration_attributes :: Name
_AddRemoveAccessorDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_AddRemoveAccessorDeclaration_body :: Name
_AddRemoveAccessorDeclaration_body = (String -> Name
Core.Name String
"body")

data IndexerDeclaration = 
  IndexerDeclarationStandard StandardIndexerDeclaration |
  IndexerDeclarationRef RefIndexerDeclaration
  deriving (IndexerDeclaration -> IndexerDeclaration -> Bool
(IndexerDeclaration -> IndexerDeclaration -> Bool)
-> (IndexerDeclaration -> IndexerDeclaration -> Bool)
-> Eq IndexerDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndexerDeclaration -> IndexerDeclaration -> Bool
== :: IndexerDeclaration -> IndexerDeclaration -> Bool
$c/= :: IndexerDeclaration -> IndexerDeclaration -> Bool
/= :: IndexerDeclaration -> IndexerDeclaration -> Bool
Eq, Eq IndexerDeclaration
Eq IndexerDeclaration =>
(IndexerDeclaration -> IndexerDeclaration -> Ordering)
-> (IndexerDeclaration -> IndexerDeclaration -> Bool)
-> (IndexerDeclaration -> IndexerDeclaration -> Bool)
-> (IndexerDeclaration -> IndexerDeclaration -> Bool)
-> (IndexerDeclaration -> IndexerDeclaration -> Bool)
-> (IndexerDeclaration -> IndexerDeclaration -> IndexerDeclaration)
-> (IndexerDeclaration -> IndexerDeclaration -> IndexerDeclaration)
-> Ord IndexerDeclaration
IndexerDeclaration -> IndexerDeclaration -> Bool
IndexerDeclaration -> IndexerDeclaration -> Ordering
IndexerDeclaration -> IndexerDeclaration -> IndexerDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IndexerDeclaration -> IndexerDeclaration -> Ordering
compare :: IndexerDeclaration -> IndexerDeclaration -> Ordering
$c< :: IndexerDeclaration -> IndexerDeclaration -> Bool
< :: IndexerDeclaration -> IndexerDeclaration -> Bool
$c<= :: IndexerDeclaration -> IndexerDeclaration -> Bool
<= :: IndexerDeclaration -> IndexerDeclaration -> Bool
$c> :: IndexerDeclaration -> IndexerDeclaration -> Bool
> :: IndexerDeclaration -> IndexerDeclaration -> Bool
$c>= :: IndexerDeclaration -> IndexerDeclaration -> Bool
>= :: IndexerDeclaration -> IndexerDeclaration -> Bool
$cmax :: IndexerDeclaration -> IndexerDeclaration -> IndexerDeclaration
max :: IndexerDeclaration -> IndexerDeclaration -> IndexerDeclaration
$cmin :: IndexerDeclaration -> IndexerDeclaration -> IndexerDeclaration
min :: IndexerDeclaration -> IndexerDeclaration -> IndexerDeclaration
Ord, ReadPrec [IndexerDeclaration]
ReadPrec IndexerDeclaration
Int -> ReadS IndexerDeclaration
ReadS [IndexerDeclaration]
(Int -> ReadS IndexerDeclaration)
-> ReadS [IndexerDeclaration]
-> ReadPrec IndexerDeclaration
-> ReadPrec [IndexerDeclaration]
-> Read IndexerDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IndexerDeclaration
readsPrec :: Int -> ReadS IndexerDeclaration
$creadList :: ReadS [IndexerDeclaration]
readList :: ReadS [IndexerDeclaration]
$creadPrec :: ReadPrec IndexerDeclaration
readPrec :: ReadPrec IndexerDeclaration
$creadListPrec :: ReadPrec [IndexerDeclaration]
readListPrec :: ReadPrec [IndexerDeclaration]
Read, Int -> IndexerDeclaration -> String -> String
[IndexerDeclaration] -> String -> String
IndexerDeclaration -> String
(Int -> IndexerDeclaration -> String -> String)
-> (IndexerDeclaration -> String)
-> ([IndexerDeclaration] -> String -> String)
-> Show IndexerDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IndexerDeclaration -> String -> String
showsPrec :: Int -> IndexerDeclaration -> String -> String
$cshow :: IndexerDeclaration -> String
show :: IndexerDeclaration -> String
$cshowList :: [IndexerDeclaration] -> String -> String
showList :: [IndexerDeclaration] -> String -> String
Show)

_IndexerDeclaration :: Name
_IndexerDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IndexerDeclaration")

_IndexerDeclaration_standard :: Name
_IndexerDeclaration_standard = (String -> Name
Core.Name String
"standard")

_IndexerDeclaration_ref :: Name
_IndexerDeclaration_ref = (String -> Name
Core.Name String
"ref")

data StandardIndexerDeclaration = 
  StandardIndexerDeclaration {
    StandardIndexerDeclaration -> Maybe Attributes
standardIndexerDeclarationAttributes :: (Maybe Attributes),
    StandardIndexerDeclaration -> [IndexerModifier]
standardIndexerDeclarationModifiers :: [IndexerModifier],
    StandardIndexerDeclaration -> IndexerDeclarator
standardIndexerDeclarationDeclarator :: IndexerDeclarator,
    StandardIndexerDeclaration -> IndexerBody
standardIndexerDeclarationBody :: IndexerBody}
  deriving (StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
(StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool)
-> (StandardIndexerDeclaration
    -> StandardIndexerDeclaration -> Bool)
-> Eq StandardIndexerDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
== :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
$c/= :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
/= :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
Eq, Eq StandardIndexerDeclaration
Eq StandardIndexerDeclaration =>
(StandardIndexerDeclaration
 -> StandardIndexerDeclaration -> Ordering)
-> (StandardIndexerDeclaration
    -> StandardIndexerDeclaration -> Bool)
-> (StandardIndexerDeclaration
    -> StandardIndexerDeclaration -> Bool)
-> (StandardIndexerDeclaration
    -> StandardIndexerDeclaration -> Bool)
-> (StandardIndexerDeclaration
    -> StandardIndexerDeclaration -> Bool)
-> (StandardIndexerDeclaration
    -> StandardIndexerDeclaration -> StandardIndexerDeclaration)
-> (StandardIndexerDeclaration
    -> StandardIndexerDeclaration -> StandardIndexerDeclaration)
-> Ord StandardIndexerDeclaration
StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
StandardIndexerDeclaration
-> StandardIndexerDeclaration -> Ordering
StandardIndexerDeclaration
-> StandardIndexerDeclaration -> StandardIndexerDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StandardIndexerDeclaration
-> StandardIndexerDeclaration -> Ordering
compare :: StandardIndexerDeclaration
-> StandardIndexerDeclaration -> Ordering
$c< :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
< :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
$c<= :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
<= :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
$c> :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
> :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
$c>= :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
>= :: StandardIndexerDeclaration -> StandardIndexerDeclaration -> Bool
$cmax :: StandardIndexerDeclaration
-> StandardIndexerDeclaration -> StandardIndexerDeclaration
max :: StandardIndexerDeclaration
-> StandardIndexerDeclaration -> StandardIndexerDeclaration
$cmin :: StandardIndexerDeclaration
-> StandardIndexerDeclaration -> StandardIndexerDeclaration
min :: StandardIndexerDeclaration
-> StandardIndexerDeclaration -> StandardIndexerDeclaration
Ord, ReadPrec [StandardIndexerDeclaration]
ReadPrec StandardIndexerDeclaration
Int -> ReadS StandardIndexerDeclaration
ReadS [StandardIndexerDeclaration]
(Int -> ReadS StandardIndexerDeclaration)
-> ReadS [StandardIndexerDeclaration]
-> ReadPrec StandardIndexerDeclaration
-> ReadPrec [StandardIndexerDeclaration]
-> Read StandardIndexerDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StandardIndexerDeclaration
readsPrec :: Int -> ReadS StandardIndexerDeclaration
$creadList :: ReadS [StandardIndexerDeclaration]
readList :: ReadS [StandardIndexerDeclaration]
$creadPrec :: ReadPrec StandardIndexerDeclaration
readPrec :: ReadPrec StandardIndexerDeclaration
$creadListPrec :: ReadPrec [StandardIndexerDeclaration]
readListPrec :: ReadPrec [StandardIndexerDeclaration]
Read, Int -> StandardIndexerDeclaration -> String -> String
[StandardIndexerDeclaration] -> String -> String
StandardIndexerDeclaration -> String
(Int -> StandardIndexerDeclaration -> String -> String)
-> (StandardIndexerDeclaration -> String)
-> ([StandardIndexerDeclaration] -> String -> String)
-> Show StandardIndexerDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StandardIndexerDeclaration -> String -> String
showsPrec :: Int -> StandardIndexerDeclaration -> String -> String
$cshow :: StandardIndexerDeclaration -> String
show :: StandardIndexerDeclaration -> String
$cshowList :: [StandardIndexerDeclaration] -> String -> String
showList :: [StandardIndexerDeclaration] -> String -> String
Show)

_StandardIndexerDeclaration :: Name
_StandardIndexerDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StandardIndexerDeclaration")

_StandardIndexerDeclaration_attributes :: Name
_StandardIndexerDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_StandardIndexerDeclaration_modifiers :: Name
_StandardIndexerDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_StandardIndexerDeclaration_declarator :: Name
_StandardIndexerDeclaration_declarator = (String -> Name
Core.Name String
"declarator")

_StandardIndexerDeclaration_body :: Name
_StandardIndexerDeclaration_body = (String -> Name
Core.Name String
"body")

data RefIndexerDeclaration = 
  RefIndexerDeclaration {
    RefIndexerDeclaration -> Maybe Attributes
refIndexerDeclarationAttributes :: (Maybe Attributes),
    RefIndexerDeclaration -> [IndexerModifier]
refIndexerDeclarationModifiers :: [IndexerModifier],
    RefIndexerDeclaration -> RefKind
refIndexerDeclarationRefKind :: RefKind,
    RefIndexerDeclaration -> IndexerDeclarator
refIndexerDeclarationDeclarator :: IndexerDeclarator,
    RefIndexerDeclaration -> RefIndexerBody
refIndexerDeclarationBody :: RefIndexerBody}
  deriving (RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
(RefIndexerDeclaration -> RefIndexerDeclaration -> Bool)
-> (RefIndexerDeclaration -> RefIndexerDeclaration -> Bool)
-> Eq RefIndexerDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
== :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
$c/= :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
/= :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
Eq, Eq RefIndexerDeclaration
Eq RefIndexerDeclaration =>
(RefIndexerDeclaration -> RefIndexerDeclaration -> Ordering)
-> (RefIndexerDeclaration -> RefIndexerDeclaration -> Bool)
-> (RefIndexerDeclaration -> RefIndexerDeclaration -> Bool)
-> (RefIndexerDeclaration -> RefIndexerDeclaration -> Bool)
-> (RefIndexerDeclaration -> RefIndexerDeclaration -> Bool)
-> (RefIndexerDeclaration
    -> RefIndexerDeclaration -> RefIndexerDeclaration)
-> (RefIndexerDeclaration
    -> RefIndexerDeclaration -> RefIndexerDeclaration)
-> Ord RefIndexerDeclaration
RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
RefIndexerDeclaration -> RefIndexerDeclaration -> Ordering
RefIndexerDeclaration
-> RefIndexerDeclaration -> RefIndexerDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefIndexerDeclaration -> RefIndexerDeclaration -> Ordering
compare :: RefIndexerDeclaration -> RefIndexerDeclaration -> Ordering
$c< :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
< :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
$c<= :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
<= :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
$c> :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
> :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
$c>= :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
>= :: RefIndexerDeclaration -> RefIndexerDeclaration -> Bool
$cmax :: RefIndexerDeclaration
-> RefIndexerDeclaration -> RefIndexerDeclaration
max :: RefIndexerDeclaration
-> RefIndexerDeclaration -> RefIndexerDeclaration
$cmin :: RefIndexerDeclaration
-> RefIndexerDeclaration -> RefIndexerDeclaration
min :: RefIndexerDeclaration
-> RefIndexerDeclaration -> RefIndexerDeclaration
Ord, ReadPrec [RefIndexerDeclaration]
ReadPrec RefIndexerDeclaration
Int -> ReadS RefIndexerDeclaration
ReadS [RefIndexerDeclaration]
(Int -> ReadS RefIndexerDeclaration)
-> ReadS [RefIndexerDeclaration]
-> ReadPrec RefIndexerDeclaration
-> ReadPrec [RefIndexerDeclaration]
-> Read RefIndexerDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefIndexerDeclaration
readsPrec :: Int -> ReadS RefIndexerDeclaration
$creadList :: ReadS [RefIndexerDeclaration]
readList :: ReadS [RefIndexerDeclaration]
$creadPrec :: ReadPrec RefIndexerDeclaration
readPrec :: ReadPrec RefIndexerDeclaration
$creadListPrec :: ReadPrec [RefIndexerDeclaration]
readListPrec :: ReadPrec [RefIndexerDeclaration]
Read, Int -> RefIndexerDeclaration -> String -> String
[RefIndexerDeclaration] -> String -> String
RefIndexerDeclaration -> String
(Int -> RefIndexerDeclaration -> String -> String)
-> (RefIndexerDeclaration -> String)
-> ([RefIndexerDeclaration] -> String -> String)
-> Show RefIndexerDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefIndexerDeclaration -> String -> String
showsPrec :: Int -> RefIndexerDeclaration -> String -> String
$cshow :: RefIndexerDeclaration -> String
show :: RefIndexerDeclaration -> String
$cshowList :: [RefIndexerDeclaration] -> String -> String
showList :: [RefIndexerDeclaration] -> String -> String
Show)

_RefIndexerDeclaration :: Name
_RefIndexerDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefIndexerDeclaration")

_RefIndexerDeclaration_attributes :: Name
_RefIndexerDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_RefIndexerDeclaration_modifiers :: Name
_RefIndexerDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_RefIndexerDeclaration_refKind :: Name
_RefIndexerDeclaration_refKind = (String -> Name
Core.Name String
"refKind")

_RefIndexerDeclaration_declarator :: Name
_RefIndexerDeclaration_declarator = (String -> Name
Core.Name String
"declarator")

_RefIndexerDeclaration_body :: Name
_RefIndexerDeclaration_body = (String -> Name
Core.Name String
"body")

data IndexerModifier = 
  IndexerModifierNew  |
  IndexerModifierPublic  |
  IndexerModifierProtected  |
  IndexerModifierInternal  |
  IndexerModifierPrivate  |
  IndexerModifierVirtual  |
  IndexerModifierSealed  |
  IndexerModifierOverride  |
  IndexerModifierAbstract  |
  IndexerModifierExtern  |
  IndexerModifierUnsafe 
  deriving (IndexerModifier -> IndexerModifier -> Bool
(IndexerModifier -> IndexerModifier -> Bool)
-> (IndexerModifier -> IndexerModifier -> Bool)
-> Eq IndexerModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndexerModifier -> IndexerModifier -> Bool
== :: IndexerModifier -> IndexerModifier -> Bool
$c/= :: IndexerModifier -> IndexerModifier -> Bool
/= :: IndexerModifier -> IndexerModifier -> Bool
Eq, Eq IndexerModifier
Eq IndexerModifier =>
(IndexerModifier -> IndexerModifier -> Ordering)
-> (IndexerModifier -> IndexerModifier -> Bool)
-> (IndexerModifier -> IndexerModifier -> Bool)
-> (IndexerModifier -> IndexerModifier -> Bool)
-> (IndexerModifier -> IndexerModifier -> Bool)
-> (IndexerModifier -> IndexerModifier -> IndexerModifier)
-> (IndexerModifier -> IndexerModifier -> IndexerModifier)
-> Ord IndexerModifier
IndexerModifier -> IndexerModifier -> Bool
IndexerModifier -> IndexerModifier -> Ordering
IndexerModifier -> IndexerModifier -> IndexerModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IndexerModifier -> IndexerModifier -> Ordering
compare :: IndexerModifier -> IndexerModifier -> Ordering
$c< :: IndexerModifier -> IndexerModifier -> Bool
< :: IndexerModifier -> IndexerModifier -> Bool
$c<= :: IndexerModifier -> IndexerModifier -> Bool
<= :: IndexerModifier -> IndexerModifier -> Bool
$c> :: IndexerModifier -> IndexerModifier -> Bool
> :: IndexerModifier -> IndexerModifier -> Bool
$c>= :: IndexerModifier -> IndexerModifier -> Bool
>= :: IndexerModifier -> IndexerModifier -> Bool
$cmax :: IndexerModifier -> IndexerModifier -> IndexerModifier
max :: IndexerModifier -> IndexerModifier -> IndexerModifier
$cmin :: IndexerModifier -> IndexerModifier -> IndexerModifier
min :: IndexerModifier -> IndexerModifier -> IndexerModifier
Ord, ReadPrec [IndexerModifier]
ReadPrec IndexerModifier
Int -> ReadS IndexerModifier
ReadS [IndexerModifier]
(Int -> ReadS IndexerModifier)
-> ReadS [IndexerModifier]
-> ReadPrec IndexerModifier
-> ReadPrec [IndexerModifier]
-> Read IndexerModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IndexerModifier
readsPrec :: Int -> ReadS IndexerModifier
$creadList :: ReadS [IndexerModifier]
readList :: ReadS [IndexerModifier]
$creadPrec :: ReadPrec IndexerModifier
readPrec :: ReadPrec IndexerModifier
$creadListPrec :: ReadPrec [IndexerModifier]
readListPrec :: ReadPrec [IndexerModifier]
Read, Int -> IndexerModifier -> String -> String
[IndexerModifier] -> String -> String
IndexerModifier -> String
(Int -> IndexerModifier -> String -> String)
-> (IndexerModifier -> String)
-> ([IndexerModifier] -> String -> String)
-> Show IndexerModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IndexerModifier -> String -> String
showsPrec :: Int -> IndexerModifier -> String -> String
$cshow :: IndexerModifier -> String
show :: IndexerModifier -> String
$cshowList :: [IndexerModifier] -> String -> String
showList :: [IndexerModifier] -> String -> String
Show)

_IndexerModifier :: Name
_IndexerModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IndexerModifier")

_IndexerModifier_new :: Name
_IndexerModifier_new = (String -> Name
Core.Name String
"new")

_IndexerModifier_public :: Name
_IndexerModifier_public = (String -> Name
Core.Name String
"public")

_IndexerModifier_protected :: Name
_IndexerModifier_protected = (String -> Name
Core.Name String
"protected")

_IndexerModifier_internal :: Name
_IndexerModifier_internal = (String -> Name
Core.Name String
"internal")

_IndexerModifier_private :: Name
_IndexerModifier_private = (String -> Name
Core.Name String
"private")

_IndexerModifier_virtual :: Name
_IndexerModifier_virtual = (String -> Name
Core.Name String
"virtual")

_IndexerModifier_sealed :: Name
_IndexerModifier_sealed = (String -> Name
Core.Name String
"sealed")

_IndexerModifier_override :: Name
_IndexerModifier_override = (String -> Name
Core.Name String
"override")

_IndexerModifier_abstract :: Name
_IndexerModifier_abstract = (String -> Name
Core.Name String
"abstract")

_IndexerModifier_extern :: Name
_IndexerModifier_extern = (String -> Name
Core.Name String
"extern")

_IndexerModifier_unsafe :: Name
_IndexerModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

data IndexerDeclarator = 
  IndexerDeclarator {
    IndexerDeclarator -> Type
indexerDeclaratorType :: Type,
    IndexerDeclarator -> Maybe InterfaceType
indexerDeclaratorInterface :: (Maybe InterfaceType),
    IndexerDeclarator -> FormalParameterList
indexerDeclaratorParameters :: FormalParameterList}
  deriving (IndexerDeclarator -> IndexerDeclarator -> Bool
(IndexerDeclarator -> IndexerDeclarator -> Bool)
-> (IndexerDeclarator -> IndexerDeclarator -> Bool)
-> Eq IndexerDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndexerDeclarator -> IndexerDeclarator -> Bool
== :: IndexerDeclarator -> IndexerDeclarator -> Bool
$c/= :: IndexerDeclarator -> IndexerDeclarator -> Bool
/= :: IndexerDeclarator -> IndexerDeclarator -> Bool
Eq, Eq IndexerDeclarator
Eq IndexerDeclarator =>
(IndexerDeclarator -> IndexerDeclarator -> Ordering)
-> (IndexerDeclarator -> IndexerDeclarator -> Bool)
-> (IndexerDeclarator -> IndexerDeclarator -> Bool)
-> (IndexerDeclarator -> IndexerDeclarator -> Bool)
-> (IndexerDeclarator -> IndexerDeclarator -> Bool)
-> (IndexerDeclarator -> IndexerDeclarator -> IndexerDeclarator)
-> (IndexerDeclarator -> IndexerDeclarator -> IndexerDeclarator)
-> Ord IndexerDeclarator
IndexerDeclarator -> IndexerDeclarator -> Bool
IndexerDeclarator -> IndexerDeclarator -> Ordering
IndexerDeclarator -> IndexerDeclarator -> IndexerDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IndexerDeclarator -> IndexerDeclarator -> Ordering
compare :: IndexerDeclarator -> IndexerDeclarator -> Ordering
$c< :: IndexerDeclarator -> IndexerDeclarator -> Bool
< :: IndexerDeclarator -> IndexerDeclarator -> Bool
$c<= :: IndexerDeclarator -> IndexerDeclarator -> Bool
<= :: IndexerDeclarator -> IndexerDeclarator -> Bool
$c> :: IndexerDeclarator -> IndexerDeclarator -> Bool
> :: IndexerDeclarator -> IndexerDeclarator -> Bool
$c>= :: IndexerDeclarator -> IndexerDeclarator -> Bool
>= :: IndexerDeclarator -> IndexerDeclarator -> Bool
$cmax :: IndexerDeclarator -> IndexerDeclarator -> IndexerDeclarator
max :: IndexerDeclarator -> IndexerDeclarator -> IndexerDeclarator
$cmin :: IndexerDeclarator -> IndexerDeclarator -> IndexerDeclarator
min :: IndexerDeclarator -> IndexerDeclarator -> IndexerDeclarator
Ord, ReadPrec [IndexerDeclarator]
ReadPrec IndexerDeclarator
Int -> ReadS IndexerDeclarator
ReadS [IndexerDeclarator]
(Int -> ReadS IndexerDeclarator)
-> ReadS [IndexerDeclarator]
-> ReadPrec IndexerDeclarator
-> ReadPrec [IndexerDeclarator]
-> Read IndexerDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IndexerDeclarator
readsPrec :: Int -> ReadS IndexerDeclarator
$creadList :: ReadS [IndexerDeclarator]
readList :: ReadS [IndexerDeclarator]
$creadPrec :: ReadPrec IndexerDeclarator
readPrec :: ReadPrec IndexerDeclarator
$creadListPrec :: ReadPrec [IndexerDeclarator]
readListPrec :: ReadPrec [IndexerDeclarator]
Read, Int -> IndexerDeclarator -> String -> String
[IndexerDeclarator] -> String -> String
IndexerDeclarator -> String
(Int -> IndexerDeclarator -> String -> String)
-> (IndexerDeclarator -> String)
-> ([IndexerDeclarator] -> String -> String)
-> Show IndexerDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IndexerDeclarator -> String -> String
showsPrec :: Int -> IndexerDeclarator -> String -> String
$cshow :: IndexerDeclarator -> String
show :: IndexerDeclarator -> String
$cshowList :: [IndexerDeclarator] -> String -> String
showList :: [IndexerDeclarator] -> String -> String
Show)

_IndexerDeclarator :: Name
_IndexerDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IndexerDeclarator")

_IndexerDeclarator_type :: Name
_IndexerDeclarator_type = (String -> Name
Core.Name String
"type")

_IndexerDeclarator_interface :: Name
_IndexerDeclarator_interface = (String -> Name
Core.Name String
"interface")

_IndexerDeclarator_parameters :: Name
_IndexerDeclarator_parameters = (String -> Name
Core.Name String
"parameters")

data IndexerBody = 
  IndexerBodyBlock AccessorDeclarations |
  IndexerBodyExpression Expression
  deriving (IndexerBody -> IndexerBody -> Bool
(IndexerBody -> IndexerBody -> Bool)
-> (IndexerBody -> IndexerBody -> Bool) -> Eq IndexerBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IndexerBody -> IndexerBody -> Bool
== :: IndexerBody -> IndexerBody -> Bool
$c/= :: IndexerBody -> IndexerBody -> Bool
/= :: IndexerBody -> IndexerBody -> Bool
Eq, Eq IndexerBody
Eq IndexerBody =>
(IndexerBody -> IndexerBody -> Ordering)
-> (IndexerBody -> IndexerBody -> Bool)
-> (IndexerBody -> IndexerBody -> Bool)
-> (IndexerBody -> IndexerBody -> Bool)
-> (IndexerBody -> IndexerBody -> Bool)
-> (IndexerBody -> IndexerBody -> IndexerBody)
-> (IndexerBody -> IndexerBody -> IndexerBody)
-> Ord IndexerBody
IndexerBody -> IndexerBody -> Bool
IndexerBody -> IndexerBody -> Ordering
IndexerBody -> IndexerBody -> IndexerBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IndexerBody -> IndexerBody -> Ordering
compare :: IndexerBody -> IndexerBody -> Ordering
$c< :: IndexerBody -> IndexerBody -> Bool
< :: IndexerBody -> IndexerBody -> Bool
$c<= :: IndexerBody -> IndexerBody -> Bool
<= :: IndexerBody -> IndexerBody -> Bool
$c> :: IndexerBody -> IndexerBody -> Bool
> :: IndexerBody -> IndexerBody -> Bool
$c>= :: IndexerBody -> IndexerBody -> Bool
>= :: IndexerBody -> IndexerBody -> Bool
$cmax :: IndexerBody -> IndexerBody -> IndexerBody
max :: IndexerBody -> IndexerBody -> IndexerBody
$cmin :: IndexerBody -> IndexerBody -> IndexerBody
min :: IndexerBody -> IndexerBody -> IndexerBody
Ord, ReadPrec [IndexerBody]
ReadPrec IndexerBody
Int -> ReadS IndexerBody
ReadS [IndexerBody]
(Int -> ReadS IndexerBody)
-> ReadS [IndexerBody]
-> ReadPrec IndexerBody
-> ReadPrec [IndexerBody]
-> Read IndexerBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS IndexerBody
readsPrec :: Int -> ReadS IndexerBody
$creadList :: ReadS [IndexerBody]
readList :: ReadS [IndexerBody]
$creadPrec :: ReadPrec IndexerBody
readPrec :: ReadPrec IndexerBody
$creadListPrec :: ReadPrec [IndexerBody]
readListPrec :: ReadPrec [IndexerBody]
Read, Int -> IndexerBody -> String -> String
[IndexerBody] -> String -> String
IndexerBody -> String
(Int -> IndexerBody -> String -> String)
-> (IndexerBody -> String)
-> ([IndexerBody] -> String -> String)
-> Show IndexerBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> IndexerBody -> String -> String
showsPrec :: Int -> IndexerBody -> String -> String
$cshow :: IndexerBody -> String
show :: IndexerBody -> String
$cshowList :: [IndexerBody] -> String -> String
showList :: [IndexerBody] -> String -> String
Show)

_IndexerBody :: Name
_IndexerBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.IndexerBody")

_IndexerBody_block :: Name
_IndexerBody_block = (String -> Name
Core.Name String
"block")

_IndexerBody_expression :: Name
_IndexerBody_expression = (String -> Name
Core.Name String
"expression")

data RefIndexerBody = 
  RefIndexerBodyBlock RefGetAccessorDeclaration |
  RefIndexerBodyRef VariableReference
  deriving (RefIndexerBody -> RefIndexerBody -> Bool
(RefIndexerBody -> RefIndexerBody -> Bool)
-> (RefIndexerBody -> RefIndexerBody -> Bool) -> Eq RefIndexerBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RefIndexerBody -> RefIndexerBody -> Bool
== :: RefIndexerBody -> RefIndexerBody -> Bool
$c/= :: RefIndexerBody -> RefIndexerBody -> Bool
/= :: RefIndexerBody -> RefIndexerBody -> Bool
Eq, Eq RefIndexerBody
Eq RefIndexerBody =>
(RefIndexerBody -> RefIndexerBody -> Ordering)
-> (RefIndexerBody -> RefIndexerBody -> Bool)
-> (RefIndexerBody -> RefIndexerBody -> Bool)
-> (RefIndexerBody -> RefIndexerBody -> Bool)
-> (RefIndexerBody -> RefIndexerBody -> Bool)
-> (RefIndexerBody -> RefIndexerBody -> RefIndexerBody)
-> (RefIndexerBody -> RefIndexerBody -> RefIndexerBody)
-> Ord RefIndexerBody
RefIndexerBody -> RefIndexerBody -> Bool
RefIndexerBody -> RefIndexerBody -> Ordering
RefIndexerBody -> RefIndexerBody -> RefIndexerBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RefIndexerBody -> RefIndexerBody -> Ordering
compare :: RefIndexerBody -> RefIndexerBody -> Ordering
$c< :: RefIndexerBody -> RefIndexerBody -> Bool
< :: RefIndexerBody -> RefIndexerBody -> Bool
$c<= :: RefIndexerBody -> RefIndexerBody -> Bool
<= :: RefIndexerBody -> RefIndexerBody -> Bool
$c> :: RefIndexerBody -> RefIndexerBody -> Bool
> :: RefIndexerBody -> RefIndexerBody -> Bool
$c>= :: RefIndexerBody -> RefIndexerBody -> Bool
>= :: RefIndexerBody -> RefIndexerBody -> Bool
$cmax :: RefIndexerBody -> RefIndexerBody -> RefIndexerBody
max :: RefIndexerBody -> RefIndexerBody -> RefIndexerBody
$cmin :: RefIndexerBody -> RefIndexerBody -> RefIndexerBody
min :: RefIndexerBody -> RefIndexerBody -> RefIndexerBody
Ord, ReadPrec [RefIndexerBody]
ReadPrec RefIndexerBody
Int -> ReadS RefIndexerBody
ReadS [RefIndexerBody]
(Int -> ReadS RefIndexerBody)
-> ReadS [RefIndexerBody]
-> ReadPrec RefIndexerBody
-> ReadPrec [RefIndexerBody]
-> Read RefIndexerBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS RefIndexerBody
readsPrec :: Int -> ReadS RefIndexerBody
$creadList :: ReadS [RefIndexerBody]
readList :: ReadS [RefIndexerBody]
$creadPrec :: ReadPrec RefIndexerBody
readPrec :: ReadPrec RefIndexerBody
$creadListPrec :: ReadPrec [RefIndexerBody]
readListPrec :: ReadPrec [RefIndexerBody]
Read, Int -> RefIndexerBody -> String -> String
[RefIndexerBody] -> String -> String
RefIndexerBody -> String
(Int -> RefIndexerBody -> String -> String)
-> (RefIndexerBody -> String)
-> ([RefIndexerBody] -> String -> String)
-> Show RefIndexerBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> RefIndexerBody -> String -> String
showsPrec :: Int -> RefIndexerBody -> String -> String
$cshow :: RefIndexerBody -> String
show :: RefIndexerBody -> String
$cshowList :: [RefIndexerBody] -> String -> String
showList :: [RefIndexerBody] -> String -> String
Show)

_RefIndexerBody :: Name
_RefIndexerBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.RefIndexerBody")

_RefIndexerBody_block :: Name
_RefIndexerBody_block = (String -> Name
Core.Name String
"block")

_RefIndexerBody_ref :: Name
_RefIndexerBody_ref = (String -> Name
Core.Name String
"ref")

data OperatorDeclaration = 
  OperatorDeclaration {
    OperatorDeclaration -> Maybe Attributes
operatorDeclarationAttributes :: (Maybe Attributes),
    OperatorDeclaration -> [OperatorModifier]
operatorDeclarationModifiers :: [OperatorModifier],
    OperatorDeclaration -> OperatorDeclarator
operatorDeclarationDeclarator :: OperatorDeclarator,
    OperatorDeclaration -> OperatorBody
operatorDeclarationBody :: OperatorBody}
  deriving (OperatorDeclaration -> OperatorDeclaration -> Bool
(OperatorDeclaration -> OperatorDeclaration -> Bool)
-> (OperatorDeclaration -> OperatorDeclaration -> Bool)
-> Eq OperatorDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperatorDeclaration -> OperatorDeclaration -> Bool
== :: OperatorDeclaration -> OperatorDeclaration -> Bool
$c/= :: OperatorDeclaration -> OperatorDeclaration -> Bool
/= :: OperatorDeclaration -> OperatorDeclaration -> Bool
Eq, Eq OperatorDeclaration
Eq OperatorDeclaration =>
(OperatorDeclaration -> OperatorDeclaration -> Ordering)
-> (OperatorDeclaration -> OperatorDeclaration -> Bool)
-> (OperatorDeclaration -> OperatorDeclaration -> Bool)
-> (OperatorDeclaration -> OperatorDeclaration -> Bool)
-> (OperatorDeclaration -> OperatorDeclaration -> Bool)
-> (OperatorDeclaration
    -> OperatorDeclaration -> OperatorDeclaration)
-> (OperatorDeclaration
    -> OperatorDeclaration -> OperatorDeclaration)
-> Ord OperatorDeclaration
OperatorDeclaration -> OperatorDeclaration -> Bool
OperatorDeclaration -> OperatorDeclaration -> Ordering
OperatorDeclaration -> OperatorDeclaration -> OperatorDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: OperatorDeclaration -> OperatorDeclaration -> Ordering
compare :: OperatorDeclaration -> OperatorDeclaration -> Ordering
$c< :: OperatorDeclaration -> OperatorDeclaration -> Bool
< :: OperatorDeclaration -> OperatorDeclaration -> Bool
$c<= :: OperatorDeclaration -> OperatorDeclaration -> Bool
<= :: OperatorDeclaration -> OperatorDeclaration -> Bool
$c> :: OperatorDeclaration -> OperatorDeclaration -> Bool
> :: OperatorDeclaration -> OperatorDeclaration -> Bool
$c>= :: OperatorDeclaration -> OperatorDeclaration -> Bool
>= :: OperatorDeclaration -> OperatorDeclaration -> Bool
$cmax :: OperatorDeclaration -> OperatorDeclaration -> OperatorDeclaration
max :: OperatorDeclaration -> OperatorDeclaration -> OperatorDeclaration
$cmin :: OperatorDeclaration -> OperatorDeclaration -> OperatorDeclaration
min :: OperatorDeclaration -> OperatorDeclaration -> OperatorDeclaration
Ord, ReadPrec [OperatorDeclaration]
ReadPrec OperatorDeclaration
Int -> ReadS OperatorDeclaration
ReadS [OperatorDeclaration]
(Int -> ReadS OperatorDeclaration)
-> ReadS [OperatorDeclaration]
-> ReadPrec OperatorDeclaration
-> ReadPrec [OperatorDeclaration]
-> Read OperatorDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OperatorDeclaration
readsPrec :: Int -> ReadS OperatorDeclaration
$creadList :: ReadS [OperatorDeclaration]
readList :: ReadS [OperatorDeclaration]
$creadPrec :: ReadPrec OperatorDeclaration
readPrec :: ReadPrec OperatorDeclaration
$creadListPrec :: ReadPrec [OperatorDeclaration]
readListPrec :: ReadPrec [OperatorDeclaration]
Read, Int -> OperatorDeclaration -> String -> String
[OperatorDeclaration] -> String -> String
OperatorDeclaration -> String
(Int -> OperatorDeclaration -> String -> String)
-> (OperatorDeclaration -> String)
-> ([OperatorDeclaration] -> String -> String)
-> Show OperatorDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> OperatorDeclaration -> String -> String
showsPrec :: Int -> OperatorDeclaration -> String -> String
$cshow :: OperatorDeclaration -> String
show :: OperatorDeclaration -> String
$cshowList :: [OperatorDeclaration] -> String -> String
showList :: [OperatorDeclaration] -> String -> String
Show)

_OperatorDeclaration :: Name
_OperatorDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.OperatorDeclaration")

_OperatorDeclaration_attributes :: Name
_OperatorDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_OperatorDeclaration_modifiers :: Name
_OperatorDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_OperatorDeclaration_declarator :: Name
_OperatorDeclaration_declarator = (String -> Name
Core.Name String
"declarator")

_OperatorDeclaration_body :: Name
_OperatorDeclaration_body = (String -> Name
Core.Name String
"body")

data OperatorModifier = 
  OperatorModifierPublic  |
  OperatorModifierStatic  |
  OperatorModifierExtern  |
  OperatorModifierUnsafe 
  deriving (OperatorModifier -> OperatorModifier -> Bool
(OperatorModifier -> OperatorModifier -> Bool)
-> (OperatorModifier -> OperatorModifier -> Bool)
-> Eq OperatorModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperatorModifier -> OperatorModifier -> Bool
== :: OperatorModifier -> OperatorModifier -> Bool
$c/= :: OperatorModifier -> OperatorModifier -> Bool
/= :: OperatorModifier -> OperatorModifier -> Bool
Eq, Eq OperatorModifier
Eq OperatorModifier =>
(OperatorModifier -> OperatorModifier -> Ordering)
-> (OperatorModifier -> OperatorModifier -> Bool)
-> (OperatorModifier -> OperatorModifier -> Bool)
-> (OperatorModifier -> OperatorModifier -> Bool)
-> (OperatorModifier -> OperatorModifier -> Bool)
-> (OperatorModifier -> OperatorModifier -> OperatorModifier)
-> (OperatorModifier -> OperatorModifier -> OperatorModifier)
-> Ord OperatorModifier
OperatorModifier -> OperatorModifier -> Bool
OperatorModifier -> OperatorModifier -> Ordering
OperatorModifier -> OperatorModifier -> OperatorModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: OperatorModifier -> OperatorModifier -> Ordering
compare :: OperatorModifier -> OperatorModifier -> Ordering
$c< :: OperatorModifier -> OperatorModifier -> Bool
< :: OperatorModifier -> OperatorModifier -> Bool
$c<= :: OperatorModifier -> OperatorModifier -> Bool
<= :: OperatorModifier -> OperatorModifier -> Bool
$c> :: OperatorModifier -> OperatorModifier -> Bool
> :: OperatorModifier -> OperatorModifier -> Bool
$c>= :: OperatorModifier -> OperatorModifier -> Bool
>= :: OperatorModifier -> OperatorModifier -> Bool
$cmax :: OperatorModifier -> OperatorModifier -> OperatorModifier
max :: OperatorModifier -> OperatorModifier -> OperatorModifier
$cmin :: OperatorModifier -> OperatorModifier -> OperatorModifier
min :: OperatorModifier -> OperatorModifier -> OperatorModifier
Ord, ReadPrec [OperatorModifier]
ReadPrec OperatorModifier
Int -> ReadS OperatorModifier
ReadS [OperatorModifier]
(Int -> ReadS OperatorModifier)
-> ReadS [OperatorModifier]
-> ReadPrec OperatorModifier
-> ReadPrec [OperatorModifier]
-> Read OperatorModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OperatorModifier
readsPrec :: Int -> ReadS OperatorModifier
$creadList :: ReadS [OperatorModifier]
readList :: ReadS [OperatorModifier]
$creadPrec :: ReadPrec OperatorModifier
readPrec :: ReadPrec OperatorModifier
$creadListPrec :: ReadPrec [OperatorModifier]
readListPrec :: ReadPrec [OperatorModifier]
Read, Int -> OperatorModifier -> String -> String
[OperatorModifier] -> String -> String
OperatorModifier -> String
(Int -> OperatorModifier -> String -> String)
-> (OperatorModifier -> String)
-> ([OperatorModifier] -> String -> String)
-> Show OperatorModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> OperatorModifier -> String -> String
showsPrec :: Int -> OperatorModifier -> String -> String
$cshow :: OperatorModifier -> String
show :: OperatorModifier -> String
$cshowList :: [OperatorModifier] -> String -> String
showList :: [OperatorModifier] -> String -> String
Show)

_OperatorModifier :: Name
_OperatorModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.OperatorModifier")

_OperatorModifier_public :: Name
_OperatorModifier_public = (String -> Name
Core.Name String
"public")

_OperatorModifier_static :: Name
_OperatorModifier_static = (String -> Name
Core.Name String
"static")

_OperatorModifier_extern :: Name
_OperatorModifier_extern = (String -> Name
Core.Name String
"extern")

_OperatorModifier_unsafe :: Name
_OperatorModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

data OperatorDeclarator = 
  OperatorDeclaratorUnary UnaryOperatorDeclarator |
  OperatorDeclaratorBinary BinaryOperatorDeclarator |
  OperatorDeclaratorConversion ConversionOperatorDeclarator
  deriving (OperatorDeclarator -> OperatorDeclarator -> Bool
(OperatorDeclarator -> OperatorDeclarator -> Bool)
-> (OperatorDeclarator -> OperatorDeclarator -> Bool)
-> Eq OperatorDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperatorDeclarator -> OperatorDeclarator -> Bool
== :: OperatorDeclarator -> OperatorDeclarator -> Bool
$c/= :: OperatorDeclarator -> OperatorDeclarator -> Bool
/= :: OperatorDeclarator -> OperatorDeclarator -> Bool
Eq, Eq OperatorDeclarator
Eq OperatorDeclarator =>
(OperatorDeclarator -> OperatorDeclarator -> Ordering)
-> (OperatorDeclarator -> OperatorDeclarator -> Bool)
-> (OperatorDeclarator -> OperatorDeclarator -> Bool)
-> (OperatorDeclarator -> OperatorDeclarator -> Bool)
-> (OperatorDeclarator -> OperatorDeclarator -> Bool)
-> (OperatorDeclarator -> OperatorDeclarator -> OperatorDeclarator)
-> (OperatorDeclarator -> OperatorDeclarator -> OperatorDeclarator)
-> Ord OperatorDeclarator
OperatorDeclarator -> OperatorDeclarator -> Bool
OperatorDeclarator -> OperatorDeclarator -> Ordering
OperatorDeclarator -> OperatorDeclarator -> OperatorDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: OperatorDeclarator -> OperatorDeclarator -> Ordering
compare :: OperatorDeclarator -> OperatorDeclarator -> Ordering
$c< :: OperatorDeclarator -> OperatorDeclarator -> Bool
< :: OperatorDeclarator -> OperatorDeclarator -> Bool
$c<= :: OperatorDeclarator -> OperatorDeclarator -> Bool
<= :: OperatorDeclarator -> OperatorDeclarator -> Bool
$c> :: OperatorDeclarator -> OperatorDeclarator -> Bool
> :: OperatorDeclarator -> OperatorDeclarator -> Bool
$c>= :: OperatorDeclarator -> OperatorDeclarator -> Bool
>= :: OperatorDeclarator -> OperatorDeclarator -> Bool
$cmax :: OperatorDeclarator -> OperatorDeclarator -> OperatorDeclarator
max :: OperatorDeclarator -> OperatorDeclarator -> OperatorDeclarator
$cmin :: OperatorDeclarator -> OperatorDeclarator -> OperatorDeclarator
min :: OperatorDeclarator -> OperatorDeclarator -> OperatorDeclarator
Ord, ReadPrec [OperatorDeclarator]
ReadPrec OperatorDeclarator
Int -> ReadS OperatorDeclarator
ReadS [OperatorDeclarator]
(Int -> ReadS OperatorDeclarator)
-> ReadS [OperatorDeclarator]
-> ReadPrec OperatorDeclarator
-> ReadPrec [OperatorDeclarator]
-> Read OperatorDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OperatorDeclarator
readsPrec :: Int -> ReadS OperatorDeclarator
$creadList :: ReadS [OperatorDeclarator]
readList :: ReadS [OperatorDeclarator]
$creadPrec :: ReadPrec OperatorDeclarator
readPrec :: ReadPrec OperatorDeclarator
$creadListPrec :: ReadPrec [OperatorDeclarator]
readListPrec :: ReadPrec [OperatorDeclarator]
Read, Int -> OperatorDeclarator -> String -> String
[OperatorDeclarator] -> String -> String
OperatorDeclarator -> String
(Int -> OperatorDeclarator -> String -> String)
-> (OperatorDeclarator -> String)
-> ([OperatorDeclarator] -> String -> String)
-> Show OperatorDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> OperatorDeclarator -> String -> String
showsPrec :: Int -> OperatorDeclarator -> String -> String
$cshow :: OperatorDeclarator -> String
show :: OperatorDeclarator -> String
$cshowList :: [OperatorDeclarator] -> String -> String
showList :: [OperatorDeclarator] -> String -> String
Show)

_OperatorDeclarator :: Name
_OperatorDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.OperatorDeclarator")

_OperatorDeclarator_unary :: Name
_OperatorDeclarator_unary = (String -> Name
Core.Name String
"unary")

_OperatorDeclarator_binary :: Name
_OperatorDeclarator_binary = (String -> Name
Core.Name String
"binary")

_OperatorDeclarator_conversion :: Name
_OperatorDeclarator_conversion = (String -> Name
Core.Name String
"conversion")

data UnaryOperatorDeclarator = 
  UnaryOperatorDeclarator {
    UnaryOperatorDeclarator -> Type
unaryOperatorDeclaratorType :: Type,
    UnaryOperatorDeclarator -> OverloadableUnaryOperator
unaryOperatorDeclaratorOperator :: OverloadableUnaryOperator,
    UnaryOperatorDeclarator -> FixedParameter
unaryOperatorDeclaratorParameter :: FixedParameter}
  deriving (UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
(UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool)
-> (UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool)
-> Eq UnaryOperatorDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
== :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
$c/= :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
/= :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
Eq, Eq UnaryOperatorDeclarator
Eq UnaryOperatorDeclarator =>
(UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Ordering)
-> (UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool)
-> (UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool)
-> (UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool)
-> (UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool)
-> (UnaryOperatorDeclarator
    -> UnaryOperatorDeclarator -> UnaryOperatorDeclarator)
-> (UnaryOperatorDeclarator
    -> UnaryOperatorDeclarator -> UnaryOperatorDeclarator)
-> Ord UnaryOperatorDeclarator
UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Ordering
UnaryOperatorDeclarator
-> UnaryOperatorDeclarator -> UnaryOperatorDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Ordering
compare :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Ordering
$c< :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
< :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
$c<= :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
<= :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
$c> :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
> :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
$c>= :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
>= :: UnaryOperatorDeclarator -> UnaryOperatorDeclarator -> Bool
$cmax :: UnaryOperatorDeclarator
-> UnaryOperatorDeclarator -> UnaryOperatorDeclarator
max :: UnaryOperatorDeclarator
-> UnaryOperatorDeclarator -> UnaryOperatorDeclarator
$cmin :: UnaryOperatorDeclarator
-> UnaryOperatorDeclarator -> UnaryOperatorDeclarator
min :: UnaryOperatorDeclarator
-> UnaryOperatorDeclarator -> UnaryOperatorDeclarator
Ord, ReadPrec [UnaryOperatorDeclarator]
ReadPrec UnaryOperatorDeclarator
Int -> ReadS UnaryOperatorDeclarator
ReadS [UnaryOperatorDeclarator]
(Int -> ReadS UnaryOperatorDeclarator)
-> ReadS [UnaryOperatorDeclarator]
-> ReadPrec UnaryOperatorDeclarator
-> ReadPrec [UnaryOperatorDeclarator]
-> Read UnaryOperatorDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS UnaryOperatorDeclarator
readsPrec :: Int -> ReadS UnaryOperatorDeclarator
$creadList :: ReadS [UnaryOperatorDeclarator]
readList :: ReadS [UnaryOperatorDeclarator]
$creadPrec :: ReadPrec UnaryOperatorDeclarator
readPrec :: ReadPrec UnaryOperatorDeclarator
$creadListPrec :: ReadPrec [UnaryOperatorDeclarator]
readListPrec :: ReadPrec [UnaryOperatorDeclarator]
Read, Int -> UnaryOperatorDeclarator -> String -> String
[UnaryOperatorDeclarator] -> String -> String
UnaryOperatorDeclarator -> String
(Int -> UnaryOperatorDeclarator -> String -> String)
-> (UnaryOperatorDeclarator -> String)
-> ([UnaryOperatorDeclarator] -> String -> String)
-> Show UnaryOperatorDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> UnaryOperatorDeclarator -> String -> String
showsPrec :: Int -> UnaryOperatorDeclarator -> String -> String
$cshow :: UnaryOperatorDeclarator -> String
show :: UnaryOperatorDeclarator -> String
$cshowList :: [UnaryOperatorDeclarator] -> String -> String
showList :: [UnaryOperatorDeclarator] -> String -> String
Show)

_UnaryOperatorDeclarator :: Name
_UnaryOperatorDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.UnaryOperatorDeclarator")

_UnaryOperatorDeclarator_type :: Name
_UnaryOperatorDeclarator_type = (String -> Name
Core.Name String
"type")

_UnaryOperatorDeclarator_operator :: Name
_UnaryOperatorDeclarator_operator = (String -> Name
Core.Name String
"operator")

_UnaryOperatorDeclarator_parameter :: Name
_UnaryOperatorDeclarator_parameter = (String -> Name
Core.Name String
"parameter")

data OverloadableUnaryOperator = 
  OverloadableUnaryOperatorPlus  |
  OverloadableUnaryOperatorMinus  |
  OverloadableUnaryOperatorNot  |
  OverloadableUnaryOperatorComplement  |
  OverloadableUnaryOperatorIncrement  |
  OverloadableUnaryOperatorDecrement  |
  OverloadableUnaryOperatorTrue  |
  OverloadableUnaryOperatorFalse 
  deriving (OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
(OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool)
-> (OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool)
-> Eq OverloadableUnaryOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
== :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
$c/= :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
/= :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
Eq, Eq OverloadableUnaryOperator
Eq OverloadableUnaryOperator =>
(OverloadableUnaryOperator
 -> OverloadableUnaryOperator -> Ordering)
-> (OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool)
-> (OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool)
-> (OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool)
-> (OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool)
-> (OverloadableUnaryOperator
    -> OverloadableUnaryOperator -> OverloadableUnaryOperator)
-> (OverloadableUnaryOperator
    -> OverloadableUnaryOperator -> OverloadableUnaryOperator)
-> Ord OverloadableUnaryOperator
OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
OverloadableUnaryOperator -> OverloadableUnaryOperator -> Ordering
OverloadableUnaryOperator
-> OverloadableUnaryOperator -> OverloadableUnaryOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Ordering
compare :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Ordering
$c< :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
< :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
$c<= :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
<= :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
$c> :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
> :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
$c>= :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
>= :: OverloadableUnaryOperator -> OverloadableUnaryOperator -> Bool
$cmax :: OverloadableUnaryOperator
-> OverloadableUnaryOperator -> OverloadableUnaryOperator
max :: OverloadableUnaryOperator
-> OverloadableUnaryOperator -> OverloadableUnaryOperator
$cmin :: OverloadableUnaryOperator
-> OverloadableUnaryOperator -> OverloadableUnaryOperator
min :: OverloadableUnaryOperator
-> OverloadableUnaryOperator -> OverloadableUnaryOperator
Ord, ReadPrec [OverloadableUnaryOperator]
ReadPrec OverloadableUnaryOperator
Int -> ReadS OverloadableUnaryOperator
ReadS [OverloadableUnaryOperator]
(Int -> ReadS OverloadableUnaryOperator)
-> ReadS [OverloadableUnaryOperator]
-> ReadPrec OverloadableUnaryOperator
-> ReadPrec [OverloadableUnaryOperator]
-> Read OverloadableUnaryOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OverloadableUnaryOperator
readsPrec :: Int -> ReadS OverloadableUnaryOperator
$creadList :: ReadS [OverloadableUnaryOperator]
readList :: ReadS [OverloadableUnaryOperator]
$creadPrec :: ReadPrec OverloadableUnaryOperator
readPrec :: ReadPrec OverloadableUnaryOperator
$creadListPrec :: ReadPrec [OverloadableUnaryOperator]
readListPrec :: ReadPrec [OverloadableUnaryOperator]
Read, Int -> OverloadableUnaryOperator -> String -> String
[OverloadableUnaryOperator] -> String -> String
OverloadableUnaryOperator -> String
(Int -> OverloadableUnaryOperator -> String -> String)
-> (OverloadableUnaryOperator -> String)
-> ([OverloadableUnaryOperator] -> String -> String)
-> Show OverloadableUnaryOperator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> OverloadableUnaryOperator -> String -> String
showsPrec :: Int -> OverloadableUnaryOperator -> String -> String
$cshow :: OverloadableUnaryOperator -> String
show :: OverloadableUnaryOperator -> String
$cshowList :: [OverloadableUnaryOperator] -> String -> String
showList :: [OverloadableUnaryOperator] -> String -> String
Show)

_OverloadableUnaryOperator :: Name
_OverloadableUnaryOperator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.OverloadableUnaryOperator")

_OverloadableUnaryOperator_plus :: Name
_OverloadableUnaryOperator_plus = (String -> Name
Core.Name String
"plus")

_OverloadableUnaryOperator_minus :: Name
_OverloadableUnaryOperator_minus = (String -> Name
Core.Name String
"minus")

_OverloadableUnaryOperator_not :: Name
_OverloadableUnaryOperator_not = (String -> Name
Core.Name String
"not")

_OverloadableUnaryOperator_complement :: Name
_OverloadableUnaryOperator_complement = (String -> Name
Core.Name String
"complement")

_OverloadableUnaryOperator_increment :: Name
_OverloadableUnaryOperator_increment = (String -> Name
Core.Name String
"increment")

_OverloadableUnaryOperator_decrement :: Name
_OverloadableUnaryOperator_decrement = (String -> Name
Core.Name String
"decrement")

_OverloadableUnaryOperator_true :: Name
_OverloadableUnaryOperator_true = (String -> Name
Core.Name String
"true")

_OverloadableUnaryOperator_false :: Name
_OverloadableUnaryOperator_false = (String -> Name
Core.Name String
"false")

data BinaryOperatorDeclarator = 
  BinaryOperatorDeclarator {
    BinaryOperatorDeclarator -> Type
binaryOperatorDeclaratorType :: Type,
    BinaryOperatorDeclarator -> OverloadableBinaryOperator
binaryOperatorDeclaratorOperator :: OverloadableBinaryOperator,
    BinaryOperatorDeclarator -> FixedParameter
binaryOperatorDeclaratorLeft :: FixedParameter,
    BinaryOperatorDeclarator -> FixedParameter
binaryOperatorDeclaratorRight :: FixedParameter}
  deriving (BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
(BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool)
-> (BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool)
-> Eq BinaryOperatorDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
== :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
$c/= :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
/= :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
Eq, Eq BinaryOperatorDeclarator
Eq BinaryOperatorDeclarator =>
(BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Ordering)
-> (BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool)
-> (BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool)
-> (BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool)
-> (BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool)
-> (BinaryOperatorDeclarator
    -> BinaryOperatorDeclarator -> BinaryOperatorDeclarator)
-> (BinaryOperatorDeclarator
    -> BinaryOperatorDeclarator -> BinaryOperatorDeclarator)
-> Ord BinaryOperatorDeclarator
BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Ordering
BinaryOperatorDeclarator
-> BinaryOperatorDeclarator -> BinaryOperatorDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Ordering
compare :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Ordering
$c< :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
< :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
$c<= :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
<= :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
$c> :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
> :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
$c>= :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
>= :: BinaryOperatorDeclarator -> BinaryOperatorDeclarator -> Bool
$cmax :: BinaryOperatorDeclarator
-> BinaryOperatorDeclarator -> BinaryOperatorDeclarator
max :: BinaryOperatorDeclarator
-> BinaryOperatorDeclarator -> BinaryOperatorDeclarator
$cmin :: BinaryOperatorDeclarator
-> BinaryOperatorDeclarator -> BinaryOperatorDeclarator
min :: BinaryOperatorDeclarator
-> BinaryOperatorDeclarator -> BinaryOperatorDeclarator
Ord, ReadPrec [BinaryOperatorDeclarator]
ReadPrec BinaryOperatorDeclarator
Int -> ReadS BinaryOperatorDeclarator
ReadS [BinaryOperatorDeclarator]
(Int -> ReadS BinaryOperatorDeclarator)
-> ReadS [BinaryOperatorDeclarator]
-> ReadPrec BinaryOperatorDeclarator
-> ReadPrec [BinaryOperatorDeclarator]
-> Read BinaryOperatorDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS BinaryOperatorDeclarator
readsPrec :: Int -> ReadS BinaryOperatorDeclarator
$creadList :: ReadS [BinaryOperatorDeclarator]
readList :: ReadS [BinaryOperatorDeclarator]
$creadPrec :: ReadPrec BinaryOperatorDeclarator
readPrec :: ReadPrec BinaryOperatorDeclarator
$creadListPrec :: ReadPrec [BinaryOperatorDeclarator]
readListPrec :: ReadPrec [BinaryOperatorDeclarator]
Read, Int -> BinaryOperatorDeclarator -> String -> String
[BinaryOperatorDeclarator] -> String -> String
BinaryOperatorDeclarator -> String
(Int -> BinaryOperatorDeclarator -> String -> String)
-> (BinaryOperatorDeclarator -> String)
-> ([BinaryOperatorDeclarator] -> String -> String)
-> Show BinaryOperatorDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> BinaryOperatorDeclarator -> String -> String
showsPrec :: Int -> BinaryOperatorDeclarator -> String -> String
$cshow :: BinaryOperatorDeclarator -> String
show :: BinaryOperatorDeclarator -> String
$cshowList :: [BinaryOperatorDeclarator] -> String -> String
showList :: [BinaryOperatorDeclarator] -> String -> String
Show)

_BinaryOperatorDeclarator :: Name
_BinaryOperatorDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.BinaryOperatorDeclarator")

_BinaryOperatorDeclarator_type :: Name
_BinaryOperatorDeclarator_type = (String -> Name
Core.Name String
"type")

_BinaryOperatorDeclarator_operator :: Name
_BinaryOperatorDeclarator_operator = (String -> Name
Core.Name String
"operator")

_BinaryOperatorDeclarator_left :: Name
_BinaryOperatorDeclarator_left = (String -> Name
Core.Name String
"left")

_BinaryOperatorDeclarator_right :: Name
_BinaryOperatorDeclarator_right = (String -> Name
Core.Name String
"right")

data OverloadableBinaryOperator = 
  OverloadableBinaryOperatorAdd  |
  OverloadableBinaryOperatorSubtract  |
  OverloadableBinaryOperatorMultiply  |
  OverloadableBinaryOperatorDivide  |
  OverloadableBinaryOperatorModulus  |
  OverloadableBinaryOperatorAnd  |
  OverloadableBinaryOperatorOr  |
  OverloadableBinaryOperatorXor  |
  OverloadableBinaryOperatorLeftShift  |
  OverloadableBinaryOperatorRightShift  |
  OverloadableBinaryOperatorEqual  |
  OverloadableBinaryOperatorNotEqual  |
  OverloadableBinaryOperatorGreaterThan  |
  OverloadableBinaryOperatorLessThan  |
  OverloadableBinaryOperatorGreaterThanOrEqual  |
  OverloadableBinaryOperatorLessThanOrEqual 
  deriving (OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
(OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool)
-> (OverloadableBinaryOperator
    -> OverloadableBinaryOperator -> Bool)
-> Eq OverloadableBinaryOperator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
== :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
$c/= :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
/= :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
Eq, Eq OverloadableBinaryOperator
Eq OverloadableBinaryOperator =>
(OverloadableBinaryOperator
 -> OverloadableBinaryOperator -> Ordering)
-> (OverloadableBinaryOperator
    -> OverloadableBinaryOperator -> Bool)
-> (OverloadableBinaryOperator
    -> OverloadableBinaryOperator -> Bool)
-> (OverloadableBinaryOperator
    -> OverloadableBinaryOperator -> Bool)
-> (OverloadableBinaryOperator
    -> OverloadableBinaryOperator -> Bool)
-> (OverloadableBinaryOperator
    -> OverloadableBinaryOperator -> OverloadableBinaryOperator)
-> (OverloadableBinaryOperator
    -> OverloadableBinaryOperator -> OverloadableBinaryOperator)
-> Ord OverloadableBinaryOperator
OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
OverloadableBinaryOperator
-> OverloadableBinaryOperator -> Ordering
OverloadableBinaryOperator
-> OverloadableBinaryOperator -> OverloadableBinaryOperator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: OverloadableBinaryOperator
-> OverloadableBinaryOperator -> Ordering
compare :: OverloadableBinaryOperator
-> OverloadableBinaryOperator -> Ordering
$c< :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
< :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
$c<= :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
<= :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
$c> :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
> :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
$c>= :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
>= :: OverloadableBinaryOperator -> OverloadableBinaryOperator -> Bool
$cmax :: OverloadableBinaryOperator
-> OverloadableBinaryOperator -> OverloadableBinaryOperator
max :: OverloadableBinaryOperator
-> OverloadableBinaryOperator -> OverloadableBinaryOperator
$cmin :: OverloadableBinaryOperator
-> OverloadableBinaryOperator -> OverloadableBinaryOperator
min :: OverloadableBinaryOperator
-> OverloadableBinaryOperator -> OverloadableBinaryOperator
Ord, ReadPrec [OverloadableBinaryOperator]
ReadPrec OverloadableBinaryOperator
Int -> ReadS OverloadableBinaryOperator
ReadS [OverloadableBinaryOperator]
(Int -> ReadS OverloadableBinaryOperator)
-> ReadS [OverloadableBinaryOperator]
-> ReadPrec OverloadableBinaryOperator
-> ReadPrec [OverloadableBinaryOperator]
-> Read OverloadableBinaryOperator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OverloadableBinaryOperator
readsPrec :: Int -> ReadS OverloadableBinaryOperator
$creadList :: ReadS [OverloadableBinaryOperator]
readList :: ReadS [OverloadableBinaryOperator]
$creadPrec :: ReadPrec OverloadableBinaryOperator
readPrec :: ReadPrec OverloadableBinaryOperator
$creadListPrec :: ReadPrec [OverloadableBinaryOperator]
readListPrec :: ReadPrec [OverloadableBinaryOperator]
Read, Int -> OverloadableBinaryOperator -> String -> String
[OverloadableBinaryOperator] -> String -> String
OverloadableBinaryOperator -> String
(Int -> OverloadableBinaryOperator -> String -> String)
-> (OverloadableBinaryOperator -> String)
-> ([OverloadableBinaryOperator] -> String -> String)
-> Show OverloadableBinaryOperator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> OverloadableBinaryOperator -> String -> String
showsPrec :: Int -> OverloadableBinaryOperator -> String -> String
$cshow :: OverloadableBinaryOperator -> String
show :: OverloadableBinaryOperator -> String
$cshowList :: [OverloadableBinaryOperator] -> String -> String
showList :: [OverloadableBinaryOperator] -> String -> String
Show)

_OverloadableBinaryOperator :: Name
_OverloadableBinaryOperator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.OverloadableBinaryOperator")

_OverloadableBinaryOperator_add :: Name
_OverloadableBinaryOperator_add = (String -> Name
Core.Name String
"add")

_OverloadableBinaryOperator_subtract :: Name
_OverloadableBinaryOperator_subtract = (String -> Name
Core.Name String
"subtract")

_OverloadableBinaryOperator_multiply :: Name
_OverloadableBinaryOperator_multiply = (String -> Name
Core.Name String
"multiply")

_OverloadableBinaryOperator_divide :: Name
_OverloadableBinaryOperator_divide = (String -> Name
Core.Name String
"divide")

_OverloadableBinaryOperator_modulus :: Name
_OverloadableBinaryOperator_modulus = (String -> Name
Core.Name String
"modulus")

_OverloadableBinaryOperator_and :: Name
_OverloadableBinaryOperator_and = (String -> Name
Core.Name String
"and")

_OverloadableBinaryOperator_or :: Name
_OverloadableBinaryOperator_or = (String -> Name
Core.Name String
"or")

_OverloadableBinaryOperator_xor :: Name
_OverloadableBinaryOperator_xor = (String -> Name
Core.Name String
"xor")

_OverloadableBinaryOperator_leftShift :: Name
_OverloadableBinaryOperator_leftShift = (String -> Name
Core.Name String
"leftShift")

_OverloadableBinaryOperator_rightShift :: Name
_OverloadableBinaryOperator_rightShift = (String -> Name
Core.Name String
"rightShift")

_OverloadableBinaryOperator_equal :: Name
_OverloadableBinaryOperator_equal = (String -> Name
Core.Name String
"equal")

_OverloadableBinaryOperator_notEqual :: Name
_OverloadableBinaryOperator_notEqual = (String -> Name
Core.Name String
"notEqual")

_OverloadableBinaryOperator_greaterThan :: Name
_OverloadableBinaryOperator_greaterThan = (String -> Name
Core.Name String
"greaterThan")

_OverloadableBinaryOperator_lessThan :: Name
_OverloadableBinaryOperator_lessThan = (String -> Name
Core.Name String
"lessThan")

_OverloadableBinaryOperator_greaterThanOrEqual :: Name
_OverloadableBinaryOperator_greaterThanOrEqual = (String -> Name
Core.Name String
"greaterThanOrEqual")

_OverloadableBinaryOperator_lessThanOrEqual :: Name
_OverloadableBinaryOperator_lessThanOrEqual = (String -> Name
Core.Name String
"lessThanOrEqual")

data ConversionOperatorDeclarator = 
  ConversionOperatorDeclarator {
    ConversionOperatorDeclarator -> ConversionKind
conversionOperatorDeclaratorKind :: ConversionKind,
    ConversionOperatorDeclarator -> Type
conversionOperatorDeclaratorType :: Type,
    ConversionOperatorDeclarator -> FixedParameter
conversionOperatorDeclaratorParameter :: FixedParameter}
  deriving (ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
(ConversionOperatorDeclarator
 -> ConversionOperatorDeclarator -> Bool)
-> (ConversionOperatorDeclarator
    -> ConversionOperatorDeclarator -> Bool)
-> Eq ConversionOperatorDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
== :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
$c/= :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
/= :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
Eq, Eq ConversionOperatorDeclarator
Eq ConversionOperatorDeclarator =>
(ConversionOperatorDeclarator
 -> ConversionOperatorDeclarator -> Ordering)
-> (ConversionOperatorDeclarator
    -> ConversionOperatorDeclarator -> Bool)
-> (ConversionOperatorDeclarator
    -> ConversionOperatorDeclarator -> Bool)
-> (ConversionOperatorDeclarator
    -> ConversionOperatorDeclarator -> Bool)
-> (ConversionOperatorDeclarator
    -> ConversionOperatorDeclarator -> Bool)
-> (ConversionOperatorDeclarator
    -> ConversionOperatorDeclarator -> ConversionOperatorDeclarator)
-> (ConversionOperatorDeclarator
    -> ConversionOperatorDeclarator -> ConversionOperatorDeclarator)
-> Ord ConversionOperatorDeclarator
ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Ordering
ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> ConversionOperatorDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Ordering
compare :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Ordering
$c< :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
< :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
$c<= :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
<= :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
$c> :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
> :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
$c>= :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
>= :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> Bool
$cmax :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> ConversionOperatorDeclarator
max :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> ConversionOperatorDeclarator
$cmin :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> ConversionOperatorDeclarator
min :: ConversionOperatorDeclarator
-> ConversionOperatorDeclarator -> ConversionOperatorDeclarator
Ord, ReadPrec [ConversionOperatorDeclarator]
ReadPrec ConversionOperatorDeclarator
Int -> ReadS ConversionOperatorDeclarator
ReadS [ConversionOperatorDeclarator]
(Int -> ReadS ConversionOperatorDeclarator)
-> ReadS [ConversionOperatorDeclarator]
-> ReadPrec ConversionOperatorDeclarator
-> ReadPrec [ConversionOperatorDeclarator]
-> Read ConversionOperatorDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConversionOperatorDeclarator
readsPrec :: Int -> ReadS ConversionOperatorDeclarator
$creadList :: ReadS [ConversionOperatorDeclarator]
readList :: ReadS [ConversionOperatorDeclarator]
$creadPrec :: ReadPrec ConversionOperatorDeclarator
readPrec :: ReadPrec ConversionOperatorDeclarator
$creadListPrec :: ReadPrec [ConversionOperatorDeclarator]
readListPrec :: ReadPrec [ConversionOperatorDeclarator]
Read, Int -> ConversionOperatorDeclarator -> String -> String
[ConversionOperatorDeclarator] -> String -> String
ConversionOperatorDeclarator -> String
(Int -> ConversionOperatorDeclarator -> String -> String)
-> (ConversionOperatorDeclarator -> String)
-> ([ConversionOperatorDeclarator] -> String -> String)
-> Show ConversionOperatorDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConversionOperatorDeclarator -> String -> String
showsPrec :: Int -> ConversionOperatorDeclarator -> String -> String
$cshow :: ConversionOperatorDeclarator -> String
show :: ConversionOperatorDeclarator -> String
$cshowList :: [ConversionOperatorDeclarator] -> String -> String
showList :: [ConversionOperatorDeclarator] -> String -> String
Show)

_ConversionOperatorDeclarator :: Name
_ConversionOperatorDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConversionOperatorDeclarator")

_ConversionOperatorDeclarator_kind :: Name
_ConversionOperatorDeclarator_kind = (String -> Name
Core.Name String
"kind")

_ConversionOperatorDeclarator_type :: Name
_ConversionOperatorDeclarator_type = (String -> Name
Core.Name String
"type")

_ConversionOperatorDeclarator_parameter :: Name
_ConversionOperatorDeclarator_parameter = (String -> Name
Core.Name String
"parameter")

data ConversionKind = 
  ConversionKindImplicit  |
  ConversionKindExplicit 
  deriving (ConversionKind -> ConversionKind -> Bool
(ConversionKind -> ConversionKind -> Bool)
-> (ConversionKind -> ConversionKind -> Bool) -> Eq ConversionKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConversionKind -> ConversionKind -> Bool
== :: ConversionKind -> ConversionKind -> Bool
$c/= :: ConversionKind -> ConversionKind -> Bool
/= :: ConversionKind -> ConversionKind -> Bool
Eq, Eq ConversionKind
Eq ConversionKind =>
(ConversionKind -> ConversionKind -> Ordering)
-> (ConversionKind -> ConversionKind -> Bool)
-> (ConversionKind -> ConversionKind -> Bool)
-> (ConversionKind -> ConversionKind -> Bool)
-> (ConversionKind -> ConversionKind -> Bool)
-> (ConversionKind -> ConversionKind -> ConversionKind)
-> (ConversionKind -> ConversionKind -> ConversionKind)
-> Ord ConversionKind
ConversionKind -> ConversionKind -> Bool
ConversionKind -> ConversionKind -> Ordering
ConversionKind -> ConversionKind -> ConversionKind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConversionKind -> ConversionKind -> Ordering
compare :: ConversionKind -> ConversionKind -> Ordering
$c< :: ConversionKind -> ConversionKind -> Bool
< :: ConversionKind -> ConversionKind -> Bool
$c<= :: ConversionKind -> ConversionKind -> Bool
<= :: ConversionKind -> ConversionKind -> Bool
$c> :: ConversionKind -> ConversionKind -> Bool
> :: ConversionKind -> ConversionKind -> Bool
$c>= :: ConversionKind -> ConversionKind -> Bool
>= :: ConversionKind -> ConversionKind -> Bool
$cmax :: ConversionKind -> ConversionKind -> ConversionKind
max :: ConversionKind -> ConversionKind -> ConversionKind
$cmin :: ConversionKind -> ConversionKind -> ConversionKind
min :: ConversionKind -> ConversionKind -> ConversionKind
Ord, ReadPrec [ConversionKind]
ReadPrec ConversionKind
Int -> ReadS ConversionKind
ReadS [ConversionKind]
(Int -> ReadS ConversionKind)
-> ReadS [ConversionKind]
-> ReadPrec ConversionKind
-> ReadPrec [ConversionKind]
-> Read ConversionKind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConversionKind
readsPrec :: Int -> ReadS ConversionKind
$creadList :: ReadS [ConversionKind]
readList :: ReadS [ConversionKind]
$creadPrec :: ReadPrec ConversionKind
readPrec :: ReadPrec ConversionKind
$creadListPrec :: ReadPrec [ConversionKind]
readListPrec :: ReadPrec [ConversionKind]
Read, Int -> ConversionKind -> String -> String
[ConversionKind] -> String -> String
ConversionKind -> String
(Int -> ConversionKind -> String -> String)
-> (ConversionKind -> String)
-> ([ConversionKind] -> String -> String)
-> Show ConversionKind
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConversionKind -> String -> String
showsPrec :: Int -> ConversionKind -> String -> String
$cshow :: ConversionKind -> String
show :: ConversionKind -> String
$cshowList :: [ConversionKind] -> String -> String
showList :: [ConversionKind] -> String -> String
Show)

_ConversionKind :: Name
_ConversionKind = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConversionKind")

_ConversionKind_implicit :: Name
_ConversionKind_implicit = (String -> Name
Core.Name String
"implicit")

_ConversionKind_explicit :: Name
_ConversionKind_explicit = (String -> Name
Core.Name String
"explicit")

data OperatorBody = 
  OperatorBodyBlock Block |
  OperatorBodyExpression Expression |
  OperatorBodyEmpty 
  deriving (OperatorBody -> OperatorBody -> Bool
(OperatorBody -> OperatorBody -> Bool)
-> (OperatorBody -> OperatorBody -> Bool) -> Eq OperatorBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperatorBody -> OperatorBody -> Bool
== :: OperatorBody -> OperatorBody -> Bool
$c/= :: OperatorBody -> OperatorBody -> Bool
/= :: OperatorBody -> OperatorBody -> Bool
Eq, Eq OperatorBody
Eq OperatorBody =>
(OperatorBody -> OperatorBody -> Ordering)
-> (OperatorBody -> OperatorBody -> Bool)
-> (OperatorBody -> OperatorBody -> Bool)
-> (OperatorBody -> OperatorBody -> Bool)
-> (OperatorBody -> OperatorBody -> Bool)
-> (OperatorBody -> OperatorBody -> OperatorBody)
-> (OperatorBody -> OperatorBody -> OperatorBody)
-> Ord OperatorBody
OperatorBody -> OperatorBody -> Bool
OperatorBody -> OperatorBody -> Ordering
OperatorBody -> OperatorBody -> OperatorBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: OperatorBody -> OperatorBody -> Ordering
compare :: OperatorBody -> OperatorBody -> Ordering
$c< :: OperatorBody -> OperatorBody -> Bool
< :: OperatorBody -> OperatorBody -> Bool
$c<= :: OperatorBody -> OperatorBody -> Bool
<= :: OperatorBody -> OperatorBody -> Bool
$c> :: OperatorBody -> OperatorBody -> Bool
> :: OperatorBody -> OperatorBody -> Bool
$c>= :: OperatorBody -> OperatorBody -> Bool
>= :: OperatorBody -> OperatorBody -> Bool
$cmax :: OperatorBody -> OperatorBody -> OperatorBody
max :: OperatorBody -> OperatorBody -> OperatorBody
$cmin :: OperatorBody -> OperatorBody -> OperatorBody
min :: OperatorBody -> OperatorBody -> OperatorBody
Ord, ReadPrec [OperatorBody]
ReadPrec OperatorBody
Int -> ReadS OperatorBody
ReadS [OperatorBody]
(Int -> ReadS OperatorBody)
-> ReadS [OperatorBody]
-> ReadPrec OperatorBody
-> ReadPrec [OperatorBody]
-> Read OperatorBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS OperatorBody
readsPrec :: Int -> ReadS OperatorBody
$creadList :: ReadS [OperatorBody]
readList :: ReadS [OperatorBody]
$creadPrec :: ReadPrec OperatorBody
readPrec :: ReadPrec OperatorBody
$creadListPrec :: ReadPrec [OperatorBody]
readListPrec :: ReadPrec [OperatorBody]
Read, Int -> OperatorBody -> String -> String
[OperatorBody] -> String -> String
OperatorBody -> String
(Int -> OperatorBody -> String -> String)
-> (OperatorBody -> String)
-> ([OperatorBody] -> String -> String)
-> Show OperatorBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> OperatorBody -> String -> String
showsPrec :: Int -> OperatorBody -> String -> String
$cshow :: OperatorBody -> String
show :: OperatorBody -> String
$cshowList :: [OperatorBody] -> String -> String
showList :: [OperatorBody] -> String -> String
Show)

_OperatorBody :: Name
_OperatorBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.OperatorBody")

_OperatorBody_block :: Name
_OperatorBody_block = (String -> Name
Core.Name String
"block")

_OperatorBody_expression :: Name
_OperatorBody_expression = (String -> Name
Core.Name String
"expression")

_OperatorBody_empty :: Name
_OperatorBody_empty = (String -> Name
Core.Name String
"empty")

data ConstructorDeclaration = 
  ConstructorDeclaration {
    ConstructorDeclaration -> Maybe Attributes
constructorDeclarationAttributes :: (Maybe Attributes),
    ConstructorDeclaration -> [ConstructorModifier]
constructorDeclarationModifiers :: [ConstructorModifier],
    ConstructorDeclaration -> ConstructorDeclarator
constructorDeclarationDeclarator :: ConstructorDeclarator,
    ConstructorDeclaration -> ConstructorBody
constructorDeclarationBody :: ConstructorBody}
  deriving (ConstructorDeclaration -> ConstructorDeclaration -> Bool
(ConstructorDeclaration -> ConstructorDeclaration -> Bool)
-> (ConstructorDeclaration -> ConstructorDeclaration -> Bool)
-> Eq ConstructorDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
== :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
$c/= :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
/= :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
Eq, Eq ConstructorDeclaration
Eq ConstructorDeclaration =>
(ConstructorDeclaration -> ConstructorDeclaration -> Ordering)
-> (ConstructorDeclaration -> ConstructorDeclaration -> Bool)
-> (ConstructorDeclaration -> ConstructorDeclaration -> Bool)
-> (ConstructorDeclaration -> ConstructorDeclaration -> Bool)
-> (ConstructorDeclaration -> ConstructorDeclaration -> Bool)
-> (ConstructorDeclaration
    -> ConstructorDeclaration -> ConstructorDeclaration)
-> (ConstructorDeclaration
    -> ConstructorDeclaration -> ConstructorDeclaration)
-> Ord ConstructorDeclaration
ConstructorDeclaration -> ConstructorDeclaration -> Bool
ConstructorDeclaration -> ConstructorDeclaration -> Ordering
ConstructorDeclaration
-> ConstructorDeclaration -> ConstructorDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstructorDeclaration -> ConstructorDeclaration -> Ordering
compare :: ConstructorDeclaration -> ConstructorDeclaration -> Ordering
$c< :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
< :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
$c<= :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
<= :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
$c> :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
> :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
$c>= :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
>= :: ConstructorDeclaration -> ConstructorDeclaration -> Bool
$cmax :: ConstructorDeclaration
-> ConstructorDeclaration -> ConstructorDeclaration
max :: ConstructorDeclaration
-> ConstructorDeclaration -> ConstructorDeclaration
$cmin :: ConstructorDeclaration
-> ConstructorDeclaration -> ConstructorDeclaration
min :: ConstructorDeclaration
-> ConstructorDeclaration -> ConstructorDeclaration
Ord, ReadPrec [ConstructorDeclaration]
ReadPrec ConstructorDeclaration
Int -> ReadS ConstructorDeclaration
ReadS [ConstructorDeclaration]
(Int -> ReadS ConstructorDeclaration)
-> ReadS [ConstructorDeclaration]
-> ReadPrec ConstructorDeclaration
-> ReadPrec [ConstructorDeclaration]
-> Read ConstructorDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConstructorDeclaration
readsPrec :: Int -> ReadS ConstructorDeclaration
$creadList :: ReadS [ConstructorDeclaration]
readList :: ReadS [ConstructorDeclaration]
$creadPrec :: ReadPrec ConstructorDeclaration
readPrec :: ReadPrec ConstructorDeclaration
$creadListPrec :: ReadPrec [ConstructorDeclaration]
readListPrec :: ReadPrec [ConstructorDeclaration]
Read, Int -> ConstructorDeclaration -> String -> String
[ConstructorDeclaration] -> String -> String
ConstructorDeclaration -> String
(Int -> ConstructorDeclaration -> String -> String)
-> (ConstructorDeclaration -> String)
-> ([ConstructorDeclaration] -> String -> String)
-> Show ConstructorDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConstructorDeclaration -> String -> String
showsPrec :: Int -> ConstructorDeclaration -> String -> String
$cshow :: ConstructorDeclaration -> String
show :: ConstructorDeclaration -> String
$cshowList :: [ConstructorDeclaration] -> String -> String
showList :: [ConstructorDeclaration] -> String -> String
Show)

_ConstructorDeclaration :: Name
_ConstructorDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConstructorDeclaration")

_ConstructorDeclaration_attributes :: Name
_ConstructorDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_ConstructorDeclaration_modifiers :: Name
_ConstructorDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_ConstructorDeclaration_declarator :: Name
_ConstructorDeclaration_declarator = (String -> Name
Core.Name String
"declarator")

_ConstructorDeclaration_body :: Name
_ConstructorDeclaration_body = (String -> Name
Core.Name String
"body")

data ConstructorModifier = 
  ConstructorModifierPublic  |
  ConstructorModifierProtected  |
  ConstructorModifierInternal  |
  ConstructorModifierPrivate  |
  ConstructorModifierExtern  |
  ConstructorModifierUnsafe 
  deriving (ConstructorModifier -> ConstructorModifier -> Bool
(ConstructorModifier -> ConstructorModifier -> Bool)
-> (ConstructorModifier -> ConstructorModifier -> Bool)
-> Eq ConstructorModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstructorModifier -> ConstructorModifier -> Bool
== :: ConstructorModifier -> ConstructorModifier -> Bool
$c/= :: ConstructorModifier -> ConstructorModifier -> Bool
/= :: ConstructorModifier -> ConstructorModifier -> Bool
Eq, Eq ConstructorModifier
Eq ConstructorModifier =>
(ConstructorModifier -> ConstructorModifier -> Ordering)
-> (ConstructorModifier -> ConstructorModifier -> Bool)
-> (ConstructorModifier -> ConstructorModifier -> Bool)
-> (ConstructorModifier -> ConstructorModifier -> Bool)
-> (ConstructorModifier -> ConstructorModifier -> Bool)
-> (ConstructorModifier
    -> ConstructorModifier -> ConstructorModifier)
-> (ConstructorModifier
    -> ConstructorModifier -> ConstructorModifier)
-> Ord ConstructorModifier
ConstructorModifier -> ConstructorModifier -> Bool
ConstructorModifier -> ConstructorModifier -> Ordering
ConstructorModifier -> ConstructorModifier -> ConstructorModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstructorModifier -> ConstructorModifier -> Ordering
compare :: ConstructorModifier -> ConstructorModifier -> Ordering
$c< :: ConstructorModifier -> ConstructorModifier -> Bool
< :: ConstructorModifier -> ConstructorModifier -> Bool
$c<= :: ConstructorModifier -> ConstructorModifier -> Bool
<= :: ConstructorModifier -> ConstructorModifier -> Bool
$c> :: ConstructorModifier -> ConstructorModifier -> Bool
> :: ConstructorModifier -> ConstructorModifier -> Bool
$c>= :: ConstructorModifier -> ConstructorModifier -> Bool
>= :: ConstructorModifier -> ConstructorModifier -> Bool
$cmax :: ConstructorModifier -> ConstructorModifier -> ConstructorModifier
max :: ConstructorModifier -> ConstructorModifier -> ConstructorModifier
$cmin :: ConstructorModifier -> ConstructorModifier -> ConstructorModifier
min :: ConstructorModifier -> ConstructorModifier -> ConstructorModifier
Ord, ReadPrec [ConstructorModifier]
ReadPrec ConstructorModifier
Int -> ReadS ConstructorModifier
ReadS [ConstructorModifier]
(Int -> ReadS ConstructorModifier)
-> ReadS [ConstructorModifier]
-> ReadPrec ConstructorModifier
-> ReadPrec [ConstructorModifier]
-> Read ConstructorModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConstructorModifier
readsPrec :: Int -> ReadS ConstructorModifier
$creadList :: ReadS [ConstructorModifier]
readList :: ReadS [ConstructorModifier]
$creadPrec :: ReadPrec ConstructorModifier
readPrec :: ReadPrec ConstructorModifier
$creadListPrec :: ReadPrec [ConstructorModifier]
readListPrec :: ReadPrec [ConstructorModifier]
Read, Int -> ConstructorModifier -> String -> String
[ConstructorModifier] -> String -> String
ConstructorModifier -> String
(Int -> ConstructorModifier -> String -> String)
-> (ConstructorModifier -> String)
-> ([ConstructorModifier] -> String -> String)
-> Show ConstructorModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConstructorModifier -> String -> String
showsPrec :: Int -> ConstructorModifier -> String -> String
$cshow :: ConstructorModifier -> String
show :: ConstructorModifier -> String
$cshowList :: [ConstructorModifier] -> String -> String
showList :: [ConstructorModifier] -> String -> String
Show)

_ConstructorModifier :: Name
_ConstructorModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConstructorModifier")

_ConstructorModifier_public :: Name
_ConstructorModifier_public = (String -> Name
Core.Name String
"public")

_ConstructorModifier_protected :: Name
_ConstructorModifier_protected = (String -> Name
Core.Name String
"protected")

_ConstructorModifier_internal :: Name
_ConstructorModifier_internal = (String -> Name
Core.Name String
"internal")

_ConstructorModifier_private :: Name
_ConstructorModifier_private = (String -> Name
Core.Name String
"private")

_ConstructorModifier_extern :: Name
_ConstructorModifier_extern = (String -> Name
Core.Name String
"extern")

_ConstructorModifier_unsafe :: Name
_ConstructorModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

data ConstructorDeclarator = 
  ConstructorDeclarator {
    ConstructorDeclarator -> Identifier
constructorDeclaratorName :: Identifier,
    ConstructorDeclarator -> Maybe FormalParameterList
constructorDeclaratorParameters :: (Maybe FormalParameterList),
    ConstructorDeclarator -> Maybe ConstructorInitializer
constructorDeclaratorInitializer :: (Maybe ConstructorInitializer)}
  deriving (ConstructorDeclarator -> ConstructorDeclarator -> Bool
(ConstructorDeclarator -> ConstructorDeclarator -> Bool)
-> (ConstructorDeclarator -> ConstructorDeclarator -> Bool)
-> Eq ConstructorDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
== :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
$c/= :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
/= :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
Eq, Eq ConstructorDeclarator
Eq ConstructorDeclarator =>
(ConstructorDeclarator -> ConstructorDeclarator -> Ordering)
-> (ConstructorDeclarator -> ConstructorDeclarator -> Bool)
-> (ConstructorDeclarator -> ConstructorDeclarator -> Bool)
-> (ConstructorDeclarator -> ConstructorDeclarator -> Bool)
-> (ConstructorDeclarator -> ConstructorDeclarator -> Bool)
-> (ConstructorDeclarator
    -> ConstructorDeclarator -> ConstructorDeclarator)
-> (ConstructorDeclarator
    -> ConstructorDeclarator -> ConstructorDeclarator)
-> Ord ConstructorDeclarator
ConstructorDeclarator -> ConstructorDeclarator -> Bool
ConstructorDeclarator -> ConstructorDeclarator -> Ordering
ConstructorDeclarator
-> ConstructorDeclarator -> ConstructorDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstructorDeclarator -> ConstructorDeclarator -> Ordering
compare :: ConstructorDeclarator -> ConstructorDeclarator -> Ordering
$c< :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
< :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
$c<= :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
<= :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
$c> :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
> :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
$c>= :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
>= :: ConstructorDeclarator -> ConstructorDeclarator -> Bool
$cmax :: ConstructorDeclarator
-> ConstructorDeclarator -> ConstructorDeclarator
max :: ConstructorDeclarator
-> ConstructorDeclarator -> ConstructorDeclarator
$cmin :: ConstructorDeclarator
-> ConstructorDeclarator -> ConstructorDeclarator
min :: ConstructorDeclarator
-> ConstructorDeclarator -> ConstructorDeclarator
Ord, ReadPrec [ConstructorDeclarator]
ReadPrec ConstructorDeclarator
Int -> ReadS ConstructorDeclarator
ReadS [ConstructorDeclarator]
(Int -> ReadS ConstructorDeclarator)
-> ReadS [ConstructorDeclarator]
-> ReadPrec ConstructorDeclarator
-> ReadPrec [ConstructorDeclarator]
-> Read ConstructorDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConstructorDeclarator
readsPrec :: Int -> ReadS ConstructorDeclarator
$creadList :: ReadS [ConstructorDeclarator]
readList :: ReadS [ConstructorDeclarator]
$creadPrec :: ReadPrec ConstructorDeclarator
readPrec :: ReadPrec ConstructorDeclarator
$creadListPrec :: ReadPrec [ConstructorDeclarator]
readListPrec :: ReadPrec [ConstructorDeclarator]
Read, Int -> ConstructorDeclarator -> String -> String
[ConstructorDeclarator] -> String -> String
ConstructorDeclarator -> String
(Int -> ConstructorDeclarator -> String -> String)
-> (ConstructorDeclarator -> String)
-> ([ConstructorDeclarator] -> String -> String)
-> Show ConstructorDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConstructorDeclarator -> String -> String
showsPrec :: Int -> ConstructorDeclarator -> String -> String
$cshow :: ConstructorDeclarator -> String
show :: ConstructorDeclarator -> String
$cshowList :: [ConstructorDeclarator] -> String -> String
showList :: [ConstructorDeclarator] -> String -> String
Show)

_ConstructorDeclarator :: Name
_ConstructorDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConstructorDeclarator")

_ConstructorDeclarator_name :: Name
_ConstructorDeclarator_name = (String -> Name
Core.Name String
"name")

_ConstructorDeclarator_parameters :: Name
_ConstructorDeclarator_parameters = (String -> Name
Core.Name String
"parameters")

_ConstructorDeclarator_initializer :: Name
_ConstructorDeclarator_initializer = (String -> Name
Core.Name String
"initializer")

data ConstructorInitializer = 
  ConstructorInitializerBase (Maybe ArgumentList) |
  ConstructorInitializerThis (Maybe ArgumentList)
  deriving (ConstructorInitializer -> ConstructorInitializer -> Bool
(ConstructorInitializer -> ConstructorInitializer -> Bool)
-> (ConstructorInitializer -> ConstructorInitializer -> Bool)
-> Eq ConstructorInitializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstructorInitializer -> ConstructorInitializer -> Bool
== :: ConstructorInitializer -> ConstructorInitializer -> Bool
$c/= :: ConstructorInitializer -> ConstructorInitializer -> Bool
/= :: ConstructorInitializer -> ConstructorInitializer -> Bool
Eq, Eq ConstructorInitializer
Eq ConstructorInitializer =>
(ConstructorInitializer -> ConstructorInitializer -> Ordering)
-> (ConstructorInitializer -> ConstructorInitializer -> Bool)
-> (ConstructorInitializer -> ConstructorInitializer -> Bool)
-> (ConstructorInitializer -> ConstructorInitializer -> Bool)
-> (ConstructorInitializer -> ConstructorInitializer -> Bool)
-> (ConstructorInitializer
    -> ConstructorInitializer -> ConstructorInitializer)
-> (ConstructorInitializer
    -> ConstructorInitializer -> ConstructorInitializer)
-> Ord ConstructorInitializer
ConstructorInitializer -> ConstructorInitializer -> Bool
ConstructorInitializer -> ConstructorInitializer -> Ordering
ConstructorInitializer
-> ConstructorInitializer -> ConstructorInitializer
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstructorInitializer -> ConstructorInitializer -> Ordering
compare :: ConstructorInitializer -> ConstructorInitializer -> Ordering
$c< :: ConstructorInitializer -> ConstructorInitializer -> Bool
< :: ConstructorInitializer -> ConstructorInitializer -> Bool
$c<= :: ConstructorInitializer -> ConstructorInitializer -> Bool
<= :: ConstructorInitializer -> ConstructorInitializer -> Bool
$c> :: ConstructorInitializer -> ConstructorInitializer -> Bool
> :: ConstructorInitializer -> ConstructorInitializer -> Bool
$c>= :: ConstructorInitializer -> ConstructorInitializer -> Bool
>= :: ConstructorInitializer -> ConstructorInitializer -> Bool
$cmax :: ConstructorInitializer
-> ConstructorInitializer -> ConstructorInitializer
max :: ConstructorInitializer
-> ConstructorInitializer -> ConstructorInitializer
$cmin :: ConstructorInitializer
-> ConstructorInitializer -> ConstructorInitializer
min :: ConstructorInitializer
-> ConstructorInitializer -> ConstructorInitializer
Ord, ReadPrec [ConstructorInitializer]
ReadPrec ConstructorInitializer
Int -> ReadS ConstructorInitializer
ReadS [ConstructorInitializer]
(Int -> ReadS ConstructorInitializer)
-> ReadS [ConstructorInitializer]
-> ReadPrec ConstructorInitializer
-> ReadPrec [ConstructorInitializer]
-> Read ConstructorInitializer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConstructorInitializer
readsPrec :: Int -> ReadS ConstructorInitializer
$creadList :: ReadS [ConstructorInitializer]
readList :: ReadS [ConstructorInitializer]
$creadPrec :: ReadPrec ConstructorInitializer
readPrec :: ReadPrec ConstructorInitializer
$creadListPrec :: ReadPrec [ConstructorInitializer]
readListPrec :: ReadPrec [ConstructorInitializer]
Read, Int -> ConstructorInitializer -> String -> String
[ConstructorInitializer] -> String -> String
ConstructorInitializer -> String
(Int -> ConstructorInitializer -> String -> String)
-> (ConstructorInitializer -> String)
-> ([ConstructorInitializer] -> String -> String)
-> Show ConstructorInitializer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConstructorInitializer -> String -> String
showsPrec :: Int -> ConstructorInitializer -> String -> String
$cshow :: ConstructorInitializer -> String
show :: ConstructorInitializer -> String
$cshowList :: [ConstructorInitializer] -> String -> String
showList :: [ConstructorInitializer] -> String -> String
Show)

_ConstructorInitializer :: Name
_ConstructorInitializer = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConstructorInitializer")

_ConstructorInitializer_base :: Name
_ConstructorInitializer_base = (String -> Name
Core.Name String
"base")

_ConstructorInitializer_this :: Name
_ConstructorInitializer_this = (String -> Name
Core.Name String
"this")

data ConstructorBody = 
  ConstructorBodyBlock Block |
  ConstructorBodyExpression Expression |
  ConstructorBodyEmpty 
  deriving (ConstructorBody -> ConstructorBody -> Bool
(ConstructorBody -> ConstructorBody -> Bool)
-> (ConstructorBody -> ConstructorBody -> Bool)
-> Eq ConstructorBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ConstructorBody -> ConstructorBody -> Bool
== :: ConstructorBody -> ConstructorBody -> Bool
$c/= :: ConstructorBody -> ConstructorBody -> Bool
/= :: ConstructorBody -> ConstructorBody -> Bool
Eq, Eq ConstructorBody
Eq ConstructorBody =>
(ConstructorBody -> ConstructorBody -> Ordering)
-> (ConstructorBody -> ConstructorBody -> Bool)
-> (ConstructorBody -> ConstructorBody -> Bool)
-> (ConstructorBody -> ConstructorBody -> Bool)
-> (ConstructorBody -> ConstructorBody -> Bool)
-> (ConstructorBody -> ConstructorBody -> ConstructorBody)
-> (ConstructorBody -> ConstructorBody -> ConstructorBody)
-> Ord ConstructorBody
ConstructorBody -> ConstructorBody -> Bool
ConstructorBody -> ConstructorBody -> Ordering
ConstructorBody -> ConstructorBody -> ConstructorBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ConstructorBody -> ConstructorBody -> Ordering
compare :: ConstructorBody -> ConstructorBody -> Ordering
$c< :: ConstructorBody -> ConstructorBody -> Bool
< :: ConstructorBody -> ConstructorBody -> Bool
$c<= :: ConstructorBody -> ConstructorBody -> Bool
<= :: ConstructorBody -> ConstructorBody -> Bool
$c> :: ConstructorBody -> ConstructorBody -> Bool
> :: ConstructorBody -> ConstructorBody -> Bool
$c>= :: ConstructorBody -> ConstructorBody -> Bool
>= :: ConstructorBody -> ConstructorBody -> Bool
$cmax :: ConstructorBody -> ConstructorBody -> ConstructorBody
max :: ConstructorBody -> ConstructorBody -> ConstructorBody
$cmin :: ConstructorBody -> ConstructorBody -> ConstructorBody
min :: ConstructorBody -> ConstructorBody -> ConstructorBody
Ord, ReadPrec [ConstructorBody]
ReadPrec ConstructorBody
Int -> ReadS ConstructorBody
ReadS [ConstructorBody]
(Int -> ReadS ConstructorBody)
-> ReadS [ConstructorBody]
-> ReadPrec ConstructorBody
-> ReadPrec [ConstructorBody]
-> Read ConstructorBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ConstructorBody
readsPrec :: Int -> ReadS ConstructorBody
$creadList :: ReadS [ConstructorBody]
readList :: ReadS [ConstructorBody]
$creadPrec :: ReadPrec ConstructorBody
readPrec :: ReadPrec ConstructorBody
$creadListPrec :: ReadPrec [ConstructorBody]
readListPrec :: ReadPrec [ConstructorBody]
Read, Int -> ConstructorBody -> String -> String
[ConstructorBody] -> String -> String
ConstructorBody -> String
(Int -> ConstructorBody -> String -> String)
-> (ConstructorBody -> String)
-> ([ConstructorBody] -> String -> String)
-> Show ConstructorBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ConstructorBody -> String -> String
showsPrec :: Int -> ConstructorBody -> String -> String
$cshow :: ConstructorBody -> String
show :: ConstructorBody -> String
$cshowList :: [ConstructorBody] -> String -> String
showList :: [ConstructorBody] -> String -> String
Show)

_ConstructorBody :: Name
_ConstructorBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ConstructorBody")

_ConstructorBody_block :: Name
_ConstructorBody_block = (String -> Name
Core.Name String
"block")

_ConstructorBody_expression :: Name
_ConstructorBody_expression = (String -> Name
Core.Name String
"expression")

_ConstructorBody_empty :: Name
_ConstructorBody_empty = (String -> Name
Core.Name String
"empty")

data StaticConstructorDeclaration = 
  StaticConstructorDeclaration {
    StaticConstructorDeclaration -> Maybe Attributes
staticConstructorDeclarationAttributes :: (Maybe Attributes),
    StaticConstructorDeclaration -> StaticConstructorModifiers
staticConstructorDeclarationModifiers :: StaticConstructorModifiers,
    StaticConstructorDeclaration -> Identifier
staticConstructorDeclarationName :: Identifier,
    StaticConstructorDeclaration -> StaticConstructorBody
staticConstructorDeclarationBody :: StaticConstructorBody}
  deriving (StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
(StaticConstructorDeclaration
 -> StaticConstructorDeclaration -> Bool)
-> (StaticConstructorDeclaration
    -> StaticConstructorDeclaration -> Bool)
-> Eq StaticConstructorDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
== :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
$c/= :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
/= :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
Eq, Eq StaticConstructorDeclaration
Eq StaticConstructorDeclaration =>
(StaticConstructorDeclaration
 -> StaticConstructorDeclaration -> Ordering)
-> (StaticConstructorDeclaration
    -> StaticConstructorDeclaration -> Bool)
-> (StaticConstructorDeclaration
    -> StaticConstructorDeclaration -> Bool)
-> (StaticConstructorDeclaration
    -> StaticConstructorDeclaration -> Bool)
-> (StaticConstructorDeclaration
    -> StaticConstructorDeclaration -> Bool)
-> (StaticConstructorDeclaration
    -> StaticConstructorDeclaration -> StaticConstructorDeclaration)
-> (StaticConstructorDeclaration
    -> StaticConstructorDeclaration -> StaticConstructorDeclaration)
-> Ord StaticConstructorDeclaration
StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Ordering
StaticConstructorDeclaration
-> StaticConstructorDeclaration -> StaticConstructorDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Ordering
compare :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Ordering
$c< :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
< :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
$c<= :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
<= :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
$c> :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
> :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
$c>= :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
>= :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> Bool
$cmax :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> StaticConstructorDeclaration
max :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> StaticConstructorDeclaration
$cmin :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> StaticConstructorDeclaration
min :: StaticConstructorDeclaration
-> StaticConstructorDeclaration -> StaticConstructorDeclaration
Ord, ReadPrec [StaticConstructorDeclaration]
ReadPrec StaticConstructorDeclaration
Int -> ReadS StaticConstructorDeclaration
ReadS [StaticConstructorDeclaration]
(Int -> ReadS StaticConstructorDeclaration)
-> ReadS [StaticConstructorDeclaration]
-> ReadPrec StaticConstructorDeclaration
-> ReadPrec [StaticConstructorDeclaration]
-> Read StaticConstructorDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StaticConstructorDeclaration
readsPrec :: Int -> ReadS StaticConstructorDeclaration
$creadList :: ReadS [StaticConstructorDeclaration]
readList :: ReadS [StaticConstructorDeclaration]
$creadPrec :: ReadPrec StaticConstructorDeclaration
readPrec :: ReadPrec StaticConstructorDeclaration
$creadListPrec :: ReadPrec [StaticConstructorDeclaration]
readListPrec :: ReadPrec [StaticConstructorDeclaration]
Read, Int -> StaticConstructorDeclaration -> String -> String
[StaticConstructorDeclaration] -> String -> String
StaticConstructorDeclaration -> String
(Int -> StaticConstructorDeclaration -> String -> String)
-> (StaticConstructorDeclaration -> String)
-> ([StaticConstructorDeclaration] -> String -> String)
-> Show StaticConstructorDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StaticConstructorDeclaration -> String -> String
showsPrec :: Int -> StaticConstructorDeclaration -> String -> String
$cshow :: StaticConstructorDeclaration -> String
show :: StaticConstructorDeclaration -> String
$cshowList :: [StaticConstructorDeclaration] -> String -> String
showList :: [StaticConstructorDeclaration] -> String -> String
Show)

_StaticConstructorDeclaration :: Name
_StaticConstructorDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StaticConstructorDeclaration")

_StaticConstructorDeclaration_attributes :: Name
_StaticConstructorDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_StaticConstructorDeclaration_modifiers :: Name
_StaticConstructorDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_StaticConstructorDeclaration_name :: Name
_StaticConstructorDeclaration_name = (String -> Name
Core.Name String
"name")

_StaticConstructorDeclaration_body :: Name
_StaticConstructorDeclaration_body = (String -> Name
Core.Name String
"body")

data StaticConstructorModifiers = 
  StaticConstructorModifiers {
    StaticConstructorModifiers -> Bool
staticConstructorModifiersExtern :: Bool,
    StaticConstructorModifiers -> Bool
staticConstructorModifiersUnsafe :: Bool}
  deriving (StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
(StaticConstructorModifiers -> StaticConstructorModifiers -> Bool)
-> (StaticConstructorModifiers
    -> StaticConstructorModifiers -> Bool)
-> Eq StaticConstructorModifiers
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
== :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
$c/= :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
/= :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
Eq, Eq StaticConstructorModifiers
Eq StaticConstructorModifiers =>
(StaticConstructorModifiers
 -> StaticConstructorModifiers -> Ordering)
-> (StaticConstructorModifiers
    -> StaticConstructorModifiers -> Bool)
-> (StaticConstructorModifiers
    -> StaticConstructorModifiers -> Bool)
-> (StaticConstructorModifiers
    -> StaticConstructorModifiers -> Bool)
-> (StaticConstructorModifiers
    -> StaticConstructorModifiers -> Bool)
-> (StaticConstructorModifiers
    -> StaticConstructorModifiers -> StaticConstructorModifiers)
-> (StaticConstructorModifiers
    -> StaticConstructorModifiers -> StaticConstructorModifiers)
-> Ord StaticConstructorModifiers
StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
StaticConstructorModifiers
-> StaticConstructorModifiers -> Ordering
StaticConstructorModifiers
-> StaticConstructorModifiers -> StaticConstructorModifiers
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StaticConstructorModifiers
-> StaticConstructorModifiers -> Ordering
compare :: StaticConstructorModifiers
-> StaticConstructorModifiers -> Ordering
$c< :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
< :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
$c<= :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
<= :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
$c> :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
> :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
$c>= :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
>= :: StaticConstructorModifiers -> StaticConstructorModifiers -> Bool
$cmax :: StaticConstructorModifiers
-> StaticConstructorModifiers -> StaticConstructorModifiers
max :: StaticConstructorModifiers
-> StaticConstructorModifiers -> StaticConstructorModifiers
$cmin :: StaticConstructorModifiers
-> StaticConstructorModifiers -> StaticConstructorModifiers
min :: StaticConstructorModifiers
-> StaticConstructorModifiers -> StaticConstructorModifiers
Ord, ReadPrec [StaticConstructorModifiers]
ReadPrec StaticConstructorModifiers
Int -> ReadS StaticConstructorModifiers
ReadS [StaticConstructorModifiers]
(Int -> ReadS StaticConstructorModifiers)
-> ReadS [StaticConstructorModifiers]
-> ReadPrec StaticConstructorModifiers
-> ReadPrec [StaticConstructorModifiers]
-> Read StaticConstructorModifiers
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StaticConstructorModifiers
readsPrec :: Int -> ReadS StaticConstructorModifiers
$creadList :: ReadS [StaticConstructorModifiers]
readList :: ReadS [StaticConstructorModifiers]
$creadPrec :: ReadPrec StaticConstructorModifiers
readPrec :: ReadPrec StaticConstructorModifiers
$creadListPrec :: ReadPrec [StaticConstructorModifiers]
readListPrec :: ReadPrec [StaticConstructorModifiers]
Read, Int -> StaticConstructorModifiers -> String -> String
[StaticConstructorModifiers] -> String -> String
StaticConstructorModifiers -> String
(Int -> StaticConstructorModifiers -> String -> String)
-> (StaticConstructorModifiers -> String)
-> ([StaticConstructorModifiers] -> String -> String)
-> Show StaticConstructorModifiers
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StaticConstructorModifiers -> String -> String
showsPrec :: Int -> StaticConstructorModifiers -> String -> String
$cshow :: StaticConstructorModifiers -> String
show :: StaticConstructorModifiers -> String
$cshowList :: [StaticConstructorModifiers] -> String -> String
showList :: [StaticConstructorModifiers] -> String -> String
Show)

_StaticConstructorModifiers :: Name
_StaticConstructorModifiers = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StaticConstructorModifiers")

_StaticConstructorModifiers_extern :: Name
_StaticConstructorModifiers_extern = (String -> Name
Core.Name String
"extern")

_StaticConstructorModifiers_unsafe :: Name
_StaticConstructorModifiers_unsafe = (String -> Name
Core.Name String
"unsafe")

data StaticConstructorBody = 
  StaticConstructorBodyBlock Block |
  StaticConstructorBodyExpression Expression |
  StaticConstructorBodyEmpty 
  deriving (StaticConstructorBody -> StaticConstructorBody -> Bool
(StaticConstructorBody -> StaticConstructorBody -> Bool)
-> (StaticConstructorBody -> StaticConstructorBody -> Bool)
-> Eq StaticConstructorBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StaticConstructorBody -> StaticConstructorBody -> Bool
== :: StaticConstructorBody -> StaticConstructorBody -> Bool
$c/= :: StaticConstructorBody -> StaticConstructorBody -> Bool
/= :: StaticConstructorBody -> StaticConstructorBody -> Bool
Eq, Eq StaticConstructorBody
Eq StaticConstructorBody =>
(StaticConstructorBody -> StaticConstructorBody -> Ordering)
-> (StaticConstructorBody -> StaticConstructorBody -> Bool)
-> (StaticConstructorBody -> StaticConstructorBody -> Bool)
-> (StaticConstructorBody -> StaticConstructorBody -> Bool)
-> (StaticConstructorBody -> StaticConstructorBody -> Bool)
-> (StaticConstructorBody
    -> StaticConstructorBody -> StaticConstructorBody)
-> (StaticConstructorBody
    -> StaticConstructorBody -> StaticConstructorBody)
-> Ord StaticConstructorBody
StaticConstructorBody -> StaticConstructorBody -> Bool
StaticConstructorBody -> StaticConstructorBody -> Ordering
StaticConstructorBody
-> StaticConstructorBody -> StaticConstructorBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StaticConstructorBody -> StaticConstructorBody -> Ordering
compare :: StaticConstructorBody -> StaticConstructorBody -> Ordering
$c< :: StaticConstructorBody -> StaticConstructorBody -> Bool
< :: StaticConstructorBody -> StaticConstructorBody -> Bool
$c<= :: StaticConstructorBody -> StaticConstructorBody -> Bool
<= :: StaticConstructorBody -> StaticConstructorBody -> Bool
$c> :: StaticConstructorBody -> StaticConstructorBody -> Bool
> :: StaticConstructorBody -> StaticConstructorBody -> Bool
$c>= :: StaticConstructorBody -> StaticConstructorBody -> Bool
>= :: StaticConstructorBody -> StaticConstructorBody -> Bool
$cmax :: StaticConstructorBody
-> StaticConstructorBody -> StaticConstructorBody
max :: StaticConstructorBody
-> StaticConstructorBody -> StaticConstructorBody
$cmin :: StaticConstructorBody
-> StaticConstructorBody -> StaticConstructorBody
min :: StaticConstructorBody
-> StaticConstructorBody -> StaticConstructorBody
Ord, ReadPrec [StaticConstructorBody]
ReadPrec StaticConstructorBody
Int -> ReadS StaticConstructorBody
ReadS [StaticConstructorBody]
(Int -> ReadS StaticConstructorBody)
-> ReadS [StaticConstructorBody]
-> ReadPrec StaticConstructorBody
-> ReadPrec [StaticConstructorBody]
-> Read StaticConstructorBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StaticConstructorBody
readsPrec :: Int -> ReadS StaticConstructorBody
$creadList :: ReadS [StaticConstructorBody]
readList :: ReadS [StaticConstructorBody]
$creadPrec :: ReadPrec StaticConstructorBody
readPrec :: ReadPrec StaticConstructorBody
$creadListPrec :: ReadPrec [StaticConstructorBody]
readListPrec :: ReadPrec [StaticConstructorBody]
Read, Int -> StaticConstructorBody -> String -> String
[StaticConstructorBody] -> String -> String
StaticConstructorBody -> String
(Int -> StaticConstructorBody -> String -> String)
-> (StaticConstructorBody -> String)
-> ([StaticConstructorBody] -> String -> String)
-> Show StaticConstructorBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StaticConstructorBody -> String -> String
showsPrec :: Int -> StaticConstructorBody -> String -> String
$cshow :: StaticConstructorBody -> String
show :: StaticConstructorBody -> String
$cshowList :: [StaticConstructorBody] -> String -> String
showList :: [StaticConstructorBody] -> String -> String
Show)

_StaticConstructorBody :: Name
_StaticConstructorBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StaticConstructorBody")

_StaticConstructorBody_block :: Name
_StaticConstructorBody_block = (String -> Name
Core.Name String
"block")

_StaticConstructorBody_expression :: Name
_StaticConstructorBody_expression = (String -> Name
Core.Name String
"expression")

_StaticConstructorBody_empty :: Name
_StaticConstructorBody_empty = (String -> Name
Core.Name String
"empty")

data FinalizerDeclaration = 
  FinalizerDeclaration {
    FinalizerDeclaration -> Maybe Attributes
finalizerDeclarationAttributes :: (Maybe Attributes),
    FinalizerDeclaration -> Bool
finalizerDeclarationExtern :: Bool,
    FinalizerDeclaration -> Bool
finalizerDeclarationUnsafe :: Bool,
    FinalizerDeclaration -> Identifier
finalizerDeclarationName :: Identifier,
    FinalizerDeclaration -> FinalizerBody
finalizerDeclarationBody :: FinalizerBody}
  deriving (FinalizerDeclaration -> FinalizerDeclaration -> Bool
(FinalizerDeclaration -> FinalizerDeclaration -> Bool)
-> (FinalizerDeclaration -> FinalizerDeclaration -> Bool)
-> Eq FinalizerDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
== :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
$c/= :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
/= :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
Eq, Eq FinalizerDeclaration
Eq FinalizerDeclaration =>
(FinalizerDeclaration -> FinalizerDeclaration -> Ordering)
-> (FinalizerDeclaration -> FinalizerDeclaration -> Bool)
-> (FinalizerDeclaration -> FinalizerDeclaration -> Bool)
-> (FinalizerDeclaration -> FinalizerDeclaration -> Bool)
-> (FinalizerDeclaration -> FinalizerDeclaration -> Bool)
-> (FinalizerDeclaration
    -> FinalizerDeclaration -> FinalizerDeclaration)
-> (FinalizerDeclaration
    -> FinalizerDeclaration -> FinalizerDeclaration)
-> Ord FinalizerDeclaration
FinalizerDeclaration -> FinalizerDeclaration -> Bool
FinalizerDeclaration -> FinalizerDeclaration -> Ordering
FinalizerDeclaration
-> FinalizerDeclaration -> FinalizerDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FinalizerDeclaration -> FinalizerDeclaration -> Ordering
compare :: FinalizerDeclaration -> FinalizerDeclaration -> Ordering
$c< :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
< :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
$c<= :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
<= :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
$c> :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
> :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
$c>= :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
>= :: FinalizerDeclaration -> FinalizerDeclaration -> Bool
$cmax :: FinalizerDeclaration
-> FinalizerDeclaration -> FinalizerDeclaration
max :: FinalizerDeclaration
-> FinalizerDeclaration -> FinalizerDeclaration
$cmin :: FinalizerDeclaration
-> FinalizerDeclaration -> FinalizerDeclaration
min :: FinalizerDeclaration
-> FinalizerDeclaration -> FinalizerDeclaration
Ord, ReadPrec [FinalizerDeclaration]
ReadPrec FinalizerDeclaration
Int -> ReadS FinalizerDeclaration
ReadS [FinalizerDeclaration]
(Int -> ReadS FinalizerDeclaration)
-> ReadS [FinalizerDeclaration]
-> ReadPrec FinalizerDeclaration
-> ReadPrec [FinalizerDeclaration]
-> Read FinalizerDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FinalizerDeclaration
readsPrec :: Int -> ReadS FinalizerDeclaration
$creadList :: ReadS [FinalizerDeclaration]
readList :: ReadS [FinalizerDeclaration]
$creadPrec :: ReadPrec FinalizerDeclaration
readPrec :: ReadPrec FinalizerDeclaration
$creadListPrec :: ReadPrec [FinalizerDeclaration]
readListPrec :: ReadPrec [FinalizerDeclaration]
Read, Int -> FinalizerDeclaration -> String -> String
[FinalizerDeclaration] -> String -> String
FinalizerDeclaration -> String
(Int -> FinalizerDeclaration -> String -> String)
-> (FinalizerDeclaration -> String)
-> ([FinalizerDeclaration] -> String -> String)
-> Show FinalizerDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FinalizerDeclaration -> String -> String
showsPrec :: Int -> FinalizerDeclaration -> String -> String
$cshow :: FinalizerDeclaration -> String
show :: FinalizerDeclaration -> String
$cshowList :: [FinalizerDeclaration] -> String -> String
showList :: [FinalizerDeclaration] -> String -> String
Show)

_FinalizerDeclaration :: Name
_FinalizerDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FinalizerDeclaration")

_FinalizerDeclaration_attributes :: Name
_FinalizerDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_FinalizerDeclaration_extern :: Name
_FinalizerDeclaration_extern = (String -> Name
Core.Name String
"extern")

_FinalizerDeclaration_unsafe :: Name
_FinalizerDeclaration_unsafe = (String -> Name
Core.Name String
"unsafe")

_FinalizerDeclaration_name :: Name
_FinalizerDeclaration_name = (String -> Name
Core.Name String
"name")

_FinalizerDeclaration_body :: Name
_FinalizerDeclaration_body = (String -> Name
Core.Name String
"body")

data FinalizerBody = 
  FinalizerBodyBlock Block |
  FinalizerBodyExpression Expression |
  FinalizerBodyEmpty 
  deriving (FinalizerBody -> FinalizerBody -> Bool
(FinalizerBody -> FinalizerBody -> Bool)
-> (FinalizerBody -> FinalizerBody -> Bool) -> Eq FinalizerBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FinalizerBody -> FinalizerBody -> Bool
== :: FinalizerBody -> FinalizerBody -> Bool
$c/= :: FinalizerBody -> FinalizerBody -> Bool
/= :: FinalizerBody -> FinalizerBody -> Bool
Eq, Eq FinalizerBody
Eq FinalizerBody =>
(FinalizerBody -> FinalizerBody -> Ordering)
-> (FinalizerBody -> FinalizerBody -> Bool)
-> (FinalizerBody -> FinalizerBody -> Bool)
-> (FinalizerBody -> FinalizerBody -> Bool)
-> (FinalizerBody -> FinalizerBody -> Bool)
-> (FinalizerBody -> FinalizerBody -> FinalizerBody)
-> (FinalizerBody -> FinalizerBody -> FinalizerBody)
-> Ord FinalizerBody
FinalizerBody -> FinalizerBody -> Bool
FinalizerBody -> FinalizerBody -> Ordering
FinalizerBody -> FinalizerBody -> FinalizerBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FinalizerBody -> FinalizerBody -> Ordering
compare :: FinalizerBody -> FinalizerBody -> Ordering
$c< :: FinalizerBody -> FinalizerBody -> Bool
< :: FinalizerBody -> FinalizerBody -> Bool
$c<= :: FinalizerBody -> FinalizerBody -> Bool
<= :: FinalizerBody -> FinalizerBody -> Bool
$c> :: FinalizerBody -> FinalizerBody -> Bool
> :: FinalizerBody -> FinalizerBody -> Bool
$c>= :: FinalizerBody -> FinalizerBody -> Bool
>= :: FinalizerBody -> FinalizerBody -> Bool
$cmax :: FinalizerBody -> FinalizerBody -> FinalizerBody
max :: FinalizerBody -> FinalizerBody -> FinalizerBody
$cmin :: FinalizerBody -> FinalizerBody -> FinalizerBody
min :: FinalizerBody -> FinalizerBody -> FinalizerBody
Ord, ReadPrec [FinalizerBody]
ReadPrec FinalizerBody
Int -> ReadS FinalizerBody
ReadS [FinalizerBody]
(Int -> ReadS FinalizerBody)
-> ReadS [FinalizerBody]
-> ReadPrec FinalizerBody
-> ReadPrec [FinalizerBody]
-> Read FinalizerBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FinalizerBody
readsPrec :: Int -> ReadS FinalizerBody
$creadList :: ReadS [FinalizerBody]
readList :: ReadS [FinalizerBody]
$creadPrec :: ReadPrec FinalizerBody
readPrec :: ReadPrec FinalizerBody
$creadListPrec :: ReadPrec [FinalizerBody]
readListPrec :: ReadPrec [FinalizerBody]
Read, Int -> FinalizerBody -> String -> String
[FinalizerBody] -> String -> String
FinalizerBody -> String
(Int -> FinalizerBody -> String -> String)
-> (FinalizerBody -> String)
-> ([FinalizerBody] -> String -> String)
-> Show FinalizerBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FinalizerBody -> String -> String
showsPrec :: Int -> FinalizerBody -> String -> String
$cshow :: FinalizerBody -> String
show :: FinalizerBody -> String
$cshowList :: [FinalizerBody] -> String -> String
showList :: [FinalizerBody] -> String -> String
Show)

_FinalizerBody :: Name
_FinalizerBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FinalizerBody")

_FinalizerBody_block :: Name
_FinalizerBody_block = (String -> Name
Core.Name String
"block")

_FinalizerBody_expression :: Name
_FinalizerBody_expression = (String -> Name
Core.Name String
"expression")

_FinalizerBody_empty :: Name
_FinalizerBody_empty = (String -> Name
Core.Name String
"empty")

data StructDeclaration = 
  StructDeclaration {
    StructDeclaration -> Maybe Attributes
structDeclarationAttributes :: (Maybe Attributes),
    StructDeclaration -> [StructModifier]
structDeclarationModifiers :: [StructModifier],
    StructDeclaration -> Bool
structDeclarationRef :: Bool,
    StructDeclaration -> Bool
structDeclarationPartial :: Bool,
    StructDeclaration -> Identifier
structDeclarationName :: Identifier,
    StructDeclaration -> Maybe TypeParameterList
structDeclarationParameters :: (Maybe TypeParameterList),
    StructDeclaration -> [InterfaceType]
structDeclarationInterfaces :: [InterfaceType],
    StructDeclaration -> [TypeParameterConstraintsClause]
structDeclarationConstraints :: [TypeParameterConstraintsClause],
    StructDeclaration -> [StructMemberDeclaration]
structDeclarationBody :: [StructMemberDeclaration]}
  deriving (StructDeclaration -> StructDeclaration -> Bool
(StructDeclaration -> StructDeclaration -> Bool)
-> (StructDeclaration -> StructDeclaration -> Bool)
-> Eq StructDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StructDeclaration -> StructDeclaration -> Bool
== :: StructDeclaration -> StructDeclaration -> Bool
$c/= :: StructDeclaration -> StructDeclaration -> Bool
/= :: StructDeclaration -> StructDeclaration -> Bool
Eq, Eq StructDeclaration
Eq StructDeclaration =>
(StructDeclaration -> StructDeclaration -> Ordering)
-> (StructDeclaration -> StructDeclaration -> Bool)
-> (StructDeclaration -> StructDeclaration -> Bool)
-> (StructDeclaration -> StructDeclaration -> Bool)
-> (StructDeclaration -> StructDeclaration -> Bool)
-> (StructDeclaration -> StructDeclaration -> StructDeclaration)
-> (StructDeclaration -> StructDeclaration -> StructDeclaration)
-> Ord StructDeclaration
StructDeclaration -> StructDeclaration -> Bool
StructDeclaration -> StructDeclaration -> Ordering
StructDeclaration -> StructDeclaration -> StructDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StructDeclaration -> StructDeclaration -> Ordering
compare :: StructDeclaration -> StructDeclaration -> Ordering
$c< :: StructDeclaration -> StructDeclaration -> Bool
< :: StructDeclaration -> StructDeclaration -> Bool
$c<= :: StructDeclaration -> StructDeclaration -> Bool
<= :: StructDeclaration -> StructDeclaration -> Bool
$c> :: StructDeclaration -> StructDeclaration -> Bool
> :: StructDeclaration -> StructDeclaration -> Bool
$c>= :: StructDeclaration -> StructDeclaration -> Bool
>= :: StructDeclaration -> StructDeclaration -> Bool
$cmax :: StructDeclaration -> StructDeclaration -> StructDeclaration
max :: StructDeclaration -> StructDeclaration -> StructDeclaration
$cmin :: StructDeclaration -> StructDeclaration -> StructDeclaration
min :: StructDeclaration -> StructDeclaration -> StructDeclaration
Ord, ReadPrec [StructDeclaration]
ReadPrec StructDeclaration
Int -> ReadS StructDeclaration
ReadS [StructDeclaration]
(Int -> ReadS StructDeclaration)
-> ReadS [StructDeclaration]
-> ReadPrec StructDeclaration
-> ReadPrec [StructDeclaration]
-> Read StructDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StructDeclaration
readsPrec :: Int -> ReadS StructDeclaration
$creadList :: ReadS [StructDeclaration]
readList :: ReadS [StructDeclaration]
$creadPrec :: ReadPrec StructDeclaration
readPrec :: ReadPrec StructDeclaration
$creadListPrec :: ReadPrec [StructDeclaration]
readListPrec :: ReadPrec [StructDeclaration]
Read, Int -> StructDeclaration -> String -> String
[StructDeclaration] -> String -> String
StructDeclaration -> String
(Int -> StructDeclaration -> String -> String)
-> (StructDeclaration -> String)
-> ([StructDeclaration] -> String -> String)
-> Show StructDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StructDeclaration -> String -> String
showsPrec :: Int -> StructDeclaration -> String -> String
$cshow :: StructDeclaration -> String
show :: StructDeclaration -> String
$cshowList :: [StructDeclaration] -> String -> String
showList :: [StructDeclaration] -> String -> String
Show)

_StructDeclaration :: Name
_StructDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StructDeclaration")

_StructDeclaration_attributes :: Name
_StructDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_StructDeclaration_modifiers :: Name
_StructDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_StructDeclaration_ref :: Name
_StructDeclaration_ref = (String -> Name
Core.Name String
"ref")

_StructDeclaration_partial :: Name
_StructDeclaration_partial = (String -> Name
Core.Name String
"partial")

_StructDeclaration_name :: Name
_StructDeclaration_name = (String -> Name
Core.Name String
"name")

_StructDeclaration_parameters :: Name
_StructDeclaration_parameters = (String -> Name
Core.Name String
"parameters")

_StructDeclaration_interfaces :: Name
_StructDeclaration_interfaces = (String -> Name
Core.Name String
"interfaces")

_StructDeclaration_constraints :: Name
_StructDeclaration_constraints = (String -> Name
Core.Name String
"constraints")

_StructDeclaration_body :: Name
_StructDeclaration_body = (String -> Name
Core.Name String
"body")

data StructModifier = 
  StructModifierNew  |
  StructModifierPublic  |
  StructModifierProtected  |
  StructModifierInternal  |
  StructModifierPrivate  |
  StructModifierReadonly  |
  StructModifierUnsafe 
  deriving (StructModifier -> StructModifier -> Bool
(StructModifier -> StructModifier -> Bool)
-> (StructModifier -> StructModifier -> Bool) -> Eq StructModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StructModifier -> StructModifier -> Bool
== :: StructModifier -> StructModifier -> Bool
$c/= :: StructModifier -> StructModifier -> Bool
/= :: StructModifier -> StructModifier -> Bool
Eq, Eq StructModifier
Eq StructModifier =>
(StructModifier -> StructModifier -> Ordering)
-> (StructModifier -> StructModifier -> Bool)
-> (StructModifier -> StructModifier -> Bool)
-> (StructModifier -> StructModifier -> Bool)
-> (StructModifier -> StructModifier -> Bool)
-> (StructModifier -> StructModifier -> StructModifier)
-> (StructModifier -> StructModifier -> StructModifier)
-> Ord StructModifier
StructModifier -> StructModifier -> Bool
StructModifier -> StructModifier -> Ordering
StructModifier -> StructModifier -> StructModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StructModifier -> StructModifier -> Ordering
compare :: StructModifier -> StructModifier -> Ordering
$c< :: StructModifier -> StructModifier -> Bool
< :: StructModifier -> StructModifier -> Bool
$c<= :: StructModifier -> StructModifier -> Bool
<= :: StructModifier -> StructModifier -> Bool
$c> :: StructModifier -> StructModifier -> Bool
> :: StructModifier -> StructModifier -> Bool
$c>= :: StructModifier -> StructModifier -> Bool
>= :: StructModifier -> StructModifier -> Bool
$cmax :: StructModifier -> StructModifier -> StructModifier
max :: StructModifier -> StructModifier -> StructModifier
$cmin :: StructModifier -> StructModifier -> StructModifier
min :: StructModifier -> StructModifier -> StructModifier
Ord, ReadPrec [StructModifier]
ReadPrec StructModifier
Int -> ReadS StructModifier
ReadS [StructModifier]
(Int -> ReadS StructModifier)
-> ReadS [StructModifier]
-> ReadPrec StructModifier
-> ReadPrec [StructModifier]
-> Read StructModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StructModifier
readsPrec :: Int -> ReadS StructModifier
$creadList :: ReadS [StructModifier]
readList :: ReadS [StructModifier]
$creadPrec :: ReadPrec StructModifier
readPrec :: ReadPrec StructModifier
$creadListPrec :: ReadPrec [StructModifier]
readListPrec :: ReadPrec [StructModifier]
Read, Int -> StructModifier -> String -> String
[StructModifier] -> String -> String
StructModifier -> String
(Int -> StructModifier -> String -> String)
-> (StructModifier -> String)
-> ([StructModifier] -> String -> String)
-> Show StructModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StructModifier -> String -> String
showsPrec :: Int -> StructModifier -> String -> String
$cshow :: StructModifier -> String
show :: StructModifier -> String
$cshowList :: [StructModifier] -> String -> String
showList :: [StructModifier] -> String -> String
Show)

_StructModifier :: Name
_StructModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StructModifier")

_StructModifier_new :: Name
_StructModifier_new = (String -> Name
Core.Name String
"new")

_StructModifier_public :: Name
_StructModifier_public = (String -> Name
Core.Name String
"public")

_StructModifier_protected :: Name
_StructModifier_protected = (String -> Name
Core.Name String
"protected")

_StructModifier_internal :: Name
_StructModifier_internal = (String -> Name
Core.Name String
"internal")

_StructModifier_private :: Name
_StructModifier_private = (String -> Name
Core.Name String
"private")

_StructModifier_readonly :: Name
_StructModifier_readonly = (String -> Name
Core.Name String
"readonly")

_StructModifier_unsafe :: Name
_StructModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

data StructMemberDeclaration = 
  StructMemberDeclarationConstant ConstantDeclaration |
  StructMemberDeclarationField FieldDeclaration |
  StructMemberDeclarationMethod MethodDeclaration |
  StructMemberDeclarationProperty PropertyDeclaration |
  StructMemberDeclarationEvent EventDeclaration |
  StructMemberDeclarationIndexer IndexerDeclaration |
  StructMemberDeclarationOperator OperatorDeclaration |
  StructMemberDeclarationConstructor ConstructorDeclaration |
  StructMemberDeclarationStaticConstructor StaticConstructorDeclaration |
  StructMemberDeclarationType TypeDeclaration |
  StructMemberDeclarationFixedSizeBuffer FixedSizeBufferDeclaration
  deriving (StructMemberDeclaration -> StructMemberDeclaration -> Bool
(StructMemberDeclaration -> StructMemberDeclaration -> Bool)
-> (StructMemberDeclaration -> StructMemberDeclaration -> Bool)
-> Eq StructMemberDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
== :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
$c/= :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
/= :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
Eq, Eq StructMemberDeclaration
Eq StructMemberDeclaration =>
(StructMemberDeclaration -> StructMemberDeclaration -> Ordering)
-> (StructMemberDeclaration -> StructMemberDeclaration -> Bool)
-> (StructMemberDeclaration -> StructMemberDeclaration -> Bool)
-> (StructMemberDeclaration -> StructMemberDeclaration -> Bool)
-> (StructMemberDeclaration -> StructMemberDeclaration -> Bool)
-> (StructMemberDeclaration
    -> StructMemberDeclaration -> StructMemberDeclaration)
-> (StructMemberDeclaration
    -> StructMemberDeclaration -> StructMemberDeclaration)
-> Ord StructMemberDeclaration
StructMemberDeclaration -> StructMemberDeclaration -> Bool
StructMemberDeclaration -> StructMemberDeclaration -> Ordering
StructMemberDeclaration
-> StructMemberDeclaration -> StructMemberDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: StructMemberDeclaration -> StructMemberDeclaration -> Ordering
compare :: StructMemberDeclaration -> StructMemberDeclaration -> Ordering
$c< :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
< :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
$c<= :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
<= :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
$c> :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
> :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
$c>= :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
>= :: StructMemberDeclaration -> StructMemberDeclaration -> Bool
$cmax :: StructMemberDeclaration
-> StructMemberDeclaration -> StructMemberDeclaration
max :: StructMemberDeclaration
-> StructMemberDeclaration -> StructMemberDeclaration
$cmin :: StructMemberDeclaration
-> StructMemberDeclaration -> StructMemberDeclaration
min :: StructMemberDeclaration
-> StructMemberDeclaration -> StructMemberDeclaration
Ord, ReadPrec [StructMemberDeclaration]
ReadPrec StructMemberDeclaration
Int -> ReadS StructMemberDeclaration
ReadS [StructMemberDeclaration]
(Int -> ReadS StructMemberDeclaration)
-> ReadS [StructMemberDeclaration]
-> ReadPrec StructMemberDeclaration
-> ReadPrec [StructMemberDeclaration]
-> Read StructMemberDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS StructMemberDeclaration
readsPrec :: Int -> ReadS StructMemberDeclaration
$creadList :: ReadS [StructMemberDeclaration]
readList :: ReadS [StructMemberDeclaration]
$creadPrec :: ReadPrec StructMemberDeclaration
readPrec :: ReadPrec StructMemberDeclaration
$creadListPrec :: ReadPrec [StructMemberDeclaration]
readListPrec :: ReadPrec [StructMemberDeclaration]
Read, Int -> StructMemberDeclaration -> String -> String
[StructMemberDeclaration] -> String -> String
StructMemberDeclaration -> String
(Int -> StructMemberDeclaration -> String -> String)
-> (StructMemberDeclaration -> String)
-> ([StructMemberDeclaration] -> String -> String)
-> Show StructMemberDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> StructMemberDeclaration -> String -> String
showsPrec :: Int -> StructMemberDeclaration -> String -> String
$cshow :: StructMemberDeclaration -> String
show :: StructMemberDeclaration -> String
$cshowList :: [StructMemberDeclaration] -> String -> String
showList :: [StructMemberDeclaration] -> String -> String
Show)

_StructMemberDeclaration :: Name
_StructMemberDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.StructMemberDeclaration")

_StructMemberDeclaration_constant :: Name
_StructMemberDeclaration_constant = (String -> Name
Core.Name String
"constant")

_StructMemberDeclaration_field :: Name
_StructMemberDeclaration_field = (String -> Name
Core.Name String
"field")

_StructMemberDeclaration_method :: Name
_StructMemberDeclaration_method = (String -> Name
Core.Name String
"method")

_StructMemberDeclaration_property :: Name
_StructMemberDeclaration_property = (String -> Name
Core.Name String
"property")

_StructMemberDeclaration_event :: Name
_StructMemberDeclaration_event = (String -> Name
Core.Name String
"event")

_StructMemberDeclaration_indexer :: Name
_StructMemberDeclaration_indexer = (String -> Name
Core.Name String
"indexer")

_StructMemberDeclaration_operator :: Name
_StructMemberDeclaration_operator = (String -> Name
Core.Name String
"operator")

_StructMemberDeclaration_constructor :: Name
_StructMemberDeclaration_constructor = (String -> Name
Core.Name String
"constructor")

_StructMemberDeclaration_staticConstructor :: Name
_StructMemberDeclaration_staticConstructor = (String -> Name
Core.Name String
"staticConstructor")

_StructMemberDeclaration_type :: Name
_StructMemberDeclaration_type = (String -> Name
Core.Name String
"type")

_StructMemberDeclaration_fixedSizeBuffer :: Name
_StructMemberDeclaration_fixedSizeBuffer = (String -> Name
Core.Name String
"fixedSizeBuffer")

newtype ArrayInitializer = 
  ArrayInitializer {
    ArrayInitializer -> [VariableInitializer]
unArrayInitializer :: [VariableInitializer]}
  deriving (ArrayInitializer -> ArrayInitializer -> Bool
(ArrayInitializer -> ArrayInitializer -> Bool)
-> (ArrayInitializer -> ArrayInitializer -> Bool)
-> Eq ArrayInitializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArrayInitializer -> ArrayInitializer -> Bool
== :: ArrayInitializer -> ArrayInitializer -> Bool
$c/= :: ArrayInitializer -> ArrayInitializer -> Bool
/= :: ArrayInitializer -> ArrayInitializer -> Bool
Eq, Eq ArrayInitializer
Eq ArrayInitializer =>
(ArrayInitializer -> ArrayInitializer -> Ordering)
-> (ArrayInitializer -> ArrayInitializer -> Bool)
-> (ArrayInitializer -> ArrayInitializer -> Bool)
-> (ArrayInitializer -> ArrayInitializer -> Bool)
-> (ArrayInitializer -> ArrayInitializer -> Bool)
-> (ArrayInitializer -> ArrayInitializer -> ArrayInitializer)
-> (ArrayInitializer -> ArrayInitializer -> ArrayInitializer)
-> Ord ArrayInitializer
ArrayInitializer -> ArrayInitializer -> Bool
ArrayInitializer -> ArrayInitializer -> Ordering
ArrayInitializer -> ArrayInitializer -> ArrayInitializer
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ArrayInitializer -> ArrayInitializer -> Ordering
compare :: ArrayInitializer -> ArrayInitializer -> Ordering
$c< :: ArrayInitializer -> ArrayInitializer -> Bool
< :: ArrayInitializer -> ArrayInitializer -> Bool
$c<= :: ArrayInitializer -> ArrayInitializer -> Bool
<= :: ArrayInitializer -> ArrayInitializer -> Bool
$c> :: ArrayInitializer -> ArrayInitializer -> Bool
> :: ArrayInitializer -> ArrayInitializer -> Bool
$c>= :: ArrayInitializer -> ArrayInitializer -> Bool
>= :: ArrayInitializer -> ArrayInitializer -> Bool
$cmax :: ArrayInitializer -> ArrayInitializer -> ArrayInitializer
max :: ArrayInitializer -> ArrayInitializer -> ArrayInitializer
$cmin :: ArrayInitializer -> ArrayInitializer -> ArrayInitializer
min :: ArrayInitializer -> ArrayInitializer -> ArrayInitializer
Ord, ReadPrec [ArrayInitializer]
ReadPrec ArrayInitializer
Int -> ReadS ArrayInitializer
ReadS [ArrayInitializer]
(Int -> ReadS ArrayInitializer)
-> ReadS [ArrayInitializer]
-> ReadPrec ArrayInitializer
-> ReadPrec [ArrayInitializer]
-> Read ArrayInitializer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ArrayInitializer
readsPrec :: Int -> ReadS ArrayInitializer
$creadList :: ReadS [ArrayInitializer]
readList :: ReadS [ArrayInitializer]
$creadPrec :: ReadPrec ArrayInitializer
readPrec :: ReadPrec ArrayInitializer
$creadListPrec :: ReadPrec [ArrayInitializer]
readListPrec :: ReadPrec [ArrayInitializer]
Read, Int -> ArrayInitializer -> String -> String
[ArrayInitializer] -> String -> String
ArrayInitializer -> String
(Int -> ArrayInitializer -> String -> String)
-> (ArrayInitializer -> String)
-> ([ArrayInitializer] -> String -> String)
-> Show ArrayInitializer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ArrayInitializer -> String -> String
showsPrec :: Int -> ArrayInitializer -> String -> String
$cshow :: ArrayInitializer -> String
show :: ArrayInitializer -> String
$cshowList :: [ArrayInitializer] -> String -> String
showList :: [ArrayInitializer] -> String -> String
Show)

_ArrayInitializer :: Name
_ArrayInitializer = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.ArrayInitializer")

data VariableInitializer = 
  VariableInitializerExpression Expression |
  VariableInitializerArray ArrayInitializer
  deriving (VariableInitializer -> VariableInitializer -> Bool
(VariableInitializer -> VariableInitializer -> Bool)
-> (VariableInitializer -> VariableInitializer -> Bool)
-> Eq VariableInitializer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariableInitializer -> VariableInitializer -> Bool
== :: VariableInitializer -> VariableInitializer -> Bool
$c/= :: VariableInitializer -> VariableInitializer -> Bool
/= :: VariableInitializer -> VariableInitializer -> Bool
Eq, Eq VariableInitializer
Eq VariableInitializer =>
(VariableInitializer -> VariableInitializer -> Ordering)
-> (VariableInitializer -> VariableInitializer -> Bool)
-> (VariableInitializer -> VariableInitializer -> Bool)
-> (VariableInitializer -> VariableInitializer -> Bool)
-> (VariableInitializer -> VariableInitializer -> Bool)
-> (VariableInitializer
    -> VariableInitializer -> VariableInitializer)
-> (VariableInitializer
    -> VariableInitializer -> VariableInitializer)
-> Ord VariableInitializer
VariableInitializer -> VariableInitializer -> Bool
VariableInitializer -> VariableInitializer -> Ordering
VariableInitializer -> VariableInitializer -> VariableInitializer
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VariableInitializer -> VariableInitializer -> Ordering
compare :: VariableInitializer -> VariableInitializer -> Ordering
$c< :: VariableInitializer -> VariableInitializer -> Bool
< :: VariableInitializer -> VariableInitializer -> Bool
$c<= :: VariableInitializer -> VariableInitializer -> Bool
<= :: VariableInitializer -> VariableInitializer -> Bool
$c> :: VariableInitializer -> VariableInitializer -> Bool
> :: VariableInitializer -> VariableInitializer -> Bool
$c>= :: VariableInitializer -> VariableInitializer -> Bool
>= :: VariableInitializer -> VariableInitializer -> Bool
$cmax :: VariableInitializer -> VariableInitializer -> VariableInitializer
max :: VariableInitializer -> VariableInitializer -> VariableInitializer
$cmin :: VariableInitializer -> VariableInitializer -> VariableInitializer
min :: VariableInitializer -> VariableInitializer -> VariableInitializer
Ord, ReadPrec [VariableInitializer]
ReadPrec VariableInitializer
Int -> ReadS VariableInitializer
ReadS [VariableInitializer]
(Int -> ReadS VariableInitializer)
-> ReadS [VariableInitializer]
-> ReadPrec VariableInitializer
-> ReadPrec [VariableInitializer]
-> Read VariableInitializer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VariableInitializer
readsPrec :: Int -> ReadS VariableInitializer
$creadList :: ReadS [VariableInitializer]
readList :: ReadS [VariableInitializer]
$creadPrec :: ReadPrec VariableInitializer
readPrec :: ReadPrec VariableInitializer
$creadListPrec :: ReadPrec [VariableInitializer]
readListPrec :: ReadPrec [VariableInitializer]
Read, Int -> VariableInitializer -> String -> String
[VariableInitializer] -> String -> String
VariableInitializer -> String
(Int -> VariableInitializer -> String -> String)
-> (VariableInitializer -> String)
-> ([VariableInitializer] -> String -> String)
-> Show VariableInitializer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VariableInitializer -> String -> String
showsPrec :: Int -> VariableInitializer -> String -> String
$cshow :: VariableInitializer -> String
show :: VariableInitializer -> String
$cshowList :: [VariableInitializer] -> String -> String
showList :: [VariableInitializer] -> String -> String
Show)

_VariableInitializer :: Name
_VariableInitializer = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.VariableInitializer")

_VariableInitializer_expression :: Name
_VariableInitializer_expression = (String -> Name
Core.Name String
"expression")

_VariableInitializer_array :: Name
_VariableInitializer_array = (String -> Name
Core.Name String
"array")

data InterfaceDeclaration = 
  InterfaceDeclaration {
    InterfaceDeclaration -> Maybe Attributes
interfaceDeclarationAttributes :: (Maybe Attributes),
    InterfaceDeclaration -> [InterfaceModifier]
interfaceDeclarationModifiers :: [InterfaceModifier],
    InterfaceDeclaration -> Bool
interfaceDeclarationPartial :: Bool,
    InterfaceDeclaration -> Identifier
interfaceDeclarationName :: Identifier,
    InterfaceDeclaration -> Maybe VariantTypeParameters
interfaceDeclarationParameters :: (Maybe VariantTypeParameters),
    InterfaceDeclaration -> [InterfaceType]
interfaceDeclarationBase :: [InterfaceType],
    InterfaceDeclaration -> [TypeParameterConstraintsClause]
interfaceDeclarationConstraints :: [TypeParameterConstraintsClause],
    InterfaceDeclaration -> [InterfaceMemberDeclaration]
interfaceDeclarationBody :: [InterfaceMemberDeclaration]}
  deriving (InterfaceDeclaration -> InterfaceDeclaration -> Bool
(InterfaceDeclaration -> InterfaceDeclaration -> Bool)
-> (InterfaceDeclaration -> InterfaceDeclaration -> Bool)
-> Eq InterfaceDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
== :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
$c/= :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
/= :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
Eq, Eq InterfaceDeclaration
Eq InterfaceDeclaration =>
(InterfaceDeclaration -> InterfaceDeclaration -> Ordering)
-> (InterfaceDeclaration -> InterfaceDeclaration -> Bool)
-> (InterfaceDeclaration -> InterfaceDeclaration -> Bool)
-> (InterfaceDeclaration -> InterfaceDeclaration -> Bool)
-> (InterfaceDeclaration -> InterfaceDeclaration -> Bool)
-> (InterfaceDeclaration
    -> InterfaceDeclaration -> InterfaceDeclaration)
-> (InterfaceDeclaration
    -> InterfaceDeclaration -> InterfaceDeclaration)
-> Ord InterfaceDeclaration
InterfaceDeclaration -> InterfaceDeclaration -> Bool
InterfaceDeclaration -> InterfaceDeclaration -> Ordering
InterfaceDeclaration
-> InterfaceDeclaration -> InterfaceDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterfaceDeclaration -> InterfaceDeclaration -> Ordering
compare :: InterfaceDeclaration -> InterfaceDeclaration -> Ordering
$c< :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
< :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
$c<= :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
<= :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
$c> :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
> :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
$c>= :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
>= :: InterfaceDeclaration -> InterfaceDeclaration -> Bool
$cmax :: InterfaceDeclaration
-> InterfaceDeclaration -> InterfaceDeclaration
max :: InterfaceDeclaration
-> InterfaceDeclaration -> InterfaceDeclaration
$cmin :: InterfaceDeclaration
-> InterfaceDeclaration -> InterfaceDeclaration
min :: InterfaceDeclaration
-> InterfaceDeclaration -> InterfaceDeclaration
Ord, ReadPrec [InterfaceDeclaration]
ReadPrec InterfaceDeclaration
Int -> ReadS InterfaceDeclaration
ReadS [InterfaceDeclaration]
(Int -> ReadS InterfaceDeclaration)
-> ReadS [InterfaceDeclaration]
-> ReadPrec InterfaceDeclaration
-> ReadPrec [InterfaceDeclaration]
-> Read InterfaceDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterfaceDeclaration
readsPrec :: Int -> ReadS InterfaceDeclaration
$creadList :: ReadS [InterfaceDeclaration]
readList :: ReadS [InterfaceDeclaration]
$creadPrec :: ReadPrec InterfaceDeclaration
readPrec :: ReadPrec InterfaceDeclaration
$creadListPrec :: ReadPrec [InterfaceDeclaration]
readListPrec :: ReadPrec [InterfaceDeclaration]
Read, Int -> InterfaceDeclaration -> String -> String
[InterfaceDeclaration] -> String -> String
InterfaceDeclaration -> String
(Int -> InterfaceDeclaration -> String -> String)
-> (InterfaceDeclaration -> String)
-> ([InterfaceDeclaration] -> String -> String)
-> Show InterfaceDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterfaceDeclaration -> String -> String
showsPrec :: Int -> InterfaceDeclaration -> String -> String
$cshow :: InterfaceDeclaration -> String
show :: InterfaceDeclaration -> String
$cshowList :: [InterfaceDeclaration] -> String -> String
showList :: [InterfaceDeclaration] -> String -> String
Show)

_InterfaceDeclaration :: Name
_InterfaceDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterfaceDeclaration")

_InterfaceDeclaration_attributes :: Name
_InterfaceDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_InterfaceDeclaration_modifiers :: Name
_InterfaceDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_InterfaceDeclaration_partial :: Name
_InterfaceDeclaration_partial = (String -> Name
Core.Name String
"partial")

_InterfaceDeclaration_name :: Name
_InterfaceDeclaration_name = (String -> Name
Core.Name String
"name")

_InterfaceDeclaration_parameters :: Name
_InterfaceDeclaration_parameters = (String -> Name
Core.Name String
"parameters")

_InterfaceDeclaration_base :: Name
_InterfaceDeclaration_base = (String -> Name
Core.Name String
"base")

_InterfaceDeclaration_constraints :: Name
_InterfaceDeclaration_constraints = (String -> Name
Core.Name String
"constraints")

_InterfaceDeclaration_body :: Name
_InterfaceDeclaration_body = (String -> Name
Core.Name String
"body")

data InterfaceModifier = 
  InterfaceModifierNew  |
  InterfaceModifierPublic  |
  InterfaceModifierProtected  |
  InterfaceModifierInternal  |
  InterfaceModifierPrivate  |
  InterfaceModifierUnsafe 
  deriving (InterfaceModifier -> InterfaceModifier -> Bool
(InterfaceModifier -> InterfaceModifier -> Bool)
-> (InterfaceModifier -> InterfaceModifier -> Bool)
-> Eq InterfaceModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterfaceModifier -> InterfaceModifier -> Bool
== :: InterfaceModifier -> InterfaceModifier -> Bool
$c/= :: InterfaceModifier -> InterfaceModifier -> Bool
/= :: InterfaceModifier -> InterfaceModifier -> Bool
Eq, Eq InterfaceModifier
Eq InterfaceModifier =>
(InterfaceModifier -> InterfaceModifier -> Ordering)
-> (InterfaceModifier -> InterfaceModifier -> Bool)
-> (InterfaceModifier -> InterfaceModifier -> Bool)
-> (InterfaceModifier -> InterfaceModifier -> Bool)
-> (InterfaceModifier -> InterfaceModifier -> Bool)
-> (InterfaceModifier -> InterfaceModifier -> InterfaceModifier)
-> (InterfaceModifier -> InterfaceModifier -> InterfaceModifier)
-> Ord InterfaceModifier
InterfaceModifier -> InterfaceModifier -> Bool
InterfaceModifier -> InterfaceModifier -> Ordering
InterfaceModifier -> InterfaceModifier -> InterfaceModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterfaceModifier -> InterfaceModifier -> Ordering
compare :: InterfaceModifier -> InterfaceModifier -> Ordering
$c< :: InterfaceModifier -> InterfaceModifier -> Bool
< :: InterfaceModifier -> InterfaceModifier -> Bool
$c<= :: InterfaceModifier -> InterfaceModifier -> Bool
<= :: InterfaceModifier -> InterfaceModifier -> Bool
$c> :: InterfaceModifier -> InterfaceModifier -> Bool
> :: InterfaceModifier -> InterfaceModifier -> Bool
$c>= :: InterfaceModifier -> InterfaceModifier -> Bool
>= :: InterfaceModifier -> InterfaceModifier -> Bool
$cmax :: InterfaceModifier -> InterfaceModifier -> InterfaceModifier
max :: InterfaceModifier -> InterfaceModifier -> InterfaceModifier
$cmin :: InterfaceModifier -> InterfaceModifier -> InterfaceModifier
min :: InterfaceModifier -> InterfaceModifier -> InterfaceModifier
Ord, ReadPrec [InterfaceModifier]
ReadPrec InterfaceModifier
Int -> ReadS InterfaceModifier
ReadS [InterfaceModifier]
(Int -> ReadS InterfaceModifier)
-> ReadS [InterfaceModifier]
-> ReadPrec InterfaceModifier
-> ReadPrec [InterfaceModifier]
-> Read InterfaceModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterfaceModifier
readsPrec :: Int -> ReadS InterfaceModifier
$creadList :: ReadS [InterfaceModifier]
readList :: ReadS [InterfaceModifier]
$creadPrec :: ReadPrec InterfaceModifier
readPrec :: ReadPrec InterfaceModifier
$creadListPrec :: ReadPrec [InterfaceModifier]
readListPrec :: ReadPrec [InterfaceModifier]
Read, Int -> InterfaceModifier -> String -> String
[InterfaceModifier] -> String -> String
InterfaceModifier -> String
(Int -> InterfaceModifier -> String -> String)
-> (InterfaceModifier -> String)
-> ([InterfaceModifier] -> String -> String)
-> Show InterfaceModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterfaceModifier -> String -> String
showsPrec :: Int -> InterfaceModifier -> String -> String
$cshow :: InterfaceModifier -> String
show :: InterfaceModifier -> String
$cshowList :: [InterfaceModifier] -> String -> String
showList :: [InterfaceModifier] -> String -> String
Show)

_InterfaceModifier :: Name
_InterfaceModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterfaceModifier")

_InterfaceModifier_new :: Name
_InterfaceModifier_new = (String -> Name
Core.Name String
"new")

_InterfaceModifier_public :: Name
_InterfaceModifier_public = (String -> Name
Core.Name String
"public")

_InterfaceModifier_protected :: Name
_InterfaceModifier_protected = (String -> Name
Core.Name String
"protected")

_InterfaceModifier_internal :: Name
_InterfaceModifier_internal = (String -> Name
Core.Name String
"internal")

_InterfaceModifier_private :: Name
_InterfaceModifier_private = (String -> Name
Core.Name String
"private")

_InterfaceModifier_unsafe :: Name
_InterfaceModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

newtype VariantTypeParameters = 
  VariantTypeParameters {
    VariantTypeParameters -> [VariantTypeParameter]
unVariantTypeParameters :: [VariantTypeParameter]}
  deriving (VariantTypeParameters -> VariantTypeParameters -> Bool
(VariantTypeParameters -> VariantTypeParameters -> Bool)
-> (VariantTypeParameters -> VariantTypeParameters -> Bool)
-> Eq VariantTypeParameters
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariantTypeParameters -> VariantTypeParameters -> Bool
== :: VariantTypeParameters -> VariantTypeParameters -> Bool
$c/= :: VariantTypeParameters -> VariantTypeParameters -> Bool
/= :: VariantTypeParameters -> VariantTypeParameters -> Bool
Eq, Eq VariantTypeParameters
Eq VariantTypeParameters =>
(VariantTypeParameters -> VariantTypeParameters -> Ordering)
-> (VariantTypeParameters -> VariantTypeParameters -> Bool)
-> (VariantTypeParameters -> VariantTypeParameters -> Bool)
-> (VariantTypeParameters -> VariantTypeParameters -> Bool)
-> (VariantTypeParameters -> VariantTypeParameters -> Bool)
-> (VariantTypeParameters
    -> VariantTypeParameters -> VariantTypeParameters)
-> (VariantTypeParameters
    -> VariantTypeParameters -> VariantTypeParameters)
-> Ord VariantTypeParameters
VariantTypeParameters -> VariantTypeParameters -> Bool
VariantTypeParameters -> VariantTypeParameters -> Ordering
VariantTypeParameters
-> VariantTypeParameters -> VariantTypeParameters
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VariantTypeParameters -> VariantTypeParameters -> Ordering
compare :: VariantTypeParameters -> VariantTypeParameters -> Ordering
$c< :: VariantTypeParameters -> VariantTypeParameters -> Bool
< :: VariantTypeParameters -> VariantTypeParameters -> Bool
$c<= :: VariantTypeParameters -> VariantTypeParameters -> Bool
<= :: VariantTypeParameters -> VariantTypeParameters -> Bool
$c> :: VariantTypeParameters -> VariantTypeParameters -> Bool
> :: VariantTypeParameters -> VariantTypeParameters -> Bool
$c>= :: VariantTypeParameters -> VariantTypeParameters -> Bool
>= :: VariantTypeParameters -> VariantTypeParameters -> Bool
$cmax :: VariantTypeParameters
-> VariantTypeParameters -> VariantTypeParameters
max :: VariantTypeParameters
-> VariantTypeParameters -> VariantTypeParameters
$cmin :: VariantTypeParameters
-> VariantTypeParameters -> VariantTypeParameters
min :: VariantTypeParameters
-> VariantTypeParameters -> VariantTypeParameters
Ord, ReadPrec [VariantTypeParameters]
ReadPrec VariantTypeParameters
Int -> ReadS VariantTypeParameters
ReadS [VariantTypeParameters]
(Int -> ReadS VariantTypeParameters)
-> ReadS [VariantTypeParameters]
-> ReadPrec VariantTypeParameters
-> ReadPrec [VariantTypeParameters]
-> Read VariantTypeParameters
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VariantTypeParameters
readsPrec :: Int -> ReadS VariantTypeParameters
$creadList :: ReadS [VariantTypeParameters]
readList :: ReadS [VariantTypeParameters]
$creadPrec :: ReadPrec VariantTypeParameters
readPrec :: ReadPrec VariantTypeParameters
$creadListPrec :: ReadPrec [VariantTypeParameters]
readListPrec :: ReadPrec [VariantTypeParameters]
Read, Int -> VariantTypeParameters -> String -> String
[VariantTypeParameters] -> String -> String
VariantTypeParameters -> String
(Int -> VariantTypeParameters -> String -> String)
-> (VariantTypeParameters -> String)
-> ([VariantTypeParameters] -> String -> String)
-> Show VariantTypeParameters
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VariantTypeParameters -> String -> String
showsPrec :: Int -> VariantTypeParameters -> String -> String
$cshow :: VariantTypeParameters -> String
show :: VariantTypeParameters -> String
$cshowList :: [VariantTypeParameters] -> String -> String
showList :: [VariantTypeParameters] -> String -> String
Show)

_VariantTypeParameters :: Name
_VariantTypeParameters = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.VariantTypeParameters")

data VariantTypeParameter = 
  VariantTypeParameter {
    VariantTypeParameter -> Maybe Attributes
variantTypeParameterAttributes :: (Maybe Attributes),
    VariantTypeParameter -> Maybe VarianceAnnotation
variantTypeParameterVariance :: (Maybe VarianceAnnotation),
    VariantTypeParameter -> TypeParameter
variantTypeParameterParameter :: TypeParameter}
  deriving (VariantTypeParameter -> VariantTypeParameter -> Bool
(VariantTypeParameter -> VariantTypeParameter -> Bool)
-> (VariantTypeParameter -> VariantTypeParameter -> Bool)
-> Eq VariantTypeParameter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VariantTypeParameter -> VariantTypeParameter -> Bool
== :: VariantTypeParameter -> VariantTypeParameter -> Bool
$c/= :: VariantTypeParameter -> VariantTypeParameter -> Bool
/= :: VariantTypeParameter -> VariantTypeParameter -> Bool
Eq, Eq VariantTypeParameter
Eq VariantTypeParameter =>
(VariantTypeParameter -> VariantTypeParameter -> Ordering)
-> (VariantTypeParameter -> VariantTypeParameter -> Bool)
-> (VariantTypeParameter -> VariantTypeParameter -> Bool)
-> (VariantTypeParameter -> VariantTypeParameter -> Bool)
-> (VariantTypeParameter -> VariantTypeParameter -> Bool)
-> (VariantTypeParameter
    -> VariantTypeParameter -> VariantTypeParameter)
-> (VariantTypeParameter
    -> VariantTypeParameter -> VariantTypeParameter)
-> Ord VariantTypeParameter
VariantTypeParameter -> VariantTypeParameter -> Bool
VariantTypeParameter -> VariantTypeParameter -> Ordering
VariantTypeParameter
-> VariantTypeParameter -> VariantTypeParameter
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VariantTypeParameter -> VariantTypeParameter -> Ordering
compare :: VariantTypeParameter -> VariantTypeParameter -> Ordering
$c< :: VariantTypeParameter -> VariantTypeParameter -> Bool
< :: VariantTypeParameter -> VariantTypeParameter -> Bool
$c<= :: VariantTypeParameter -> VariantTypeParameter -> Bool
<= :: VariantTypeParameter -> VariantTypeParameter -> Bool
$c> :: VariantTypeParameter -> VariantTypeParameter -> Bool
> :: VariantTypeParameter -> VariantTypeParameter -> Bool
$c>= :: VariantTypeParameter -> VariantTypeParameter -> Bool
>= :: VariantTypeParameter -> VariantTypeParameter -> Bool
$cmax :: VariantTypeParameter
-> VariantTypeParameter -> VariantTypeParameter
max :: VariantTypeParameter
-> VariantTypeParameter -> VariantTypeParameter
$cmin :: VariantTypeParameter
-> VariantTypeParameter -> VariantTypeParameter
min :: VariantTypeParameter
-> VariantTypeParameter -> VariantTypeParameter
Ord, ReadPrec [VariantTypeParameter]
ReadPrec VariantTypeParameter
Int -> ReadS VariantTypeParameter
ReadS [VariantTypeParameter]
(Int -> ReadS VariantTypeParameter)
-> ReadS [VariantTypeParameter]
-> ReadPrec VariantTypeParameter
-> ReadPrec [VariantTypeParameter]
-> Read VariantTypeParameter
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VariantTypeParameter
readsPrec :: Int -> ReadS VariantTypeParameter
$creadList :: ReadS [VariantTypeParameter]
readList :: ReadS [VariantTypeParameter]
$creadPrec :: ReadPrec VariantTypeParameter
readPrec :: ReadPrec VariantTypeParameter
$creadListPrec :: ReadPrec [VariantTypeParameter]
readListPrec :: ReadPrec [VariantTypeParameter]
Read, Int -> VariantTypeParameter -> String -> String
[VariantTypeParameter] -> String -> String
VariantTypeParameter -> String
(Int -> VariantTypeParameter -> String -> String)
-> (VariantTypeParameter -> String)
-> ([VariantTypeParameter] -> String -> String)
-> Show VariantTypeParameter
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VariantTypeParameter -> String -> String
showsPrec :: Int -> VariantTypeParameter -> String -> String
$cshow :: VariantTypeParameter -> String
show :: VariantTypeParameter -> String
$cshowList :: [VariantTypeParameter] -> String -> String
showList :: [VariantTypeParameter] -> String -> String
Show)

_VariantTypeParameter :: Name
_VariantTypeParameter = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.VariantTypeParameter")

_VariantTypeParameter_attributes :: Name
_VariantTypeParameter_attributes = (String -> Name
Core.Name String
"attributes")

_VariantTypeParameter_variance :: Name
_VariantTypeParameter_variance = (String -> Name
Core.Name String
"variance")

_VariantTypeParameter_parameter :: Name
_VariantTypeParameter_parameter = (String -> Name
Core.Name String
"parameter")

data VarianceAnnotation = 
  VarianceAnnotationIn  |
  VarianceAnnotationOut 
  deriving (VarianceAnnotation -> VarianceAnnotation -> Bool
(VarianceAnnotation -> VarianceAnnotation -> Bool)
-> (VarianceAnnotation -> VarianceAnnotation -> Bool)
-> Eq VarianceAnnotation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VarianceAnnotation -> VarianceAnnotation -> Bool
== :: VarianceAnnotation -> VarianceAnnotation -> Bool
$c/= :: VarianceAnnotation -> VarianceAnnotation -> Bool
/= :: VarianceAnnotation -> VarianceAnnotation -> Bool
Eq, Eq VarianceAnnotation
Eq VarianceAnnotation =>
(VarianceAnnotation -> VarianceAnnotation -> Ordering)
-> (VarianceAnnotation -> VarianceAnnotation -> Bool)
-> (VarianceAnnotation -> VarianceAnnotation -> Bool)
-> (VarianceAnnotation -> VarianceAnnotation -> Bool)
-> (VarianceAnnotation -> VarianceAnnotation -> Bool)
-> (VarianceAnnotation -> VarianceAnnotation -> VarianceAnnotation)
-> (VarianceAnnotation -> VarianceAnnotation -> VarianceAnnotation)
-> Ord VarianceAnnotation
VarianceAnnotation -> VarianceAnnotation -> Bool
VarianceAnnotation -> VarianceAnnotation -> Ordering
VarianceAnnotation -> VarianceAnnotation -> VarianceAnnotation
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: VarianceAnnotation -> VarianceAnnotation -> Ordering
compare :: VarianceAnnotation -> VarianceAnnotation -> Ordering
$c< :: VarianceAnnotation -> VarianceAnnotation -> Bool
< :: VarianceAnnotation -> VarianceAnnotation -> Bool
$c<= :: VarianceAnnotation -> VarianceAnnotation -> Bool
<= :: VarianceAnnotation -> VarianceAnnotation -> Bool
$c> :: VarianceAnnotation -> VarianceAnnotation -> Bool
> :: VarianceAnnotation -> VarianceAnnotation -> Bool
$c>= :: VarianceAnnotation -> VarianceAnnotation -> Bool
>= :: VarianceAnnotation -> VarianceAnnotation -> Bool
$cmax :: VarianceAnnotation -> VarianceAnnotation -> VarianceAnnotation
max :: VarianceAnnotation -> VarianceAnnotation -> VarianceAnnotation
$cmin :: VarianceAnnotation -> VarianceAnnotation -> VarianceAnnotation
min :: VarianceAnnotation -> VarianceAnnotation -> VarianceAnnotation
Ord, ReadPrec [VarianceAnnotation]
ReadPrec VarianceAnnotation
Int -> ReadS VarianceAnnotation
ReadS [VarianceAnnotation]
(Int -> ReadS VarianceAnnotation)
-> ReadS [VarianceAnnotation]
-> ReadPrec VarianceAnnotation
-> ReadPrec [VarianceAnnotation]
-> Read VarianceAnnotation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS VarianceAnnotation
readsPrec :: Int -> ReadS VarianceAnnotation
$creadList :: ReadS [VarianceAnnotation]
readList :: ReadS [VarianceAnnotation]
$creadPrec :: ReadPrec VarianceAnnotation
readPrec :: ReadPrec VarianceAnnotation
$creadListPrec :: ReadPrec [VarianceAnnotation]
readListPrec :: ReadPrec [VarianceAnnotation]
Read, Int -> VarianceAnnotation -> String -> String
[VarianceAnnotation] -> String -> String
VarianceAnnotation -> String
(Int -> VarianceAnnotation -> String -> String)
-> (VarianceAnnotation -> String)
-> ([VarianceAnnotation] -> String -> String)
-> Show VarianceAnnotation
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> VarianceAnnotation -> String -> String
showsPrec :: Int -> VarianceAnnotation -> String -> String
$cshow :: VarianceAnnotation -> String
show :: VarianceAnnotation -> String
$cshowList :: [VarianceAnnotation] -> String -> String
showList :: [VarianceAnnotation] -> String -> String
Show)

_VarianceAnnotation :: Name
_VarianceAnnotation = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.VarianceAnnotation")

_VarianceAnnotation_in :: Name
_VarianceAnnotation_in = (String -> Name
Core.Name String
"in")

_VarianceAnnotation_out :: Name
_VarianceAnnotation_out = (String -> Name
Core.Name String
"out")

data InterfaceMemberDeclaration = 
  InterfaceMemberDeclarationMethod InterfaceMethodDeclaration |
  InterfaceMemberDeclarationProperty InterfacePropertyDeclaration |
  InterfaceMemberDeclarationEvent InterfaceEventDeclaration |
  InterfaceMemberDeclarationIndexer InterfaceIndexerDeclaration
  deriving (InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
(InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool)
-> (InterfaceMemberDeclaration
    -> InterfaceMemberDeclaration -> Bool)
-> Eq InterfaceMemberDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
== :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
$c/= :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
/= :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
Eq, Eq InterfaceMemberDeclaration
Eq InterfaceMemberDeclaration =>
(InterfaceMemberDeclaration
 -> InterfaceMemberDeclaration -> Ordering)
-> (InterfaceMemberDeclaration
    -> InterfaceMemberDeclaration -> Bool)
-> (InterfaceMemberDeclaration
    -> InterfaceMemberDeclaration -> Bool)
-> (InterfaceMemberDeclaration
    -> InterfaceMemberDeclaration -> Bool)
-> (InterfaceMemberDeclaration
    -> InterfaceMemberDeclaration -> Bool)
-> (InterfaceMemberDeclaration
    -> InterfaceMemberDeclaration -> InterfaceMemberDeclaration)
-> (InterfaceMemberDeclaration
    -> InterfaceMemberDeclaration -> InterfaceMemberDeclaration)
-> Ord InterfaceMemberDeclaration
InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
InterfaceMemberDeclaration
-> InterfaceMemberDeclaration -> Ordering
InterfaceMemberDeclaration
-> InterfaceMemberDeclaration -> InterfaceMemberDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterfaceMemberDeclaration
-> InterfaceMemberDeclaration -> Ordering
compare :: InterfaceMemberDeclaration
-> InterfaceMemberDeclaration -> Ordering
$c< :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
< :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
$c<= :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
<= :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
$c> :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
> :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
$c>= :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
>= :: InterfaceMemberDeclaration -> InterfaceMemberDeclaration -> Bool
$cmax :: InterfaceMemberDeclaration
-> InterfaceMemberDeclaration -> InterfaceMemberDeclaration
max :: InterfaceMemberDeclaration
-> InterfaceMemberDeclaration -> InterfaceMemberDeclaration
$cmin :: InterfaceMemberDeclaration
-> InterfaceMemberDeclaration -> InterfaceMemberDeclaration
min :: InterfaceMemberDeclaration
-> InterfaceMemberDeclaration -> InterfaceMemberDeclaration
Ord, ReadPrec [InterfaceMemberDeclaration]
ReadPrec InterfaceMemberDeclaration
Int -> ReadS InterfaceMemberDeclaration
ReadS [InterfaceMemberDeclaration]
(Int -> ReadS InterfaceMemberDeclaration)
-> ReadS [InterfaceMemberDeclaration]
-> ReadPrec InterfaceMemberDeclaration
-> ReadPrec [InterfaceMemberDeclaration]
-> Read InterfaceMemberDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterfaceMemberDeclaration
readsPrec :: Int -> ReadS InterfaceMemberDeclaration
$creadList :: ReadS [InterfaceMemberDeclaration]
readList :: ReadS [InterfaceMemberDeclaration]
$creadPrec :: ReadPrec InterfaceMemberDeclaration
readPrec :: ReadPrec InterfaceMemberDeclaration
$creadListPrec :: ReadPrec [InterfaceMemberDeclaration]
readListPrec :: ReadPrec [InterfaceMemberDeclaration]
Read, Int -> InterfaceMemberDeclaration -> String -> String
[InterfaceMemberDeclaration] -> String -> String
InterfaceMemberDeclaration -> String
(Int -> InterfaceMemberDeclaration -> String -> String)
-> (InterfaceMemberDeclaration -> String)
-> ([InterfaceMemberDeclaration] -> String -> String)
-> Show InterfaceMemberDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterfaceMemberDeclaration -> String -> String
showsPrec :: Int -> InterfaceMemberDeclaration -> String -> String
$cshow :: InterfaceMemberDeclaration -> String
show :: InterfaceMemberDeclaration -> String
$cshowList :: [InterfaceMemberDeclaration] -> String -> String
showList :: [InterfaceMemberDeclaration] -> String -> String
Show)

_InterfaceMemberDeclaration :: Name
_InterfaceMemberDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterfaceMemberDeclaration")

_InterfaceMemberDeclaration_method :: Name
_InterfaceMemberDeclaration_method = (String -> Name
Core.Name String
"method")

_InterfaceMemberDeclaration_property :: Name
_InterfaceMemberDeclaration_property = (String -> Name
Core.Name String
"property")

_InterfaceMemberDeclaration_event :: Name
_InterfaceMemberDeclaration_event = (String -> Name
Core.Name String
"event")

_InterfaceMemberDeclaration_indexer :: Name
_InterfaceMemberDeclaration_indexer = (String -> Name
Core.Name String
"indexer")

data InterfaceMethodDeclaration = 
  InterfaceMethodDeclaration {
    InterfaceMethodDeclaration -> Maybe Attributes
interfaceMethodDeclarationAttributes :: (Maybe Attributes),
    InterfaceMethodDeclaration -> Bool
interfaceMethodDeclarationNew :: Bool,
    InterfaceMethodDeclaration -> ReturnType
interfaceMethodDeclarationReturnType :: ReturnType,
    InterfaceMethodDeclaration -> Maybe RefKind
interfaceMethodDeclarationRefKind :: (Maybe RefKind),
    InterfaceMethodDeclaration -> InterfaceMethodHeader
interfaceMethodDeclarationHeader :: InterfaceMethodHeader}
  deriving (InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
(InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool)
-> (InterfaceMethodDeclaration
    -> InterfaceMethodDeclaration -> Bool)
-> Eq InterfaceMethodDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
== :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
$c/= :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
/= :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
Eq, Eq InterfaceMethodDeclaration
Eq InterfaceMethodDeclaration =>
(InterfaceMethodDeclaration
 -> InterfaceMethodDeclaration -> Ordering)
-> (InterfaceMethodDeclaration
    -> InterfaceMethodDeclaration -> Bool)
-> (InterfaceMethodDeclaration
    -> InterfaceMethodDeclaration -> Bool)
-> (InterfaceMethodDeclaration
    -> InterfaceMethodDeclaration -> Bool)
-> (InterfaceMethodDeclaration
    -> InterfaceMethodDeclaration -> Bool)
-> (InterfaceMethodDeclaration
    -> InterfaceMethodDeclaration -> InterfaceMethodDeclaration)
-> (InterfaceMethodDeclaration
    -> InterfaceMethodDeclaration -> InterfaceMethodDeclaration)
-> Ord InterfaceMethodDeclaration
InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
InterfaceMethodDeclaration
-> InterfaceMethodDeclaration -> Ordering
InterfaceMethodDeclaration
-> InterfaceMethodDeclaration -> InterfaceMethodDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterfaceMethodDeclaration
-> InterfaceMethodDeclaration -> Ordering
compare :: InterfaceMethodDeclaration
-> InterfaceMethodDeclaration -> Ordering
$c< :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
< :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
$c<= :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
<= :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
$c> :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
> :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
$c>= :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
>= :: InterfaceMethodDeclaration -> InterfaceMethodDeclaration -> Bool
$cmax :: InterfaceMethodDeclaration
-> InterfaceMethodDeclaration -> InterfaceMethodDeclaration
max :: InterfaceMethodDeclaration
-> InterfaceMethodDeclaration -> InterfaceMethodDeclaration
$cmin :: InterfaceMethodDeclaration
-> InterfaceMethodDeclaration -> InterfaceMethodDeclaration
min :: InterfaceMethodDeclaration
-> InterfaceMethodDeclaration -> InterfaceMethodDeclaration
Ord, ReadPrec [InterfaceMethodDeclaration]
ReadPrec InterfaceMethodDeclaration
Int -> ReadS InterfaceMethodDeclaration
ReadS [InterfaceMethodDeclaration]
(Int -> ReadS InterfaceMethodDeclaration)
-> ReadS [InterfaceMethodDeclaration]
-> ReadPrec InterfaceMethodDeclaration
-> ReadPrec [InterfaceMethodDeclaration]
-> Read InterfaceMethodDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterfaceMethodDeclaration
readsPrec :: Int -> ReadS InterfaceMethodDeclaration
$creadList :: ReadS [InterfaceMethodDeclaration]
readList :: ReadS [InterfaceMethodDeclaration]
$creadPrec :: ReadPrec InterfaceMethodDeclaration
readPrec :: ReadPrec InterfaceMethodDeclaration
$creadListPrec :: ReadPrec [InterfaceMethodDeclaration]
readListPrec :: ReadPrec [InterfaceMethodDeclaration]
Read, Int -> InterfaceMethodDeclaration -> String -> String
[InterfaceMethodDeclaration] -> String -> String
InterfaceMethodDeclaration -> String
(Int -> InterfaceMethodDeclaration -> String -> String)
-> (InterfaceMethodDeclaration -> String)
-> ([InterfaceMethodDeclaration] -> String -> String)
-> Show InterfaceMethodDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterfaceMethodDeclaration -> String -> String
showsPrec :: Int -> InterfaceMethodDeclaration -> String -> String
$cshow :: InterfaceMethodDeclaration -> String
show :: InterfaceMethodDeclaration -> String
$cshowList :: [InterfaceMethodDeclaration] -> String -> String
showList :: [InterfaceMethodDeclaration] -> String -> String
Show)

_InterfaceMethodDeclaration :: Name
_InterfaceMethodDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterfaceMethodDeclaration")

_InterfaceMethodDeclaration_attributes :: Name
_InterfaceMethodDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_InterfaceMethodDeclaration_new :: Name
_InterfaceMethodDeclaration_new = (String -> Name
Core.Name String
"new")

_InterfaceMethodDeclaration_returnType :: Name
_InterfaceMethodDeclaration_returnType = (String -> Name
Core.Name String
"returnType")

_InterfaceMethodDeclaration_refKind :: Name
_InterfaceMethodDeclaration_refKind = (String -> Name
Core.Name String
"refKind")

_InterfaceMethodDeclaration_header :: Name
_InterfaceMethodDeclaration_header = (String -> Name
Core.Name String
"header")

data InterfaceMethodHeader = 
  InterfaceMethodHeader {
    InterfaceMethodHeader -> Identifier
interfaceMethodHeaderName :: Identifier,
    InterfaceMethodHeader -> Maybe FormalParameterList
interfaceMethodHeaderParameters :: (Maybe FormalParameterList),
    InterfaceMethodHeader -> Maybe TypeParameterList
interfaceMethodHeaderTypeParameters :: (Maybe TypeParameterList),
    InterfaceMethodHeader -> [TypeParameterConstraintsClause]
interfaceMethodHeaderConstraints :: [TypeParameterConstraintsClause]}
  deriving (InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
(InterfaceMethodHeader -> InterfaceMethodHeader -> Bool)
-> (InterfaceMethodHeader -> InterfaceMethodHeader -> Bool)
-> Eq InterfaceMethodHeader
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
== :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
$c/= :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
/= :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
Eq, Eq InterfaceMethodHeader
Eq InterfaceMethodHeader =>
(InterfaceMethodHeader -> InterfaceMethodHeader -> Ordering)
-> (InterfaceMethodHeader -> InterfaceMethodHeader -> Bool)
-> (InterfaceMethodHeader -> InterfaceMethodHeader -> Bool)
-> (InterfaceMethodHeader -> InterfaceMethodHeader -> Bool)
-> (InterfaceMethodHeader -> InterfaceMethodHeader -> Bool)
-> (InterfaceMethodHeader
    -> InterfaceMethodHeader -> InterfaceMethodHeader)
-> (InterfaceMethodHeader
    -> InterfaceMethodHeader -> InterfaceMethodHeader)
-> Ord InterfaceMethodHeader
InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
InterfaceMethodHeader -> InterfaceMethodHeader -> Ordering
InterfaceMethodHeader
-> InterfaceMethodHeader -> InterfaceMethodHeader
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterfaceMethodHeader -> InterfaceMethodHeader -> Ordering
compare :: InterfaceMethodHeader -> InterfaceMethodHeader -> Ordering
$c< :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
< :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
$c<= :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
<= :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
$c> :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
> :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
$c>= :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
>= :: InterfaceMethodHeader -> InterfaceMethodHeader -> Bool
$cmax :: InterfaceMethodHeader
-> InterfaceMethodHeader -> InterfaceMethodHeader
max :: InterfaceMethodHeader
-> InterfaceMethodHeader -> InterfaceMethodHeader
$cmin :: InterfaceMethodHeader
-> InterfaceMethodHeader -> InterfaceMethodHeader
min :: InterfaceMethodHeader
-> InterfaceMethodHeader -> InterfaceMethodHeader
Ord, ReadPrec [InterfaceMethodHeader]
ReadPrec InterfaceMethodHeader
Int -> ReadS InterfaceMethodHeader
ReadS [InterfaceMethodHeader]
(Int -> ReadS InterfaceMethodHeader)
-> ReadS [InterfaceMethodHeader]
-> ReadPrec InterfaceMethodHeader
-> ReadPrec [InterfaceMethodHeader]
-> Read InterfaceMethodHeader
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterfaceMethodHeader
readsPrec :: Int -> ReadS InterfaceMethodHeader
$creadList :: ReadS [InterfaceMethodHeader]
readList :: ReadS [InterfaceMethodHeader]
$creadPrec :: ReadPrec InterfaceMethodHeader
readPrec :: ReadPrec InterfaceMethodHeader
$creadListPrec :: ReadPrec [InterfaceMethodHeader]
readListPrec :: ReadPrec [InterfaceMethodHeader]
Read, Int -> InterfaceMethodHeader -> String -> String
[InterfaceMethodHeader] -> String -> String
InterfaceMethodHeader -> String
(Int -> InterfaceMethodHeader -> String -> String)
-> (InterfaceMethodHeader -> String)
-> ([InterfaceMethodHeader] -> String -> String)
-> Show InterfaceMethodHeader
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterfaceMethodHeader -> String -> String
showsPrec :: Int -> InterfaceMethodHeader -> String -> String
$cshow :: InterfaceMethodHeader -> String
show :: InterfaceMethodHeader -> String
$cshowList :: [InterfaceMethodHeader] -> String -> String
showList :: [InterfaceMethodHeader] -> String -> String
Show)

_InterfaceMethodHeader :: Name
_InterfaceMethodHeader = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterfaceMethodHeader")

_InterfaceMethodHeader_name :: Name
_InterfaceMethodHeader_name = (String -> Name
Core.Name String
"name")

_InterfaceMethodHeader_parameters :: Name
_InterfaceMethodHeader_parameters = (String -> Name
Core.Name String
"parameters")

_InterfaceMethodHeader_typeParameters :: Name
_InterfaceMethodHeader_typeParameters = (String -> Name
Core.Name String
"typeParameters")

_InterfaceMethodHeader_constraints :: Name
_InterfaceMethodHeader_constraints = (String -> Name
Core.Name String
"constraints")

data InterfacePropertyDeclaration = 
  InterfacePropertyDeclaration {
    InterfacePropertyDeclaration -> Maybe Attributes
interfacePropertyDeclarationAttributes :: (Maybe Attributes),
    InterfacePropertyDeclaration -> Bool
interfacePropertyDeclarationNew :: Bool,
    InterfacePropertyDeclaration -> Maybe RefKind
interfacePropertyDeclarationRefKind :: (Maybe RefKind),
    InterfacePropertyDeclaration -> Type
interfacePropertyDeclarationType :: Type,
    InterfacePropertyDeclaration -> Identifier
interfacePropertyDeclarationName :: Identifier,
    InterfacePropertyDeclaration -> InterfaceAccessors
interfacePropertyDeclarationAccessors :: InterfaceAccessors}
  deriving (InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
(InterfacePropertyDeclaration
 -> InterfacePropertyDeclaration -> Bool)
-> (InterfacePropertyDeclaration
    -> InterfacePropertyDeclaration -> Bool)
-> Eq InterfacePropertyDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
== :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
$c/= :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
/= :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
Eq, Eq InterfacePropertyDeclaration
Eq InterfacePropertyDeclaration =>
(InterfacePropertyDeclaration
 -> InterfacePropertyDeclaration -> Ordering)
-> (InterfacePropertyDeclaration
    -> InterfacePropertyDeclaration -> Bool)
-> (InterfacePropertyDeclaration
    -> InterfacePropertyDeclaration -> Bool)
-> (InterfacePropertyDeclaration
    -> InterfacePropertyDeclaration -> Bool)
-> (InterfacePropertyDeclaration
    -> InterfacePropertyDeclaration -> Bool)
-> (InterfacePropertyDeclaration
    -> InterfacePropertyDeclaration -> InterfacePropertyDeclaration)
-> (InterfacePropertyDeclaration
    -> InterfacePropertyDeclaration -> InterfacePropertyDeclaration)
-> Ord InterfacePropertyDeclaration
InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Ordering
InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> InterfacePropertyDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Ordering
compare :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Ordering
$c< :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
< :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
$c<= :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
<= :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
$c> :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
> :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
$c>= :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
>= :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> Bool
$cmax :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> InterfacePropertyDeclaration
max :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> InterfacePropertyDeclaration
$cmin :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> InterfacePropertyDeclaration
min :: InterfacePropertyDeclaration
-> InterfacePropertyDeclaration -> InterfacePropertyDeclaration
Ord, ReadPrec [InterfacePropertyDeclaration]
ReadPrec InterfacePropertyDeclaration
Int -> ReadS InterfacePropertyDeclaration
ReadS [InterfacePropertyDeclaration]
(Int -> ReadS InterfacePropertyDeclaration)
-> ReadS [InterfacePropertyDeclaration]
-> ReadPrec InterfacePropertyDeclaration
-> ReadPrec [InterfacePropertyDeclaration]
-> Read InterfacePropertyDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterfacePropertyDeclaration
readsPrec :: Int -> ReadS InterfacePropertyDeclaration
$creadList :: ReadS [InterfacePropertyDeclaration]
readList :: ReadS [InterfacePropertyDeclaration]
$creadPrec :: ReadPrec InterfacePropertyDeclaration
readPrec :: ReadPrec InterfacePropertyDeclaration
$creadListPrec :: ReadPrec [InterfacePropertyDeclaration]
readListPrec :: ReadPrec [InterfacePropertyDeclaration]
Read, Int -> InterfacePropertyDeclaration -> String -> String
[InterfacePropertyDeclaration] -> String -> String
InterfacePropertyDeclaration -> String
(Int -> InterfacePropertyDeclaration -> String -> String)
-> (InterfacePropertyDeclaration -> String)
-> ([InterfacePropertyDeclaration] -> String -> String)
-> Show InterfacePropertyDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterfacePropertyDeclaration -> String -> String
showsPrec :: Int -> InterfacePropertyDeclaration -> String -> String
$cshow :: InterfacePropertyDeclaration -> String
show :: InterfacePropertyDeclaration -> String
$cshowList :: [InterfacePropertyDeclaration] -> String -> String
showList :: [InterfacePropertyDeclaration] -> String -> String
Show)

_InterfacePropertyDeclaration :: Name
_InterfacePropertyDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterfacePropertyDeclaration")

_InterfacePropertyDeclaration_attributes :: Name
_InterfacePropertyDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_InterfacePropertyDeclaration_new :: Name
_InterfacePropertyDeclaration_new = (String -> Name
Core.Name String
"new")

_InterfacePropertyDeclaration_refKind :: Name
_InterfacePropertyDeclaration_refKind = (String -> Name
Core.Name String
"refKind")

_InterfacePropertyDeclaration_type :: Name
_InterfacePropertyDeclaration_type = (String -> Name
Core.Name String
"type")

_InterfacePropertyDeclaration_name :: Name
_InterfacePropertyDeclaration_name = (String -> Name
Core.Name String
"name")

_InterfacePropertyDeclaration_accessors :: Name
_InterfacePropertyDeclaration_accessors = (String -> Name
Core.Name String
"accessors")

data InterfaceAccessors = 
  InterfaceAccessors {
    InterfaceAccessors -> Maybe Attributes
interfaceAccessorsAttributes :: (Maybe Attributes),
    InterfaceAccessors -> Maybe Attributes
interfaceAccessorsGet :: (Maybe Attributes),
    InterfaceAccessors -> Maybe Attributes
interfaceAccessorsSet :: (Maybe Attributes)}
  deriving (InterfaceAccessors -> InterfaceAccessors -> Bool
(InterfaceAccessors -> InterfaceAccessors -> Bool)
-> (InterfaceAccessors -> InterfaceAccessors -> Bool)
-> Eq InterfaceAccessors
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterfaceAccessors -> InterfaceAccessors -> Bool
== :: InterfaceAccessors -> InterfaceAccessors -> Bool
$c/= :: InterfaceAccessors -> InterfaceAccessors -> Bool
/= :: InterfaceAccessors -> InterfaceAccessors -> Bool
Eq, Eq InterfaceAccessors
Eq InterfaceAccessors =>
(InterfaceAccessors -> InterfaceAccessors -> Ordering)
-> (InterfaceAccessors -> InterfaceAccessors -> Bool)
-> (InterfaceAccessors -> InterfaceAccessors -> Bool)
-> (InterfaceAccessors -> InterfaceAccessors -> Bool)
-> (InterfaceAccessors -> InterfaceAccessors -> Bool)
-> (InterfaceAccessors -> InterfaceAccessors -> InterfaceAccessors)
-> (InterfaceAccessors -> InterfaceAccessors -> InterfaceAccessors)
-> Ord InterfaceAccessors
InterfaceAccessors -> InterfaceAccessors -> Bool
InterfaceAccessors -> InterfaceAccessors -> Ordering
InterfaceAccessors -> InterfaceAccessors -> InterfaceAccessors
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterfaceAccessors -> InterfaceAccessors -> Ordering
compare :: InterfaceAccessors -> InterfaceAccessors -> Ordering
$c< :: InterfaceAccessors -> InterfaceAccessors -> Bool
< :: InterfaceAccessors -> InterfaceAccessors -> Bool
$c<= :: InterfaceAccessors -> InterfaceAccessors -> Bool
<= :: InterfaceAccessors -> InterfaceAccessors -> Bool
$c> :: InterfaceAccessors -> InterfaceAccessors -> Bool
> :: InterfaceAccessors -> InterfaceAccessors -> Bool
$c>= :: InterfaceAccessors -> InterfaceAccessors -> Bool
>= :: InterfaceAccessors -> InterfaceAccessors -> Bool
$cmax :: InterfaceAccessors -> InterfaceAccessors -> InterfaceAccessors
max :: InterfaceAccessors -> InterfaceAccessors -> InterfaceAccessors
$cmin :: InterfaceAccessors -> InterfaceAccessors -> InterfaceAccessors
min :: InterfaceAccessors -> InterfaceAccessors -> InterfaceAccessors
Ord, ReadPrec [InterfaceAccessors]
ReadPrec InterfaceAccessors
Int -> ReadS InterfaceAccessors
ReadS [InterfaceAccessors]
(Int -> ReadS InterfaceAccessors)
-> ReadS [InterfaceAccessors]
-> ReadPrec InterfaceAccessors
-> ReadPrec [InterfaceAccessors]
-> Read InterfaceAccessors
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterfaceAccessors
readsPrec :: Int -> ReadS InterfaceAccessors
$creadList :: ReadS [InterfaceAccessors]
readList :: ReadS [InterfaceAccessors]
$creadPrec :: ReadPrec InterfaceAccessors
readPrec :: ReadPrec InterfaceAccessors
$creadListPrec :: ReadPrec [InterfaceAccessors]
readListPrec :: ReadPrec [InterfaceAccessors]
Read, Int -> InterfaceAccessors -> String -> String
[InterfaceAccessors] -> String -> String
InterfaceAccessors -> String
(Int -> InterfaceAccessors -> String -> String)
-> (InterfaceAccessors -> String)
-> ([InterfaceAccessors] -> String -> String)
-> Show InterfaceAccessors
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterfaceAccessors -> String -> String
showsPrec :: Int -> InterfaceAccessors -> String -> String
$cshow :: InterfaceAccessors -> String
show :: InterfaceAccessors -> String
$cshowList :: [InterfaceAccessors] -> String -> String
showList :: [InterfaceAccessors] -> String -> String
Show)

_InterfaceAccessors :: Name
_InterfaceAccessors = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterfaceAccessors")

_InterfaceAccessors_attributes :: Name
_InterfaceAccessors_attributes = (String -> Name
Core.Name String
"attributes")

_InterfaceAccessors_get :: Name
_InterfaceAccessors_get = (String -> Name
Core.Name String
"get")

_InterfaceAccessors_set :: Name
_InterfaceAccessors_set = (String -> Name
Core.Name String
"set")

data InterfaceEventDeclaration = 
  InterfaceEventDeclaration {
    InterfaceEventDeclaration -> Maybe Attributes
interfaceEventDeclarationAttributes :: (Maybe Attributes),
    InterfaceEventDeclaration -> Bool
interfaceEventDeclarationNew :: Bool,
    InterfaceEventDeclaration -> Type
interfaceEventDeclarationType :: Type,
    InterfaceEventDeclaration -> Identifier
interfaceEventDeclarationName :: Identifier}
  deriving (InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
(InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool)
-> (InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool)
-> Eq InterfaceEventDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
== :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
$c/= :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
/= :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
Eq, Eq InterfaceEventDeclaration
Eq InterfaceEventDeclaration =>
(InterfaceEventDeclaration
 -> InterfaceEventDeclaration -> Ordering)
-> (InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool)
-> (InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool)
-> (InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool)
-> (InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool)
-> (InterfaceEventDeclaration
    -> InterfaceEventDeclaration -> InterfaceEventDeclaration)
-> (InterfaceEventDeclaration
    -> InterfaceEventDeclaration -> InterfaceEventDeclaration)
-> Ord InterfaceEventDeclaration
InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
InterfaceEventDeclaration -> InterfaceEventDeclaration -> Ordering
InterfaceEventDeclaration
-> InterfaceEventDeclaration -> InterfaceEventDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Ordering
compare :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Ordering
$c< :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
< :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
$c<= :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
<= :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
$c> :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
> :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
$c>= :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
>= :: InterfaceEventDeclaration -> InterfaceEventDeclaration -> Bool
$cmax :: InterfaceEventDeclaration
-> InterfaceEventDeclaration -> InterfaceEventDeclaration
max :: InterfaceEventDeclaration
-> InterfaceEventDeclaration -> InterfaceEventDeclaration
$cmin :: InterfaceEventDeclaration
-> InterfaceEventDeclaration -> InterfaceEventDeclaration
min :: InterfaceEventDeclaration
-> InterfaceEventDeclaration -> InterfaceEventDeclaration
Ord, ReadPrec [InterfaceEventDeclaration]
ReadPrec InterfaceEventDeclaration
Int -> ReadS InterfaceEventDeclaration
ReadS [InterfaceEventDeclaration]
(Int -> ReadS InterfaceEventDeclaration)
-> ReadS [InterfaceEventDeclaration]
-> ReadPrec InterfaceEventDeclaration
-> ReadPrec [InterfaceEventDeclaration]
-> Read InterfaceEventDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterfaceEventDeclaration
readsPrec :: Int -> ReadS InterfaceEventDeclaration
$creadList :: ReadS [InterfaceEventDeclaration]
readList :: ReadS [InterfaceEventDeclaration]
$creadPrec :: ReadPrec InterfaceEventDeclaration
readPrec :: ReadPrec InterfaceEventDeclaration
$creadListPrec :: ReadPrec [InterfaceEventDeclaration]
readListPrec :: ReadPrec [InterfaceEventDeclaration]
Read, Int -> InterfaceEventDeclaration -> String -> String
[InterfaceEventDeclaration] -> String -> String
InterfaceEventDeclaration -> String
(Int -> InterfaceEventDeclaration -> String -> String)
-> (InterfaceEventDeclaration -> String)
-> ([InterfaceEventDeclaration] -> String -> String)
-> Show InterfaceEventDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterfaceEventDeclaration -> String -> String
showsPrec :: Int -> InterfaceEventDeclaration -> String -> String
$cshow :: InterfaceEventDeclaration -> String
show :: InterfaceEventDeclaration -> String
$cshowList :: [InterfaceEventDeclaration] -> String -> String
showList :: [InterfaceEventDeclaration] -> String -> String
Show)

_InterfaceEventDeclaration :: Name
_InterfaceEventDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterfaceEventDeclaration")

_InterfaceEventDeclaration_attributes :: Name
_InterfaceEventDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_InterfaceEventDeclaration_new :: Name
_InterfaceEventDeclaration_new = (String -> Name
Core.Name String
"new")

_InterfaceEventDeclaration_type :: Name
_InterfaceEventDeclaration_type = (String -> Name
Core.Name String
"type")

_InterfaceEventDeclaration_name :: Name
_InterfaceEventDeclaration_name = (String -> Name
Core.Name String
"name")

data InterfaceIndexerDeclaration = 
  InterfaceIndexerDeclaration {
    InterfaceIndexerDeclaration -> Maybe Attributes
interfaceIndexerDeclarationAttributes :: (Maybe Attributes),
    InterfaceIndexerDeclaration -> Bool
interfaceIndexerDeclarationNew :: Bool,
    InterfaceIndexerDeclaration -> Maybe RefKind
interfaceIndexerDeclarationRefKind :: (Maybe RefKind),
    InterfaceIndexerDeclaration -> Type
interfaceIndexerDeclarationType :: Type,
    InterfaceIndexerDeclaration -> FormalParameterList
interfaceIndexerDeclarationParameters :: FormalParameterList,
    InterfaceIndexerDeclaration -> InterfaceAccessors
interfaceIndexerDeclarationAccessors :: InterfaceAccessors}
  deriving (InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
(InterfaceIndexerDeclaration
 -> InterfaceIndexerDeclaration -> Bool)
-> (InterfaceIndexerDeclaration
    -> InterfaceIndexerDeclaration -> Bool)
-> Eq InterfaceIndexerDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
== :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
$c/= :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
/= :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
Eq, Eq InterfaceIndexerDeclaration
Eq InterfaceIndexerDeclaration =>
(InterfaceIndexerDeclaration
 -> InterfaceIndexerDeclaration -> Ordering)
-> (InterfaceIndexerDeclaration
    -> InterfaceIndexerDeclaration -> Bool)
-> (InterfaceIndexerDeclaration
    -> InterfaceIndexerDeclaration -> Bool)
-> (InterfaceIndexerDeclaration
    -> InterfaceIndexerDeclaration -> Bool)
-> (InterfaceIndexerDeclaration
    -> InterfaceIndexerDeclaration -> Bool)
-> (InterfaceIndexerDeclaration
    -> InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration)
-> (InterfaceIndexerDeclaration
    -> InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration)
-> Ord InterfaceIndexerDeclaration
InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
InterfaceIndexerDeclaration
-> InterfaceIndexerDeclaration -> Ordering
InterfaceIndexerDeclaration
-> InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: InterfaceIndexerDeclaration
-> InterfaceIndexerDeclaration -> Ordering
compare :: InterfaceIndexerDeclaration
-> InterfaceIndexerDeclaration -> Ordering
$c< :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
< :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
$c<= :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
<= :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
$c> :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
> :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
$c>= :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
>= :: InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration -> Bool
$cmax :: InterfaceIndexerDeclaration
-> InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration
max :: InterfaceIndexerDeclaration
-> InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration
$cmin :: InterfaceIndexerDeclaration
-> InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration
min :: InterfaceIndexerDeclaration
-> InterfaceIndexerDeclaration -> InterfaceIndexerDeclaration
Ord, ReadPrec [InterfaceIndexerDeclaration]
ReadPrec InterfaceIndexerDeclaration
Int -> ReadS InterfaceIndexerDeclaration
ReadS [InterfaceIndexerDeclaration]
(Int -> ReadS InterfaceIndexerDeclaration)
-> ReadS [InterfaceIndexerDeclaration]
-> ReadPrec InterfaceIndexerDeclaration
-> ReadPrec [InterfaceIndexerDeclaration]
-> Read InterfaceIndexerDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS InterfaceIndexerDeclaration
readsPrec :: Int -> ReadS InterfaceIndexerDeclaration
$creadList :: ReadS [InterfaceIndexerDeclaration]
readList :: ReadS [InterfaceIndexerDeclaration]
$creadPrec :: ReadPrec InterfaceIndexerDeclaration
readPrec :: ReadPrec InterfaceIndexerDeclaration
$creadListPrec :: ReadPrec [InterfaceIndexerDeclaration]
readListPrec :: ReadPrec [InterfaceIndexerDeclaration]
Read, Int -> InterfaceIndexerDeclaration -> String -> String
[InterfaceIndexerDeclaration] -> String -> String
InterfaceIndexerDeclaration -> String
(Int -> InterfaceIndexerDeclaration -> String -> String)
-> (InterfaceIndexerDeclaration -> String)
-> ([InterfaceIndexerDeclaration] -> String -> String)
-> Show InterfaceIndexerDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> InterfaceIndexerDeclaration -> String -> String
showsPrec :: Int -> InterfaceIndexerDeclaration -> String -> String
$cshow :: InterfaceIndexerDeclaration -> String
show :: InterfaceIndexerDeclaration -> String
$cshowList :: [InterfaceIndexerDeclaration] -> String -> String
showList :: [InterfaceIndexerDeclaration] -> String -> String
Show)

_InterfaceIndexerDeclaration :: Name
_InterfaceIndexerDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.InterfaceIndexerDeclaration")

_InterfaceIndexerDeclaration_attributes :: Name
_InterfaceIndexerDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_InterfaceIndexerDeclaration_new :: Name
_InterfaceIndexerDeclaration_new = (String -> Name
Core.Name String
"new")

_InterfaceIndexerDeclaration_refKind :: Name
_InterfaceIndexerDeclaration_refKind = (String -> Name
Core.Name String
"refKind")

_InterfaceIndexerDeclaration_type :: Name
_InterfaceIndexerDeclaration_type = (String -> Name
Core.Name String
"type")

_InterfaceIndexerDeclaration_parameters :: Name
_InterfaceIndexerDeclaration_parameters = (String -> Name
Core.Name String
"parameters")

_InterfaceIndexerDeclaration_accessors :: Name
_InterfaceIndexerDeclaration_accessors = (String -> Name
Core.Name String
"accessors")

data EnumDeclaration = 
  EnumDeclaration {
    EnumDeclaration -> Maybe Attributes
enumDeclarationAttributes :: (Maybe Attributes),
    EnumDeclaration -> [EnumModifier]
enumDeclarationModifiers :: [EnumModifier],
    EnumDeclaration -> Identifier
enumDeclarationName :: Identifier,
    EnumDeclaration -> Maybe EnumBase
enumDeclarationBase :: (Maybe EnumBase),
    EnumDeclaration -> Maybe EnumBody
enumDeclarationBody :: (Maybe EnumBody)}
  deriving (EnumDeclaration -> EnumDeclaration -> Bool
(EnumDeclaration -> EnumDeclaration -> Bool)
-> (EnumDeclaration -> EnumDeclaration -> Bool)
-> Eq EnumDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnumDeclaration -> EnumDeclaration -> Bool
== :: EnumDeclaration -> EnumDeclaration -> Bool
$c/= :: EnumDeclaration -> EnumDeclaration -> Bool
/= :: EnumDeclaration -> EnumDeclaration -> Bool
Eq, Eq EnumDeclaration
Eq EnumDeclaration =>
(EnumDeclaration -> EnumDeclaration -> Ordering)
-> (EnumDeclaration -> EnumDeclaration -> Bool)
-> (EnumDeclaration -> EnumDeclaration -> Bool)
-> (EnumDeclaration -> EnumDeclaration -> Bool)
-> (EnumDeclaration -> EnumDeclaration -> Bool)
-> (EnumDeclaration -> EnumDeclaration -> EnumDeclaration)
-> (EnumDeclaration -> EnumDeclaration -> EnumDeclaration)
-> Ord EnumDeclaration
EnumDeclaration -> EnumDeclaration -> Bool
EnumDeclaration -> EnumDeclaration -> Ordering
EnumDeclaration -> EnumDeclaration -> EnumDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EnumDeclaration -> EnumDeclaration -> Ordering
compare :: EnumDeclaration -> EnumDeclaration -> Ordering
$c< :: EnumDeclaration -> EnumDeclaration -> Bool
< :: EnumDeclaration -> EnumDeclaration -> Bool
$c<= :: EnumDeclaration -> EnumDeclaration -> Bool
<= :: EnumDeclaration -> EnumDeclaration -> Bool
$c> :: EnumDeclaration -> EnumDeclaration -> Bool
> :: EnumDeclaration -> EnumDeclaration -> Bool
$c>= :: EnumDeclaration -> EnumDeclaration -> Bool
>= :: EnumDeclaration -> EnumDeclaration -> Bool
$cmax :: EnumDeclaration -> EnumDeclaration -> EnumDeclaration
max :: EnumDeclaration -> EnumDeclaration -> EnumDeclaration
$cmin :: EnumDeclaration -> EnumDeclaration -> EnumDeclaration
min :: EnumDeclaration -> EnumDeclaration -> EnumDeclaration
Ord, ReadPrec [EnumDeclaration]
ReadPrec EnumDeclaration
Int -> ReadS EnumDeclaration
ReadS [EnumDeclaration]
(Int -> ReadS EnumDeclaration)
-> ReadS [EnumDeclaration]
-> ReadPrec EnumDeclaration
-> ReadPrec [EnumDeclaration]
-> Read EnumDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EnumDeclaration
readsPrec :: Int -> ReadS EnumDeclaration
$creadList :: ReadS [EnumDeclaration]
readList :: ReadS [EnumDeclaration]
$creadPrec :: ReadPrec EnumDeclaration
readPrec :: ReadPrec EnumDeclaration
$creadListPrec :: ReadPrec [EnumDeclaration]
readListPrec :: ReadPrec [EnumDeclaration]
Read, Int -> EnumDeclaration -> String -> String
[EnumDeclaration] -> String -> String
EnumDeclaration -> String
(Int -> EnumDeclaration -> String -> String)
-> (EnumDeclaration -> String)
-> ([EnumDeclaration] -> String -> String)
-> Show EnumDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EnumDeclaration -> String -> String
showsPrec :: Int -> EnumDeclaration -> String -> String
$cshow :: EnumDeclaration -> String
show :: EnumDeclaration -> String
$cshowList :: [EnumDeclaration] -> String -> String
showList :: [EnumDeclaration] -> String -> String
Show)

_EnumDeclaration :: Name
_EnumDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EnumDeclaration")

_EnumDeclaration_attributes :: Name
_EnumDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_EnumDeclaration_modifiers :: Name
_EnumDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_EnumDeclaration_name :: Name
_EnumDeclaration_name = (String -> Name
Core.Name String
"name")

_EnumDeclaration_base :: Name
_EnumDeclaration_base = (String -> Name
Core.Name String
"base")

_EnumDeclaration_body :: Name
_EnumDeclaration_body = (String -> Name
Core.Name String
"body")

data EnumBase = 
  EnumBaseType IntegralType |
  EnumBaseName TypeName
  deriving (EnumBase -> EnumBase -> Bool
(EnumBase -> EnumBase -> Bool)
-> (EnumBase -> EnumBase -> Bool) -> Eq EnumBase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnumBase -> EnumBase -> Bool
== :: EnumBase -> EnumBase -> Bool
$c/= :: EnumBase -> EnumBase -> Bool
/= :: EnumBase -> EnumBase -> Bool
Eq, Eq EnumBase
Eq EnumBase =>
(EnumBase -> EnumBase -> Ordering)
-> (EnumBase -> EnumBase -> Bool)
-> (EnumBase -> EnumBase -> Bool)
-> (EnumBase -> EnumBase -> Bool)
-> (EnumBase -> EnumBase -> Bool)
-> (EnumBase -> EnumBase -> EnumBase)
-> (EnumBase -> EnumBase -> EnumBase)
-> Ord EnumBase
EnumBase -> EnumBase -> Bool
EnumBase -> EnumBase -> Ordering
EnumBase -> EnumBase -> EnumBase
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EnumBase -> EnumBase -> Ordering
compare :: EnumBase -> EnumBase -> Ordering
$c< :: EnumBase -> EnumBase -> Bool
< :: EnumBase -> EnumBase -> Bool
$c<= :: EnumBase -> EnumBase -> Bool
<= :: EnumBase -> EnumBase -> Bool
$c> :: EnumBase -> EnumBase -> Bool
> :: EnumBase -> EnumBase -> Bool
$c>= :: EnumBase -> EnumBase -> Bool
>= :: EnumBase -> EnumBase -> Bool
$cmax :: EnumBase -> EnumBase -> EnumBase
max :: EnumBase -> EnumBase -> EnumBase
$cmin :: EnumBase -> EnumBase -> EnumBase
min :: EnumBase -> EnumBase -> EnumBase
Ord, ReadPrec [EnumBase]
ReadPrec EnumBase
Int -> ReadS EnumBase
ReadS [EnumBase]
(Int -> ReadS EnumBase)
-> ReadS [EnumBase]
-> ReadPrec EnumBase
-> ReadPrec [EnumBase]
-> Read EnumBase
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EnumBase
readsPrec :: Int -> ReadS EnumBase
$creadList :: ReadS [EnumBase]
readList :: ReadS [EnumBase]
$creadPrec :: ReadPrec EnumBase
readPrec :: ReadPrec EnumBase
$creadListPrec :: ReadPrec [EnumBase]
readListPrec :: ReadPrec [EnumBase]
Read, Int -> EnumBase -> String -> String
[EnumBase] -> String -> String
EnumBase -> String
(Int -> EnumBase -> String -> String)
-> (EnumBase -> String)
-> ([EnumBase] -> String -> String)
-> Show EnumBase
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EnumBase -> String -> String
showsPrec :: Int -> EnumBase -> String -> String
$cshow :: EnumBase -> String
show :: EnumBase -> String
$cshowList :: [EnumBase] -> String -> String
showList :: [EnumBase] -> String -> String
Show)

_EnumBase :: Name
_EnumBase = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EnumBase")

_EnumBase_type :: Name
_EnumBase_type = (String -> Name
Core.Name String
"type")

_EnumBase_name :: Name
_EnumBase_name = (String -> Name
Core.Name String
"name")

newtype EnumBody = 
  EnumBody {
    EnumBody -> [EnumMemberDeclaration]
unEnumBody :: [EnumMemberDeclaration]}
  deriving (EnumBody -> EnumBody -> Bool
(EnumBody -> EnumBody -> Bool)
-> (EnumBody -> EnumBody -> Bool) -> Eq EnumBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnumBody -> EnumBody -> Bool
== :: EnumBody -> EnumBody -> Bool
$c/= :: EnumBody -> EnumBody -> Bool
/= :: EnumBody -> EnumBody -> Bool
Eq, Eq EnumBody
Eq EnumBody =>
(EnumBody -> EnumBody -> Ordering)
-> (EnumBody -> EnumBody -> Bool)
-> (EnumBody -> EnumBody -> Bool)
-> (EnumBody -> EnumBody -> Bool)
-> (EnumBody -> EnumBody -> Bool)
-> (EnumBody -> EnumBody -> EnumBody)
-> (EnumBody -> EnumBody -> EnumBody)
-> Ord EnumBody
EnumBody -> EnumBody -> Bool
EnumBody -> EnumBody -> Ordering
EnumBody -> EnumBody -> EnumBody
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EnumBody -> EnumBody -> Ordering
compare :: EnumBody -> EnumBody -> Ordering
$c< :: EnumBody -> EnumBody -> Bool
< :: EnumBody -> EnumBody -> Bool
$c<= :: EnumBody -> EnumBody -> Bool
<= :: EnumBody -> EnumBody -> Bool
$c> :: EnumBody -> EnumBody -> Bool
> :: EnumBody -> EnumBody -> Bool
$c>= :: EnumBody -> EnumBody -> Bool
>= :: EnumBody -> EnumBody -> Bool
$cmax :: EnumBody -> EnumBody -> EnumBody
max :: EnumBody -> EnumBody -> EnumBody
$cmin :: EnumBody -> EnumBody -> EnumBody
min :: EnumBody -> EnumBody -> EnumBody
Ord, ReadPrec [EnumBody]
ReadPrec EnumBody
Int -> ReadS EnumBody
ReadS [EnumBody]
(Int -> ReadS EnumBody)
-> ReadS [EnumBody]
-> ReadPrec EnumBody
-> ReadPrec [EnumBody]
-> Read EnumBody
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EnumBody
readsPrec :: Int -> ReadS EnumBody
$creadList :: ReadS [EnumBody]
readList :: ReadS [EnumBody]
$creadPrec :: ReadPrec EnumBody
readPrec :: ReadPrec EnumBody
$creadListPrec :: ReadPrec [EnumBody]
readListPrec :: ReadPrec [EnumBody]
Read, Int -> EnumBody -> String -> String
[EnumBody] -> String -> String
EnumBody -> String
(Int -> EnumBody -> String -> String)
-> (EnumBody -> String)
-> ([EnumBody] -> String -> String)
-> Show EnumBody
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EnumBody -> String -> String
showsPrec :: Int -> EnumBody -> String -> String
$cshow :: EnumBody -> String
show :: EnumBody -> String
$cshowList :: [EnumBody] -> String -> String
showList :: [EnumBody] -> String -> String
Show)

_EnumBody :: Name
_EnumBody = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EnumBody")

data EnumModifier = 
  EnumModifierNew  |
  EnumModifierPublic  |
  EnumModifierProtected  |
  EnumModifierInternal  |
  EnumModifierPrivate 
  deriving (EnumModifier -> EnumModifier -> Bool
(EnumModifier -> EnumModifier -> Bool)
-> (EnumModifier -> EnumModifier -> Bool) -> Eq EnumModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnumModifier -> EnumModifier -> Bool
== :: EnumModifier -> EnumModifier -> Bool
$c/= :: EnumModifier -> EnumModifier -> Bool
/= :: EnumModifier -> EnumModifier -> Bool
Eq, Eq EnumModifier
Eq EnumModifier =>
(EnumModifier -> EnumModifier -> Ordering)
-> (EnumModifier -> EnumModifier -> Bool)
-> (EnumModifier -> EnumModifier -> Bool)
-> (EnumModifier -> EnumModifier -> Bool)
-> (EnumModifier -> EnumModifier -> Bool)
-> (EnumModifier -> EnumModifier -> EnumModifier)
-> (EnumModifier -> EnumModifier -> EnumModifier)
-> Ord EnumModifier
EnumModifier -> EnumModifier -> Bool
EnumModifier -> EnumModifier -> Ordering
EnumModifier -> EnumModifier -> EnumModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EnumModifier -> EnumModifier -> Ordering
compare :: EnumModifier -> EnumModifier -> Ordering
$c< :: EnumModifier -> EnumModifier -> Bool
< :: EnumModifier -> EnumModifier -> Bool
$c<= :: EnumModifier -> EnumModifier -> Bool
<= :: EnumModifier -> EnumModifier -> Bool
$c> :: EnumModifier -> EnumModifier -> Bool
> :: EnumModifier -> EnumModifier -> Bool
$c>= :: EnumModifier -> EnumModifier -> Bool
>= :: EnumModifier -> EnumModifier -> Bool
$cmax :: EnumModifier -> EnumModifier -> EnumModifier
max :: EnumModifier -> EnumModifier -> EnumModifier
$cmin :: EnumModifier -> EnumModifier -> EnumModifier
min :: EnumModifier -> EnumModifier -> EnumModifier
Ord, ReadPrec [EnumModifier]
ReadPrec EnumModifier
Int -> ReadS EnumModifier
ReadS [EnumModifier]
(Int -> ReadS EnumModifier)
-> ReadS [EnumModifier]
-> ReadPrec EnumModifier
-> ReadPrec [EnumModifier]
-> Read EnumModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EnumModifier
readsPrec :: Int -> ReadS EnumModifier
$creadList :: ReadS [EnumModifier]
readList :: ReadS [EnumModifier]
$creadPrec :: ReadPrec EnumModifier
readPrec :: ReadPrec EnumModifier
$creadListPrec :: ReadPrec [EnumModifier]
readListPrec :: ReadPrec [EnumModifier]
Read, Int -> EnumModifier -> String -> String
[EnumModifier] -> String -> String
EnumModifier -> String
(Int -> EnumModifier -> String -> String)
-> (EnumModifier -> String)
-> ([EnumModifier] -> String -> String)
-> Show EnumModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EnumModifier -> String -> String
showsPrec :: Int -> EnumModifier -> String -> String
$cshow :: EnumModifier -> String
show :: EnumModifier -> String
$cshowList :: [EnumModifier] -> String -> String
showList :: [EnumModifier] -> String -> String
Show)

_EnumModifier :: Name
_EnumModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EnumModifier")

_EnumModifier_new :: Name
_EnumModifier_new = (String -> Name
Core.Name String
"new")

_EnumModifier_public :: Name
_EnumModifier_public = (String -> Name
Core.Name String
"public")

_EnumModifier_protected :: Name
_EnumModifier_protected = (String -> Name
Core.Name String
"protected")

_EnumModifier_internal :: Name
_EnumModifier_internal = (String -> Name
Core.Name String
"internal")

_EnumModifier_private :: Name
_EnumModifier_private = (String -> Name
Core.Name String
"private")

data EnumMemberDeclaration = 
  EnumMemberDeclaration {
    EnumMemberDeclaration -> Maybe Attributes
enumMemberDeclarationAttributes :: (Maybe Attributes),
    EnumMemberDeclaration -> Identifier
enumMemberDeclarationName :: Identifier,
    EnumMemberDeclaration -> Maybe ConstantExpression
enumMemberDeclarationValue :: (Maybe ConstantExpression)}
  deriving (EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
(EnumMemberDeclaration -> EnumMemberDeclaration -> Bool)
-> (EnumMemberDeclaration -> EnumMemberDeclaration -> Bool)
-> Eq EnumMemberDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
== :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
$c/= :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
/= :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
Eq, Eq EnumMemberDeclaration
Eq EnumMemberDeclaration =>
(EnumMemberDeclaration -> EnumMemberDeclaration -> Ordering)
-> (EnumMemberDeclaration -> EnumMemberDeclaration -> Bool)
-> (EnumMemberDeclaration -> EnumMemberDeclaration -> Bool)
-> (EnumMemberDeclaration -> EnumMemberDeclaration -> Bool)
-> (EnumMemberDeclaration -> EnumMemberDeclaration -> Bool)
-> (EnumMemberDeclaration
    -> EnumMemberDeclaration -> EnumMemberDeclaration)
-> (EnumMemberDeclaration
    -> EnumMemberDeclaration -> EnumMemberDeclaration)
-> Ord EnumMemberDeclaration
EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
EnumMemberDeclaration -> EnumMemberDeclaration -> Ordering
EnumMemberDeclaration
-> EnumMemberDeclaration -> EnumMemberDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EnumMemberDeclaration -> EnumMemberDeclaration -> Ordering
compare :: EnumMemberDeclaration -> EnumMemberDeclaration -> Ordering
$c< :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
< :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
$c<= :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
<= :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
$c> :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
> :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
$c>= :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
>= :: EnumMemberDeclaration -> EnumMemberDeclaration -> Bool
$cmax :: EnumMemberDeclaration
-> EnumMemberDeclaration -> EnumMemberDeclaration
max :: EnumMemberDeclaration
-> EnumMemberDeclaration -> EnumMemberDeclaration
$cmin :: EnumMemberDeclaration
-> EnumMemberDeclaration -> EnumMemberDeclaration
min :: EnumMemberDeclaration
-> EnumMemberDeclaration -> EnumMemberDeclaration
Ord, ReadPrec [EnumMemberDeclaration]
ReadPrec EnumMemberDeclaration
Int -> ReadS EnumMemberDeclaration
ReadS [EnumMemberDeclaration]
(Int -> ReadS EnumMemberDeclaration)
-> ReadS [EnumMemberDeclaration]
-> ReadPrec EnumMemberDeclaration
-> ReadPrec [EnumMemberDeclaration]
-> Read EnumMemberDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS EnumMemberDeclaration
readsPrec :: Int -> ReadS EnumMemberDeclaration
$creadList :: ReadS [EnumMemberDeclaration]
readList :: ReadS [EnumMemberDeclaration]
$creadPrec :: ReadPrec EnumMemberDeclaration
readPrec :: ReadPrec EnumMemberDeclaration
$creadListPrec :: ReadPrec [EnumMemberDeclaration]
readListPrec :: ReadPrec [EnumMemberDeclaration]
Read, Int -> EnumMemberDeclaration -> String -> String
[EnumMemberDeclaration] -> String -> String
EnumMemberDeclaration -> String
(Int -> EnumMemberDeclaration -> String -> String)
-> (EnumMemberDeclaration -> String)
-> ([EnumMemberDeclaration] -> String -> String)
-> Show EnumMemberDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> EnumMemberDeclaration -> String -> String
showsPrec :: Int -> EnumMemberDeclaration -> String -> String
$cshow :: EnumMemberDeclaration -> String
show :: EnumMemberDeclaration -> String
$cshowList :: [EnumMemberDeclaration] -> String -> String
showList :: [EnumMemberDeclaration] -> String -> String
Show)

_EnumMemberDeclaration :: Name
_EnumMemberDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.EnumMemberDeclaration")

_EnumMemberDeclaration_attributes :: Name
_EnumMemberDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_EnumMemberDeclaration_name :: Name
_EnumMemberDeclaration_name = (String -> Name
Core.Name String
"name")

_EnumMemberDeclaration_value :: Name
_EnumMemberDeclaration_value = (String -> Name
Core.Name String
"value")

data DelegateDeclaration = 
  DelegateDeclaration {
    DelegateDeclaration -> Maybe Attributes
delegateDeclarationAttributes :: (Maybe Attributes),
    DelegateDeclaration -> [DelegateModifier]
delegateDeclarationModifiers :: [DelegateModifier],
    DelegateDeclaration -> ReturnType
delegateDeclarationReturnType :: ReturnType,
    DelegateDeclaration -> Maybe RefKind
delegateDeclarationRefKind :: (Maybe RefKind),
    DelegateDeclaration -> Maybe Type
delegateDeclarationRefReturnType :: (Maybe Type),
    DelegateDeclaration -> DelegateHeader
delegateDeclarationHeader :: DelegateHeader}
  deriving (DelegateDeclaration -> DelegateDeclaration -> Bool
(DelegateDeclaration -> DelegateDeclaration -> Bool)
-> (DelegateDeclaration -> DelegateDeclaration -> Bool)
-> Eq DelegateDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DelegateDeclaration -> DelegateDeclaration -> Bool
== :: DelegateDeclaration -> DelegateDeclaration -> Bool
$c/= :: DelegateDeclaration -> DelegateDeclaration -> Bool
/= :: DelegateDeclaration -> DelegateDeclaration -> Bool
Eq, Eq DelegateDeclaration
Eq DelegateDeclaration =>
(DelegateDeclaration -> DelegateDeclaration -> Ordering)
-> (DelegateDeclaration -> DelegateDeclaration -> Bool)
-> (DelegateDeclaration -> DelegateDeclaration -> Bool)
-> (DelegateDeclaration -> DelegateDeclaration -> Bool)
-> (DelegateDeclaration -> DelegateDeclaration -> Bool)
-> (DelegateDeclaration
    -> DelegateDeclaration -> DelegateDeclaration)
-> (DelegateDeclaration
    -> DelegateDeclaration -> DelegateDeclaration)
-> Ord DelegateDeclaration
DelegateDeclaration -> DelegateDeclaration -> Bool
DelegateDeclaration -> DelegateDeclaration -> Ordering
DelegateDeclaration -> DelegateDeclaration -> DelegateDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DelegateDeclaration -> DelegateDeclaration -> Ordering
compare :: DelegateDeclaration -> DelegateDeclaration -> Ordering
$c< :: DelegateDeclaration -> DelegateDeclaration -> Bool
< :: DelegateDeclaration -> DelegateDeclaration -> Bool
$c<= :: DelegateDeclaration -> DelegateDeclaration -> Bool
<= :: DelegateDeclaration -> DelegateDeclaration -> Bool
$c> :: DelegateDeclaration -> DelegateDeclaration -> Bool
> :: DelegateDeclaration -> DelegateDeclaration -> Bool
$c>= :: DelegateDeclaration -> DelegateDeclaration -> Bool
>= :: DelegateDeclaration -> DelegateDeclaration -> Bool
$cmax :: DelegateDeclaration -> DelegateDeclaration -> DelegateDeclaration
max :: DelegateDeclaration -> DelegateDeclaration -> DelegateDeclaration
$cmin :: DelegateDeclaration -> DelegateDeclaration -> DelegateDeclaration
min :: DelegateDeclaration -> DelegateDeclaration -> DelegateDeclaration
Ord, ReadPrec [DelegateDeclaration]
ReadPrec DelegateDeclaration
Int -> ReadS DelegateDeclaration
ReadS [DelegateDeclaration]
(Int -> ReadS DelegateDeclaration)
-> ReadS [DelegateDeclaration]
-> ReadPrec DelegateDeclaration
-> ReadPrec [DelegateDeclaration]
-> Read DelegateDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DelegateDeclaration
readsPrec :: Int -> ReadS DelegateDeclaration
$creadList :: ReadS [DelegateDeclaration]
readList :: ReadS [DelegateDeclaration]
$creadPrec :: ReadPrec DelegateDeclaration
readPrec :: ReadPrec DelegateDeclaration
$creadListPrec :: ReadPrec [DelegateDeclaration]
readListPrec :: ReadPrec [DelegateDeclaration]
Read, Int -> DelegateDeclaration -> String -> String
[DelegateDeclaration] -> String -> String
DelegateDeclaration -> String
(Int -> DelegateDeclaration -> String -> String)
-> (DelegateDeclaration -> String)
-> ([DelegateDeclaration] -> String -> String)
-> Show DelegateDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DelegateDeclaration -> String -> String
showsPrec :: Int -> DelegateDeclaration -> String -> String
$cshow :: DelegateDeclaration -> String
show :: DelegateDeclaration -> String
$cshowList :: [DelegateDeclaration] -> String -> String
showList :: [DelegateDeclaration] -> String -> String
Show)

_DelegateDeclaration :: Name
_DelegateDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DelegateDeclaration")

_DelegateDeclaration_attributes :: Name
_DelegateDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_DelegateDeclaration_modifiers :: Name
_DelegateDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_DelegateDeclaration_returnType :: Name
_DelegateDeclaration_returnType = (String -> Name
Core.Name String
"returnType")

_DelegateDeclaration_refKind :: Name
_DelegateDeclaration_refKind = (String -> Name
Core.Name String
"refKind")

_DelegateDeclaration_refReturnType :: Name
_DelegateDeclaration_refReturnType = (String -> Name
Core.Name String
"refReturnType")

_DelegateDeclaration_header :: Name
_DelegateDeclaration_header = (String -> Name
Core.Name String
"header")

data DelegateHeader = 
  DelegateHeader {
    DelegateHeader -> Identifier
delegateHeaderName :: Identifier,
    DelegateHeader -> Maybe VariantTypeParameters
delegateHeaderTypeParameters :: (Maybe VariantTypeParameters),
    DelegateHeader -> Maybe FormalParameterList
delegateHeaderParameters :: (Maybe FormalParameterList),
    DelegateHeader -> [TypeParameterConstraintsClause]
delegateHeaderConstraints :: [TypeParameterConstraintsClause]}
  deriving (DelegateHeader -> DelegateHeader -> Bool
(DelegateHeader -> DelegateHeader -> Bool)
-> (DelegateHeader -> DelegateHeader -> Bool) -> Eq DelegateHeader
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DelegateHeader -> DelegateHeader -> Bool
== :: DelegateHeader -> DelegateHeader -> Bool
$c/= :: DelegateHeader -> DelegateHeader -> Bool
/= :: DelegateHeader -> DelegateHeader -> Bool
Eq, Eq DelegateHeader
Eq DelegateHeader =>
(DelegateHeader -> DelegateHeader -> Ordering)
-> (DelegateHeader -> DelegateHeader -> Bool)
-> (DelegateHeader -> DelegateHeader -> Bool)
-> (DelegateHeader -> DelegateHeader -> Bool)
-> (DelegateHeader -> DelegateHeader -> Bool)
-> (DelegateHeader -> DelegateHeader -> DelegateHeader)
-> (DelegateHeader -> DelegateHeader -> DelegateHeader)
-> Ord DelegateHeader
DelegateHeader -> DelegateHeader -> Bool
DelegateHeader -> DelegateHeader -> Ordering
DelegateHeader -> DelegateHeader -> DelegateHeader
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DelegateHeader -> DelegateHeader -> Ordering
compare :: DelegateHeader -> DelegateHeader -> Ordering
$c< :: DelegateHeader -> DelegateHeader -> Bool
< :: DelegateHeader -> DelegateHeader -> Bool
$c<= :: DelegateHeader -> DelegateHeader -> Bool
<= :: DelegateHeader -> DelegateHeader -> Bool
$c> :: DelegateHeader -> DelegateHeader -> Bool
> :: DelegateHeader -> DelegateHeader -> Bool
$c>= :: DelegateHeader -> DelegateHeader -> Bool
>= :: DelegateHeader -> DelegateHeader -> Bool
$cmax :: DelegateHeader -> DelegateHeader -> DelegateHeader
max :: DelegateHeader -> DelegateHeader -> DelegateHeader
$cmin :: DelegateHeader -> DelegateHeader -> DelegateHeader
min :: DelegateHeader -> DelegateHeader -> DelegateHeader
Ord, ReadPrec [DelegateHeader]
ReadPrec DelegateHeader
Int -> ReadS DelegateHeader
ReadS [DelegateHeader]
(Int -> ReadS DelegateHeader)
-> ReadS [DelegateHeader]
-> ReadPrec DelegateHeader
-> ReadPrec [DelegateHeader]
-> Read DelegateHeader
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DelegateHeader
readsPrec :: Int -> ReadS DelegateHeader
$creadList :: ReadS [DelegateHeader]
readList :: ReadS [DelegateHeader]
$creadPrec :: ReadPrec DelegateHeader
readPrec :: ReadPrec DelegateHeader
$creadListPrec :: ReadPrec [DelegateHeader]
readListPrec :: ReadPrec [DelegateHeader]
Read, Int -> DelegateHeader -> String -> String
[DelegateHeader] -> String -> String
DelegateHeader -> String
(Int -> DelegateHeader -> String -> String)
-> (DelegateHeader -> String)
-> ([DelegateHeader] -> String -> String)
-> Show DelegateHeader
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DelegateHeader -> String -> String
showsPrec :: Int -> DelegateHeader -> String -> String
$cshow :: DelegateHeader -> String
show :: DelegateHeader -> String
$cshowList :: [DelegateHeader] -> String -> String
showList :: [DelegateHeader] -> String -> String
Show)

_DelegateHeader :: Name
_DelegateHeader = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DelegateHeader")

_DelegateHeader_name :: Name
_DelegateHeader_name = (String -> Name
Core.Name String
"name")

_DelegateHeader_typeParameters :: Name
_DelegateHeader_typeParameters = (String -> Name
Core.Name String
"typeParameters")

_DelegateHeader_parameters :: Name
_DelegateHeader_parameters = (String -> Name
Core.Name String
"parameters")

_DelegateHeader_constraints :: Name
_DelegateHeader_constraints = (String -> Name
Core.Name String
"constraints")

data DelegateModifier = 
  DelegateModifierNew  |
  DelegateModifierPublic  |
  DelegateModifierProtected  |
  DelegateModifierInternal  |
  DelegateModifierPrivate  |
  DelegateModifierUnsafe 
  deriving (DelegateModifier -> DelegateModifier -> Bool
(DelegateModifier -> DelegateModifier -> Bool)
-> (DelegateModifier -> DelegateModifier -> Bool)
-> Eq DelegateModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DelegateModifier -> DelegateModifier -> Bool
== :: DelegateModifier -> DelegateModifier -> Bool
$c/= :: DelegateModifier -> DelegateModifier -> Bool
/= :: DelegateModifier -> DelegateModifier -> Bool
Eq, Eq DelegateModifier
Eq DelegateModifier =>
(DelegateModifier -> DelegateModifier -> Ordering)
-> (DelegateModifier -> DelegateModifier -> Bool)
-> (DelegateModifier -> DelegateModifier -> Bool)
-> (DelegateModifier -> DelegateModifier -> Bool)
-> (DelegateModifier -> DelegateModifier -> Bool)
-> (DelegateModifier -> DelegateModifier -> DelegateModifier)
-> (DelegateModifier -> DelegateModifier -> DelegateModifier)
-> Ord DelegateModifier
DelegateModifier -> DelegateModifier -> Bool
DelegateModifier -> DelegateModifier -> Ordering
DelegateModifier -> DelegateModifier -> DelegateModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DelegateModifier -> DelegateModifier -> Ordering
compare :: DelegateModifier -> DelegateModifier -> Ordering
$c< :: DelegateModifier -> DelegateModifier -> Bool
< :: DelegateModifier -> DelegateModifier -> Bool
$c<= :: DelegateModifier -> DelegateModifier -> Bool
<= :: DelegateModifier -> DelegateModifier -> Bool
$c> :: DelegateModifier -> DelegateModifier -> Bool
> :: DelegateModifier -> DelegateModifier -> Bool
$c>= :: DelegateModifier -> DelegateModifier -> Bool
>= :: DelegateModifier -> DelegateModifier -> Bool
$cmax :: DelegateModifier -> DelegateModifier -> DelegateModifier
max :: DelegateModifier -> DelegateModifier -> DelegateModifier
$cmin :: DelegateModifier -> DelegateModifier -> DelegateModifier
min :: DelegateModifier -> DelegateModifier -> DelegateModifier
Ord, ReadPrec [DelegateModifier]
ReadPrec DelegateModifier
Int -> ReadS DelegateModifier
ReadS [DelegateModifier]
(Int -> ReadS DelegateModifier)
-> ReadS [DelegateModifier]
-> ReadPrec DelegateModifier
-> ReadPrec [DelegateModifier]
-> Read DelegateModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS DelegateModifier
readsPrec :: Int -> ReadS DelegateModifier
$creadList :: ReadS [DelegateModifier]
readList :: ReadS [DelegateModifier]
$creadPrec :: ReadPrec DelegateModifier
readPrec :: ReadPrec DelegateModifier
$creadListPrec :: ReadPrec [DelegateModifier]
readListPrec :: ReadPrec [DelegateModifier]
Read, Int -> DelegateModifier -> String -> String
[DelegateModifier] -> String -> String
DelegateModifier -> String
(Int -> DelegateModifier -> String -> String)
-> (DelegateModifier -> String)
-> ([DelegateModifier] -> String -> String)
-> Show DelegateModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> DelegateModifier -> String -> String
showsPrec :: Int -> DelegateModifier -> String -> String
$cshow :: DelegateModifier -> String
show :: DelegateModifier -> String
$cshowList :: [DelegateModifier] -> String -> String
showList :: [DelegateModifier] -> String -> String
Show)

_DelegateModifier :: Name
_DelegateModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.DelegateModifier")

_DelegateModifier_new :: Name
_DelegateModifier_new = (String -> Name
Core.Name String
"new")

_DelegateModifier_public :: Name
_DelegateModifier_public = (String -> Name
Core.Name String
"public")

_DelegateModifier_protected :: Name
_DelegateModifier_protected = (String -> Name
Core.Name String
"protected")

_DelegateModifier_internal :: Name
_DelegateModifier_internal = (String -> Name
Core.Name String
"internal")

_DelegateModifier_private :: Name
_DelegateModifier_private = (String -> Name
Core.Name String
"private")

_DelegateModifier_unsafe :: Name
_DelegateModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

data GlobalAttributeSection = 
  GlobalAttributeSection {
    GlobalAttributeSection -> Identifier
globalAttributeSectionTarget :: Identifier,
    GlobalAttributeSection -> AttributeList
globalAttributeSectionAttributes :: AttributeList}
  deriving (GlobalAttributeSection -> GlobalAttributeSection -> Bool
(GlobalAttributeSection -> GlobalAttributeSection -> Bool)
-> (GlobalAttributeSection -> GlobalAttributeSection -> Bool)
-> Eq GlobalAttributeSection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
== :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
$c/= :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
/= :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
Eq, Eq GlobalAttributeSection
Eq GlobalAttributeSection =>
(GlobalAttributeSection -> GlobalAttributeSection -> Ordering)
-> (GlobalAttributeSection -> GlobalAttributeSection -> Bool)
-> (GlobalAttributeSection -> GlobalAttributeSection -> Bool)
-> (GlobalAttributeSection -> GlobalAttributeSection -> Bool)
-> (GlobalAttributeSection -> GlobalAttributeSection -> Bool)
-> (GlobalAttributeSection
    -> GlobalAttributeSection -> GlobalAttributeSection)
-> (GlobalAttributeSection
    -> GlobalAttributeSection -> GlobalAttributeSection)
-> Ord GlobalAttributeSection
GlobalAttributeSection -> GlobalAttributeSection -> Bool
GlobalAttributeSection -> GlobalAttributeSection -> Ordering
GlobalAttributeSection
-> GlobalAttributeSection -> GlobalAttributeSection
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GlobalAttributeSection -> GlobalAttributeSection -> Ordering
compare :: GlobalAttributeSection -> GlobalAttributeSection -> Ordering
$c< :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
< :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
$c<= :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
<= :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
$c> :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
> :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
$c>= :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
>= :: GlobalAttributeSection -> GlobalAttributeSection -> Bool
$cmax :: GlobalAttributeSection
-> GlobalAttributeSection -> GlobalAttributeSection
max :: GlobalAttributeSection
-> GlobalAttributeSection -> GlobalAttributeSection
$cmin :: GlobalAttributeSection
-> GlobalAttributeSection -> GlobalAttributeSection
min :: GlobalAttributeSection
-> GlobalAttributeSection -> GlobalAttributeSection
Ord, ReadPrec [GlobalAttributeSection]
ReadPrec GlobalAttributeSection
Int -> ReadS GlobalAttributeSection
ReadS [GlobalAttributeSection]
(Int -> ReadS GlobalAttributeSection)
-> ReadS [GlobalAttributeSection]
-> ReadPrec GlobalAttributeSection
-> ReadPrec [GlobalAttributeSection]
-> Read GlobalAttributeSection
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS GlobalAttributeSection
readsPrec :: Int -> ReadS GlobalAttributeSection
$creadList :: ReadS [GlobalAttributeSection]
readList :: ReadS [GlobalAttributeSection]
$creadPrec :: ReadPrec GlobalAttributeSection
readPrec :: ReadPrec GlobalAttributeSection
$creadListPrec :: ReadPrec [GlobalAttributeSection]
readListPrec :: ReadPrec [GlobalAttributeSection]
Read, Int -> GlobalAttributeSection -> String -> String
[GlobalAttributeSection] -> String -> String
GlobalAttributeSection -> String
(Int -> GlobalAttributeSection -> String -> String)
-> (GlobalAttributeSection -> String)
-> ([GlobalAttributeSection] -> String -> String)
-> Show GlobalAttributeSection
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> GlobalAttributeSection -> String -> String
showsPrec :: Int -> GlobalAttributeSection -> String -> String
$cshow :: GlobalAttributeSection -> String
show :: GlobalAttributeSection -> String
$cshowList :: [GlobalAttributeSection] -> String -> String
showList :: [GlobalAttributeSection] -> String -> String
Show)

_GlobalAttributeSection :: Name
_GlobalAttributeSection = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.GlobalAttributeSection")

_GlobalAttributeSection_target :: Name
_GlobalAttributeSection_target = (String -> Name
Core.Name String
"target")

_GlobalAttributeSection_attributes :: Name
_GlobalAttributeSection_attributes = (String -> Name
Core.Name String
"attributes")

newtype Attributes = 
  Attributes {
    Attributes -> [AttributeSection]
unAttributes :: [AttributeSection]}
  deriving (Attributes -> Attributes -> Bool
(Attributes -> Attributes -> Bool)
-> (Attributes -> Attributes -> Bool) -> Eq Attributes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Attributes -> Attributes -> Bool
== :: Attributes -> Attributes -> Bool
$c/= :: Attributes -> Attributes -> Bool
/= :: Attributes -> Attributes -> Bool
Eq, Eq Attributes
Eq Attributes =>
(Attributes -> Attributes -> Ordering)
-> (Attributes -> Attributes -> Bool)
-> (Attributes -> Attributes -> Bool)
-> (Attributes -> Attributes -> Bool)
-> (Attributes -> Attributes -> Bool)
-> (Attributes -> Attributes -> Attributes)
-> (Attributes -> Attributes -> Attributes)
-> Ord Attributes
Attributes -> Attributes -> Bool
Attributes -> Attributes -> Ordering
Attributes -> Attributes -> Attributes
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Attributes -> Attributes -> Ordering
compare :: Attributes -> Attributes -> Ordering
$c< :: Attributes -> Attributes -> Bool
< :: Attributes -> Attributes -> Bool
$c<= :: Attributes -> Attributes -> Bool
<= :: Attributes -> Attributes -> Bool
$c> :: Attributes -> Attributes -> Bool
> :: Attributes -> Attributes -> Bool
$c>= :: Attributes -> Attributes -> Bool
>= :: Attributes -> Attributes -> Bool
$cmax :: Attributes -> Attributes -> Attributes
max :: Attributes -> Attributes -> Attributes
$cmin :: Attributes -> Attributes -> Attributes
min :: Attributes -> Attributes -> Attributes
Ord, ReadPrec [Attributes]
ReadPrec Attributes
Int -> ReadS Attributes
ReadS [Attributes]
(Int -> ReadS Attributes)
-> ReadS [Attributes]
-> ReadPrec Attributes
-> ReadPrec [Attributes]
-> Read Attributes
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Attributes
readsPrec :: Int -> ReadS Attributes
$creadList :: ReadS [Attributes]
readList :: ReadS [Attributes]
$creadPrec :: ReadPrec Attributes
readPrec :: ReadPrec Attributes
$creadListPrec :: ReadPrec [Attributes]
readListPrec :: ReadPrec [Attributes]
Read, Int -> Attributes -> String -> String
[Attributes] -> String -> String
Attributes -> String
(Int -> Attributes -> String -> String)
-> (Attributes -> String)
-> ([Attributes] -> String -> String)
-> Show Attributes
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Attributes -> String -> String
showsPrec :: Int -> Attributes -> String -> String
$cshow :: Attributes -> String
show :: Attributes -> String
$cshowList :: [Attributes] -> String -> String
showList :: [Attributes] -> String -> String
Show)

_Attributes :: Name
_Attributes = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Attributes")

data AttributeSection = 
  AttributeSection {
    AttributeSection -> Maybe AttributeTarget
attributeSectionTarget :: (Maybe AttributeTarget),
    AttributeSection -> AttributeList
attributeSectionAttributes :: AttributeList}
  deriving (AttributeSection -> AttributeSection -> Bool
(AttributeSection -> AttributeSection -> Bool)
-> (AttributeSection -> AttributeSection -> Bool)
-> Eq AttributeSection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AttributeSection -> AttributeSection -> Bool
== :: AttributeSection -> AttributeSection -> Bool
$c/= :: AttributeSection -> AttributeSection -> Bool
/= :: AttributeSection -> AttributeSection -> Bool
Eq, Eq AttributeSection
Eq AttributeSection =>
(AttributeSection -> AttributeSection -> Ordering)
-> (AttributeSection -> AttributeSection -> Bool)
-> (AttributeSection -> AttributeSection -> Bool)
-> (AttributeSection -> AttributeSection -> Bool)
-> (AttributeSection -> AttributeSection -> Bool)
-> (AttributeSection -> AttributeSection -> AttributeSection)
-> (AttributeSection -> AttributeSection -> AttributeSection)
-> Ord AttributeSection
AttributeSection -> AttributeSection -> Bool
AttributeSection -> AttributeSection -> Ordering
AttributeSection -> AttributeSection -> AttributeSection
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AttributeSection -> AttributeSection -> Ordering
compare :: AttributeSection -> AttributeSection -> Ordering
$c< :: AttributeSection -> AttributeSection -> Bool
< :: AttributeSection -> AttributeSection -> Bool
$c<= :: AttributeSection -> AttributeSection -> Bool
<= :: AttributeSection -> AttributeSection -> Bool
$c> :: AttributeSection -> AttributeSection -> Bool
> :: AttributeSection -> AttributeSection -> Bool
$c>= :: AttributeSection -> AttributeSection -> Bool
>= :: AttributeSection -> AttributeSection -> Bool
$cmax :: AttributeSection -> AttributeSection -> AttributeSection
max :: AttributeSection -> AttributeSection -> AttributeSection
$cmin :: AttributeSection -> AttributeSection -> AttributeSection
min :: AttributeSection -> AttributeSection -> AttributeSection
Ord, ReadPrec [AttributeSection]
ReadPrec AttributeSection
Int -> ReadS AttributeSection
ReadS [AttributeSection]
(Int -> ReadS AttributeSection)
-> ReadS [AttributeSection]
-> ReadPrec AttributeSection
-> ReadPrec [AttributeSection]
-> Read AttributeSection
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AttributeSection
readsPrec :: Int -> ReadS AttributeSection
$creadList :: ReadS [AttributeSection]
readList :: ReadS [AttributeSection]
$creadPrec :: ReadPrec AttributeSection
readPrec :: ReadPrec AttributeSection
$creadListPrec :: ReadPrec [AttributeSection]
readListPrec :: ReadPrec [AttributeSection]
Read, Int -> AttributeSection -> String -> String
[AttributeSection] -> String -> String
AttributeSection -> String
(Int -> AttributeSection -> String -> String)
-> (AttributeSection -> String)
-> ([AttributeSection] -> String -> String)
-> Show AttributeSection
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AttributeSection -> String -> String
showsPrec :: Int -> AttributeSection -> String -> String
$cshow :: AttributeSection -> String
show :: AttributeSection -> String
$cshowList :: [AttributeSection] -> String -> String
showList :: [AttributeSection] -> String -> String
Show)

_AttributeSection :: Name
_AttributeSection = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AttributeSection")

_AttributeSection_target :: Name
_AttributeSection_target = (String -> Name
Core.Name String
"target")

_AttributeSection_attributes :: Name
_AttributeSection_attributes = (String -> Name
Core.Name String
"attributes")

data AttributeTarget = 
  AttributeTargetIdentifier Identifier |
  AttributeTargetKeyword Keyword
  deriving (AttributeTarget -> AttributeTarget -> Bool
(AttributeTarget -> AttributeTarget -> Bool)
-> (AttributeTarget -> AttributeTarget -> Bool)
-> Eq AttributeTarget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AttributeTarget -> AttributeTarget -> Bool
== :: AttributeTarget -> AttributeTarget -> Bool
$c/= :: AttributeTarget -> AttributeTarget -> Bool
/= :: AttributeTarget -> AttributeTarget -> Bool
Eq, Eq AttributeTarget
Eq AttributeTarget =>
(AttributeTarget -> AttributeTarget -> Ordering)
-> (AttributeTarget -> AttributeTarget -> Bool)
-> (AttributeTarget -> AttributeTarget -> Bool)
-> (AttributeTarget -> AttributeTarget -> Bool)
-> (AttributeTarget -> AttributeTarget -> Bool)
-> (AttributeTarget -> AttributeTarget -> AttributeTarget)
-> (AttributeTarget -> AttributeTarget -> AttributeTarget)
-> Ord AttributeTarget
AttributeTarget -> AttributeTarget -> Bool
AttributeTarget -> AttributeTarget -> Ordering
AttributeTarget -> AttributeTarget -> AttributeTarget
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AttributeTarget -> AttributeTarget -> Ordering
compare :: AttributeTarget -> AttributeTarget -> Ordering
$c< :: AttributeTarget -> AttributeTarget -> Bool
< :: AttributeTarget -> AttributeTarget -> Bool
$c<= :: AttributeTarget -> AttributeTarget -> Bool
<= :: AttributeTarget -> AttributeTarget -> Bool
$c> :: AttributeTarget -> AttributeTarget -> Bool
> :: AttributeTarget -> AttributeTarget -> Bool
$c>= :: AttributeTarget -> AttributeTarget -> Bool
>= :: AttributeTarget -> AttributeTarget -> Bool
$cmax :: AttributeTarget -> AttributeTarget -> AttributeTarget
max :: AttributeTarget -> AttributeTarget -> AttributeTarget
$cmin :: AttributeTarget -> AttributeTarget -> AttributeTarget
min :: AttributeTarget -> AttributeTarget -> AttributeTarget
Ord, ReadPrec [AttributeTarget]
ReadPrec AttributeTarget
Int -> ReadS AttributeTarget
ReadS [AttributeTarget]
(Int -> ReadS AttributeTarget)
-> ReadS [AttributeTarget]
-> ReadPrec AttributeTarget
-> ReadPrec [AttributeTarget]
-> Read AttributeTarget
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AttributeTarget
readsPrec :: Int -> ReadS AttributeTarget
$creadList :: ReadS [AttributeTarget]
readList :: ReadS [AttributeTarget]
$creadPrec :: ReadPrec AttributeTarget
readPrec :: ReadPrec AttributeTarget
$creadListPrec :: ReadPrec [AttributeTarget]
readListPrec :: ReadPrec [AttributeTarget]
Read, Int -> AttributeTarget -> String -> String
[AttributeTarget] -> String -> String
AttributeTarget -> String
(Int -> AttributeTarget -> String -> String)
-> (AttributeTarget -> String)
-> ([AttributeTarget] -> String -> String)
-> Show AttributeTarget
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AttributeTarget -> String -> String
showsPrec :: Int -> AttributeTarget -> String -> String
$cshow :: AttributeTarget -> String
show :: AttributeTarget -> String
$cshowList :: [AttributeTarget] -> String -> String
showList :: [AttributeTarget] -> String -> String
Show)

_AttributeTarget :: Name
_AttributeTarget = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AttributeTarget")

_AttributeTarget_identifier :: Name
_AttributeTarget_identifier = (String -> Name
Core.Name String
"identifier")

_AttributeTarget_keyword :: Name
_AttributeTarget_keyword = (String -> Name
Core.Name String
"keyword")

newtype AttributeList = 
  AttributeList {
    AttributeList -> [Attribute]
unAttributeList :: [Attribute]}
  deriving (AttributeList -> AttributeList -> Bool
(AttributeList -> AttributeList -> Bool)
-> (AttributeList -> AttributeList -> Bool) -> Eq AttributeList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AttributeList -> AttributeList -> Bool
== :: AttributeList -> AttributeList -> Bool
$c/= :: AttributeList -> AttributeList -> Bool
/= :: AttributeList -> AttributeList -> Bool
Eq, Eq AttributeList
Eq AttributeList =>
(AttributeList -> AttributeList -> Ordering)
-> (AttributeList -> AttributeList -> Bool)
-> (AttributeList -> AttributeList -> Bool)
-> (AttributeList -> AttributeList -> Bool)
-> (AttributeList -> AttributeList -> Bool)
-> (AttributeList -> AttributeList -> AttributeList)
-> (AttributeList -> AttributeList -> AttributeList)
-> Ord AttributeList
AttributeList -> AttributeList -> Bool
AttributeList -> AttributeList -> Ordering
AttributeList -> AttributeList -> AttributeList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AttributeList -> AttributeList -> Ordering
compare :: AttributeList -> AttributeList -> Ordering
$c< :: AttributeList -> AttributeList -> Bool
< :: AttributeList -> AttributeList -> Bool
$c<= :: AttributeList -> AttributeList -> Bool
<= :: AttributeList -> AttributeList -> Bool
$c> :: AttributeList -> AttributeList -> Bool
> :: AttributeList -> AttributeList -> Bool
$c>= :: AttributeList -> AttributeList -> Bool
>= :: AttributeList -> AttributeList -> Bool
$cmax :: AttributeList -> AttributeList -> AttributeList
max :: AttributeList -> AttributeList -> AttributeList
$cmin :: AttributeList -> AttributeList -> AttributeList
min :: AttributeList -> AttributeList -> AttributeList
Ord, ReadPrec [AttributeList]
ReadPrec AttributeList
Int -> ReadS AttributeList
ReadS [AttributeList]
(Int -> ReadS AttributeList)
-> ReadS [AttributeList]
-> ReadPrec AttributeList
-> ReadPrec [AttributeList]
-> Read AttributeList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AttributeList
readsPrec :: Int -> ReadS AttributeList
$creadList :: ReadS [AttributeList]
readList :: ReadS [AttributeList]
$creadPrec :: ReadPrec AttributeList
readPrec :: ReadPrec AttributeList
$creadListPrec :: ReadPrec [AttributeList]
readListPrec :: ReadPrec [AttributeList]
Read, Int -> AttributeList -> String -> String
[AttributeList] -> String -> String
AttributeList -> String
(Int -> AttributeList -> String -> String)
-> (AttributeList -> String)
-> ([AttributeList] -> String -> String)
-> Show AttributeList
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AttributeList -> String -> String
showsPrec :: Int -> AttributeList -> String -> String
$cshow :: AttributeList -> String
show :: AttributeList -> String
$cshowList :: [AttributeList] -> String -> String
showList :: [AttributeList] -> String -> String
Show)

_AttributeList :: Name
_AttributeList = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AttributeList")

data Attribute = 
  Attribute {
    Attribute -> AttributeName
attributeName :: AttributeName,
    Attribute -> Maybe AttributeArguments
attributeArguments :: (Maybe AttributeArguments)}
  deriving (Attribute -> Attribute -> Bool
(Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool) -> Eq Attribute
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Attribute -> Attribute -> Bool
== :: Attribute -> Attribute -> Bool
$c/= :: Attribute -> Attribute -> Bool
/= :: Attribute -> Attribute -> Bool
Eq, Eq Attribute
Eq Attribute =>
(Attribute -> Attribute -> Ordering)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Bool)
-> (Attribute -> Attribute -> Attribute)
-> (Attribute -> Attribute -> Attribute)
-> Ord Attribute
Attribute -> Attribute -> Bool
Attribute -> Attribute -> Ordering
Attribute -> Attribute -> Attribute
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Attribute -> Attribute -> Ordering
compare :: Attribute -> Attribute -> Ordering
$c< :: Attribute -> Attribute -> Bool
< :: Attribute -> Attribute -> Bool
$c<= :: Attribute -> Attribute -> Bool
<= :: Attribute -> Attribute -> Bool
$c> :: Attribute -> Attribute -> Bool
> :: Attribute -> Attribute -> Bool
$c>= :: Attribute -> Attribute -> Bool
>= :: Attribute -> Attribute -> Bool
$cmax :: Attribute -> Attribute -> Attribute
max :: Attribute -> Attribute -> Attribute
$cmin :: Attribute -> Attribute -> Attribute
min :: Attribute -> Attribute -> Attribute
Ord, ReadPrec [Attribute]
ReadPrec Attribute
Int -> ReadS Attribute
ReadS [Attribute]
(Int -> ReadS Attribute)
-> ReadS [Attribute]
-> ReadPrec Attribute
-> ReadPrec [Attribute]
-> Read Attribute
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Attribute
readsPrec :: Int -> ReadS Attribute
$creadList :: ReadS [Attribute]
readList :: ReadS [Attribute]
$creadPrec :: ReadPrec Attribute
readPrec :: ReadPrec Attribute
$creadListPrec :: ReadPrec [Attribute]
readListPrec :: ReadPrec [Attribute]
Read, Int -> Attribute -> String -> String
[Attribute] -> String -> String
Attribute -> String
(Int -> Attribute -> String -> String)
-> (Attribute -> String)
-> ([Attribute] -> String -> String)
-> Show Attribute
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Attribute -> String -> String
showsPrec :: Int -> Attribute -> String -> String
$cshow :: Attribute -> String
show :: Attribute -> String
$cshowList :: [Attribute] -> String -> String
showList :: [Attribute] -> String -> String
Show)

_Attribute :: Name
_Attribute = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.Attribute")

_Attribute_name :: Name
_Attribute_name = (String -> Name
Core.Name String
"name")

_Attribute_arguments :: Name
_Attribute_arguments = (String -> Name
Core.Name String
"arguments")

newtype AttributeName = 
  AttributeName {
    AttributeName -> TypeName
unAttributeName :: TypeName}
  deriving (AttributeName -> AttributeName -> Bool
(AttributeName -> AttributeName -> Bool)
-> (AttributeName -> AttributeName -> Bool) -> Eq AttributeName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AttributeName -> AttributeName -> Bool
== :: AttributeName -> AttributeName -> Bool
$c/= :: AttributeName -> AttributeName -> Bool
/= :: AttributeName -> AttributeName -> Bool
Eq, Eq AttributeName
Eq AttributeName =>
(AttributeName -> AttributeName -> Ordering)
-> (AttributeName -> AttributeName -> Bool)
-> (AttributeName -> AttributeName -> Bool)
-> (AttributeName -> AttributeName -> Bool)
-> (AttributeName -> AttributeName -> Bool)
-> (AttributeName -> AttributeName -> AttributeName)
-> (AttributeName -> AttributeName -> AttributeName)
-> Ord AttributeName
AttributeName -> AttributeName -> Bool
AttributeName -> AttributeName -> Ordering
AttributeName -> AttributeName -> AttributeName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AttributeName -> AttributeName -> Ordering
compare :: AttributeName -> AttributeName -> Ordering
$c< :: AttributeName -> AttributeName -> Bool
< :: AttributeName -> AttributeName -> Bool
$c<= :: AttributeName -> AttributeName -> Bool
<= :: AttributeName -> AttributeName -> Bool
$c> :: AttributeName -> AttributeName -> Bool
> :: AttributeName -> AttributeName -> Bool
$c>= :: AttributeName -> AttributeName -> Bool
>= :: AttributeName -> AttributeName -> Bool
$cmax :: AttributeName -> AttributeName -> AttributeName
max :: AttributeName -> AttributeName -> AttributeName
$cmin :: AttributeName -> AttributeName -> AttributeName
min :: AttributeName -> AttributeName -> AttributeName
Ord, ReadPrec [AttributeName]
ReadPrec AttributeName
Int -> ReadS AttributeName
ReadS [AttributeName]
(Int -> ReadS AttributeName)
-> ReadS [AttributeName]
-> ReadPrec AttributeName
-> ReadPrec [AttributeName]
-> Read AttributeName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AttributeName
readsPrec :: Int -> ReadS AttributeName
$creadList :: ReadS [AttributeName]
readList :: ReadS [AttributeName]
$creadPrec :: ReadPrec AttributeName
readPrec :: ReadPrec AttributeName
$creadListPrec :: ReadPrec [AttributeName]
readListPrec :: ReadPrec [AttributeName]
Read, Int -> AttributeName -> String -> String
[AttributeName] -> String -> String
AttributeName -> String
(Int -> AttributeName -> String -> String)
-> (AttributeName -> String)
-> ([AttributeName] -> String -> String)
-> Show AttributeName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AttributeName -> String -> String
showsPrec :: Int -> AttributeName -> String -> String
$cshow :: AttributeName -> String
show :: AttributeName -> String
$cshowList :: [AttributeName] -> String -> String
showList :: [AttributeName] -> String -> String
Show)

_AttributeName :: Name
_AttributeName = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AttributeName")

data AttributeArguments = 
  AttributeArguments {
    AttributeArguments -> Maybe PositionalArgumentList
attributeArgumentsPositonal :: (Maybe PositionalArgumentList),
    AttributeArguments -> Maybe NamedArgumentList
attributeArgumentsNamed :: (Maybe NamedArgumentList)}
  deriving (AttributeArguments -> AttributeArguments -> Bool
(AttributeArguments -> AttributeArguments -> Bool)
-> (AttributeArguments -> AttributeArguments -> Bool)
-> Eq AttributeArguments
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AttributeArguments -> AttributeArguments -> Bool
== :: AttributeArguments -> AttributeArguments -> Bool
$c/= :: AttributeArguments -> AttributeArguments -> Bool
/= :: AttributeArguments -> AttributeArguments -> Bool
Eq, Eq AttributeArguments
Eq AttributeArguments =>
(AttributeArguments -> AttributeArguments -> Ordering)
-> (AttributeArguments -> AttributeArguments -> Bool)
-> (AttributeArguments -> AttributeArguments -> Bool)
-> (AttributeArguments -> AttributeArguments -> Bool)
-> (AttributeArguments -> AttributeArguments -> Bool)
-> (AttributeArguments -> AttributeArguments -> AttributeArguments)
-> (AttributeArguments -> AttributeArguments -> AttributeArguments)
-> Ord AttributeArguments
AttributeArguments -> AttributeArguments -> Bool
AttributeArguments -> AttributeArguments -> Ordering
AttributeArguments -> AttributeArguments -> AttributeArguments
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AttributeArguments -> AttributeArguments -> Ordering
compare :: AttributeArguments -> AttributeArguments -> Ordering
$c< :: AttributeArguments -> AttributeArguments -> Bool
< :: AttributeArguments -> AttributeArguments -> Bool
$c<= :: AttributeArguments -> AttributeArguments -> Bool
<= :: AttributeArguments -> AttributeArguments -> Bool
$c> :: AttributeArguments -> AttributeArguments -> Bool
> :: AttributeArguments -> AttributeArguments -> Bool
$c>= :: AttributeArguments -> AttributeArguments -> Bool
>= :: AttributeArguments -> AttributeArguments -> Bool
$cmax :: AttributeArguments -> AttributeArguments -> AttributeArguments
max :: AttributeArguments -> AttributeArguments -> AttributeArguments
$cmin :: AttributeArguments -> AttributeArguments -> AttributeArguments
min :: AttributeArguments -> AttributeArguments -> AttributeArguments
Ord, ReadPrec [AttributeArguments]
ReadPrec AttributeArguments
Int -> ReadS AttributeArguments
ReadS [AttributeArguments]
(Int -> ReadS AttributeArguments)
-> ReadS [AttributeArguments]
-> ReadPrec AttributeArguments
-> ReadPrec [AttributeArguments]
-> Read AttributeArguments
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AttributeArguments
readsPrec :: Int -> ReadS AttributeArguments
$creadList :: ReadS [AttributeArguments]
readList :: ReadS [AttributeArguments]
$creadPrec :: ReadPrec AttributeArguments
readPrec :: ReadPrec AttributeArguments
$creadListPrec :: ReadPrec [AttributeArguments]
readListPrec :: ReadPrec [AttributeArguments]
Read, Int -> AttributeArguments -> String -> String
[AttributeArguments] -> String -> String
AttributeArguments -> String
(Int -> AttributeArguments -> String -> String)
-> (AttributeArguments -> String)
-> ([AttributeArguments] -> String -> String)
-> Show AttributeArguments
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AttributeArguments -> String -> String
showsPrec :: Int -> AttributeArguments -> String -> String
$cshow :: AttributeArguments -> String
show :: AttributeArguments -> String
$cshowList :: [AttributeArguments] -> String -> String
showList :: [AttributeArguments] -> String -> String
Show)

_AttributeArguments :: Name
_AttributeArguments = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AttributeArguments")

_AttributeArguments_positonal :: Name
_AttributeArguments_positonal = (String -> Name
Core.Name String
"positonal")

_AttributeArguments_named :: Name
_AttributeArguments_named = (String -> Name
Core.Name String
"named")

newtype PositionalArgumentList = 
  PositionalArgumentList {
    PositionalArgumentList -> [PositionalArgument]
unPositionalArgumentList :: [PositionalArgument]}
  deriving (PositionalArgumentList -> PositionalArgumentList -> Bool
(PositionalArgumentList -> PositionalArgumentList -> Bool)
-> (PositionalArgumentList -> PositionalArgumentList -> Bool)
-> Eq PositionalArgumentList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PositionalArgumentList -> PositionalArgumentList -> Bool
== :: PositionalArgumentList -> PositionalArgumentList -> Bool
$c/= :: PositionalArgumentList -> PositionalArgumentList -> Bool
/= :: PositionalArgumentList -> PositionalArgumentList -> Bool
Eq, Eq PositionalArgumentList
Eq PositionalArgumentList =>
(PositionalArgumentList -> PositionalArgumentList -> Ordering)
-> (PositionalArgumentList -> PositionalArgumentList -> Bool)
-> (PositionalArgumentList -> PositionalArgumentList -> Bool)
-> (PositionalArgumentList -> PositionalArgumentList -> Bool)
-> (PositionalArgumentList -> PositionalArgumentList -> Bool)
-> (PositionalArgumentList
    -> PositionalArgumentList -> PositionalArgumentList)
-> (PositionalArgumentList
    -> PositionalArgumentList -> PositionalArgumentList)
-> Ord PositionalArgumentList
PositionalArgumentList -> PositionalArgumentList -> Bool
PositionalArgumentList -> PositionalArgumentList -> Ordering
PositionalArgumentList
-> PositionalArgumentList -> PositionalArgumentList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PositionalArgumentList -> PositionalArgumentList -> Ordering
compare :: PositionalArgumentList -> PositionalArgumentList -> Ordering
$c< :: PositionalArgumentList -> PositionalArgumentList -> Bool
< :: PositionalArgumentList -> PositionalArgumentList -> Bool
$c<= :: PositionalArgumentList -> PositionalArgumentList -> Bool
<= :: PositionalArgumentList -> PositionalArgumentList -> Bool
$c> :: PositionalArgumentList -> PositionalArgumentList -> Bool
> :: PositionalArgumentList -> PositionalArgumentList -> Bool
$c>= :: PositionalArgumentList -> PositionalArgumentList -> Bool
>= :: PositionalArgumentList -> PositionalArgumentList -> Bool
$cmax :: PositionalArgumentList
-> PositionalArgumentList -> PositionalArgumentList
max :: PositionalArgumentList
-> PositionalArgumentList -> PositionalArgumentList
$cmin :: PositionalArgumentList
-> PositionalArgumentList -> PositionalArgumentList
min :: PositionalArgumentList
-> PositionalArgumentList -> PositionalArgumentList
Ord, ReadPrec [PositionalArgumentList]
ReadPrec PositionalArgumentList
Int -> ReadS PositionalArgumentList
ReadS [PositionalArgumentList]
(Int -> ReadS PositionalArgumentList)
-> ReadS [PositionalArgumentList]
-> ReadPrec PositionalArgumentList
-> ReadPrec [PositionalArgumentList]
-> Read PositionalArgumentList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PositionalArgumentList
readsPrec :: Int -> ReadS PositionalArgumentList
$creadList :: ReadS [PositionalArgumentList]
readList :: ReadS [PositionalArgumentList]
$creadPrec :: ReadPrec PositionalArgumentList
readPrec :: ReadPrec PositionalArgumentList
$creadListPrec :: ReadPrec [PositionalArgumentList]
readListPrec :: ReadPrec [PositionalArgumentList]
Read, Int -> PositionalArgumentList -> String -> String
[PositionalArgumentList] -> String -> String
PositionalArgumentList -> String
(Int -> PositionalArgumentList -> String -> String)
-> (PositionalArgumentList -> String)
-> ([PositionalArgumentList] -> String -> String)
-> Show PositionalArgumentList
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PositionalArgumentList -> String -> String
showsPrec :: Int -> PositionalArgumentList -> String -> String
$cshow :: PositionalArgumentList -> String
show :: PositionalArgumentList -> String
$cshowList :: [PositionalArgumentList] -> String -> String
showList :: [PositionalArgumentList] -> String -> String
Show)

_PositionalArgumentList :: Name
_PositionalArgumentList = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PositionalArgumentList")

data PositionalArgument = 
  PositionalArgument {
    PositionalArgument -> Maybe Identifier
positionalArgumentName :: (Maybe Identifier),
    PositionalArgument -> AttributeArgumentExpression
positionalArgumentValue :: AttributeArgumentExpression}
  deriving (PositionalArgument -> PositionalArgument -> Bool
(PositionalArgument -> PositionalArgument -> Bool)
-> (PositionalArgument -> PositionalArgument -> Bool)
-> Eq PositionalArgument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PositionalArgument -> PositionalArgument -> Bool
== :: PositionalArgument -> PositionalArgument -> Bool
$c/= :: PositionalArgument -> PositionalArgument -> Bool
/= :: PositionalArgument -> PositionalArgument -> Bool
Eq, Eq PositionalArgument
Eq PositionalArgument =>
(PositionalArgument -> PositionalArgument -> Ordering)
-> (PositionalArgument -> PositionalArgument -> Bool)
-> (PositionalArgument -> PositionalArgument -> Bool)
-> (PositionalArgument -> PositionalArgument -> Bool)
-> (PositionalArgument -> PositionalArgument -> Bool)
-> (PositionalArgument -> PositionalArgument -> PositionalArgument)
-> (PositionalArgument -> PositionalArgument -> PositionalArgument)
-> Ord PositionalArgument
PositionalArgument -> PositionalArgument -> Bool
PositionalArgument -> PositionalArgument -> Ordering
PositionalArgument -> PositionalArgument -> PositionalArgument
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PositionalArgument -> PositionalArgument -> Ordering
compare :: PositionalArgument -> PositionalArgument -> Ordering
$c< :: PositionalArgument -> PositionalArgument -> Bool
< :: PositionalArgument -> PositionalArgument -> Bool
$c<= :: PositionalArgument -> PositionalArgument -> Bool
<= :: PositionalArgument -> PositionalArgument -> Bool
$c> :: PositionalArgument -> PositionalArgument -> Bool
> :: PositionalArgument -> PositionalArgument -> Bool
$c>= :: PositionalArgument -> PositionalArgument -> Bool
>= :: PositionalArgument -> PositionalArgument -> Bool
$cmax :: PositionalArgument -> PositionalArgument -> PositionalArgument
max :: PositionalArgument -> PositionalArgument -> PositionalArgument
$cmin :: PositionalArgument -> PositionalArgument -> PositionalArgument
min :: PositionalArgument -> PositionalArgument -> PositionalArgument
Ord, ReadPrec [PositionalArgument]
ReadPrec PositionalArgument
Int -> ReadS PositionalArgument
ReadS [PositionalArgument]
(Int -> ReadS PositionalArgument)
-> ReadS [PositionalArgument]
-> ReadPrec PositionalArgument
-> ReadPrec [PositionalArgument]
-> Read PositionalArgument
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PositionalArgument
readsPrec :: Int -> ReadS PositionalArgument
$creadList :: ReadS [PositionalArgument]
readList :: ReadS [PositionalArgument]
$creadPrec :: ReadPrec PositionalArgument
readPrec :: ReadPrec PositionalArgument
$creadListPrec :: ReadPrec [PositionalArgument]
readListPrec :: ReadPrec [PositionalArgument]
Read, Int -> PositionalArgument -> String -> String
[PositionalArgument] -> String -> String
PositionalArgument -> String
(Int -> PositionalArgument -> String -> String)
-> (PositionalArgument -> String)
-> ([PositionalArgument] -> String -> String)
-> Show PositionalArgument
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PositionalArgument -> String -> String
showsPrec :: Int -> PositionalArgument -> String -> String
$cshow :: PositionalArgument -> String
show :: PositionalArgument -> String
$cshowList :: [PositionalArgument] -> String -> String
showList :: [PositionalArgument] -> String -> String
Show)

_PositionalArgument :: Name
_PositionalArgument = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PositionalArgument")

_PositionalArgument_name :: Name
_PositionalArgument_name = (String -> Name
Core.Name String
"name")

_PositionalArgument_value :: Name
_PositionalArgument_value = (String -> Name
Core.Name String
"value")

newtype NamedArgumentList = 
  NamedArgumentList {
    NamedArgumentList -> [NamedArgument]
unNamedArgumentList :: [NamedArgument]}
  deriving (NamedArgumentList -> NamedArgumentList -> Bool
(NamedArgumentList -> NamedArgumentList -> Bool)
-> (NamedArgumentList -> NamedArgumentList -> Bool)
-> Eq NamedArgumentList
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamedArgumentList -> NamedArgumentList -> Bool
== :: NamedArgumentList -> NamedArgumentList -> Bool
$c/= :: NamedArgumentList -> NamedArgumentList -> Bool
/= :: NamedArgumentList -> NamedArgumentList -> Bool
Eq, Eq NamedArgumentList
Eq NamedArgumentList =>
(NamedArgumentList -> NamedArgumentList -> Ordering)
-> (NamedArgumentList -> NamedArgumentList -> Bool)
-> (NamedArgumentList -> NamedArgumentList -> Bool)
-> (NamedArgumentList -> NamedArgumentList -> Bool)
-> (NamedArgumentList -> NamedArgumentList -> Bool)
-> (NamedArgumentList -> NamedArgumentList -> NamedArgumentList)
-> (NamedArgumentList -> NamedArgumentList -> NamedArgumentList)
-> Ord NamedArgumentList
NamedArgumentList -> NamedArgumentList -> Bool
NamedArgumentList -> NamedArgumentList -> Ordering
NamedArgumentList -> NamedArgumentList -> NamedArgumentList
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamedArgumentList -> NamedArgumentList -> Ordering
compare :: NamedArgumentList -> NamedArgumentList -> Ordering
$c< :: NamedArgumentList -> NamedArgumentList -> Bool
< :: NamedArgumentList -> NamedArgumentList -> Bool
$c<= :: NamedArgumentList -> NamedArgumentList -> Bool
<= :: NamedArgumentList -> NamedArgumentList -> Bool
$c> :: NamedArgumentList -> NamedArgumentList -> Bool
> :: NamedArgumentList -> NamedArgumentList -> Bool
$c>= :: NamedArgumentList -> NamedArgumentList -> Bool
>= :: NamedArgumentList -> NamedArgumentList -> Bool
$cmax :: NamedArgumentList -> NamedArgumentList -> NamedArgumentList
max :: NamedArgumentList -> NamedArgumentList -> NamedArgumentList
$cmin :: NamedArgumentList -> NamedArgumentList -> NamedArgumentList
min :: NamedArgumentList -> NamedArgumentList -> NamedArgumentList
Ord, ReadPrec [NamedArgumentList]
ReadPrec NamedArgumentList
Int -> ReadS NamedArgumentList
ReadS [NamedArgumentList]
(Int -> ReadS NamedArgumentList)
-> ReadS [NamedArgumentList]
-> ReadPrec NamedArgumentList
-> ReadPrec [NamedArgumentList]
-> Read NamedArgumentList
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamedArgumentList
readsPrec :: Int -> ReadS NamedArgumentList
$creadList :: ReadS [NamedArgumentList]
readList :: ReadS [NamedArgumentList]
$creadPrec :: ReadPrec NamedArgumentList
readPrec :: ReadPrec NamedArgumentList
$creadListPrec :: ReadPrec [NamedArgumentList]
readListPrec :: ReadPrec [NamedArgumentList]
Read, Int -> NamedArgumentList -> String -> String
[NamedArgumentList] -> String -> String
NamedArgumentList -> String
(Int -> NamedArgumentList -> String -> String)
-> (NamedArgumentList -> String)
-> ([NamedArgumentList] -> String -> String)
-> Show NamedArgumentList
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NamedArgumentList -> String -> String
showsPrec :: Int -> NamedArgumentList -> String -> String
$cshow :: NamedArgumentList -> String
show :: NamedArgumentList -> String
$cshowList :: [NamedArgumentList] -> String -> String
showList :: [NamedArgumentList] -> String -> String
Show)

_NamedArgumentList :: Name
_NamedArgumentList = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NamedArgumentList")

data NamedArgument = 
  NamedArgument {
    NamedArgument -> Identifier
namedArgumentName :: Identifier,
    NamedArgument -> AttributeArgumentExpression
namedArgumentValue :: AttributeArgumentExpression}
  deriving (NamedArgument -> NamedArgument -> Bool
(NamedArgument -> NamedArgument -> Bool)
-> (NamedArgument -> NamedArgument -> Bool) -> Eq NamedArgument
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NamedArgument -> NamedArgument -> Bool
== :: NamedArgument -> NamedArgument -> Bool
$c/= :: NamedArgument -> NamedArgument -> Bool
/= :: NamedArgument -> NamedArgument -> Bool
Eq, Eq NamedArgument
Eq NamedArgument =>
(NamedArgument -> NamedArgument -> Ordering)
-> (NamedArgument -> NamedArgument -> Bool)
-> (NamedArgument -> NamedArgument -> Bool)
-> (NamedArgument -> NamedArgument -> Bool)
-> (NamedArgument -> NamedArgument -> Bool)
-> (NamedArgument -> NamedArgument -> NamedArgument)
-> (NamedArgument -> NamedArgument -> NamedArgument)
-> Ord NamedArgument
NamedArgument -> NamedArgument -> Bool
NamedArgument -> NamedArgument -> Ordering
NamedArgument -> NamedArgument -> NamedArgument
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NamedArgument -> NamedArgument -> Ordering
compare :: NamedArgument -> NamedArgument -> Ordering
$c< :: NamedArgument -> NamedArgument -> Bool
< :: NamedArgument -> NamedArgument -> Bool
$c<= :: NamedArgument -> NamedArgument -> Bool
<= :: NamedArgument -> NamedArgument -> Bool
$c> :: NamedArgument -> NamedArgument -> Bool
> :: NamedArgument -> NamedArgument -> Bool
$c>= :: NamedArgument -> NamedArgument -> Bool
>= :: NamedArgument -> NamedArgument -> Bool
$cmax :: NamedArgument -> NamedArgument -> NamedArgument
max :: NamedArgument -> NamedArgument -> NamedArgument
$cmin :: NamedArgument -> NamedArgument -> NamedArgument
min :: NamedArgument -> NamedArgument -> NamedArgument
Ord, ReadPrec [NamedArgument]
ReadPrec NamedArgument
Int -> ReadS NamedArgument
ReadS [NamedArgument]
(Int -> ReadS NamedArgument)
-> ReadS [NamedArgument]
-> ReadPrec NamedArgument
-> ReadPrec [NamedArgument]
-> Read NamedArgument
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS NamedArgument
readsPrec :: Int -> ReadS NamedArgument
$creadList :: ReadS [NamedArgument]
readList :: ReadS [NamedArgument]
$creadPrec :: ReadPrec NamedArgument
readPrec :: ReadPrec NamedArgument
$creadListPrec :: ReadPrec [NamedArgument]
readListPrec :: ReadPrec [NamedArgument]
Read, Int -> NamedArgument -> String -> String
[NamedArgument] -> String -> String
NamedArgument -> String
(Int -> NamedArgument -> String -> String)
-> (NamedArgument -> String)
-> ([NamedArgument] -> String -> String)
-> Show NamedArgument
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> NamedArgument -> String -> String
showsPrec :: Int -> NamedArgument -> String -> String
$cshow :: NamedArgument -> String
show :: NamedArgument -> String
$cshowList :: [NamedArgument] -> String -> String
showList :: [NamedArgument] -> String -> String
Show)

_NamedArgument :: Name
_NamedArgument = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.NamedArgument")

_NamedArgument_name :: Name
_NamedArgument_name = (String -> Name
Core.Name String
"name")

_NamedArgument_value :: Name
_NamedArgument_value = (String -> Name
Core.Name String
"value")

newtype AttributeArgumentExpression = 
  AttributeArgumentExpression {
    AttributeArgumentExpression -> NonAssignmentExpression
unAttributeArgumentExpression :: NonAssignmentExpression}
  deriving (AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
(AttributeArgumentExpression
 -> AttributeArgumentExpression -> Bool)
-> (AttributeArgumentExpression
    -> AttributeArgumentExpression -> Bool)
-> Eq AttributeArgumentExpression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
== :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
$c/= :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
/= :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
Eq, Eq AttributeArgumentExpression
Eq AttributeArgumentExpression =>
(AttributeArgumentExpression
 -> AttributeArgumentExpression -> Ordering)
-> (AttributeArgumentExpression
    -> AttributeArgumentExpression -> Bool)
-> (AttributeArgumentExpression
    -> AttributeArgumentExpression -> Bool)
-> (AttributeArgumentExpression
    -> AttributeArgumentExpression -> Bool)
-> (AttributeArgumentExpression
    -> AttributeArgumentExpression -> Bool)
-> (AttributeArgumentExpression
    -> AttributeArgumentExpression -> AttributeArgumentExpression)
-> (AttributeArgumentExpression
    -> AttributeArgumentExpression -> AttributeArgumentExpression)
-> Ord AttributeArgumentExpression
AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
AttributeArgumentExpression
-> AttributeArgumentExpression -> Ordering
AttributeArgumentExpression
-> AttributeArgumentExpression -> AttributeArgumentExpression
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AttributeArgumentExpression
-> AttributeArgumentExpression -> Ordering
compare :: AttributeArgumentExpression
-> AttributeArgumentExpression -> Ordering
$c< :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
< :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
$c<= :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
<= :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
$c> :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
> :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
$c>= :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
>= :: AttributeArgumentExpression -> AttributeArgumentExpression -> Bool
$cmax :: AttributeArgumentExpression
-> AttributeArgumentExpression -> AttributeArgumentExpression
max :: AttributeArgumentExpression
-> AttributeArgumentExpression -> AttributeArgumentExpression
$cmin :: AttributeArgumentExpression
-> AttributeArgumentExpression -> AttributeArgumentExpression
min :: AttributeArgumentExpression
-> AttributeArgumentExpression -> AttributeArgumentExpression
Ord, ReadPrec [AttributeArgumentExpression]
ReadPrec AttributeArgumentExpression
Int -> ReadS AttributeArgumentExpression
ReadS [AttributeArgumentExpression]
(Int -> ReadS AttributeArgumentExpression)
-> ReadS [AttributeArgumentExpression]
-> ReadPrec AttributeArgumentExpression
-> ReadPrec [AttributeArgumentExpression]
-> Read AttributeArgumentExpression
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS AttributeArgumentExpression
readsPrec :: Int -> ReadS AttributeArgumentExpression
$creadList :: ReadS [AttributeArgumentExpression]
readList :: ReadS [AttributeArgumentExpression]
$creadPrec :: ReadPrec AttributeArgumentExpression
readPrec :: ReadPrec AttributeArgumentExpression
$creadListPrec :: ReadPrec [AttributeArgumentExpression]
readListPrec :: ReadPrec [AttributeArgumentExpression]
Read, Int -> AttributeArgumentExpression -> String -> String
[AttributeArgumentExpression] -> String -> String
AttributeArgumentExpression -> String
(Int -> AttributeArgumentExpression -> String -> String)
-> (AttributeArgumentExpression -> String)
-> ([AttributeArgumentExpression] -> String -> String)
-> Show AttributeArgumentExpression
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> AttributeArgumentExpression -> String -> String
showsPrec :: Int -> AttributeArgumentExpression -> String -> String
$cshow :: AttributeArgumentExpression -> String
show :: AttributeArgumentExpression -> String
$cshowList :: [AttributeArgumentExpression] -> String -> String
showList :: [AttributeArgumentExpression] -> String -> String
Show)

_AttributeArgumentExpression :: Name
_AttributeArgumentExpression = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.AttributeArgumentExpression")

data PointerType = 
  PointerTypeValueType (Maybe ValueType) |
  PointerTypePointerDepth Int
  deriving (PointerType -> PointerType -> Bool
(PointerType -> PointerType -> Bool)
-> (PointerType -> PointerType -> Bool) -> Eq PointerType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PointerType -> PointerType -> Bool
== :: PointerType -> PointerType -> Bool
$c/= :: PointerType -> PointerType -> Bool
/= :: PointerType -> PointerType -> Bool
Eq, Eq PointerType
Eq PointerType =>
(PointerType -> PointerType -> Ordering)
-> (PointerType -> PointerType -> Bool)
-> (PointerType -> PointerType -> Bool)
-> (PointerType -> PointerType -> Bool)
-> (PointerType -> PointerType -> Bool)
-> (PointerType -> PointerType -> PointerType)
-> (PointerType -> PointerType -> PointerType)
-> Ord PointerType
PointerType -> PointerType -> Bool
PointerType -> PointerType -> Ordering
PointerType -> PointerType -> PointerType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PointerType -> PointerType -> Ordering
compare :: PointerType -> PointerType -> Ordering
$c< :: PointerType -> PointerType -> Bool
< :: PointerType -> PointerType -> Bool
$c<= :: PointerType -> PointerType -> Bool
<= :: PointerType -> PointerType -> Bool
$c> :: PointerType -> PointerType -> Bool
> :: PointerType -> PointerType -> Bool
$c>= :: PointerType -> PointerType -> Bool
>= :: PointerType -> PointerType -> Bool
$cmax :: PointerType -> PointerType -> PointerType
max :: PointerType -> PointerType -> PointerType
$cmin :: PointerType -> PointerType -> PointerType
min :: PointerType -> PointerType -> PointerType
Ord, ReadPrec [PointerType]
ReadPrec PointerType
Int -> ReadS PointerType
ReadS [PointerType]
(Int -> ReadS PointerType)
-> ReadS [PointerType]
-> ReadPrec PointerType
-> ReadPrec [PointerType]
-> Read PointerType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PointerType
readsPrec :: Int -> ReadS PointerType
$creadList :: ReadS [PointerType]
readList :: ReadS [PointerType]
$creadPrec :: ReadPrec PointerType
readPrec :: ReadPrec PointerType
$creadListPrec :: ReadPrec [PointerType]
readListPrec :: ReadPrec [PointerType]
Read, Int -> PointerType -> String -> String
[PointerType] -> String -> String
PointerType -> String
(Int -> PointerType -> String -> String)
-> (PointerType -> String)
-> ([PointerType] -> String -> String)
-> Show PointerType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PointerType -> String -> String
showsPrec :: Int -> PointerType -> String -> String
$cshow :: PointerType -> String
show :: PointerType -> String
$cshowList :: [PointerType] -> String -> String
showList :: [PointerType] -> String -> String
Show)

_PointerType :: Name
_PointerType = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PointerType")

_PointerType_valueType :: Name
_PointerType_valueType = (String -> Name
Core.Name String
"valueType")

_PointerType_pointerDepth :: Name
_PointerType_pointerDepth = (String -> Name
Core.Name String
"pointerDepth")

data PointerMemberAccess = 
  PointerMemberAccess {
    PointerMemberAccess -> PrimaryExpression
pointerMemberAccessPointer :: PrimaryExpression,
    PointerMemberAccess -> Identifier
pointerMemberAccessMember :: Identifier,
    PointerMemberAccess -> Maybe TypeArgumentList
pointerMemberAccessTypeArguments :: (Maybe TypeArgumentList)}
  deriving (PointerMemberAccess -> PointerMemberAccess -> Bool
(PointerMemberAccess -> PointerMemberAccess -> Bool)
-> (PointerMemberAccess -> PointerMemberAccess -> Bool)
-> Eq PointerMemberAccess
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PointerMemberAccess -> PointerMemberAccess -> Bool
== :: PointerMemberAccess -> PointerMemberAccess -> Bool
$c/= :: PointerMemberAccess -> PointerMemberAccess -> Bool
/= :: PointerMemberAccess -> PointerMemberAccess -> Bool
Eq, Eq PointerMemberAccess
Eq PointerMemberAccess =>
(PointerMemberAccess -> PointerMemberAccess -> Ordering)
-> (PointerMemberAccess -> PointerMemberAccess -> Bool)
-> (PointerMemberAccess -> PointerMemberAccess -> Bool)
-> (PointerMemberAccess -> PointerMemberAccess -> Bool)
-> (PointerMemberAccess -> PointerMemberAccess -> Bool)
-> (PointerMemberAccess
    -> PointerMemberAccess -> PointerMemberAccess)
-> (PointerMemberAccess
    -> PointerMemberAccess -> PointerMemberAccess)
-> Ord PointerMemberAccess
PointerMemberAccess -> PointerMemberAccess -> Bool
PointerMemberAccess -> PointerMemberAccess -> Ordering
PointerMemberAccess -> PointerMemberAccess -> PointerMemberAccess
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PointerMemberAccess -> PointerMemberAccess -> Ordering
compare :: PointerMemberAccess -> PointerMemberAccess -> Ordering
$c< :: PointerMemberAccess -> PointerMemberAccess -> Bool
< :: PointerMemberAccess -> PointerMemberAccess -> Bool
$c<= :: PointerMemberAccess -> PointerMemberAccess -> Bool
<= :: PointerMemberAccess -> PointerMemberAccess -> Bool
$c> :: PointerMemberAccess -> PointerMemberAccess -> Bool
> :: PointerMemberAccess -> PointerMemberAccess -> Bool
$c>= :: PointerMemberAccess -> PointerMemberAccess -> Bool
>= :: PointerMemberAccess -> PointerMemberAccess -> Bool
$cmax :: PointerMemberAccess -> PointerMemberAccess -> PointerMemberAccess
max :: PointerMemberAccess -> PointerMemberAccess -> PointerMemberAccess
$cmin :: PointerMemberAccess -> PointerMemberAccess -> PointerMemberAccess
min :: PointerMemberAccess -> PointerMemberAccess -> PointerMemberAccess
Ord, ReadPrec [PointerMemberAccess]
ReadPrec PointerMemberAccess
Int -> ReadS PointerMemberAccess
ReadS [PointerMemberAccess]
(Int -> ReadS PointerMemberAccess)
-> ReadS [PointerMemberAccess]
-> ReadPrec PointerMemberAccess
-> ReadPrec [PointerMemberAccess]
-> Read PointerMemberAccess
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PointerMemberAccess
readsPrec :: Int -> ReadS PointerMemberAccess
$creadList :: ReadS [PointerMemberAccess]
readList :: ReadS [PointerMemberAccess]
$creadPrec :: ReadPrec PointerMemberAccess
readPrec :: ReadPrec PointerMemberAccess
$creadListPrec :: ReadPrec [PointerMemberAccess]
readListPrec :: ReadPrec [PointerMemberAccess]
Read, Int -> PointerMemberAccess -> String -> String
[PointerMemberAccess] -> String -> String
PointerMemberAccess -> String
(Int -> PointerMemberAccess -> String -> String)
-> (PointerMemberAccess -> String)
-> ([PointerMemberAccess] -> String -> String)
-> Show PointerMemberAccess
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PointerMemberAccess -> String -> String
showsPrec :: Int -> PointerMemberAccess -> String -> String
$cshow :: PointerMemberAccess -> String
show :: PointerMemberAccess -> String
$cshowList :: [PointerMemberAccess] -> String -> String
showList :: [PointerMemberAccess] -> String -> String
Show)

_PointerMemberAccess :: Name
_PointerMemberAccess = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PointerMemberAccess")

_PointerMemberAccess_pointer :: Name
_PointerMemberAccess_pointer = (String -> Name
Core.Name String
"pointer")

_PointerMemberAccess_member :: Name
_PointerMemberAccess_member = (String -> Name
Core.Name String
"member")

_PointerMemberAccess_typeArguments :: Name
_PointerMemberAccess_typeArguments = (String -> Name
Core.Name String
"typeArguments")

data PointerElementAccess = 
  PointerElementAccess {
    PointerElementAccess -> PrimaryNoArrayCreationExpression
pointerElementAccessPointer :: PrimaryNoArrayCreationExpression,
    PointerElementAccess -> Expression
pointerElementAccessIndex :: Expression}
  deriving (PointerElementAccess -> PointerElementAccess -> Bool
(PointerElementAccess -> PointerElementAccess -> Bool)
-> (PointerElementAccess -> PointerElementAccess -> Bool)
-> Eq PointerElementAccess
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PointerElementAccess -> PointerElementAccess -> Bool
== :: PointerElementAccess -> PointerElementAccess -> Bool
$c/= :: PointerElementAccess -> PointerElementAccess -> Bool
/= :: PointerElementAccess -> PointerElementAccess -> Bool
Eq, Eq PointerElementAccess
Eq PointerElementAccess =>
(PointerElementAccess -> PointerElementAccess -> Ordering)
-> (PointerElementAccess -> PointerElementAccess -> Bool)
-> (PointerElementAccess -> PointerElementAccess -> Bool)
-> (PointerElementAccess -> PointerElementAccess -> Bool)
-> (PointerElementAccess -> PointerElementAccess -> Bool)
-> (PointerElementAccess
    -> PointerElementAccess -> PointerElementAccess)
-> (PointerElementAccess
    -> PointerElementAccess -> PointerElementAccess)
-> Ord PointerElementAccess
PointerElementAccess -> PointerElementAccess -> Bool
PointerElementAccess -> PointerElementAccess -> Ordering
PointerElementAccess
-> PointerElementAccess -> PointerElementAccess
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PointerElementAccess -> PointerElementAccess -> Ordering
compare :: PointerElementAccess -> PointerElementAccess -> Ordering
$c< :: PointerElementAccess -> PointerElementAccess -> Bool
< :: PointerElementAccess -> PointerElementAccess -> Bool
$c<= :: PointerElementAccess -> PointerElementAccess -> Bool
<= :: PointerElementAccess -> PointerElementAccess -> Bool
$c> :: PointerElementAccess -> PointerElementAccess -> Bool
> :: PointerElementAccess -> PointerElementAccess -> Bool
$c>= :: PointerElementAccess -> PointerElementAccess -> Bool
>= :: PointerElementAccess -> PointerElementAccess -> Bool
$cmax :: PointerElementAccess
-> PointerElementAccess -> PointerElementAccess
max :: PointerElementAccess
-> PointerElementAccess -> PointerElementAccess
$cmin :: PointerElementAccess
-> PointerElementAccess -> PointerElementAccess
min :: PointerElementAccess
-> PointerElementAccess -> PointerElementAccess
Ord, ReadPrec [PointerElementAccess]
ReadPrec PointerElementAccess
Int -> ReadS PointerElementAccess
ReadS [PointerElementAccess]
(Int -> ReadS PointerElementAccess)
-> ReadS [PointerElementAccess]
-> ReadPrec PointerElementAccess
-> ReadPrec [PointerElementAccess]
-> Read PointerElementAccess
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PointerElementAccess
readsPrec :: Int -> ReadS PointerElementAccess
$creadList :: ReadS [PointerElementAccess]
readList :: ReadS [PointerElementAccess]
$creadPrec :: ReadPrec PointerElementAccess
readPrec :: ReadPrec PointerElementAccess
$creadListPrec :: ReadPrec [PointerElementAccess]
readListPrec :: ReadPrec [PointerElementAccess]
Read, Int -> PointerElementAccess -> String -> String
[PointerElementAccess] -> String -> String
PointerElementAccess -> String
(Int -> PointerElementAccess -> String -> String)
-> (PointerElementAccess -> String)
-> ([PointerElementAccess] -> String -> String)
-> Show PointerElementAccess
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PointerElementAccess -> String -> String
showsPrec :: Int -> PointerElementAccess -> String -> String
$cshow :: PointerElementAccess -> String
show :: PointerElementAccess -> String
$cshowList :: [PointerElementAccess] -> String -> String
showList :: [PointerElementAccess] -> String -> String
Show)

_PointerElementAccess :: Name
_PointerElementAccess = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.PointerElementAccess")

_PointerElementAccess_pointer :: Name
_PointerElementAccess_pointer = (String -> Name
Core.Name String
"pointer")

_PointerElementAccess_index :: Name
_PointerElementAccess_index = (String -> Name
Core.Name String
"index")

data FixedStatement = 
  FixedStatement {
    FixedStatement -> PointerType
fixedStatementPointerType :: PointerType,
    FixedStatement -> [FixedPointerDeclarator]
fixedStatementDeclarators :: [FixedPointerDeclarator],
    FixedStatement -> EmbeddedStatement
fixedStatementStatement :: EmbeddedStatement}
  deriving (FixedStatement -> FixedStatement -> Bool
(FixedStatement -> FixedStatement -> Bool)
-> (FixedStatement -> FixedStatement -> Bool) -> Eq FixedStatement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FixedStatement -> FixedStatement -> Bool
== :: FixedStatement -> FixedStatement -> Bool
$c/= :: FixedStatement -> FixedStatement -> Bool
/= :: FixedStatement -> FixedStatement -> Bool
Eq, Eq FixedStatement
Eq FixedStatement =>
(FixedStatement -> FixedStatement -> Ordering)
-> (FixedStatement -> FixedStatement -> Bool)
-> (FixedStatement -> FixedStatement -> Bool)
-> (FixedStatement -> FixedStatement -> Bool)
-> (FixedStatement -> FixedStatement -> Bool)
-> (FixedStatement -> FixedStatement -> FixedStatement)
-> (FixedStatement -> FixedStatement -> FixedStatement)
-> Ord FixedStatement
FixedStatement -> FixedStatement -> Bool
FixedStatement -> FixedStatement -> Ordering
FixedStatement -> FixedStatement -> FixedStatement
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FixedStatement -> FixedStatement -> Ordering
compare :: FixedStatement -> FixedStatement -> Ordering
$c< :: FixedStatement -> FixedStatement -> Bool
< :: FixedStatement -> FixedStatement -> Bool
$c<= :: FixedStatement -> FixedStatement -> Bool
<= :: FixedStatement -> FixedStatement -> Bool
$c> :: FixedStatement -> FixedStatement -> Bool
> :: FixedStatement -> FixedStatement -> Bool
$c>= :: FixedStatement -> FixedStatement -> Bool
>= :: FixedStatement -> FixedStatement -> Bool
$cmax :: FixedStatement -> FixedStatement -> FixedStatement
max :: FixedStatement -> FixedStatement -> FixedStatement
$cmin :: FixedStatement -> FixedStatement -> FixedStatement
min :: FixedStatement -> FixedStatement -> FixedStatement
Ord, ReadPrec [FixedStatement]
ReadPrec FixedStatement
Int -> ReadS FixedStatement
ReadS [FixedStatement]
(Int -> ReadS FixedStatement)
-> ReadS [FixedStatement]
-> ReadPrec FixedStatement
-> ReadPrec [FixedStatement]
-> Read FixedStatement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FixedStatement
readsPrec :: Int -> ReadS FixedStatement
$creadList :: ReadS [FixedStatement]
readList :: ReadS [FixedStatement]
$creadPrec :: ReadPrec FixedStatement
readPrec :: ReadPrec FixedStatement
$creadListPrec :: ReadPrec [FixedStatement]
readListPrec :: ReadPrec [FixedStatement]
Read, Int -> FixedStatement -> String -> String
[FixedStatement] -> String -> String
FixedStatement -> String
(Int -> FixedStatement -> String -> String)
-> (FixedStatement -> String)
-> ([FixedStatement] -> String -> String)
-> Show FixedStatement
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FixedStatement -> String -> String
showsPrec :: Int -> FixedStatement -> String -> String
$cshow :: FixedStatement -> String
show :: FixedStatement -> String
$cshowList :: [FixedStatement] -> String -> String
showList :: [FixedStatement] -> String -> String
Show)

_FixedStatement :: Name
_FixedStatement = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FixedStatement")

_FixedStatement_pointerType :: Name
_FixedStatement_pointerType = (String -> Name
Core.Name String
"pointerType")

_FixedStatement_declarators :: Name
_FixedStatement_declarators = (String -> Name
Core.Name String
"declarators")

_FixedStatement_statement :: Name
_FixedStatement_statement = (String -> Name
Core.Name String
"statement")

data FixedPointerDeclarator = 
  FixedPointerDeclaratorReference VariableReference |
  FixedPointerDeclaratorExpression Expression
  deriving (FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
(FixedPointerDeclarator -> FixedPointerDeclarator -> Bool)
-> (FixedPointerDeclarator -> FixedPointerDeclarator -> Bool)
-> Eq FixedPointerDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
== :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
$c/= :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
/= :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
Eq, Eq FixedPointerDeclarator
Eq FixedPointerDeclarator =>
(FixedPointerDeclarator -> FixedPointerDeclarator -> Ordering)
-> (FixedPointerDeclarator -> FixedPointerDeclarator -> Bool)
-> (FixedPointerDeclarator -> FixedPointerDeclarator -> Bool)
-> (FixedPointerDeclarator -> FixedPointerDeclarator -> Bool)
-> (FixedPointerDeclarator -> FixedPointerDeclarator -> Bool)
-> (FixedPointerDeclarator
    -> FixedPointerDeclarator -> FixedPointerDeclarator)
-> (FixedPointerDeclarator
    -> FixedPointerDeclarator -> FixedPointerDeclarator)
-> Ord FixedPointerDeclarator
FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
FixedPointerDeclarator -> FixedPointerDeclarator -> Ordering
FixedPointerDeclarator
-> FixedPointerDeclarator -> FixedPointerDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FixedPointerDeclarator -> FixedPointerDeclarator -> Ordering
compare :: FixedPointerDeclarator -> FixedPointerDeclarator -> Ordering
$c< :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
< :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
$c<= :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
<= :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
$c> :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
> :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
$c>= :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
>= :: FixedPointerDeclarator -> FixedPointerDeclarator -> Bool
$cmax :: FixedPointerDeclarator
-> FixedPointerDeclarator -> FixedPointerDeclarator
max :: FixedPointerDeclarator
-> FixedPointerDeclarator -> FixedPointerDeclarator
$cmin :: FixedPointerDeclarator
-> FixedPointerDeclarator -> FixedPointerDeclarator
min :: FixedPointerDeclarator
-> FixedPointerDeclarator -> FixedPointerDeclarator
Ord, ReadPrec [FixedPointerDeclarator]
ReadPrec FixedPointerDeclarator
Int -> ReadS FixedPointerDeclarator
ReadS [FixedPointerDeclarator]
(Int -> ReadS FixedPointerDeclarator)
-> ReadS [FixedPointerDeclarator]
-> ReadPrec FixedPointerDeclarator
-> ReadPrec [FixedPointerDeclarator]
-> Read FixedPointerDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FixedPointerDeclarator
readsPrec :: Int -> ReadS FixedPointerDeclarator
$creadList :: ReadS [FixedPointerDeclarator]
readList :: ReadS [FixedPointerDeclarator]
$creadPrec :: ReadPrec FixedPointerDeclarator
readPrec :: ReadPrec FixedPointerDeclarator
$creadListPrec :: ReadPrec [FixedPointerDeclarator]
readListPrec :: ReadPrec [FixedPointerDeclarator]
Read, Int -> FixedPointerDeclarator -> String -> String
[FixedPointerDeclarator] -> String -> String
FixedPointerDeclarator -> String
(Int -> FixedPointerDeclarator -> String -> String)
-> (FixedPointerDeclarator -> String)
-> ([FixedPointerDeclarator] -> String -> String)
-> Show FixedPointerDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FixedPointerDeclarator -> String -> String
showsPrec :: Int -> FixedPointerDeclarator -> String -> String
$cshow :: FixedPointerDeclarator -> String
show :: FixedPointerDeclarator -> String
$cshowList :: [FixedPointerDeclarator] -> String -> String
showList :: [FixedPointerDeclarator] -> String -> String
Show)

_FixedPointerDeclarator :: Name
_FixedPointerDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FixedPointerDeclarator")

_FixedPointerDeclarator_reference :: Name
_FixedPointerDeclarator_reference = (String -> Name
Core.Name String
"reference")

_FixedPointerDeclarator_expression :: Name
_FixedPointerDeclarator_expression = (String -> Name
Core.Name String
"expression")

data FixedSizeBufferDeclaration = 
  FixedSizeBufferDeclaration {
    FixedSizeBufferDeclaration -> Maybe Attributes
fixedSizeBufferDeclarationAttributes :: (Maybe Attributes),
    FixedSizeBufferDeclaration -> [FixedSizeBufferModifier]
fixedSizeBufferDeclarationModifiers :: [FixedSizeBufferModifier],
    FixedSizeBufferDeclaration -> Type
fixedSizeBufferDeclarationElementType :: Type,
    FixedSizeBufferDeclaration -> [FixedSizeBufferDeclarator]
fixedSizeBufferDeclarationDeclarators :: [FixedSizeBufferDeclarator]}
  deriving (FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
(FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool)
-> (FixedSizeBufferDeclaration
    -> FixedSizeBufferDeclaration -> Bool)
-> Eq FixedSizeBufferDeclaration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
== :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
$c/= :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
/= :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
Eq, Eq FixedSizeBufferDeclaration
Eq FixedSizeBufferDeclaration =>
(FixedSizeBufferDeclaration
 -> FixedSizeBufferDeclaration -> Ordering)
-> (FixedSizeBufferDeclaration
    -> FixedSizeBufferDeclaration -> Bool)
-> (FixedSizeBufferDeclaration
    -> FixedSizeBufferDeclaration -> Bool)
-> (FixedSizeBufferDeclaration
    -> FixedSizeBufferDeclaration -> Bool)
-> (FixedSizeBufferDeclaration
    -> FixedSizeBufferDeclaration -> Bool)
-> (FixedSizeBufferDeclaration
    -> FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration)
-> (FixedSizeBufferDeclaration
    -> FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration)
-> Ord FixedSizeBufferDeclaration
FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
FixedSizeBufferDeclaration
-> FixedSizeBufferDeclaration -> Ordering
FixedSizeBufferDeclaration
-> FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FixedSizeBufferDeclaration
-> FixedSizeBufferDeclaration -> Ordering
compare :: FixedSizeBufferDeclaration
-> FixedSizeBufferDeclaration -> Ordering
$c< :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
< :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
$c<= :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
<= :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
$c> :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
> :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
$c>= :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
>= :: FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration -> Bool
$cmax :: FixedSizeBufferDeclaration
-> FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration
max :: FixedSizeBufferDeclaration
-> FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration
$cmin :: FixedSizeBufferDeclaration
-> FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration
min :: FixedSizeBufferDeclaration
-> FixedSizeBufferDeclaration -> FixedSizeBufferDeclaration
Ord, ReadPrec [FixedSizeBufferDeclaration]
ReadPrec FixedSizeBufferDeclaration
Int -> ReadS FixedSizeBufferDeclaration
ReadS [FixedSizeBufferDeclaration]
(Int -> ReadS FixedSizeBufferDeclaration)
-> ReadS [FixedSizeBufferDeclaration]
-> ReadPrec FixedSizeBufferDeclaration
-> ReadPrec [FixedSizeBufferDeclaration]
-> Read FixedSizeBufferDeclaration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FixedSizeBufferDeclaration
readsPrec :: Int -> ReadS FixedSizeBufferDeclaration
$creadList :: ReadS [FixedSizeBufferDeclaration]
readList :: ReadS [FixedSizeBufferDeclaration]
$creadPrec :: ReadPrec FixedSizeBufferDeclaration
readPrec :: ReadPrec FixedSizeBufferDeclaration
$creadListPrec :: ReadPrec [FixedSizeBufferDeclaration]
readListPrec :: ReadPrec [FixedSizeBufferDeclaration]
Read, Int -> FixedSizeBufferDeclaration -> String -> String
[FixedSizeBufferDeclaration] -> String -> String
FixedSizeBufferDeclaration -> String
(Int -> FixedSizeBufferDeclaration -> String -> String)
-> (FixedSizeBufferDeclaration -> String)
-> ([FixedSizeBufferDeclaration] -> String -> String)
-> Show FixedSizeBufferDeclaration
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FixedSizeBufferDeclaration -> String -> String
showsPrec :: Int -> FixedSizeBufferDeclaration -> String -> String
$cshow :: FixedSizeBufferDeclaration -> String
show :: FixedSizeBufferDeclaration -> String
$cshowList :: [FixedSizeBufferDeclaration] -> String -> String
showList :: [FixedSizeBufferDeclaration] -> String -> String
Show)

_FixedSizeBufferDeclaration :: Name
_FixedSizeBufferDeclaration = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FixedSizeBufferDeclaration")

_FixedSizeBufferDeclaration_attributes :: Name
_FixedSizeBufferDeclaration_attributes = (String -> Name
Core.Name String
"attributes")

_FixedSizeBufferDeclaration_modifiers :: Name
_FixedSizeBufferDeclaration_modifiers = (String -> Name
Core.Name String
"modifiers")

_FixedSizeBufferDeclaration_elementType :: Name
_FixedSizeBufferDeclaration_elementType = (String -> Name
Core.Name String
"elementType")

_FixedSizeBufferDeclaration_declarators :: Name
_FixedSizeBufferDeclaration_declarators = (String -> Name
Core.Name String
"declarators")

data FixedSizeBufferModifier = 
  FixedSizeBufferModifierNew  |
  FixedSizeBufferModifierPublic  |
  FixedSizeBufferModifierInternal  |
  FixedSizeBufferModifierPrivate  |
  FixedSizeBufferModifierUnsafe 
  deriving (FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
(FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool)
-> (FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool)
-> Eq FixedSizeBufferModifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
== :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
$c/= :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
/= :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
Eq, Eq FixedSizeBufferModifier
Eq FixedSizeBufferModifier =>
(FixedSizeBufferModifier -> FixedSizeBufferModifier -> Ordering)
-> (FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool)
-> (FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool)
-> (FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool)
-> (FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool)
-> (FixedSizeBufferModifier
    -> FixedSizeBufferModifier -> FixedSizeBufferModifier)
-> (FixedSizeBufferModifier
    -> FixedSizeBufferModifier -> FixedSizeBufferModifier)
-> Ord FixedSizeBufferModifier
FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
FixedSizeBufferModifier -> FixedSizeBufferModifier -> Ordering
FixedSizeBufferModifier
-> FixedSizeBufferModifier -> FixedSizeBufferModifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Ordering
compare :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Ordering
$c< :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
< :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
$c<= :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
<= :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
$c> :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
> :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
$c>= :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
>= :: FixedSizeBufferModifier -> FixedSizeBufferModifier -> Bool
$cmax :: FixedSizeBufferModifier
-> FixedSizeBufferModifier -> FixedSizeBufferModifier
max :: FixedSizeBufferModifier
-> FixedSizeBufferModifier -> FixedSizeBufferModifier
$cmin :: FixedSizeBufferModifier
-> FixedSizeBufferModifier -> FixedSizeBufferModifier
min :: FixedSizeBufferModifier
-> FixedSizeBufferModifier -> FixedSizeBufferModifier
Ord, ReadPrec [FixedSizeBufferModifier]
ReadPrec FixedSizeBufferModifier
Int -> ReadS FixedSizeBufferModifier
ReadS [FixedSizeBufferModifier]
(Int -> ReadS FixedSizeBufferModifier)
-> ReadS [FixedSizeBufferModifier]
-> ReadPrec FixedSizeBufferModifier
-> ReadPrec [FixedSizeBufferModifier]
-> Read FixedSizeBufferModifier
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FixedSizeBufferModifier
readsPrec :: Int -> ReadS FixedSizeBufferModifier
$creadList :: ReadS [FixedSizeBufferModifier]
readList :: ReadS [FixedSizeBufferModifier]
$creadPrec :: ReadPrec FixedSizeBufferModifier
readPrec :: ReadPrec FixedSizeBufferModifier
$creadListPrec :: ReadPrec [FixedSizeBufferModifier]
readListPrec :: ReadPrec [FixedSizeBufferModifier]
Read, Int -> FixedSizeBufferModifier -> String -> String
[FixedSizeBufferModifier] -> String -> String
FixedSizeBufferModifier -> String
(Int -> FixedSizeBufferModifier -> String -> String)
-> (FixedSizeBufferModifier -> String)
-> ([FixedSizeBufferModifier] -> String -> String)
-> Show FixedSizeBufferModifier
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FixedSizeBufferModifier -> String -> String
showsPrec :: Int -> FixedSizeBufferModifier -> String -> String
$cshow :: FixedSizeBufferModifier -> String
show :: FixedSizeBufferModifier -> String
$cshowList :: [FixedSizeBufferModifier] -> String -> String
showList :: [FixedSizeBufferModifier] -> String -> String
Show)

_FixedSizeBufferModifier :: Name
_FixedSizeBufferModifier = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FixedSizeBufferModifier")

_FixedSizeBufferModifier_new :: Name
_FixedSizeBufferModifier_new = (String -> Name
Core.Name String
"new")

_FixedSizeBufferModifier_public :: Name
_FixedSizeBufferModifier_public = (String -> Name
Core.Name String
"public")

_FixedSizeBufferModifier_internal :: Name
_FixedSizeBufferModifier_internal = (String -> Name
Core.Name String
"internal")

_FixedSizeBufferModifier_private :: Name
_FixedSizeBufferModifier_private = (String -> Name
Core.Name String
"private")

_FixedSizeBufferModifier_unsafe :: Name
_FixedSizeBufferModifier_unsafe = (String -> Name
Core.Name String
"unsafe")

data FixedSizeBufferDeclarator = 
  FixedSizeBufferDeclarator {
    FixedSizeBufferDeclarator -> Identifier
fixedSizeBufferDeclaratorName :: Identifier,
    FixedSizeBufferDeclarator -> ConstantExpression
fixedSizeBufferDeclaratorSize :: ConstantExpression}
  deriving (FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
(FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool)
-> (FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool)
-> Eq FixedSizeBufferDeclarator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
== :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
$c/= :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
/= :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
Eq, Eq FixedSizeBufferDeclarator
Eq FixedSizeBufferDeclarator =>
(FixedSizeBufferDeclarator
 -> FixedSizeBufferDeclarator -> Ordering)
-> (FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool)
-> (FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool)
-> (FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool)
-> (FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool)
-> (FixedSizeBufferDeclarator
    -> FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator)
-> (FixedSizeBufferDeclarator
    -> FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator)
-> Ord FixedSizeBufferDeclarator
FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Ordering
FixedSizeBufferDeclarator
-> FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Ordering
compare :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Ordering
$c< :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
< :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
$c<= :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
<= :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
$c> :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
> :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
$c>= :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
>= :: FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator -> Bool
$cmax :: FixedSizeBufferDeclarator
-> FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator
max :: FixedSizeBufferDeclarator
-> FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator
$cmin :: FixedSizeBufferDeclarator
-> FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator
min :: FixedSizeBufferDeclarator
-> FixedSizeBufferDeclarator -> FixedSizeBufferDeclarator
Ord, ReadPrec [FixedSizeBufferDeclarator]
ReadPrec FixedSizeBufferDeclarator
Int -> ReadS FixedSizeBufferDeclarator
ReadS [FixedSizeBufferDeclarator]
(Int -> ReadS FixedSizeBufferDeclarator)
-> ReadS [FixedSizeBufferDeclarator]
-> ReadPrec FixedSizeBufferDeclarator
-> ReadPrec [FixedSizeBufferDeclarator]
-> Read FixedSizeBufferDeclarator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS FixedSizeBufferDeclarator
readsPrec :: Int -> ReadS FixedSizeBufferDeclarator
$creadList :: ReadS [FixedSizeBufferDeclarator]
readList :: ReadS [FixedSizeBufferDeclarator]
$creadPrec :: ReadPrec FixedSizeBufferDeclarator
readPrec :: ReadPrec FixedSizeBufferDeclarator
$creadListPrec :: ReadPrec [FixedSizeBufferDeclarator]
readListPrec :: ReadPrec [FixedSizeBufferDeclarator]
Read, Int -> FixedSizeBufferDeclarator -> String -> String
[FixedSizeBufferDeclarator] -> String -> String
FixedSizeBufferDeclarator -> String
(Int -> FixedSizeBufferDeclarator -> String -> String)
-> (FixedSizeBufferDeclarator -> String)
-> ([FixedSizeBufferDeclarator] -> String -> String)
-> Show FixedSizeBufferDeclarator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> FixedSizeBufferDeclarator -> String -> String
showsPrec :: Int -> FixedSizeBufferDeclarator -> String -> String
$cshow :: FixedSizeBufferDeclarator -> String
show :: FixedSizeBufferDeclarator -> String
$cshowList :: [FixedSizeBufferDeclarator] -> String -> String
showList :: [FixedSizeBufferDeclarator] -> String -> String
Show)

_FixedSizeBufferDeclarator :: Name
_FixedSizeBufferDeclarator = (String -> Name
Core.Name String
"hydra/ext/csharp/syntax.FixedSizeBufferDeclarator")

_FixedSizeBufferDeclarator_name :: Name
_FixedSizeBufferDeclarator_name = (String -> Name
Core.Name String
"name")

_FixedSizeBufferDeclarator_size :: Name
_FixedSizeBufferDeclarator_size = (String -> Name
Core.Name String
"size")