hydra-python-0.17.0: src/main/haskell/Hydra/Python/Syntax.hs

-- Note: this is an automatically generated file. Do not edit.

-- | A Python syntax model, tracking the Python 3.14 PEG grammar:
-- |   https://docs.python.org/3.14/reference/grammar.html

module Hydra.Python.Syntax where

import qualified Hydra.Core as Core
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci

data AnnotatedStatement =
  AnnotatedStatement {
    annotatedStatementComment :: String,
    annotatedStatementStatement :: Statement}
  deriving (Eq, Ord, Read, Show)

_AnnotatedStatement = Core.Name "hydra.python.syntax.AnnotatedStatement"

_AnnotatedStatement_comment = Core.Name "comment"

_AnnotatedStatement_statement = Core.Name "statement"

newtype Module =
  Module {
    unModule :: [[Statement]]}
  deriving (Eq, Ord, Read, Show)

_Module = Core.Name "hydra.python.syntax.Module"

data QuoteStyle =
  QuoteStyleSingle |
  QuoteStyleDouble |
  QuoteStyleTripleSingle |
  QuoteStyleTripleDouble
  deriving (Eq, Ord, Read, Show)

_QuoteStyle = Core.Name "hydra.python.syntax.QuoteStyle"

_QuoteStyle_single = Core.Name "single"

_QuoteStyle_double = Core.Name "double"

_QuoteStyle_tripleSingle = Core.Name "tripleSingle"

_QuoteStyle_tripleDouble = Core.Name "tripleDouble"

data StringPrefix =
  StringPrefixRaw |
  StringPrefixBytes |
  StringPrefixRawBytes |
  StringPrefixUnicode
  deriving (Eq, Ord, Read, Show)

_StringPrefix = Core.Name "hydra.python.syntax.StringPrefix"

_StringPrefix_raw = Core.Name "raw"

_StringPrefix_bytes = Core.Name "bytes"

_StringPrefix_rawBytes = Core.Name "rawBytes"

_StringPrefix_unicode = Core.Name "unicode"

newtype Name =
  Name {
    unName :: String}
  deriving (Eq, Ord, Read, Show)

_Name = Core.Name "hydra.python.syntax.Name"

data Number =
  NumberInteger Integer |
  NumberFloat Double |
  NumberImaginary Double
  deriving (Eq, Ord, Read, Show)

_Number = Core.Name "hydra.python.syntax.Number"

_Number_integer = Core.Name "integer"

_Number_float = Core.Name "float"

_Number_imaginary = Core.Name "imaginary"

data String_ =
  String_ {
    stringValue :: String,
    stringPrefix :: (Maybe StringPrefix),
    stringQuoteStyle :: QuoteStyle}
  deriving (Eq, Ord, Read, Show)

_String = Core.Name "hydra.python.syntax.String"

_String_value = Core.Name "value"

_String_prefix = Core.Name "prefix"

_String_quoteStyle = Core.Name "quoteStyle"

newtype TypeComment =
  TypeComment {
    unTypeComment :: String}
  deriving (Eq, Ord, Read, Show)

_TypeComment = Core.Name "hydra.python.syntax.TypeComment"

newtype File =
  File {
    unFile :: [Statement]}
  deriving (Eq, Ord, Read, Show)

_File = Core.Name "hydra.python.syntax.File"

newtype Interactive =
  Interactive {
    unInteractive :: Statement}
  deriving (Eq, Ord, Read, Show)

_Interactive = Core.Name "hydra.python.syntax.Interactive"

newtype Eval =
  Eval {
    unEval :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_Eval = Core.Name "hydra.python.syntax.Eval"

data Statement =
  StatementCompound CompoundStatement |
  StatementSimple [SimpleStatement] |
  StatementAnnotated AnnotatedStatement
  deriving (Eq, Ord, Read, Show)

_Statement = Core.Name "hydra.python.syntax.Statement"

_Statement_compound = Core.Name "compound"

_Statement_simple = Core.Name "simple"

_Statement_annotated = Core.Name "annotated"

data SimpleStatement =
  SimpleStatementAssignment Assignment |
  SimpleStatementTypeAlias TypeAlias |
  SimpleStatementStarExpressions [StarExpression] |
  SimpleStatementReturn ReturnStatement |
  SimpleStatementImport ImportStatement |
  SimpleStatementRaise RaiseStatement |
  SimpleStatementPass |
  SimpleStatementDel DelStatement |
  SimpleStatementYield YieldStatement |
  SimpleStatementAssert AssertStatement |
  SimpleStatementBreak |
  SimpleStatementContinue |
  SimpleStatementGlobal [Name] |
  SimpleStatementNonlocal [Name]
  deriving (Eq, Ord, Read, Show)

_SimpleStatement = Core.Name "hydra.python.syntax.SimpleStatement"

_SimpleStatement_assignment = Core.Name "assignment"

_SimpleStatement_typeAlias = Core.Name "typeAlias"

_SimpleStatement_starExpressions = Core.Name "starExpressions"

_SimpleStatement_return = Core.Name "return"

_SimpleStatement_import = Core.Name "import"

_SimpleStatement_raise = Core.Name "raise"

_SimpleStatement_pass = Core.Name "pass"

_SimpleStatement_del = Core.Name "del"

_SimpleStatement_yield = Core.Name "yield"

_SimpleStatement_assert = Core.Name "assert"

_SimpleStatement_break = Core.Name "break"

_SimpleStatement_continue = Core.Name "continue"

_SimpleStatement_global = Core.Name "global"

_SimpleStatement_nonlocal = Core.Name "nonlocal"

data CompoundStatement =
  CompoundStatementFunction FunctionDefinition |
  CompoundStatementIf IfStatement |
  CompoundStatementClassDef ClassDefinition |
  CompoundStatementWith WithStatement |
  CompoundStatementFor ForStatement |
  CompoundStatementTry TryStatement |
  CompoundStatementWhile WhileStatement |
  CompoundStatementMatch MatchStatement
  deriving (Eq, Ord, Read, Show)

_CompoundStatement = Core.Name "hydra.python.syntax.CompoundStatement"

_CompoundStatement_function = Core.Name "function"

_CompoundStatement_if = Core.Name "if"

_CompoundStatement_classDef = Core.Name "classDef"

_CompoundStatement_with = Core.Name "with"

_CompoundStatement_for = Core.Name "for"

_CompoundStatement_try = Core.Name "try"

_CompoundStatement_while = Core.Name "while"

_CompoundStatement_match = Core.Name "match"

data Assignment =
  AssignmentTyped TypedAssignment |
  AssignmentUntyped UntypedAssignment |
  AssignmentAug AugAssignment
  deriving (Eq, Ord, Read, Show)

_Assignment = Core.Name "hydra.python.syntax.Assignment"

_Assignment_typed = Core.Name "typed"

_Assignment_untyped = Core.Name "untyped"

_Assignment_aug = Core.Name "aug"

data TypedAssignment =
  TypedAssignment {
    typedAssignmentLhs :: SingleTarget,
    typedAssignmentType :: Expression,
    typedAssignmentRhs :: (Maybe AnnotatedRhs)}
  deriving (Eq, Ord, Read, Show)

_TypedAssignment = Core.Name "hydra.python.syntax.TypedAssignment"

_TypedAssignment_lhs = Core.Name "lhs"

_TypedAssignment_type = Core.Name "type"

_TypedAssignment_rhs = Core.Name "rhs"

data UntypedAssignment =
  UntypedAssignment {
    untypedAssignmentTargets :: [StarTarget],
    untypedAssignmentRhs :: AnnotatedRhs,
    untypedAssignmentTypeComment :: (Maybe TypeComment)}
  deriving (Eq, Ord, Read, Show)

_UntypedAssignment = Core.Name "hydra.python.syntax.UntypedAssignment"

_UntypedAssignment_targets = Core.Name "targets"

_UntypedAssignment_rhs = Core.Name "rhs"

_UntypedAssignment_typeComment = Core.Name "typeComment"

data AugAssignment =
  AugAssignment {
    augAssignmentLhs :: SingleTarget,
    augAssignmentAugassign :: AugAssign,
    augAssignmentRhs :: AnnotatedRhs}
  deriving (Eq, Ord, Read, Show)

_AugAssignment = Core.Name "hydra.python.syntax.AugAssignment"

_AugAssignment_lhs = Core.Name "lhs"

_AugAssignment_augassign = Core.Name "augassign"

_AugAssignment_rhs = Core.Name "rhs"

data AnnotatedRhs =
  AnnotatedRhsYield YieldExpression |
  AnnotatedRhsStar [StarExpression]
  deriving (Eq, Ord, Read, Show)

_AnnotatedRhs = Core.Name "hydra.python.syntax.AnnotatedRhs"

_AnnotatedRhs_yield = Core.Name "yield"

_AnnotatedRhs_star = Core.Name "star"

data AugAssign =
  AugAssignPlusEqual |
  AugAssignMinusEqual |
  AugAssignTimesEqual |
  AugAssignAtEqual |
  AugAssignSlashEqual |
  AugAssignPercentEqual |
  AugAssignAmpersandEqual |
  AugAssignBarEqual |
  AugAssignCaretEqual |
  AugAssignLeftShiftEqual |
  AugAssignRightShiftEqual |
  AugAssignStarStarEqual |
  AugAssignDoubleSlashEqual
  deriving (Eq, Ord, Read, Show)

_AugAssign = Core.Name "hydra.python.syntax.AugAssign"

_AugAssign_plusEqual = Core.Name "plusEqual"

_AugAssign_minusEqual = Core.Name "minusEqual"

_AugAssign_timesEqual = Core.Name "timesEqual"

_AugAssign_atEqual = Core.Name "atEqual"

_AugAssign_slashEqual = Core.Name "slashEqual"

_AugAssign_percentEqual = Core.Name "percentEqual"

_AugAssign_ampersandEqual = Core.Name "ampersandEqual"

_AugAssign_barEqual = Core.Name "barEqual"

_AugAssign_caretEqual = Core.Name "caretEqual"

_AugAssign_leftShiftEqual = Core.Name "leftShiftEqual"

_AugAssign_rightShiftEqual = Core.Name "rightShiftEqual"

_AugAssign_starStarEqual = Core.Name "starStarEqual"

_AugAssign_doubleSlashEqual = Core.Name "doubleSlashEqual"

newtype ReturnStatement =
  ReturnStatement {
    unReturnStatement :: [StarExpression]}
  deriving (Eq, Ord, Read, Show)

_ReturnStatement = Core.Name "hydra.python.syntax.ReturnStatement"

newtype RaiseStatement =
  RaiseStatement {
    unRaiseStatement :: (Maybe RaiseExpression)}
  deriving (Eq, Ord, Read, Show)

_RaiseStatement = Core.Name "hydra.python.syntax.RaiseStatement"

data RaiseExpression =
  RaiseExpression {
    raiseExpressionExpression :: Expression,
    raiseExpressionFrom :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_RaiseExpression = Core.Name "hydra.python.syntax.RaiseExpression"

_RaiseExpression_expression = Core.Name "expression"

_RaiseExpression_from = Core.Name "from"

newtype DelStatement =
  DelStatement {
    unDelStatement :: DelTargets}
  deriving (Eq, Ord, Read, Show)

_DelStatement = Core.Name "hydra.python.syntax.DelStatement"

newtype YieldStatement =
  YieldStatement {
    unYieldStatement :: YieldExpression}
  deriving (Eq, Ord, Read, Show)

_YieldStatement = Core.Name "hydra.python.syntax.YieldStatement"

data AssertStatement =
  AssertStatement {
    assertStatementExpression1 :: Expression,
    assertStatementExpression2 :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_AssertStatement = Core.Name "hydra.python.syntax.AssertStatement"

_AssertStatement_expression1 = Core.Name "expression1"

_AssertStatement_expression2 = Core.Name "expression2"

data ImportStatement =
  ImportStatementName ImportName |
  ImportStatementFrom ImportFrom
  deriving (Eq, Ord, Read, Show)

_ImportStatement = Core.Name "hydra.python.syntax.ImportStatement"

_ImportStatement_name = Core.Name "name"

_ImportStatement_from = Core.Name "from"

newtype ImportName =
  ImportName {
    unImportName :: [DottedAsName]}
  deriving (Eq, Ord, Read, Show)

_ImportName = Core.Name "hydra.python.syntax.ImportName"

data ImportFrom =
  ImportFrom {
    importFromPrefixes :: [RelativeImportPrefix],
    importFromDottedName :: (Maybe DottedName),
    importFromTargets :: ImportFromTargets}
  deriving (Eq, Ord, Read, Show)

_ImportFrom = Core.Name "hydra.python.syntax.ImportFrom"

_ImportFrom_prefixes = Core.Name "prefixes"

_ImportFrom_dottedName = Core.Name "dottedName"

_ImportFrom_targets = Core.Name "targets"

data RelativeImportPrefix =
  RelativeImportPrefixDot |
  RelativeImportPrefixEllipsis
  deriving (Eq, Ord, Read, Show)

_RelativeImportPrefix = Core.Name "hydra.python.syntax.RelativeImportPrefix"

_RelativeImportPrefix_dot = Core.Name "dot"

_RelativeImportPrefix_ellipsis = Core.Name "ellipsis"

data ImportFromTargets =
  ImportFromTargetsSimple [ImportFromAsName] |
  ImportFromTargetsParens [ImportFromAsName] |
  ImportFromTargetsStar
  deriving (Eq, Ord, Read, Show)

_ImportFromTargets = Core.Name "hydra.python.syntax.ImportFromTargets"

_ImportFromTargets_simple = Core.Name "simple"

_ImportFromTargets_parens = Core.Name "parens"

_ImportFromTargets_star = Core.Name "star"

data ImportFromAsName =
  ImportFromAsName {
    importFromAsNameName :: Name,
    importFromAsNameAs :: (Maybe Name)}
  deriving (Eq, Ord, Read, Show)

_ImportFromAsName = Core.Name "hydra.python.syntax.ImportFromAsName"

_ImportFromAsName_name = Core.Name "name"

_ImportFromAsName_as = Core.Name "as"

data DottedAsName =
  DottedAsName {
    dottedAsNameName :: DottedName,
    dottedAsNameAs :: (Maybe Name)}
  deriving (Eq, Ord, Read, Show)

_DottedAsName = Core.Name "hydra.python.syntax.DottedAsName"

_DottedAsName_name = Core.Name "name"

_DottedAsName_as = Core.Name "as"

newtype DottedName =
  DottedName {
    unDottedName :: [Name]}
  deriving (Eq, Ord, Read, Show)

_DottedName = Core.Name "hydra.python.syntax.DottedName"

data Block =
  BlockIndented [[Statement]] |
  BlockSimple [SimpleStatement]
  deriving (Eq, Ord, Read, Show)

_Block = Core.Name "hydra.python.syntax.Block"

_Block_indented = Core.Name "indented"

_Block_simple = Core.Name "simple"

newtype Decorators =
  Decorators {
    unDecorators :: [NamedExpression]}
  deriving (Eq, Ord, Read, Show)

_Decorators = Core.Name "hydra.python.syntax.Decorators"

data ClassDefinition =
  ClassDefinition {
    classDefinitionDecorators :: (Maybe Decorators),
    classDefinitionName :: Name,
    classDefinitionTypeParams :: [TypeParameter],
    classDefinitionArguments :: (Maybe Args),
    classDefinitionBody :: Block}
  deriving (Eq, Ord, Read, Show)

_ClassDefinition = Core.Name "hydra.python.syntax.ClassDefinition"

_ClassDefinition_decorators = Core.Name "decorators"

_ClassDefinition_name = Core.Name "name"

_ClassDefinition_typeParams = Core.Name "typeParams"

_ClassDefinition_arguments = Core.Name "arguments"

_ClassDefinition_body = Core.Name "body"

data FunctionDefinition =
  FunctionDefinition {
    functionDefinitionDecorators :: (Maybe Decorators),
    functionDefinitionRaw :: FunctionDefRaw}
  deriving (Eq, Ord, Read, Show)

_FunctionDefinition = Core.Name "hydra.python.syntax.FunctionDefinition"

_FunctionDefinition_decorators = Core.Name "decorators"

_FunctionDefinition_raw = Core.Name "raw"

data FunctionDefRaw =
  FunctionDefRaw {
    functionDefRawAsync :: Bool,
    functionDefRawName :: Name,
    functionDefRawTypeParams :: [TypeParameter],
    functionDefRawParams :: (Maybe Parameters),
    functionDefRawReturnType :: (Maybe Expression),
    functionDefRawFuncTypeComment :: (Maybe FuncTypeComment),
    functionDefRawBlock :: Block}
  deriving (Eq, Ord, Read, Show)

_FunctionDefRaw = Core.Name "hydra.python.syntax.FunctionDefRaw"

_FunctionDefRaw_async = Core.Name "async"

_FunctionDefRaw_name = Core.Name "name"

_FunctionDefRaw_typeParams = Core.Name "typeParams"

_FunctionDefRaw_params = Core.Name "params"

_FunctionDefRaw_returnType = Core.Name "returnType"

_FunctionDefRaw_funcTypeComment = Core.Name "funcTypeComment"

_FunctionDefRaw_block = Core.Name "block"

data Parameters =
  ParametersSlashNoDefault SlashNoDefaultParameters |
  ParametersSlashWithDefault SlashWithDefaultParameters |
  ParametersParamNoDefault ParamNoDefaultParameters |
  ParametersParamWithDefault ParamWithDefaultParameters |
  ParametersStarEtc StarEtc
  deriving (Eq, Ord, Read, Show)

_Parameters = Core.Name "hydra.python.syntax.Parameters"

_Parameters_slashNoDefault = Core.Name "slashNoDefault"

_Parameters_slashWithDefault = Core.Name "slashWithDefault"

_Parameters_paramNoDefault = Core.Name "paramNoDefault"

_Parameters_paramWithDefault = Core.Name "paramWithDefault"

_Parameters_starEtc = Core.Name "starEtc"

data SlashNoDefaultParameters =
  SlashNoDefaultParameters {
    slashNoDefaultParametersSlash :: SlashNoDefault,
    slashNoDefaultParametersParamNoDefault :: [ParamNoDefault],
    slashNoDefaultParametersParamWithDefault :: [ParamWithDefault],
    slashNoDefaultParametersStarEtc :: (Maybe StarEtc)}
  deriving (Eq, Ord, Read, Show)

_SlashNoDefaultParameters = Core.Name "hydra.python.syntax.SlashNoDefaultParameters"

_SlashNoDefaultParameters_slash = Core.Name "slash"

_SlashNoDefaultParameters_paramNoDefault = Core.Name "paramNoDefault"

_SlashNoDefaultParameters_paramWithDefault = Core.Name "paramWithDefault"

_SlashNoDefaultParameters_starEtc = Core.Name "starEtc"

data SlashWithDefaultParameters =
  SlashWithDefaultParameters {
    slashWithDefaultParametersParamNoDefault :: [ParamNoDefault],
    slashWithDefaultParametersParamWithDefault :: [ParamWithDefault],
    slashWithDefaultParametersStarEtc :: (Maybe StarEtc)}
  deriving (Eq, Ord, Read, Show)

_SlashWithDefaultParameters = Core.Name "hydra.python.syntax.SlashWithDefaultParameters"

_SlashWithDefaultParameters_paramNoDefault = Core.Name "paramNoDefault"

_SlashWithDefaultParameters_paramWithDefault = Core.Name "paramWithDefault"

_SlashWithDefaultParameters_starEtc = Core.Name "starEtc"

data ParamNoDefaultParameters =
  ParamNoDefaultParameters {
    paramNoDefaultParametersParamNoDefault :: [ParamNoDefault],
    paramNoDefaultParametersParamWithDefault :: [ParamWithDefault],
    paramNoDefaultParametersStarEtc :: (Maybe StarEtc)}
  deriving (Eq, Ord, Read, Show)

_ParamNoDefaultParameters = Core.Name "hydra.python.syntax.ParamNoDefaultParameters"

_ParamNoDefaultParameters_paramNoDefault = Core.Name "paramNoDefault"

_ParamNoDefaultParameters_paramWithDefault = Core.Name "paramWithDefault"

_ParamNoDefaultParameters_starEtc = Core.Name "starEtc"

data ParamWithDefaultParameters =
  ParamWithDefaultParameters {
    paramWithDefaultParametersParamWithDefault :: [ParamWithDefault],
    paramWithDefaultParametersStarEtc :: (Maybe StarEtc)}
  deriving (Eq, Ord, Read, Show)

_ParamWithDefaultParameters = Core.Name "hydra.python.syntax.ParamWithDefaultParameters"

_ParamWithDefaultParameters_paramWithDefault = Core.Name "paramWithDefault"

_ParamWithDefaultParameters_starEtc = Core.Name "starEtc"

newtype SlashNoDefault =
  SlashNoDefault {
    unSlashNoDefault :: [ParamNoDefault]}
  deriving (Eq, Ord, Read, Show)

_SlashNoDefault = Core.Name "hydra.python.syntax.SlashNoDefault"

data SlashWithDefault =
  SlashWithDefault {
    slashWithDefaultParamNoDefault :: [ParamNoDefault],
    slashWithDefaultParamWithDefault :: [ParamWithDefault]}
  deriving (Eq, Ord, Read, Show)

_SlashWithDefault = Core.Name "hydra.python.syntax.SlashWithDefault"

_SlashWithDefault_paramNoDefault = Core.Name "paramNoDefault"

_SlashWithDefault_paramWithDefault = Core.Name "paramWithDefault"

data StarEtc =
  StarEtcStarNoDefault NoDefaultStarEtc |
  StarEtcStarNoDefaultStarAnnotation NoDefaultStarAnnotationStarEtc |
  StarEtcStarComma CommaStarEtc |
  StarEtcKeywords Keywords
  deriving (Eq, Ord, Read, Show)

_StarEtc = Core.Name "hydra.python.syntax.StarEtc"

_StarEtc_starNoDefault = Core.Name "starNoDefault"

_StarEtc_starNoDefaultStarAnnotation = Core.Name "starNoDefaultStarAnnotation"

_StarEtc_starComma = Core.Name "starComma"

_StarEtc_keywords = Core.Name "keywords"

data NoDefaultStarEtc =
  NoDefaultStarEtc {
    noDefaultStarEtcParamNoDefault :: ParamNoDefault,
    noDefaultStarEtcParamMaybeDefault :: [ParamMaybeDefault],
    noDefaultStarEtcKeywords :: (Maybe Keywords)}
  deriving (Eq, Ord, Read, Show)

_NoDefaultStarEtc = Core.Name "hydra.python.syntax.NoDefaultStarEtc"

_NoDefaultStarEtc_paramNoDefault = Core.Name "paramNoDefault"

_NoDefaultStarEtc_paramMaybeDefault = Core.Name "paramMaybeDefault"

_NoDefaultStarEtc_keywords = Core.Name "keywords"

data NoDefaultStarAnnotationStarEtc =
  NoDefaultStarAnnotationStarEtc {
    noDefaultStarAnnotationStarEtcParamNoDefaultStarAnnotation :: ParamNoDefaultStarAnnotation,
    noDefaultStarAnnotationStarEtcParamMaybeDefault :: [ParamMaybeDefault],
    noDefaultStarAnnotationStarEtcKeywords :: (Maybe Keywords)}
  deriving (Eq, Ord, Read, Show)

_NoDefaultStarAnnotationStarEtc = Core.Name "hydra.python.syntax.NoDefaultStarAnnotationStarEtc"

_NoDefaultStarAnnotationStarEtc_paramNoDefaultStarAnnotation = Core.Name "paramNoDefaultStarAnnotation"

_NoDefaultStarAnnotationStarEtc_paramMaybeDefault = Core.Name "paramMaybeDefault"

_NoDefaultStarAnnotationStarEtc_keywords = Core.Name "keywords"

data CommaStarEtc =
  CommaStarEtc {
    commaStarEtcParamMaybeDefault :: [ParamMaybeDefault],
    commaStarEtcKeywords :: (Maybe Keywords)}
  deriving (Eq, Ord, Read, Show)

_CommaStarEtc = Core.Name "hydra.python.syntax.CommaStarEtc"

_CommaStarEtc_paramMaybeDefault = Core.Name "paramMaybeDefault"

_CommaStarEtc_keywords = Core.Name "keywords"

newtype Keywords =
  Keywords {
    unKeywords :: ParamNoDefault}
  deriving (Eq, Ord, Read, Show)

_Keywords = Core.Name "hydra.python.syntax.Keywords"

data ParamNoDefault =
  ParamNoDefault {
    paramNoDefaultParam :: Param,
    paramNoDefaultTypeComment :: (Maybe TypeComment)}
  deriving (Eq, Ord, Read, Show)

_ParamNoDefault = Core.Name "hydra.python.syntax.ParamNoDefault"

_ParamNoDefault_param = Core.Name "param"

_ParamNoDefault_typeComment = Core.Name "typeComment"

data ParamNoDefaultStarAnnotation =
  ParamNoDefaultStarAnnotation {
    paramNoDefaultStarAnnotationParamStarAnnotation :: ParamStarAnnotation,
    paramNoDefaultStarAnnotationTypeComment :: (Maybe TypeComment)}
  deriving (Eq, Ord, Read, Show)

_ParamNoDefaultStarAnnotation = Core.Name "hydra.python.syntax.ParamNoDefaultStarAnnotation"

_ParamNoDefaultStarAnnotation_paramStarAnnotation = Core.Name "paramStarAnnotation"

_ParamNoDefaultStarAnnotation_typeComment = Core.Name "typeComment"

data ParamWithDefault =
  ParamWithDefault {
    paramWithDefaultParam :: Param,
    paramWithDefaultDefault :: Default,
    paramWithDefaultTypeComment :: (Maybe TypeComment)}
  deriving (Eq, Ord, Read, Show)

_ParamWithDefault = Core.Name "hydra.python.syntax.ParamWithDefault"

_ParamWithDefault_param = Core.Name "param"

_ParamWithDefault_default = Core.Name "default"

_ParamWithDefault_typeComment = Core.Name "typeComment"

data ParamMaybeDefault =
  ParamMaybeDefault {
    paramMaybeDefaultParam :: Param,
    paramMaybeDefaultDefault :: (Maybe Default),
    paramMaybeDefaultTypeComment :: (Maybe TypeComment)}
  deriving (Eq, Ord, Read, Show)

_ParamMaybeDefault = Core.Name "hydra.python.syntax.ParamMaybeDefault"

_ParamMaybeDefault_param = Core.Name "param"

_ParamMaybeDefault_default = Core.Name "default"

_ParamMaybeDefault_typeComment = Core.Name "typeComment"

data Param =
  Param {
    paramName :: Name,
    paramAnnotation :: (Maybe Annotation)}
  deriving (Eq, Ord, Read, Show)

_Param = Core.Name "hydra.python.syntax.Param"

_Param_name = Core.Name "name"

_Param_annotation = Core.Name "annotation"

data ParamStarAnnotation =
  ParamStarAnnotation {
    paramStarAnnotationName :: Name,
    paramStarAnnotationAnnotation :: StarAnnotation}
  deriving (Eq, Ord, Read, Show)

_ParamStarAnnotation = Core.Name "hydra.python.syntax.ParamStarAnnotation"

_ParamStarAnnotation_name = Core.Name "name"

_ParamStarAnnotation_annotation = Core.Name "annotation"

newtype Annotation =
  Annotation {
    unAnnotation :: Expression}
  deriving (Eq, Ord, Read, Show)

_Annotation = Core.Name "hydra.python.syntax.Annotation"

newtype StarAnnotation =
  StarAnnotation {
    unStarAnnotation :: StarExpression}
  deriving (Eq, Ord, Read, Show)

_StarAnnotation = Core.Name "hydra.python.syntax.StarAnnotation"

newtype Default =
  Default {
    unDefault :: Expression}
  deriving (Eq, Ord, Read, Show)

_Default = Core.Name "hydra.python.syntax.Default"

data IfStatement =
  IfStatement {
    ifStatementCondition :: NamedExpression,
    ifStatementBody :: Block,
    ifStatementContinuation :: (Maybe IfTail)}
  deriving (Eq, Ord, Read, Show)

_IfStatement = Core.Name "hydra.python.syntax.IfStatement"

_IfStatement_condition = Core.Name "condition"

_IfStatement_body = Core.Name "body"

_IfStatement_continuation = Core.Name "continuation"

data IfTail =
  IfTailElif IfStatement |
  IfTailElse Block
  deriving (Eq, Ord, Read, Show)

_IfTail = Core.Name "hydra.python.syntax.IfTail"

_IfTail_elif = Core.Name "elif"

_IfTail_else = Core.Name "else"

data WhileStatement =
  WhileStatement {
    whileStatementCondition :: NamedExpression,
    whileStatementBody :: Block,
    whileStatementElse :: (Maybe Block)}
  deriving (Eq, Ord, Read, Show)

_WhileStatement = Core.Name "hydra.python.syntax.WhileStatement"

_WhileStatement_condition = Core.Name "condition"

_WhileStatement_body = Core.Name "body"

_WhileStatement_else = Core.Name "else"

data ForStatement =
  ForStatement {
    forStatementAsync :: Bool,
    forStatementTargets :: [StarTarget],
    forStatementExpressions :: [StarExpression],
    forStatementTypeComment :: (Maybe TypeComment),
    forStatementBody :: Block,
    forStatementElse :: (Maybe Block)}
  deriving (Eq, Ord, Read, Show)

_ForStatement = Core.Name "hydra.python.syntax.ForStatement"

_ForStatement_async = Core.Name "async"

_ForStatement_targets = Core.Name "targets"

_ForStatement_expressions = Core.Name "expressions"

_ForStatement_typeComment = Core.Name "typeComment"

_ForStatement_body = Core.Name "body"

_ForStatement_else = Core.Name "else"

data WithStatement =
  WithStatement {
    withStatementAsync :: Bool,
    withStatementItems :: [WithItem],
    withStatementTypeComment :: (Maybe TypeComment),
    withStatementBody :: Block}
  deriving (Eq, Ord, Read, Show)

_WithStatement = Core.Name "hydra.python.syntax.WithStatement"

_WithStatement_async = Core.Name "async"

_WithStatement_items = Core.Name "items"

_WithStatement_typeComment = Core.Name "typeComment"

_WithStatement_body = Core.Name "body"

data WithItem =
  WithItem {
    withItemExpression :: Expression,
    withItemAs :: (Maybe StarTarget)}
  deriving (Eq, Ord, Read, Show)

_WithItem = Core.Name "hydra.python.syntax.WithItem"

_WithItem_expression = Core.Name "expression"

_WithItem_as = Core.Name "as"

data TryStatement =
  TryStatementFinally TryFinallyStatement |
  TryStatementExcept TryExceptStatement |
  TryStatementExceptStar TryExceptStarStatement
  deriving (Eq, Ord, Read, Show)

_TryStatement = Core.Name "hydra.python.syntax.TryStatement"

_TryStatement_finally = Core.Name "finally"

_TryStatement_except = Core.Name "except"

_TryStatement_exceptStar = Core.Name "exceptStar"

data TryFinallyStatement =
  TryFinallyStatement {
    tryFinallyStatementBody :: Block,
    tryFinallyStatementFinally :: Block}
  deriving (Eq, Ord, Read, Show)

_TryFinallyStatement = Core.Name "hydra.python.syntax.TryFinallyStatement"

_TryFinallyStatement_body = Core.Name "body"

_TryFinallyStatement_finally = Core.Name "finally"

data TryExceptStatement =
  TryExceptStatement {
    tryExceptStatementBody :: Block,
    tryExceptStatementExcepts :: [ExceptBlock],
    tryExceptStatementElse :: (Maybe Block),
    tryExceptStatementFinally :: (Maybe Block)}
  deriving (Eq, Ord, Read, Show)

_TryExceptStatement = Core.Name "hydra.python.syntax.TryExceptStatement"

_TryExceptStatement_body = Core.Name "body"

_TryExceptStatement_excepts = Core.Name "excepts"

_TryExceptStatement_else = Core.Name "else"

_TryExceptStatement_finally = Core.Name "finally"

data TryExceptStarStatement =
  TryExceptStarStatement {
    tryExceptStarStatementBody :: Block,
    tryExceptStarStatementExcepts :: [ExceptStarBlock],
    tryExceptStarStatementElse :: (Maybe Block),
    tryExceptStarStatementFinally :: (Maybe Block)}
  deriving (Eq, Ord, Read, Show)

_TryExceptStarStatement = Core.Name "hydra.python.syntax.TryExceptStarStatement"

_TryExceptStarStatement_body = Core.Name "body"

_TryExceptStarStatement_excepts = Core.Name "excepts"

_TryExceptStarStatement_else = Core.Name "else"

_TryExceptStarStatement_finally = Core.Name "finally"

data ExceptBlock =
  ExceptBlock {
    exceptBlockExpression :: (Maybe ExceptExpression),
    exceptBlockBody :: Block}
  deriving (Eq, Ord, Read, Show)

_ExceptBlock = Core.Name "hydra.python.syntax.ExceptBlock"

_ExceptBlock_expression = Core.Name "expression"

_ExceptBlock_body = Core.Name "body"

data ExceptExpression =
  ExceptExpression {
    exceptExpressionExpression :: Expression,
    exceptExpressionAs :: (Maybe Name)}
  deriving (Eq, Ord, Read, Show)

_ExceptExpression = Core.Name "hydra.python.syntax.ExceptExpression"

_ExceptExpression_expression = Core.Name "expression"

_ExceptExpression_as = Core.Name "as"

data ExceptStarBlock =
  ExceptStarBlock {
    exceptStarBlockExpression :: Expression,
    exceptStarBlockAs :: (Maybe Name),
    exceptStarBlockBody :: Block}
  deriving (Eq, Ord, Read, Show)

_ExceptStarBlock = Core.Name "hydra.python.syntax.ExceptStarBlock"

_ExceptStarBlock_expression = Core.Name "expression"

_ExceptStarBlock_as = Core.Name "as"

_ExceptStarBlock_body = Core.Name "body"

data MatchStatement =
  MatchStatement {
    matchStatementSubject :: SubjectExpression,
    matchStatementCases :: [CaseBlock]}
  deriving (Eq, Ord, Read, Show)

_MatchStatement = Core.Name "hydra.python.syntax.MatchStatement"

_MatchStatement_subject = Core.Name "subject"

_MatchStatement_cases = Core.Name "cases"

data SubjectExpression =
  SubjectExpressionTuple [StarNamedExpression] |
  SubjectExpressionSimple NamedExpression
  deriving (Eq, Ord, Read, Show)

_SubjectExpression = Core.Name "hydra.python.syntax.SubjectExpression"

_SubjectExpression_tuple = Core.Name "tuple"

_SubjectExpression_simple = Core.Name "simple"

data CaseBlock =
  CaseBlock {
    caseBlockPatterns :: Patterns,
    caseBlockGuard :: (Maybe Guard),
    caseBlockBody :: Block}
  deriving (Eq, Ord, Read, Show)

_CaseBlock = Core.Name "hydra.python.syntax.CaseBlock"

_CaseBlock_patterns = Core.Name "patterns"

_CaseBlock_guard = Core.Name "guard"

_CaseBlock_body = Core.Name "body"

newtype Guard =
  Guard {
    unGuard :: NamedExpression}
  deriving (Eq, Ord, Read, Show)

_Guard = Core.Name "hydra.python.syntax.Guard"

data Patterns =
  PatternsSequence OpenSequencePattern |
  PatternsPattern Pattern
  deriving (Eq, Ord, Read, Show)

_Patterns = Core.Name "hydra.python.syntax.Patterns"

_Patterns_sequence = Core.Name "sequence"

_Patterns_pattern = Core.Name "pattern"

data Pattern =
  PatternAs AsPattern |
  PatternOr OrPattern
  deriving (Eq, Ord, Read, Show)

_Pattern = Core.Name "hydra.python.syntax.Pattern"

_Pattern_as = Core.Name "as"

_Pattern_or = Core.Name "or"

data AsPattern =
  AsPattern {
    asPatternPattern :: OrPattern,
    asPatternAs :: PatternCaptureTarget}
  deriving (Eq, Ord, Read, Show)

_AsPattern = Core.Name "hydra.python.syntax.AsPattern"

_AsPattern_pattern = Core.Name "pattern"

_AsPattern_as = Core.Name "as"

newtype OrPattern =
  OrPattern {
    unOrPattern :: [ClosedPattern]}
  deriving (Eq, Ord, Read, Show)

_OrPattern = Core.Name "hydra.python.syntax.OrPattern"

data ClosedPattern =
  ClosedPatternLiteral LiteralExpression |
  ClosedPatternCapture CapturePattern |
  ClosedPatternWildcard |
  ClosedPatternValue ValuePattern |
  ClosedPatternGroup GroupPattern |
  ClosedPatternSequence SequencePattern |
  ClosedPatternMapping MappingPattern |
  ClosedPatternClass ClassPattern
  deriving (Eq, Ord, Read, Show)

_ClosedPattern = Core.Name "hydra.python.syntax.ClosedPattern"

_ClosedPattern_literal = Core.Name "literal"

_ClosedPattern_capture = Core.Name "capture"

_ClosedPattern_wildcard = Core.Name "wildcard"

_ClosedPattern_value = Core.Name "value"

_ClosedPattern_group = Core.Name "group"

_ClosedPattern_sequence = Core.Name "sequence"

_ClosedPattern_mapping = Core.Name "mapping"

_ClosedPattern_class = Core.Name "class"

data LiteralExpression =
  LiteralExpressionNumber SignedNumber |
  LiteralExpressionComplex ComplexNumber |
  LiteralExpressionString String_ |
  LiteralExpressionNone |
  LiteralExpressionTrue |
  LiteralExpressionFalse
  deriving (Eq, Ord, Read, Show)

_LiteralExpression = Core.Name "hydra.python.syntax.LiteralExpression"

_LiteralExpression_number = Core.Name "number"

_LiteralExpression_complex = Core.Name "complex"

_LiteralExpression_string = Core.Name "string"

_LiteralExpression_none = Core.Name "none"

_LiteralExpression_true = Core.Name "true"

_LiteralExpression_false = Core.Name "false"

data ComplexNumber =
  ComplexNumber {
    complexNumberReal :: SignedRealNumber,
    complexNumberPlusOrMinus :: PlusOrMinus,
    complexNumberImaginary :: ImaginaryNumber}
  deriving (Eq, Ord, Read, Show)

_ComplexNumber = Core.Name "hydra.python.syntax.ComplexNumber"

_ComplexNumber_real = Core.Name "real"

_ComplexNumber_plusOrMinus = Core.Name "plusOrMinus"

_ComplexNumber_imaginary = Core.Name "imaginary"

data PlusOrMinus =
  PlusOrMinusPlus |
  PlusOrMinusMinus
  deriving (Eq, Ord, Read, Show)

_PlusOrMinus = Core.Name "hydra.python.syntax.PlusOrMinus"

_PlusOrMinus_plus = Core.Name "plus"

_PlusOrMinus_minus = Core.Name "minus"

data SignedNumber =
  SignedNumberSign PlusOrMinus |
  SignedNumberNumber Number
  deriving (Eq, Ord, Read, Show)

_SignedNumber = Core.Name "hydra.python.syntax.SignedNumber"

_SignedNumber_sign = Core.Name "sign"

_SignedNumber_number = Core.Name "number"

data SignedRealNumber =
  SignedRealNumberSign PlusOrMinus |
  SignedRealNumberNumber RealNumber
  deriving (Eq, Ord, Read, Show)

_SignedRealNumber = Core.Name "hydra.python.syntax.SignedRealNumber"

_SignedRealNumber_sign = Core.Name "sign"

_SignedRealNumber_number = Core.Name "number"

data RealNumber =
  RealNumberInteger Integer |
  RealNumberFloat Double
  deriving (Eq, Ord, Read, Show)

_RealNumber = Core.Name "hydra.python.syntax.RealNumber"

_RealNumber_integer = Core.Name "integer"

_RealNumber_float = Core.Name "float"

newtype ImaginaryNumber =
  ImaginaryNumber {
    unImaginaryNumber :: Double}
  deriving (Eq, Ord, Read, Show)

_ImaginaryNumber = Core.Name "hydra.python.syntax.ImaginaryNumber"

newtype CapturePattern =
  CapturePattern {
    unCapturePattern :: PatternCaptureTarget}
  deriving (Eq, Ord, Read, Show)

_CapturePattern = Core.Name "hydra.python.syntax.CapturePattern"

newtype PatternCaptureTarget =
  PatternCaptureTarget {
    unPatternCaptureTarget :: Name}
  deriving (Eq, Ord, Read, Show)

_PatternCaptureTarget = Core.Name "hydra.python.syntax.PatternCaptureTarget"

newtype ValuePattern =
  ValuePattern {
    unValuePattern :: Attribute}
  deriving (Eq, Ord, Read, Show)

_ValuePattern = Core.Name "hydra.python.syntax.ValuePattern"

newtype Attribute =
  Attribute {
    unAttribute :: [Name]}
  deriving (Eq, Ord, Read, Show)

_Attribute = Core.Name "hydra.python.syntax.Attribute"

newtype NameOrAttribute =
  NameOrAttribute {
    unNameOrAttribute :: [Name]}
  deriving (Eq, Ord, Read, Show)

_NameOrAttribute = Core.Name "hydra.python.syntax.NameOrAttribute"

newtype GroupPattern =
  GroupPattern {
    unGroupPattern :: Pattern}
  deriving (Eq, Ord, Read, Show)

_GroupPattern = Core.Name "hydra.python.syntax.GroupPattern"

data SequencePattern =
  SequencePatternList (Maybe MaybeSequencePattern) |
  SequencePatternTuple (Maybe OpenSequencePattern)
  deriving (Eq, Ord, Read, Show)

_SequencePattern = Core.Name "hydra.python.syntax.SequencePattern"

_SequencePattern_list = Core.Name "list"

_SequencePattern_tuple = Core.Name "tuple"

data OpenSequencePattern =
  OpenSequencePattern {
    openSequencePatternHead :: MaybeStarPattern,
    openSequencePatternTail :: (Maybe MaybeSequencePattern)}
  deriving (Eq, Ord, Read, Show)

_OpenSequencePattern = Core.Name "hydra.python.syntax.OpenSequencePattern"

_OpenSequencePattern_head = Core.Name "head"

_OpenSequencePattern_tail = Core.Name "tail"

newtype MaybeSequencePattern =
  MaybeSequencePattern {
    unMaybeSequencePattern :: [MaybeStarPattern]}
  deriving (Eq, Ord, Read, Show)

_MaybeSequencePattern = Core.Name "hydra.python.syntax.MaybeSequencePattern"

data MaybeStarPattern =
  MaybeStarPatternStar StarPattern |
  MaybeStarPatternPattern Pattern
  deriving (Eq, Ord, Read, Show)

_MaybeStarPattern = Core.Name "hydra.python.syntax.MaybeStarPattern"

_MaybeStarPattern_star = Core.Name "star"

_MaybeStarPattern_pattern = Core.Name "pattern"

data StarPattern =
  StarPatternCapture PatternCaptureTarget |
  StarPatternWildcard
  deriving (Eq, Ord, Read, Show)

_StarPattern = Core.Name "hydra.python.syntax.StarPattern"

_StarPattern_capture = Core.Name "capture"

_StarPattern_wildcard = Core.Name "wildcard"

data MappingPattern =
  MappingPattern {
    mappingPatternItems :: (Maybe ItemsPattern),
    mappingPatternDoubleStar :: (Maybe DoubleStarPattern)}
  deriving (Eq, Ord, Read, Show)

_MappingPattern = Core.Name "hydra.python.syntax.MappingPattern"

_MappingPattern_items = Core.Name "items"

_MappingPattern_doubleStar = Core.Name "doubleStar"

newtype ItemsPattern =
  ItemsPattern {
    unItemsPattern :: [KeyValuePattern]}
  deriving (Eq, Ord, Read, Show)

_ItemsPattern = Core.Name "hydra.python.syntax.ItemsPattern"

data KeyValuePattern =
  KeyValuePattern {
    keyValuePatternKey :: LiteralExpressionOrAttribute,
    keyValuePatternValue :: Pattern}
  deriving (Eq, Ord, Read, Show)

_KeyValuePattern = Core.Name "hydra.python.syntax.KeyValuePattern"

_KeyValuePattern_key = Core.Name "key"

_KeyValuePattern_value = Core.Name "value"

data LiteralExpressionOrAttribute =
  LiteralExpressionOrAttributeLiteral LiteralExpression |
  LiteralExpressionOrAttributeAttribute Attribute
  deriving (Eq, Ord, Read, Show)

_LiteralExpressionOrAttribute = Core.Name "hydra.python.syntax.LiteralExpressionOrAttribute"

_LiteralExpressionOrAttribute_literal = Core.Name "literal"

_LiteralExpressionOrAttribute_attribute = Core.Name "attribute"

newtype DoubleStarPattern =
  DoubleStarPattern {
    unDoubleStarPattern :: PatternCaptureTarget}
  deriving (Eq, Ord, Read, Show)

_DoubleStarPattern = Core.Name "hydra.python.syntax.DoubleStarPattern"

data ClassPattern =
  ClassPattern {
    classPatternNameOrAttribute :: NameOrAttribute,
    classPatternPositionalPatterns :: (Maybe PositionalPatterns),
    classPatternKeywordPatterns :: (Maybe KeywordPatterns)}
  deriving (Eq, Ord, Read, Show)

_ClassPattern = Core.Name "hydra.python.syntax.ClassPattern"

_ClassPattern_nameOrAttribute = Core.Name "nameOrAttribute"

_ClassPattern_positionalPatterns = Core.Name "positionalPatterns"

_ClassPattern_keywordPatterns = Core.Name "keywordPatterns"

newtype PositionalPatterns =
  PositionalPatterns {
    unPositionalPatterns :: [Pattern]}
  deriving (Eq, Ord, Read, Show)

_PositionalPatterns = Core.Name "hydra.python.syntax.PositionalPatterns"

newtype KeywordPatterns =
  KeywordPatterns {
    unKeywordPatterns :: [KeywordPattern]}
  deriving (Eq, Ord, Read, Show)

_KeywordPatterns = Core.Name "hydra.python.syntax.KeywordPatterns"

data KeywordPattern =
  KeywordPattern {
    keywordPatternName :: Name,
    keywordPatternPattern :: Pattern}
  deriving (Eq, Ord, Read, Show)

_KeywordPattern = Core.Name "hydra.python.syntax.KeywordPattern"

_KeywordPattern_name = Core.Name "name"

_KeywordPattern_pattern = Core.Name "pattern"

data TypeAlias =
  TypeAlias {
    typeAliasName :: Name,
    typeAliasTypeParams :: [TypeParameter],
    typeAliasExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_TypeAlias = Core.Name "hydra.python.syntax.TypeAlias"

_TypeAlias_name = Core.Name "name"

_TypeAlias_typeParams = Core.Name "typeParams"

_TypeAlias_expression = Core.Name "expression"

data TypeParameter =
  TypeParameterSimple SimpleTypeParameter |
  TypeParameterStar StarTypeParameter |
  TypeParameterDoubleStar DoubleStarTypeParameter
  deriving (Eq, Ord, Read, Show)

_TypeParameter = Core.Name "hydra.python.syntax.TypeParameter"

_TypeParameter_simple = Core.Name "simple"

_TypeParameter_star = Core.Name "star"

_TypeParameter_doubleStar = Core.Name "doubleStar"

data SimpleTypeParameter =
  SimpleTypeParameter {
    simpleTypeParameterName :: Name,
    simpleTypeParameterBound :: (Maybe Expression),
    simpleTypeParameterDefault :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_SimpleTypeParameter = Core.Name "hydra.python.syntax.SimpleTypeParameter"

_SimpleTypeParameter_name = Core.Name "name"

_SimpleTypeParameter_bound = Core.Name "bound"

_SimpleTypeParameter_default = Core.Name "default"

data StarTypeParameter =
  StarTypeParameter {
    starTypeParameterName :: Name,
    starTypeParameterDefault :: (Maybe StarExpression)}
  deriving (Eq, Ord, Read, Show)

_StarTypeParameter = Core.Name "hydra.python.syntax.StarTypeParameter"

_StarTypeParameter_name = Core.Name "name"

_StarTypeParameter_default = Core.Name "default"

data DoubleStarTypeParameter =
  DoubleStarTypeParameter {
    doubleStarTypeParameterName :: Name,
    doubleStarTypeParameterDefault :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_DoubleStarTypeParameter = Core.Name "hydra.python.syntax.DoubleStarTypeParameter"

_DoubleStarTypeParameter_name = Core.Name "name"

_DoubleStarTypeParameter_default = Core.Name "default"

data Expression =
  ExpressionConditional Conditional |
  ExpressionSimple Disjunction |
  ExpressionLambda Lambda
  deriving (Eq, Ord, Read, Show)

_Expression = Core.Name "hydra.python.syntax.Expression"

_Expression_conditional = Core.Name "conditional"

_Expression_simple = Core.Name "simple"

_Expression_lambda = Core.Name "lambda"

data Conditional =
  Conditional {
    conditionalBody :: Disjunction,
    conditionalIf :: Disjunction,
    conditionalElse :: Expression}
  deriving (Eq, Ord, Read, Show)

_Conditional = Core.Name "hydra.python.syntax.Conditional"

_Conditional_body = Core.Name "body"

_Conditional_if = Core.Name "if"

_Conditional_else = Core.Name "else"

data YieldExpression =
  YieldExpressionFrom Expression |
  YieldExpressionSimple [StarExpression]
  deriving (Eq, Ord, Read, Show)

_YieldExpression = Core.Name "hydra.python.syntax.YieldExpression"

_YieldExpression_from = Core.Name "from"

_YieldExpression_simple = Core.Name "simple"

data StarExpression =
  StarExpressionStar BitwiseOr |
  StarExpressionSimple Expression
  deriving (Eq, Ord, Read, Show)

_StarExpression = Core.Name "hydra.python.syntax.StarExpression"

_StarExpression_star = Core.Name "star"

_StarExpression_simple = Core.Name "simple"

newtype StarNamedExpressions =
  StarNamedExpressions {
    unStarNamedExpressions :: [StarNamedExpression]}
  deriving (Eq, Ord, Read, Show)

_StarNamedExpressions = Core.Name "hydra.python.syntax.StarNamedExpressions"

data StarNamedExpression =
  StarNamedExpressionStar BitwiseOr |
  StarNamedExpressionSimple NamedExpression
  deriving (Eq, Ord, Read, Show)

_StarNamedExpression = Core.Name "hydra.python.syntax.StarNamedExpression"

_StarNamedExpression_star = Core.Name "star"

_StarNamedExpression_simple = Core.Name "simple"

data AssignmentExpression =
  AssignmentExpression {
    assignmentExpressionName :: Name,
    assignmentExpressionExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_AssignmentExpression = Core.Name "hydra.python.syntax.AssignmentExpression"

_AssignmentExpression_name = Core.Name "name"

_AssignmentExpression_expression = Core.Name "expression"

data NamedExpression =
  NamedExpressionAssignment AssignmentExpression |
  NamedExpressionSimple Expression
  deriving (Eq, Ord, Read, Show)

_NamedExpression = Core.Name "hydra.python.syntax.NamedExpression"

_NamedExpression_assignment = Core.Name "assignment"

_NamedExpression_simple = Core.Name "simple"

newtype Disjunction =
  Disjunction {
    unDisjunction :: [Conjunction]}
  deriving (Eq, Ord, Read, Show)

_Disjunction = Core.Name "hydra.python.syntax.Disjunction"

newtype Conjunction =
  Conjunction {
    unConjunction :: [Inversion]}
  deriving (Eq, Ord, Read, Show)

_Conjunction = Core.Name "hydra.python.syntax.Conjunction"

data Inversion =
  InversionNot Inversion |
  InversionSimple Comparison
  deriving (Eq, Ord, Read, Show)

_Inversion = Core.Name "hydra.python.syntax.Inversion"

_Inversion_not = Core.Name "not"

_Inversion_simple = Core.Name "simple"

data Comparison =
  Comparison {
    comparisonLhs :: BitwiseOr,
    comparisonRhs :: [CompareOpBitwiseOrPair]}
  deriving (Eq, Ord, Read, Show)

_Comparison = Core.Name "hydra.python.syntax.Comparison"

_Comparison_lhs = Core.Name "lhs"

_Comparison_rhs = Core.Name "rhs"

data CompareOpBitwiseOrPair =
  CompareOpBitwiseOrPair {
    compareOpBitwiseOrPairOperator :: CompareOp,
    compareOpBitwiseOrPairRhs :: BitwiseOr}
  deriving (Eq, Ord, Read, Show)

_CompareOpBitwiseOrPair = Core.Name "hydra.python.syntax.CompareOpBitwiseOrPair"

_CompareOpBitwiseOrPair_operator = Core.Name "operator"

_CompareOpBitwiseOrPair_rhs = Core.Name "rhs"

data CompareOp =
  CompareOpEq |
  CompareOpNoteq |
  CompareOpLte |
  CompareOpLt |
  CompareOpGte |
  CompareOpGt |
  CompareOpNotin |
  CompareOpIn |
  CompareOpIsnot |
  CompareOpIs
  deriving (Eq, Ord, Read, Show)

_CompareOp = Core.Name "hydra.python.syntax.CompareOp"

_CompareOp_eq = Core.Name "eq"

_CompareOp_noteq = Core.Name "noteq"

_CompareOp_lte = Core.Name "lte"

_CompareOp_lt = Core.Name "lt"

_CompareOp_gte = Core.Name "gte"

_CompareOp_gt = Core.Name "gt"

_CompareOp_notin = Core.Name "notin"

_CompareOp_in = Core.Name "in"

_CompareOp_isnot = Core.Name "isnot"

_CompareOp_is = Core.Name "is"

data BitwiseOr =
  BitwiseOr {
    bitwiseOrLhs :: (Maybe BitwiseOr),
    bitwiseOrRhs :: BitwiseXor}
  deriving (Eq, Ord, Read, Show)

_BitwiseOr = Core.Name "hydra.python.syntax.BitwiseOr"

_BitwiseOr_lhs = Core.Name "lhs"

_BitwiseOr_rhs = Core.Name "rhs"

data BitwiseXor =
  BitwiseXor {
    bitwiseXorLhs :: (Maybe BitwiseXor),
    bitwiseXorRhs :: BitwiseAnd}
  deriving (Eq, Ord, Read, Show)

_BitwiseXor = Core.Name "hydra.python.syntax.BitwiseXor"

_BitwiseXor_lhs = Core.Name "lhs"

_BitwiseXor_rhs = Core.Name "rhs"

data BitwiseAnd =
  BitwiseAnd {
    bitwiseAndLhs :: (Maybe BitwiseAnd),
    bitwiseAndRhs :: ShiftExpression}
  deriving (Eq, Ord, Read, Show)

_BitwiseAnd = Core.Name "hydra.python.syntax.BitwiseAnd"

_BitwiseAnd_lhs = Core.Name "lhs"

_BitwiseAnd_rhs = Core.Name "rhs"

data ShiftExpression =
  ShiftExpression {
    shiftExpressionLhs :: (Maybe ShiftLhs),
    shiftExpressionRhs :: Sum}
  deriving (Eq, Ord, Read, Show)

_ShiftExpression = Core.Name "hydra.python.syntax.ShiftExpression"

_ShiftExpression_lhs = Core.Name "lhs"

_ShiftExpression_rhs = Core.Name "rhs"

data ShiftLhs =
  ShiftLhs {
    shiftLhsOperand :: ShiftExpression,
    shiftLhsOperator :: ShiftOp}
  deriving (Eq, Ord, Read, Show)

_ShiftLhs = Core.Name "hydra.python.syntax.ShiftLhs"

_ShiftLhs_operand = Core.Name "operand"

_ShiftLhs_operator = Core.Name "operator"

data ShiftOp =
  ShiftOpLeft |
  ShiftOpRight
  deriving (Eq, Ord, Read, Show)

_ShiftOp = Core.Name "hydra.python.syntax.ShiftOp"

_ShiftOp_left = Core.Name "left"

_ShiftOp_right = Core.Name "right"

data Sum =
  Sum {
    sumLhs :: (Maybe SumLhs),
    sumRhs :: Term}
  deriving (Eq, Ord, Read, Show)

_Sum = Core.Name "hydra.python.syntax.Sum"

_Sum_lhs = Core.Name "lhs"

_Sum_rhs = Core.Name "rhs"

data SumLhs =
  SumLhs {
    sumLhsOperand :: Sum,
    sumLhsOperator :: SumOp}
  deriving (Eq, Ord, Read, Show)

_SumLhs = Core.Name "hydra.python.syntax.SumLhs"

_SumLhs_operand = Core.Name "operand"

_SumLhs_operator = Core.Name "operator"

data SumOp =
  SumOpAdd |
  SumOpSub
  deriving (Eq, Ord, Read, Show)

_SumOp = Core.Name "hydra.python.syntax.SumOp"

_SumOp_add = Core.Name "add"

_SumOp_sub = Core.Name "sub"

data Term =
  Term {
    termLhs :: (Maybe TermLhs),
    termRhs :: Factor}
  deriving (Eq, Ord, Read, Show)

_Term = Core.Name "hydra.python.syntax.Term"

_Term_lhs = Core.Name "lhs"

_Term_rhs = Core.Name "rhs"

data TermLhs =
  TermLhs {
    termLhsOperand :: Term,
    termLhsOperator :: TermOp}
  deriving (Eq, Ord, Read, Show)

_TermLhs = Core.Name "hydra.python.syntax.TermLhs"

_TermLhs_operand = Core.Name "operand"

_TermLhs_operator = Core.Name "operator"

data TermOp =
  TermOpMul |
  TermOpDiv |
  TermOpFloordiv |
  TermOpMod |
  TermOpMatmul
  deriving (Eq, Ord, Read, Show)

_TermOp = Core.Name "hydra.python.syntax.TermOp"

_TermOp_mul = Core.Name "mul"

_TermOp_div = Core.Name "div"

_TermOp_floordiv = Core.Name "floordiv"

_TermOp_mod = Core.Name "mod"

_TermOp_matmul = Core.Name "matmul"

data Factor =
  FactorPositive Factor |
  FactorNegative Factor |
  FactorComplement Factor |
  FactorSimple Power
  deriving (Eq, Ord, Read, Show)

_Factor = Core.Name "hydra.python.syntax.Factor"

_Factor_positive = Core.Name "positive"

_Factor_negative = Core.Name "negative"

_Factor_complement = Core.Name "complement"

_Factor_simple = Core.Name "simple"

data Power =
  Power {
    powerLhs :: AwaitPrimary,
    powerRhs :: (Maybe Factor)}
  deriving (Eq, Ord, Read, Show)

_Power = Core.Name "hydra.python.syntax.Power"

_Power_lhs = Core.Name "lhs"

_Power_rhs = Core.Name "rhs"

data AwaitPrimary =
  AwaitPrimary {
    awaitPrimaryAwait :: Bool,
    awaitPrimaryPrimary :: Primary}
  deriving (Eq, Ord, Read, Show)

_AwaitPrimary = Core.Name "hydra.python.syntax.AwaitPrimary"

_AwaitPrimary_await = Core.Name "await"

_AwaitPrimary_primary = Core.Name "primary"

data Primary =
  PrimarySimple Atom |
  PrimaryCompound PrimaryWithRhs
  deriving (Eq, Ord, Read, Show)

_Primary = Core.Name "hydra.python.syntax.Primary"

_Primary_simple = Core.Name "simple"

_Primary_compound = Core.Name "compound"

data PrimaryWithRhs =
  PrimaryWithRhs {
    primaryWithRhsPrimary :: Primary,
    primaryWithRhsRhs :: PrimaryRhs}
  deriving (Eq, Ord, Read, Show)

_PrimaryWithRhs = Core.Name "hydra.python.syntax.PrimaryWithRhs"

_PrimaryWithRhs_primary = Core.Name "primary"

_PrimaryWithRhs_rhs = Core.Name "rhs"

data PrimaryRhs =
  PrimaryRhsProject Name |
  PrimaryRhsGenexp Genexp |
  PrimaryRhsCall Args |
  PrimaryRhsSlices Slices
  deriving (Eq, Ord, Read, Show)

_PrimaryRhs = Core.Name "hydra.python.syntax.PrimaryRhs"

_PrimaryRhs_project = Core.Name "project"

_PrimaryRhs_genexp = Core.Name "genexp"

_PrimaryRhs_call = Core.Name "call"

_PrimaryRhs_slices = Core.Name "slices"

data Slices =
  Slices {
    slicesHead :: Slice,
    slicesTail :: [SliceOrStarredExpression]}
  deriving (Eq, Ord, Read, Show)

_Slices = Core.Name "hydra.python.syntax.Slices"

_Slices_head = Core.Name "head"

_Slices_tail = Core.Name "tail"

data SliceOrStarredExpression =
  SliceOrStarredExpressionSlice Slice |
  SliceOrStarredExpressionStarred StarredExpression
  deriving (Eq, Ord, Read, Show)

_SliceOrStarredExpression = Core.Name "hydra.python.syntax.SliceOrStarredExpression"

_SliceOrStarredExpression_slice = Core.Name "slice"

_SliceOrStarredExpression_starred = Core.Name "starred"

data Slice =
  SliceNamed NamedExpression |
  SliceSlice_ SliceExpression
  deriving (Eq, Ord, Read, Show)

_Slice = Core.Name "hydra.python.syntax.Slice"

_Slice_named = Core.Name "named"

_Slice_slice_ = Core.Name "slice_"

data SliceExpression =
  SliceExpression {
    sliceExpressionStart :: (Maybe Expression),
    sliceExpressionStop :: (Maybe Expression),
    sliceExpressionStep :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_SliceExpression = Core.Name "hydra.python.syntax.SliceExpression"

_SliceExpression_start = Core.Name "start"

_SliceExpression_stop = Core.Name "stop"

_SliceExpression_step = Core.Name "step"

data Atom =
  AtomName Name |
  AtomTrue |
  AtomFalse |
  AtomNone |
  AtomString String_ |
  AtomNumber Number |
  AtomTuple Tuple |
  AtomGroup Group |
  AtomGenexp Genexp |
  AtomList List |
  AtomListcomp Listcomp |
  AtomDict Dict |
  AtomSet Set |
  AtomDictcomp Dictcomp |
  AtomSetcomp Setcomp |
  AtomEllipsis
  deriving (Eq, Ord, Read, Show)

_Atom = Core.Name "hydra.python.syntax.Atom"

_Atom_name = Core.Name "name"

_Atom_true = Core.Name "true"

_Atom_false = Core.Name "false"

_Atom_none = Core.Name "none"

_Atom_string = Core.Name "string"

_Atom_number = Core.Name "number"

_Atom_tuple = Core.Name "tuple"

_Atom_group = Core.Name "group"

_Atom_genexp = Core.Name "genexp"

_Atom_list = Core.Name "list"

_Atom_listcomp = Core.Name "listcomp"

_Atom_dict = Core.Name "dict"

_Atom_set = Core.Name "set"

_Atom_dictcomp = Core.Name "dictcomp"

_Atom_setcomp = Core.Name "setcomp"

_Atom_ellipsis = Core.Name "ellipsis"

data Group =
  GroupYield YieldExpression |
  GroupExpression NamedExpression
  deriving (Eq, Ord, Read, Show)

_Group = Core.Name "hydra.python.syntax.Group"

_Group_yield = Core.Name "yield"

_Group_expression = Core.Name "expression"

data Lambda =
  Lambda {
    lambdaParams :: LambdaParameters,
    lambdaBody :: Expression}
  deriving (Eq, Ord, Read, Show)

_Lambda = Core.Name "hydra.python.syntax.Lambda"

_Lambda_params = Core.Name "params"

_Lambda_body = Core.Name "body"

data LambdaParameters =
  LambdaParameters {
    lambdaParametersSlashNoDefault :: (Maybe LambdaSlashNoDefault),
    lambdaParametersParamNoDefault :: [LambdaParamNoDefault],
    lambdaParametersParamWithDefault :: [LambdaParamWithDefault],
    lambdaParametersStarEtc :: (Maybe LambdaStarEtc)}
  deriving (Eq, Ord, Read, Show)

_LambdaParameters = Core.Name "hydra.python.syntax.LambdaParameters"

_LambdaParameters_slashNoDefault = Core.Name "slashNoDefault"

_LambdaParameters_paramNoDefault = Core.Name "paramNoDefault"

_LambdaParameters_paramWithDefault = Core.Name "paramWithDefault"

_LambdaParameters_starEtc = Core.Name "starEtc"

data LambdaSlashNoDefault =
  LambdaSlashNoDefault {
    lambdaSlashNoDefaultParameters :: [LambdaParamNoDefault]}
  deriving (Eq, Ord, Read, Show)

_LambdaSlashNoDefault = Core.Name "hydra.python.syntax.LambdaSlashNoDefault"

_LambdaSlashNoDefault_parameters = Core.Name "parameters"

data LambdaSlashWithDefault =
  LambdaSlashWithDefault {
    lambdaSlashWithDefaultParamNoDefault :: [LambdaParamNoDefault],
    lambdaSlashWithDefaultParamWithDefault :: [LambdaParamWithDefault]}
  deriving (Eq, Ord, Read, Show)

_LambdaSlashWithDefault = Core.Name "hydra.python.syntax.LambdaSlashWithDefault"

_LambdaSlashWithDefault_paramNoDefault = Core.Name "paramNoDefault"

_LambdaSlashWithDefault_paramWithDefault = Core.Name "paramWithDefault"

data LambdaStarEtc =
  LambdaStarEtcStar Bool |
  LambdaStarEtcParamNoDefault LambdaParamNoDefault |
  LambdaStarEtcParamMaybeDefault [LambdaParamMaybeDefault] |
  LambdaStarEtcKwds LambdaKwds
  deriving (Eq, Ord, Read, Show)

_LambdaStarEtc = Core.Name "hydra.python.syntax.LambdaStarEtc"

_LambdaStarEtc_star = Core.Name "star"

_LambdaStarEtc_paramNoDefault = Core.Name "paramNoDefault"

_LambdaStarEtc_paramMaybeDefault = Core.Name "paramMaybeDefault"

_LambdaStarEtc_kwds = Core.Name "kwds"

newtype LambdaKwds =
  LambdaKwds {
    unLambdaKwds :: LambdaParamNoDefault}
  deriving (Eq, Ord, Read, Show)

_LambdaKwds = Core.Name "hydra.python.syntax.LambdaKwds"

newtype LambdaParamNoDefault =
  LambdaParamNoDefault {
    unLambdaParamNoDefault :: Name}
  deriving (Eq, Ord, Read, Show)

_LambdaParamNoDefault = Core.Name "hydra.python.syntax.LambdaParamNoDefault"

data LambdaParamWithDefault =
  LambdaParamWithDefault {
    lambdaParamWithDefaultParam :: Name,
    lambdaParamWithDefaultDefault :: (Maybe Default)}
  deriving (Eq, Ord, Read, Show)

_LambdaParamWithDefault = Core.Name "hydra.python.syntax.LambdaParamWithDefault"

_LambdaParamWithDefault_param = Core.Name "param"

_LambdaParamWithDefault_default = Core.Name "default"

data LambdaParamMaybeDefault =
  LambdaParamMaybeDefault {
    lambdaParamMaybeDefaultParam :: Name,
    lambdaParamMaybeDefaultDefault :: (Maybe Default)}
  deriving (Eq, Ord, Read, Show)

_LambdaParamMaybeDefault = Core.Name "hydra.python.syntax.LambdaParamMaybeDefault"

_LambdaParamMaybeDefault_param = Core.Name "param"

_LambdaParamMaybeDefault_default = Core.Name "default"

newtype List =
  List {
    unList :: [StarNamedExpression]}
  deriving (Eq, Ord, Read, Show)

_List = Core.Name "hydra.python.syntax.List"

newtype Tuple =
  Tuple {
    unTuple :: [StarNamedExpression]}
  deriving (Eq, Ord, Read, Show)

_Tuple = Core.Name "hydra.python.syntax.Tuple"

newtype Set =
  Set {
    unSet :: [StarNamedExpression]}
  deriving (Eq, Ord, Read, Show)

_Set = Core.Name "hydra.python.syntax.Set"

newtype Dict =
  Dict {
    unDict :: [DoubleStarredKvpair]}
  deriving (Eq, Ord, Read, Show)

_Dict = Core.Name "hydra.python.syntax.Dict"

data DoubleStarredKvpair =
  DoubleStarredKvpairStarred BitwiseOr |
  DoubleStarredKvpairPair Kvpair
  deriving (Eq, Ord, Read, Show)

_DoubleStarredKvpair = Core.Name "hydra.python.syntax.DoubleStarredKvpair"

_DoubleStarredKvpair_starred = Core.Name "starred"

_DoubleStarredKvpair_pair = Core.Name "pair"

data Kvpair =
  Kvpair {
    kvpairKey :: Expression,
    kvpairValue :: Expression}
  deriving (Eq, Ord, Read, Show)

_Kvpair = Core.Name "hydra.python.syntax.Kvpair"

_Kvpair_key = Core.Name "key"

_Kvpair_value = Core.Name "value"

newtype ForIfClauses =
  ForIfClauses {
    unForIfClauses :: [ForIfClause]}
  deriving (Eq, Ord, Read, Show)

_ForIfClauses = Core.Name "hydra.python.syntax.ForIfClauses"

data ForIfClause =
  ForIfClause {
    forIfClauseAsync :: Bool,
    forIfClauseTargets :: [StarTarget],
    forIfClauseIn :: Disjunction,
    forIfClauseIfs :: [Disjunction]}
  deriving (Eq, Ord, Read, Show)

_ForIfClause = Core.Name "hydra.python.syntax.ForIfClause"

_ForIfClause_async = Core.Name "async"

_ForIfClause_targets = Core.Name "targets"

_ForIfClause_in = Core.Name "in"

_ForIfClause_ifs = Core.Name "ifs"

data Listcomp =
  Listcomp {
    listcompExpression :: NamedExpression,
    listcompForIfClauses :: ForIfClauses}
  deriving (Eq, Ord, Read, Show)

_Listcomp = Core.Name "hydra.python.syntax.Listcomp"

_Listcomp_expression = Core.Name "expression"

_Listcomp_forIfClauses = Core.Name "forIfClauses"

data Setcomp =
  Setcomp {
    setcompExpression :: NamedExpression,
    setcompForIfClauses :: ForIfClauses}
  deriving (Eq, Ord, Read, Show)

_Setcomp = Core.Name "hydra.python.syntax.Setcomp"

_Setcomp_expression = Core.Name "expression"

_Setcomp_forIfClauses = Core.Name "forIfClauses"

data Genexp =
  Genexp {
    genexpHead :: GenexpHead,
    genexpTail :: ForIfClauses}
  deriving (Eq, Ord, Read, Show)

_Genexp = Core.Name "hydra.python.syntax.Genexp"

_Genexp_head = Core.Name "head"

_Genexp_tail = Core.Name "tail"

data GenexpHead =
  GenexpHeadAssignment AssignmentExpression |
  GenexpHeadExpression Expression
  deriving (Eq, Ord, Read, Show)

_GenexpHead = Core.Name "hydra.python.syntax.GenexpHead"

_GenexpHead_assignment = Core.Name "assignment"

_GenexpHead_expression = Core.Name "expression"

data Dictcomp =
  Dictcomp {
    dictcompKvpair :: Kvpair,
    dictcompForIfClauses :: ForIfClauses}
  deriving (Eq, Ord, Read, Show)

_Dictcomp = Core.Name "hydra.python.syntax.Dictcomp"

_Dictcomp_kvpair = Core.Name "kvpair"

_Dictcomp_forIfClauses = Core.Name "forIfClauses"

data Args =
  Args {
    argsPositional :: [PosArg],
    argsKwargOrStarred :: [KwargOrStarred],
    argsKwargOrDoubleStarred :: [KwargOrDoubleStarred]}
  deriving (Eq, Ord, Read, Show)

_Args = Core.Name "hydra.python.syntax.Args"

_Args_positional = Core.Name "positional"

_Args_kwargOrStarred = Core.Name "kwargOrStarred"

_Args_kwargOrDoubleStarred = Core.Name "kwargOrDoubleStarred"

data PosArg =
  PosArgStarred StarredExpression |
  PosArgAssignment AssignmentExpression |
  PosArgExpression Expression
  deriving (Eq, Ord, Read, Show)

_PosArg = Core.Name "hydra.python.syntax.PosArg"

_PosArg_starred = Core.Name "starred"

_PosArg_assignment = Core.Name "assignment"

_PosArg_expression = Core.Name "expression"

newtype StarredExpression =
  StarredExpression {
    unStarredExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_StarredExpression = Core.Name "hydra.python.syntax.StarredExpression"

data KwargOrStarred =
  KwargOrStarredKwarg Kwarg |
  KwargOrStarredStarred StarredExpression
  deriving (Eq, Ord, Read, Show)

_KwargOrStarred = Core.Name "hydra.python.syntax.KwargOrStarred"

_KwargOrStarred_kwarg = Core.Name "kwarg"

_KwargOrStarred_starred = Core.Name "starred"

data Kwarg =
  Kwarg {
    kwargName :: Name,
    kwargValue :: Expression}
  deriving (Eq, Ord, Read, Show)

_Kwarg = Core.Name "hydra.python.syntax.Kwarg"

_Kwarg_name = Core.Name "name"

_Kwarg_value = Core.Name "value"

data KwargOrDoubleStarred =
  KwargOrDoubleStarredKwarg Kwarg |
  KwargOrDoubleStarredDoubleStarred Expression
  deriving (Eq, Ord, Read, Show)

_KwargOrDoubleStarred = Core.Name "hydra.python.syntax.KwargOrDoubleStarred"

_KwargOrDoubleStarred_kwarg = Core.Name "kwarg"

_KwargOrDoubleStarred_doubleStarred = Core.Name "doubleStarred"

newtype StarTargetsListSeq =
  StarTargetsListSeq {
    unStarTargetsListSeq :: [StarTarget]}
  deriving (Eq, Ord, Read, Show)

_StarTargetsListSeq = Core.Name "hydra.python.syntax.StarTargetsListSeq"

newtype StarTargetsTupleSeq =
  StarTargetsTupleSeq {
    unStarTargetsTupleSeq :: [StarTarget]}
  deriving (Eq, Ord, Read, Show)

_StarTargetsTupleSeq = Core.Name "hydra.python.syntax.StarTargetsTupleSeq"

data StarTarget =
  StarTargetStarred StarTarget |
  StarTargetUnstarred TargetWithStarAtom
  deriving (Eq, Ord, Read, Show)

_StarTarget = Core.Name "hydra.python.syntax.StarTarget"

_StarTarget_starred = Core.Name "starred"

_StarTarget_unstarred = Core.Name "unstarred"

data TargetWithStarAtom =
  TargetWithStarAtomProject TPrimaryAndName |
  TargetWithStarAtomSlices TPrimaryAndSlices |
  TargetWithStarAtomAtom StarAtom
  deriving (Eq, Ord, Read, Show)

_TargetWithStarAtom = Core.Name "hydra.python.syntax.TargetWithStarAtom"

_TargetWithStarAtom_project = Core.Name "project"

_TargetWithStarAtom_slices = Core.Name "slices"

_TargetWithStarAtom_atom = Core.Name "atom"

data TPrimaryAndName =
  TPrimaryAndName {
    tPrimaryAndNamePrimary :: TPrimary,
    tPrimaryAndNameName :: Name}
  deriving (Eq, Ord, Read, Show)

_TPrimaryAndName = Core.Name "hydra.python.syntax.TPrimaryAndName"

_TPrimaryAndName_primary = Core.Name "primary"

_TPrimaryAndName_name = Core.Name "name"

data TPrimaryAndSlices =
  TPrimaryAndSlices {
    tPrimaryAndSlicesPrimary :: TPrimary,
    tPrimaryAndSlicesSlices :: Slices}
  deriving (Eq, Ord, Read, Show)

_TPrimaryAndSlices = Core.Name "hydra.python.syntax.TPrimaryAndSlices"

_TPrimaryAndSlices_primary = Core.Name "primary"

_TPrimaryAndSlices_slices = Core.Name "slices"

data StarAtom =
  StarAtomName Name |
  StarAtomTargetWithStarAtom TargetWithStarAtom |
  StarAtomStarTargetsTupleSeq (Maybe StarTargetsTupleSeq) |
  StarAtomStarTargetsListSeq (Maybe StarTargetsListSeq)
  deriving (Eq, Ord, Read, Show)

_StarAtom = Core.Name "hydra.python.syntax.StarAtom"

_StarAtom_name = Core.Name "name"

_StarAtom_targetWithStarAtom = Core.Name "targetWithStarAtom"

_StarAtom_starTargetsTupleSeq = Core.Name "starTargetsTupleSeq"

_StarAtom_starTargetsListSeq = Core.Name "starTargetsListSeq"

data SingleTarget =
  SingleTargetSubscriptAttributeTarget SingleSubscriptAttributeTarget |
  SingleTargetName Name |
  SingleTargetParens SingleTarget
  deriving (Eq, Ord, Read, Show)

_SingleTarget = Core.Name "hydra.python.syntax.SingleTarget"

_SingleTarget_subscriptAttributeTarget = Core.Name "subscriptAttributeTarget"

_SingleTarget_name = Core.Name "name"

_SingleTarget_parens = Core.Name "parens"

data SingleSubscriptAttributeTarget =
  SingleSubscriptAttributeTargetPrimaryAndName TPrimaryAndName |
  SingleSubscriptAttributeTargetPrimaryAndSlices TPrimaryAndSlices
  deriving (Eq, Ord, Read, Show)

_SingleSubscriptAttributeTarget = Core.Name "hydra.python.syntax.SingleSubscriptAttributeTarget"

_SingleSubscriptAttributeTarget_primaryAndName = Core.Name "primaryAndName"

_SingleSubscriptAttributeTarget_primaryAndSlices = Core.Name "primaryAndSlices"

data TPrimary =
  TPrimaryPrimaryAndName TPrimaryAndName |
  TPrimaryPrimaryAndSlices TPrimaryAndSlices |
  TPrimaryPrimaryAndGenexp TPrimaryAndGenexp |
  TPrimaryPrimaryAndArguments TPrimaryAndArguments |
  TPrimaryAtom Atom
  deriving (Eq, Ord, Read, Show)

_TPrimary = Core.Name "hydra.python.syntax.TPrimary"

_TPrimary_primaryAndName = Core.Name "primaryAndName"

_TPrimary_primaryAndSlices = Core.Name "primaryAndSlices"

_TPrimary_primaryAndGenexp = Core.Name "primaryAndGenexp"

_TPrimary_primaryAndArguments = Core.Name "primaryAndArguments"

_TPrimary_atom = Core.Name "atom"

data TPrimaryAndGenexp =
  TPrimaryAndGenexp {
    tPrimaryAndGenexpPrimary :: TPrimary,
    tPrimaryAndGenexpGenexp :: Genexp}
  deriving (Eq, Ord, Read, Show)

_TPrimaryAndGenexp = Core.Name "hydra.python.syntax.TPrimaryAndGenexp"

_TPrimaryAndGenexp_primary = Core.Name "primary"

_TPrimaryAndGenexp_genexp = Core.Name "genexp"

data TPrimaryAndArguments =
  TPrimaryAndArguments {
    tPrimaryAndArgumentsPrimary :: TPrimary,
    tPrimaryAndArgumentsArguments :: (Maybe Args)}
  deriving (Eq, Ord, Read, Show)

_TPrimaryAndArguments = Core.Name "hydra.python.syntax.TPrimaryAndArguments"

_TPrimaryAndArguments_primary = Core.Name "primary"

_TPrimaryAndArguments_arguments = Core.Name "arguments"

newtype DelTargets =
  DelTargets {
    unDelTargets :: [DelTarget]}
  deriving (Eq, Ord, Read, Show)

_DelTargets = Core.Name "hydra.python.syntax.DelTargets"

data DelTarget =
  DelTargetPrimaryAndName TPrimaryAndName |
  DelTargetPrimaryAndSlices TPrimaryAndSlices |
  DelTargetDelTAtom DelTAtom
  deriving (Eq, Ord, Read, Show)

_DelTarget = Core.Name "hydra.python.syntax.DelTarget"

_DelTarget_primaryAndName = Core.Name "primaryAndName"

_DelTarget_primaryAndSlices = Core.Name "primaryAndSlices"

_DelTarget_delTAtom = Core.Name "delTAtom"

data DelTAtom =
  DelTAtomName Name |
  DelTAtomTarget DelTarget |
  DelTAtomTargets DelTargets
  deriving (Eq, Ord, Read, Show)

_DelTAtom = Core.Name "hydra.python.syntax.DelTAtom"

_DelTAtom_name = Core.Name "name"

_DelTAtom_target = Core.Name "target"

_DelTAtom_targets = Core.Name "targets"

data TypeExpression =
  TypeExpressionExpression Expression |
  TypeExpressionStarredExpression Expression |
  TypeExpressionDoubleStarredExpression Expression
  deriving (Eq, Ord, Read, Show)

_TypeExpression = Core.Name "hydra.python.syntax.TypeExpression"

_TypeExpression_expression = Core.Name "expression"

_TypeExpression_starredExpression = Core.Name "starredExpression"

_TypeExpression_doubleStarredExpression = Core.Name "doubleStarredExpression"

newtype FuncTypeComment =
  FuncTypeComment {
    unFuncTypeComment :: TypeComment}
  deriving (Eq, Ord, Read, Show)

_FuncTypeComment = Core.Name "hydra.python.syntax.FuncTypeComment"