Syntax.hs

-- Note: this is an automatically generated file. Do not edit.
-- | A Haskell syntax model, loosely based on Language.Haskell.Tools.AST

module Hydra.Haskell.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
-- | A pattern-matching alternative
data Alternative =
  Alternative {
    -- | The pattern to match
    alternativePattern :: Pattern,
    -- | The right-hand side of the alternative
    alternativeRhs :: CaseRhs,
    -- | Optional local bindings
    alternativeBinds :: (Maybe LocalBindings)}
  deriving (Eq, Ord, Read, Show)
_Alternative = Core.Name "hydra.haskell.syntax.Alternative"
_Alternative_pattern = Core.Name "pattern"
_Alternative_rhs = Core.Name "rhs"
_Alternative_binds = Core.Name "binds"
-- | A type assertion
data Assertion =
  -- | A class assertion
  AssertionClass ClassAssertion |
  -- | A tuple of assertions
  AssertionTuple [Assertion]
  deriving (Eq, Ord, Read, Show)
_Assertion = Core.Name "hydra.haskell.syntax.Assertion"
_Assertion_class = Core.Name "class"
_Assertion_tuple = Core.Name "tuple"
-- | A class assertion
data ClassAssertion =
  ClassAssertion {
    -- | The name of the class
    classAssertionName :: Name,
    -- | The types to which the class is applied
    classAssertionTypes :: [Type]}
  deriving (Eq, Ord, Read, Show)
_ClassAssertion = Core.Name "hydra.haskell.syntax.ClassAssertion"
_ClassAssertion_name = Core.Name "name"
_ClassAssertion_types = Core.Name "types"
-- | The right-hand side of a pattern-matching alternative
newtype CaseRhs =
  CaseRhs {
    unCaseRhs :: Expression}
  deriving (Eq, Ord, Read, Show)
_CaseRhs = Core.Name "hydra.haskell.syntax.CaseRhs"
-- | A data constructor
data Constructor =
  -- | An ordinary (positional) constructor
  ConstructorOrdinary OrdinaryConstructor |
  -- | A record constructor
  ConstructorRecord RecordConstructor
  deriving (Eq, Ord, Read, Show)
_Constructor = Core.Name "hydra.haskell.syntax.Constructor"
_Constructor_ordinary = Core.Name "ordinary"
_Constructor_record = Core.Name "record"
-- | An ordinary (positional) data constructor
data OrdinaryConstructor =
  OrdinaryConstructor {
    -- | The name of the constructor
    ordinaryConstructorName :: Name,
    -- | The types of the positional fields
    ordinaryConstructorFields :: [Type]}
  deriving (Eq, Ord, Read, Show)
_OrdinaryConstructor = Core.Name "hydra.haskell.syntax.OrdinaryConstructor"
_OrdinaryConstructor_name = Core.Name "name"
_OrdinaryConstructor_fields = Core.Name "fields"
-- | A record-style data constructor
data RecordConstructor =
  RecordConstructor {
    -- | The name of the constructor
    recordConstructorName :: Name,
    -- | The named fields of the record
    recordConstructorFields :: [FieldWithComments]}
  deriving (Eq, Ord, Read, Show)
_RecordConstructor = Core.Name "hydra.haskell.syntax.RecordConstructor"
_RecordConstructor_name = Core.Name "name"
_RecordConstructor_fields = Core.Name "fields"
-- | A data constructor together with any comments
data ConstructorWithComments =
  ConstructorWithComments {
    -- | The constructor
    constructorWithCommentsBody :: Constructor,
    -- | Optional comments
    constructorWithCommentsComments :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)
_ConstructorWithComments = Core.Name "hydra.haskell.syntax.ConstructorWithComments"
_ConstructorWithComments_body = Core.Name "body"
_ConstructorWithComments_comments = Core.Name "comments"
-- | A data type declaration
data DataDeclaration =
  DataDeclaration {
    -- | The 'data' or 'newtype' keyword
    dataDeclarationKeyword :: DataOrNewtype,
    -- | Type class constraints
    dataDeclarationContext :: [Assertion],
    -- | The declaration head
    dataDeclarationHead :: DeclarationHead,
    -- | The data constructors
    dataDeclarationConstructors :: [ConstructorWithComments],
    -- | Derived type class instances
    dataDeclarationDeriving :: [Deriving]}
  deriving (Eq, Ord, Read, Show)
_DataDeclaration = Core.Name "hydra.haskell.syntax.DataDeclaration"
_DataDeclaration_keyword = Core.Name "keyword"
_DataDeclaration_context = Core.Name "context"
_DataDeclaration_head = Core.Name "head"
_DataDeclaration_constructors = Core.Name "constructors"
_DataDeclaration_deriving = Core.Name "deriving"
-- | The 'data' versus 'newtype keyword
data DataOrNewtype =
  DataOrNewtypeData |
  DataOrNewtypeNewtype
  deriving (Eq, Ord, Read, Show)
_DataOrNewtype = Core.Name "hydra.haskell.syntax.DataOrNewtype"
_DataOrNewtype_data = Core.Name "data"
_DataOrNewtype_newtype = Core.Name "newtype"
-- | A data declaration together with any comments
data DeclarationWithComments =
  DeclarationWithComments {
    -- | The declaration
    declarationWithCommentsBody :: Declaration,
    -- | Optional comments
    declarationWithCommentsComments :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)
_DeclarationWithComments = Core.Name "hydra.haskell.syntax.DeclarationWithComments"
_DeclarationWithComments_body = Core.Name "body"
_DeclarationWithComments_comments = Core.Name "comments"
-- | A data or value declaration
data Declaration =
  -- | A data type declaration
  DeclarationData DataDeclaration |
  -- | A type synonym declaration
  DeclarationType TypeDeclaration |
  -- | A value binding
  DeclarationValueBinding ValueBinding |
  -- | A typed binding
  DeclarationTypedBinding TypedBinding
  deriving (Eq, Ord, Read, Show)
_Declaration = Core.Name "hydra.haskell.syntax.Declaration"
_Declaration_data = Core.Name "data"
_Declaration_type = Core.Name "type"
_Declaration_valueBinding = Core.Name "valueBinding"
_Declaration_typedBinding = Core.Name "typedBinding"
-- | The left-hand side of a declaration
data DeclarationHead =
  -- | An application-style declaration head
  DeclarationHeadApplication ApplicationDeclarationHead |
  -- | A parenthesized declaration head
  DeclarationHeadParens DeclarationHead |
  -- | A simple name
  DeclarationHeadSimple Name
  deriving (Eq, Ord, Read, Show)
_DeclarationHead = Core.Name "hydra.haskell.syntax.DeclarationHead"
_DeclarationHead_application = Core.Name "application"
_DeclarationHead_parens = Core.Name "parens"
_DeclarationHead_simple = Core.Name "simple"
-- | An application-style declaration head
data ApplicationDeclarationHead =
  ApplicationDeclarationHead {
    -- | The function being applied
    applicationDeclarationHeadFunction :: DeclarationHead,
    -- | The type variable operand
    applicationDeclarationHeadOperand :: Variable}
  deriving (Eq, Ord, Read, Show)
_ApplicationDeclarationHead = Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead"
_ApplicationDeclarationHead_function = Core.Name "function"
_ApplicationDeclarationHead_operand = Core.Name "operand"
-- | A 'deriving' statement
newtype Deriving =
  Deriving {
    unDeriving :: [Name]}
  deriving (Eq, Ord, Read, Show)
_Deriving = Core.Name "hydra.haskell.syntax.Deriving"
-- | An export statement
data Export =
  -- | An exported declaration
  ExportDeclaration ImportExportSpec |
  -- | An exported module
  ExportModule ModuleName
  deriving (Eq, Ord, Read, Show)
_Export = Core.Name "hydra.haskell.syntax.Export"
_Export_declaration = Core.Name "declaration"
_Export_module = Core.Name "module"
-- | A data expression
data Expression =
  -- | A function application
  ExpressionApplication ApplicationExpression |
  -- | A case expression
  ExpressionCase CaseExpression |
  -- | A record constructor expression
  ExpressionConstructRecord ConstructRecordExpression |
  -- | A 'do' expression
  ExpressionDo [Statement] |
  -- | An 'if' expression
  ExpressionIf IfExpression |
  -- | An infix application
  ExpressionInfixApplication InfixApplicationExpression |
  -- | A literal value
  ExpressionLiteral Literal |
  -- | A lambda expression
  ExpressionLambda LambdaExpression |
  -- | A left section expression
  ExpressionLeftSection SectionExpression |
  -- | A 'let' expression
  ExpressionLet LetExpression |
  -- | A list expression
  ExpressionList [Expression] |
  -- | A parenthesized expression
  ExpressionParens Expression |
  -- | A prefix application
  ExpressionPrefixApplication PrefixApplicationExpression |
  -- | A right section expression
  ExpressionRightSection SectionExpression |
  -- | A tuple expression
  ExpressionTuple [Expression] |
  -- | A type signature expression
  ExpressionTypeSignature TypeSignatureExpression |
  -- | A record update expression
  ExpressionUpdateRecord UpdateRecordExpression |
  -- | A variable reference
  ExpressionVariable Name
  deriving (Eq, Ord, Read, Show)
_Expression = Core.Name "hydra.haskell.syntax.Expression"
_Expression_application = Core.Name "application"
_Expression_case = Core.Name "case"
_Expression_constructRecord = Core.Name "constructRecord"
_Expression_do = Core.Name "do"
_Expression_if = Core.Name "if"
_Expression_infixApplication = Core.Name "infixApplication"
_Expression_literal = Core.Name "literal"
_Expression_lambda = Core.Name "lambda"
_Expression_leftSection = Core.Name "leftSection"
_Expression_let = Core.Name "let"
_Expression_list = Core.Name "list"
_Expression_parens = Core.Name "parens"
_Expression_prefixApplication = Core.Name "prefixApplication"
_Expression_rightSection = Core.Name "rightSection"
_Expression_tuple = Core.Name "tuple"
_Expression_typeSignature = Core.Name "typeSignature"
_Expression_updateRecord = Core.Name "updateRecord"
_Expression_variable = Core.Name "variable"
-- | An application expression
data ApplicationExpression =
  ApplicationExpression {
    -- | The function being applied
    applicationExpressionFunction :: Expression,
    -- | The argument
    applicationExpressionArgument :: Expression}
  deriving (Eq, Ord, Read, Show)
_ApplicationExpression = Core.Name "hydra.haskell.syntax.ApplicationExpression"
_ApplicationExpression_function = Core.Name "function"
_ApplicationExpression_argument = Core.Name "argument"
-- | A case expression
data CaseExpression =
  CaseExpression {
    -- | The expression being matched
    caseExpressionCase :: Expression,
    -- | The pattern-matching alternatives
    caseExpressionAlternatives :: [Alternative]}
  deriving (Eq, Ord, Read, Show)
_CaseExpression = Core.Name "hydra.haskell.syntax.CaseExpression"
_CaseExpression_case = Core.Name "case"
_CaseExpression_alternatives = Core.Name "alternatives"
-- | A record constructor expression
data ConstructRecordExpression =
  ConstructRecordExpression {
    -- | The constructor name
    constructRecordExpressionName :: Name,
    -- | The field assignments
    constructRecordExpressionFields :: [FieldUpdate]}
  deriving (Eq, Ord, Read, Show)
_ConstructRecordExpression = Core.Name "hydra.haskell.syntax.ConstructRecordExpression"
_ConstructRecordExpression_name = Core.Name "name"
_ConstructRecordExpression_fields = Core.Name "fields"
-- | An 'if' expression
data IfExpression =
  IfExpression {
    -- | The condition expression
    ifExpressionCondition :: Expression,
    -- | The 'then' branch
    ifExpressionThen :: Expression,
    -- | The 'else' branch
    ifExpressionElse :: Expression}
  deriving (Eq, Ord, Read, Show)
_IfExpression = Core.Name "hydra.haskell.syntax.IfExpression"
_IfExpression_condition = Core.Name "condition"
_IfExpression_then = Core.Name "then"
_IfExpression_else = Core.Name "else"
-- | An infix application expression
data InfixApplicationExpression =
  InfixApplicationExpression {
    -- | The left-hand operand
    infixApplicationExpressionLhs :: Expression,
    -- | The infix operator
    infixApplicationExpressionOperator :: Operator,
    -- | The right-hand operand
    infixApplicationExpressionRhs :: Expression}
  deriving (Eq, Ord, Read, Show)
_InfixApplicationExpression = Core.Name "hydra.haskell.syntax.InfixApplicationExpression"
_InfixApplicationExpression_lhs = Core.Name "lhs"
_InfixApplicationExpression_operator = Core.Name "operator"
_InfixApplicationExpression_rhs = Core.Name "rhs"
-- | A lambda expression
data LambdaExpression =
  LambdaExpression {
    -- | The patterns binding parameters
    lambdaExpressionBindings :: [Pattern],
    -- | The body of the lambda
    lambdaExpressionInner :: Expression}
  deriving (Eq, Ord, Read, Show)
_LambdaExpression = Core.Name "hydra.haskell.syntax.LambdaExpression"
_LambdaExpression_bindings = Core.Name "bindings"
_LambdaExpression_inner = Core.Name "inner"
-- | A 'let' expression
data LetExpression =
  LetExpression {
    -- | The local bindings
    letExpressionBindings :: [LocalBinding],
    -- | The body of the let expression
    letExpressionInner :: Expression}
  deriving (Eq, Ord, Read, Show)
_LetExpression = Core.Name "hydra.haskell.syntax.LetExpression"
_LetExpression_bindings = Core.Name "bindings"
_LetExpression_inner = Core.Name "inner"
-- | A prefix expression
data PrefixApplicationExpression =
  PrefixApplicationExpression {
    -- | The prefix operator
    prefixApplicationExpressionOperator :: Operator,
    -- | The operand
    prefixApplicationExpressionRhs :: Expression}
  deriving (Eq, Ord, Read, Show)
_PrefixApplicationExpression = Core.Name "hydra.haskell.syntax.PrefixApplicationExpression"
_PrefixApplicationExpression_operator = Core.Name "operator"
_PrefixApplicationExpression_rhs = Core.Name "rhs"
-- | A section expression
data SectionExpression =
  SectionExpression {
    -- | The operator
    sectionExpressionOperator :: Operator,
    -- | The operand
    sectionExpressionExpression :: Expression}
  deriving (Eq, Ord, Read, Show)
_SectionExpression = Core.Name "hydra.haskell.syntax.SectionExpression"
_SectionExpression_operator = Core.Name "operator"
_SectionExpression_expression = Core.Name "expression"
-- | A type signature expression
data TypeSignatureExpression =
  TypeSignatureExpression {
    -- | The expression being typed
    typeSignatureExpressionInner :: Expression,
    -- | The type signature
    typeSignatureExpressionType :: Type}
  deriving (Eq, Ord, Read, Show)
_TypeSignatureExpression = Core.Name "hydra.haskell.syntax.TypeSignatureExpression"
_TypeSignatureExpression_inner = Core.Name "inner"
_TypeSignatureExpression_type = Core.Name "type"
-- | An update record expression
data UpdateRecordExpression =
  UpdateRecordExpression {
    -- | The record being updated
    updateRecordExpressionInner :: Expression,
    -- | The field updates
    updateRecordExpressionFields :: [FieldUpdate]}
  deriving (Eq, Ord, Read, Show)
_UpdateRecordExpression = Core.Name "hydra.haskell.syntax.UpdateRecordExpression"
_UpdateRecordExpression_inner = Core.Name "inner"
_UpdateRecordExpression_fields = Core.Name "fields"
-- | A field (name/type pair)
data Field =
  Field {
    -- | The field name
    fieldName :: Name,
    -- | The field type
    fieldType :: Type}
  deriving (Eq, Ord, Read, Show)
_Field = Core.Name "hydra.haskell.syntax.Field"
_Field_name = Core.Name "name"
_Field_type = Core.Name "type"
-- | A field together with any comments
data FieldWithComments =
  FieldWithComments {
    -- | The field
    fieldWithCommentsField :: Field,
    -- | Optional comments
    fieldWithCommentsComments :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)
_FieldWithComments = Core.Name "hydra.haskell.syntax.FieldWithComments"
_FieldWithComments_field = Core.Name "field"
_FieldWithComments_comments = Core.Name "comments"
-- | A field name and value
data FieldUpdate =
  FieldUpdate {
    -- | The field name
    fieldUpdateName :: Name,
    -- | The field value
    fieldUpdateValue :: Expression}
  deriving (Eq, Ord, Read, Show)
_FieldUpdate = Core.Name "hydra.haskell.syntax.FieldUpdate"
_FieldUpdate_name = Core.Name "name"
_FieldUpdate_value = Core.Name "value"
-- | An import statement
data Import =
  Import {
    -- | Whether the import is qualified
    importQualified :: Bool,
    -- | The module being imported
    importModule :: ModuleName,
    -- | Optional alias for the module
    importAs :: (Maybe ModuleName),
    -- | Optional import specification
    importSpec :: (Maybe SpecImport)}
  deriving (Eq, Ord, Read, Show)
_Import = Core.Name "hydra.haskell.syntax.Import"
_Import_qualified = Core.Name "qualified"
_Import_module = Core.Name "module"
_Import_as = Core.Name "as"
_Import_spec = Core.Name "spec"
-- | An import specification
data SpecImport =
  -- | A list of imports to include
  SpecImportList [ImportExportSpec] |
  -- | A list of imports to exclude
  SpecImportHiding [ImportExportSpec]
  deriving (Eq, Ord, Read, Show)
_SpecImport = Core.Name "hydra.haskell.syntax.SpecImport"
_SpecImport_list = Core.Name "list"
_SpecImport_hiding = Core.Name "hiding"
-- | An import modifier ('pattern' or 'type')
data ImportModifier =
  ImportModifierPattern |
  ImportModifierType
  deriving (Eq, Ord, Read, Show)
_ImportModifier = Core.Name "hydra.haskell.syntax.ImportModifier"
_ImportModifier_pattern = Core.Name "pattern"
_ImportModifier_type = Core.Name "type"
-- | An import or export specification
data ImportExportSpec =
  ImportExportSpec {
    -- | Optional import modifier
    importExportSpecModifier :: (Maybe ImportModifier),
    -- | The name being imported or exported
    importExportSpecName :: Name,
    -- | Optional subspecification
    importExportSpecSubspec :: (Maybe SubspecImportExportSpec)}
  deriving (Eq, Ord, Read, Show)
_ImportExportSpec = Core.Name "hydra.haskell.syntax.ImportExportSpec"
_ImportExportSpec_modifier = Core.Name "modifier"
_ImportExportSpec_name = Core.Name "name"
_ImportExportSpec_subspec = Core.Name "subspec"
-- | A subspecification within an import/export
data SubspecImportExportSpec =
  -- | Import/export all
  SubspecImportExportSpecAll |
  -- | Import/export specific names
  SubspecImportExportSpecList [Name]
  deriving (Eq, Ord, Read, Show)
_SubspecImportExportSpec = Core.Name "hydra.haskell.syntax.SubspecImportExportSpec"
_SubspecImportExportSpec_all = Core.Name "all"
_SubspecImportExportSpec_list = Core.Name "list"
-- | A literal value
data Literal =
  -- | A character literal
  LiteralChar Int |
  -- | A double-precision floating point literal
  LiteralDouble Double |
  -- | A single-precision floating point literal
  LiteralFloat Float |
  -- | A 32-bit integer literal
  LiteralInt Int |
  -- | An arbitrary-precision integer literal
  LiteralInteger Integer |
  -- | A string literal
  LiteralString String
  deriving (Eq, Ord, Read, Show)
_Literal = Core.Name "hydra.haskell.syntax.Literal"
_Literal_char = Core.Name "char"
_Literal_double = Core.Name "double"
_Literal_float = Core.Name "float"
_Literal_int = Core.Name "int"
_Literal_integer = Core.Name "integer"
_Literal_string = Core.Name "string"
-- | A local binding
data LocalBinding =
  -- | A type signature
  LocalBindingSignature TypeSignature |
  -- | A value binding
  LocalBindingValue ValueBinding
  deriving (Eq, Ord, Read, Show)
_LocalBinding = Core.Name "hydra.haskell.syntax.LocalBinding"
_LocalBinding_signature = Core.Name "signature"
_LocalBinding_value = Core.Name "value"
-- | A collection of local bindings
newtype LocalBindings =
  LocalBindings {
    unLocalBindings :: [LocalBinding]}
  deriving (Eq, Ord, Read, Show)
_LocalBindings = Core.Name "hydra.haskell.syntax.LocalBindings"
-- | A Haskell module
data Module =
  Module {
    -- | Optional module head
    moduleHead :: (Maybe ModuleHead),
    -- | Import statements
    moduleImports :: [Import],
    -- | Module declarations
    moduleDeclarations :: [DeclarationWithComments]}
  deriving (Eq, Ord, Read, Show)
_Module = Core.Name "hydra.haskell.syntax.Module"
_Module_head = Core.Name "head"
_Module_imports = Core.Name "imports"
_Module_declarations = Core.Name "declarations"
-- | A module head
data ModuleHead =
  ModuleHead {
    -- | Optional module-level comments
    moduleHeadComments :: (Maybe String),
    -- | The module name
    moduleHeadName :: ModuleName,
    -- | Export list
    moduleHeadExports :: [Export]}
  deriving (Eq, Ord, Read, Show)
_ModuleHead = Core.Name "hydra.haskell.syntax.ModuleHead"
_ModuleHead_comments = Core.Name "comments"
_ModuleHead_name = Core.Name "name"
_ModuleHead_exports = Core.Name "exports"
-- | A module name
newtype ModuleName =
  ModuleName {
    unModuleName :: String}
  deriving (Eq, Ord, Read, Show)
_ModuleName = Core.Name "hydra.haskell.syntax.ModuleName"
-- | A name
data Name =
  -- | An implicit name
  NameImplicit QualifiedName |
  -- | A normal name
  NameNormal QualifiedName |
  -- | A parenthesized name
  NameParens QualifiedName
  deriving (Eq, Ord, Read, Show)
_Name = Core.Name "hydra.haskell.syntax.Name"
_Name_implicit = Core.Name "implicit"
_Name_normal = Core.Name "normal"
_Name_parens = Core.Name "parens"
-- | A component of a qualified name
newtype NamePart =
  NamePart {
    unNamePart :: String}
  deriving (Eq, Ord, Read, Show)
_NamePart = Core.Name "hydra.haskell.syntax.NamePart"
-- | An operator
data Operator =
  -- | A function used as an infix operator
  OperatorBacktick QualifiedName |
  -- | A normal infix operator
  OperatorNormal QualifiedName
  deriving (Eq, Ord, Read, Show)
_Operator = Core.Name "hydra.haskell.syntax.Operator"
_Operator_backtick = Core.Name "backtick"
_Operator_normal = Core.Name "normal"
-- | A pattern
data Pattern =
  -- | An application pattern
  PatternApplication ApplicationPattern |
  -- | An 'as' pattern
  PatternAs AsPattern |
  -- | A list pattern
  PatternList [Pattern] |
  -- | A literal pattern
  PatternLiteral Literal |
  -- | A name pattern
  PatternName Name |
  -- | A parenthesized pattern
  PatternParens Pattern |
  -- | A record pattern
  PatternRecord RecordPattern |
  -- | A tuple pattern
  PatternTuple [Pattern] |
  -- | A typed pattern
  PatternTyped TypedPattern |
  -- | A wildcard pattern
  PatternWildcard
  deriving (Eq, Ord, Read, Show)
_Pattern = Core.Name "hydra.haskell.syntax.Pattern"
_Pattern_application = Core.Name "application"
_Pattern_as = Core.Name "as"
_Pattern_list = Core.Name "list"
_Pattern_literal = Core.Name "literal"
_Pattern_name = Core.Name "name"
_Pattern_parens = Core.Name "parens"
_Pattern_record = Core.Name "record"
_Pattern_tuple = Core.Name "tuple"
_Pattern_typed = Core.Name "typed"
_Pattern_wildcard = Core.Name "wildcard"
-- | An application pattern
data ApplicationPattern =
  ApplicationPattern {
    -- | The constructor name
    applicationPatternName :: Name,
    -- | The pattern arguments
    applicationPatternArgs :: [Pattern]}
  deriving (Eq, Ord, Read, Show)
_ApplicationPattern = Core.Name "hydra.haskell.syntax.ApplicationPattern"
_ApplicationPattern_name = Core.Name "name"
_ApplicationPattern_args = Core.Name "args"
-- | An 'as' pattern
data AsPattern =
  AsPattern {
    -- | The bound name
    asPatternName :: Name,
    -- | The inner pattern
    asPatternInner :: Pattern}
  deriving (Eq, Ord, Read, Show)
_AsPattern = Core.Name "hydra.haskell.syntax.AsPattern"
_AsPattern_name = Core.Name "name"
_AsPattern_inner = Core.Name "inner"
-- | A record pattern
data RecordPattern =
  RecordPattern {
    -- | The constructor name
    recordPatternName :: Name,
    -- | The field patterns
    recordPatternFields :: [PatternField]}
  deriving (Eq, Ord, Read, Show)
_RecordPattern = Core.Name "hydra.haskell.syntax.RecordPattern"
_RecordPattern_name = Core.Name "name"
_RecordPattern_fields = Core.Name "fields"
-- | A typed pattern
data TypedPattern =
  TypedPattern {
    -- | The inner pattern
    typedPatternInner :: Pattern,
    -- | The type annotation
    typedPatternType :: Type}
  deriving (Eq, Ord, Read, Show)
_TypedPattern = Core.Name "hydra.haskell.syntax.TypedPattern"
_TypedPattern_inner = Core.Name "inner"
_TypedPattern_type = Core.Name "type"
-- | A pattern field
data PatternField =
  PatternField {
    -- | The field name
    patternFieldName :: Name,
    -- | The field pattern
    patternFieldPattern :: Pattern}
  deriving (Eq, Ord, Read, Show)
_PatternField = Core.Name "hydra.haskell.syntax.PatternField"
_PatternField_name = Core.Name "name"
_PatternField_pattern = Core.Name "pattern"
-- | A qualified name
data QualifiedName =
  QualifiedName {
    -- | The qualifier parts
    qualifiedNameQualifiers :: [NamePart],
    -- | The unqualified name part
    qualifiedNameUnqualified :: NamePart}
  deriving (Eq, Ord, Read, Show)
_QualifiedName = Core.Name "hydra.haskell.syntax.QualifiedName"
_QualifiedName_qualifiers = Core.Name "qualifiers"
_QualifiedName_unqualified = Core.Name "unqualified"
-- | A right-hand side of a binding
newtype RightHandSide =
  RightHandSide {
    unRightHandSide :: Expression}
  deriving (Eq, Ord, Read, Show)
_RightHandSide = Core.Name "hydra.haskell.syntax.RightHandSide"
-- | A do-notation statement
newtype Statement =
  Statement {
    unStatement :: Expression}
  deriving (Eq, Ord, Read, Show)
_Statement = Core.Name "hydra.haskell.syntax.Statement"
-- | A type expression
data Type =
  -- | An application type
  TypeApplication ApplicationType |
  -- | A context type
  TypeCtx ContextType |
  -- | A function type
  TypeFunction FunctionType |
  -- | An infix type
  TypeInfix InfixType |
  -- | A list type
  TypeList Type |
  -- | A parenthesized type
  TypeParens Type |
  -- | A tuple type
  TypeTuple [Type] |
  -- | A type variable or type name
  TypeVariable Name
  deriving (Eq, Ord, Read, Show)
_Type = Core.Name "hydra.haskell.syntax.Type"
_Type_application = Core.Name "application"
_Type_ctx = Core.Name "ctx"
_Type_function = Core.Name "function"
_Type_infix = Core.Name "infix"
_Type_list = Core.Name "list"
_Type_parens = Core.Name "parens"
_Type_tuple = Core.Name "tuple"
_Type_variable = Core.Name "variable"
-- | An application type
data ApplicationType =
  ApplicationType {
    -- | The type being applied
    applicationTypeContext :: Type,
    -- | The type argument
    applicationTypeArgument :: Type}
  deriving (Eq, Ord, Read, Show)
_ApplicationType = Core.Name "hydra.haskell.syntax.ApplicationType"
_ApplicationType_context = Core.Name "context"
_ApplicationType_argument = Core.Name "argument"
-- | A type with a context (type class constraints)
data ContextType =
  ContextType {
    -- | The type class context
    contextTypeCtx :: Assertion,
    -- | The constrained type
    contextTypeType :: Type}
  deriving (Eq, Ord, Read, Show)
_ContextType = Core.Name "hydra.haskell.syntax.ContextType"
_ContextType_ctx = Core.Name "ctx"
_ContextType_type = Core.Name "type"
-- | A function type
data FunctionType =
  FunctionType {
    -- | The domain type
    functionTypeDomain :: Type,
    -- | The codomain type
    functionTypeCodomain :: Type}
  deriving (Eq, Ord, Read, Show)
_FunctionType = Core.Name "hydra.haskell.syntax.FunctionType"
_FunctionType_domain = Core.Name "domain"
_FunctionType_codomain = Core.Name "codomain"
-- | An infix type application
data InfixType =
  InfixType {
    -- | The left-hand type
    infixTypeLhs :: Type,
    -- | The type operator
    infixTypeOperator :: Operator,
    -- | The right-hand operator
    infixTypeRhs :: Operator}
  deriving (Eq, Ord, Read, Show)
_InfixType = Core.Name "hydra.haskell.syntax.InfixType"
_InfixType_lhs = Core.Name "lhs"
_InfixType_operator = Core.Name "operator"
_InfixType_rhs = Core.Name "rhs"
-- | A type synonym declaration
data TypeDeclaration =
  TypeDeclaration {
    -- | The declaration head
    typeDeclarationName :: DeclarationHead,
    -- | The type being defined
    typeDeclarationType :: Type}
  deriving (Eq, Ord, Read, Show)
_TypeDeclaration = Core.Name "hydra.haskell.syntax.TypeDeclaration"
_TypeDeclaration_name = Core.Name "name"
_TypeDeclaration_type = Core.Name "type"
-- | A type signature
data TypeSignature =
  TypeSignature {
    -- | The name being typed
    typeSignatureName :: Name,
    -- | The type
    typeSignatureType :: Type}
  deriving (Eq, Ord, Read, Show)
_TypeSignature = Core.Name "hydra.haskell.syntax.TypeSignature"
_TypeSignature_name = Core.Name "name"
_TypeSignature_type = Core.Name "type"
-- | A binding with its type signature
data TypedBinding =
  TypedBinding {
    -- | The type signature
    typedBindingTypeSignature :: TypeSignature,
    -- | The value binding
    typedBindingValueBinding :: ValueBinding}
  deriving (Eq, Ord, Read, Show)
_TypedBinding = Core.Name "hydra.haskell.syntax.TypedBinding"
_TypedBinding_typeSignature = Core.Name "typeSignature"
_TypedBinding_valueBinding = Core.Name "valueBinding"
-- | A value binding
data ValueBinding =
  -- | A simple value binding
  ValueBindingSimple SimpleValueBinding
  deriving (Eq, Ord, Read, Show)
_ValueBinding = Core.Name "hydra.haskell.syntax.ValueBinding"
_ValueBinding_simple = Core.Name "simple"
-- | A simple value binding
data SimpleValueBinding =
  SimpleValueBinding {
    -- | The pattern being bound
    simpleValueBindingPattern :: Pattern,
    -- | The right-hand side
    simpleValueBindingRhs :: RightHandSide,
    -- | Optional local bindings (where clause)
    simpleValueBindingLocalBindings :: (Maybe LocalBindings)}
  deriving (Eq, Ord, Read, Show)
_SimpleValueBinding = Core.Name "hydra.haskell.syntax.SimpleValueBinding"
_SimpleValueBinding_pattern = Core.Name "pattern"
_SimpleValueBinding_rhs = Core.Name "rhs"
_SimpleValueBinding_localBindings = Core.Name "localBindings"
-- | A type variable
newtype Variable =
  Variable {
    unVariable :: Name}
  deriving (Eq, Ord, Read, Show)
_Variable = Core.Name "hydra.haskell.syntax.Variable"