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.Ext.Haskell.Syntax where

import qualified Hydra.Core as Core
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.ByteString as B
import qualified Data.Int as I
import qualified Data.List as L
import qualified Data.Map as M
import qualified Data.Set as S

-- | 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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.haskell.syntax.RightHandSide"

-- | A do-notation statement
newtype Statement =
  Statement {
    unStatement :: Expression}
  deriving (Eq, Ord, Read, Show)

_Statement = Core.Name "hydra.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.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.ext.haskell.syntax.Variable"