hydra.haskell.syntax module

A Haskell syntax model for Hydra. Originally inspired by Language.Haskell.Tools.AST, but now diverges freely to suit Hydra’s needs.

class hydra.haskell.syntax.Alternative(pattern: Annotated[Pattern, 'The pattern to match'], rhs: Annotated[CaseRhs, 'The right-hand side of the alternative'], binds: Annotated[object, 'Optional local bindings'])

Bases: object

A pattern-matching alternative.

BINDS = Name(value='binds')

class Builder(_pattern: 'Pattern' = None, _rhs: 'CaseRhs' = None, _binds: 'Optional[LocalBindings]' = None)

Bases: object

binds(binds)

build()

pattern(pattern)

rhs(rhs)

PATTERN = Name(value='pattern')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.haskell.syntax.Alternative')

binds: Annotated[object, 'Optional local bindings']

static builder()

pattern: Annotated[Pattern, 'The pattern to match']

rhs: Annotated[CaseRhs, 'The right-hand side of the alternative']

with_binds(binds)

with_pattern(pattern)

with_rhs(rhs)

class hydra.haskell.syntax.ApplicationDeclarationHead(function: Annotated[DeclarationHead, 'The function being applied'], operand: Annotated[Variable, 'The type variable operand'])

Bases: object

An application-style declaration head.

class Builder(_function: 'DeclarationHead' = None, _operand: 'Variable' = None)

Bases: object

build()

function(function)

operand(operand)

FUNCTION = Name(value='function')

OPERAND = Name(value='operand')

TYPE_ = Name(value='hydra.haskell.syntax.ApplicationDeclarationHead')

static builder()

function: Annotated[DeclarationHead, 'The function being applied']

operand: Annotated[Variable, 'The type variable operand']

with_function(function)

with_operand(operand)

class hydra.haskell.syntax.ApplicationExpression(function: Annotated[Expression, 'The function being applied'], argument: Annotated[Expression, 'The argument'])

Bases: object

An application expression.

ARGUMENT = Name(value='argument')

class Builder(_function: 'Expression' = None, _argument: 'Expression' = None)

Bases: object

argument(argument)

build()

function(function)

FUNCTION = Name(value='function')

TYPE_ = Name(value='hydra.haskell.syntax.ApplicationExpression')

argument: Annotated[Expression, 'The argument']

static builder()

function: Annotated[Expression, 'The function being applied']

with_argument(argument)

with_function(function)

class hydra.haskell.syntax.ApplicationPattern(name: Annotated[Name, 'The constructor name'], args: Annotated[Sequence[Pattern], 'The pattern arguments'])

Bases: object

An application pattern.

ARGS = Name(value='args')

class Builder(_name: 'Name' = None, _args: 'Sequence[Pattern]' = None)

Bases: object

args(args)

build()

name(name)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.haskell.syntax.ApplicationPattern')

args: Annotated[Sequence[Pattern], 'The pattern arguments']

static builder()

name: Annotated[Name, 'The constructor name']

with_args(args)

with_name(name)

class hydra.haskell.syntax.ApplicationType(context: Annotated[Type, 'The type being applied'], argument: Annotated[Type, 'The type argument'])

Bases: object

An application type.

ARGUMENT = Name(value='argument')

class Builder(_context: 'Type' = None, _argument: 'Type' = None)

Bases: object

argument(argument)

build()

context(context)

CONTEXT = Name(value='context')

TYPE_ = Name(value='hydra.haskell.syntax.ApplicationType')

argument: Annotated[Type, 'The type argument']

static builder()

context: Annotated[Type, 'The type being applied']

with_argument(argument)

with_context(context)

class hydra.haskell.syntax.AsPattern(name: Annotated[Name, 'The bound name'], inner: Annotated[Pattern, 'The inner pattern'])

Bases: object

An ‘as’ pattern.

class Builder(_name: 'Name' = None, _inner: 'Pattern' = None)

Bases: object

build()

inner(inner)

name(name)

INNER = Name(value='inner')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.haskell.syntax.AsPattern')

static builder()

inner: Annotated[Pattern, 'The inner pattern']

name: Annotated[Name, 'The bound name']

with_inner(inner)

with_name(name)

class hydra.haskell.syntax.CaseExpression(case: Annotated[Expression, 'The expression being matched'], alternatives: Annotated[Sequence[Alternative], 'The pattern-matching alternatives'])

Bases: object

A case expression.

ALTERNATIVES = Name(value='alternatives')

class Builder(_case: 'Expression' = None, _alternatives: 'Sequence[Alternative]' = None)

Bases: object

alternatives(alternatives)

build()

case(case)

CASE = Name(value='case')

TYPE_ = Name(value='hydra.haskell.syntax.CaseExpression')

alternatives: Annotated[Sequence[Alternative], 'The pattern-matching alternatives']

static builder()

case: Annotated[Expression, 'The expression being matched']

with_alternatives(alternatives)

with_case(case)

class hydra.haskell.syntax.CaseRhs(value: T)

Bases: Node[Expression]

The right-hand side of a pattern-matching alternative.

TYPE_ = Name(value='hydra.haskell.syntax.CaseRhs')

class hydra.haskell.syntax.ClassConstraint(name: Annotated[Name, 'The name of the class'], types: Annotated[Sequence[Type], 'The types to which the class is applied'])

Bases: object

A class constraint.

class Builder(_name: 'Name' = None, _types: 'Sequence[Type]' = None)

Bases: object

build()

name(name)

types(types)

NAME = Name(value='name')

TYPES = Name(value='types')

TYPE_ = Name(value='hydra.haskell.syntax.ClassConstraint')

static builder()

name: Annotated[Name, 'The name of the class']

types: Annotated[Sequence[Type], 'The types to which the class is applied']

with_name(name)

with_types(types)

class hydra.haskell.syntax.ConstrainedType(ctx: Annotated[Constraint, 'The type class context'], type: Annotated[Type, 'The constrained type'])

Bases: object

A type with a context (type class constraints).

class Builder(_ctx: 'Constraint' = None, _type: 'Type' = None)

Bases: object

build()

ctx(ctx)

type(type)

CTX = Name(value='ctx')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.haskell.syntax.ConstrainedType')

static builder()

ctx: Annotated[Constraint, 'The type class context']

type: Annotated[Type, 'The constrained type']

with_ctx(ctx)

with_type(type)

class hydra.haskell.syntax.Constraint

Bases: object

ConstraintClass | ConstraintTuple

CLASS = Name(value='class')

TUPLE = Name(value='tuple')

TYPE_ = Name(value='hydra.haskell.syntax.Constraint')

class hydra.haskell.syntax.ConstraintClass(value: T)

Bases: Node[ClassConstraint]

A class constraint

class hydra.haskell.syntax.ConstraintTuple(value: T)

Bases: Node[Sequence[Constraint]]

A tuple of constraints

class hydra.haskell.syntax.Constructor

Bases: object

ConstructorOrdinary | ConstructorRecord

ORDINARY = Name(value='ordinary')

RECORD = Name(value='record')

TYPE_ = Name(value='hydra.haskell.syntax.Constructor')

class hydra.haskell.syntax.ConstructorOrdinary(value: T)

Bases: Node[PositionalConstructor]

An ordinary (positional) constructor

class hydra.haskell.syntax.ConstructorRecord(value: T)

Bases: Node[RecordConstructor]

A record constructor

class hydra.haskell.syntax.DataDeclaration(keyword: Annotated[DataKeyword, "The 'data' or 'newtype' keyword"], context: Annotated[Sequence[Constraint], 'Type class constraints'], head: Annotated[DeclarationHead, 'The declaration head'], constructors: Annotated[Sequence[Constructor], 'The data constructors'], deriving: Annotated[Sequence[DerivingClause], 'Derived type class instances'], comments: Annotated[object, 'Optional comments'])

Bases: object

A data type declaration.

class Builder(_keyword: 'DataKeyword' = None, _context: 'Sequence[Constraint]' = None, _head: 'DeclarationHead' = None, _constructors: 'Sequence[Constructor]' = None, _deriving: 'Sequence[DerivingClause]' = None, _comments: 'Optional[str]' = None)

Bases: object

build()

comments(comments)

constructors(constructors)

context(context)

deriving(deriving)

head(head)

keyword(keyword)

COMMENTS = Name(value='comments')

CONSTRUCTORS = Name(value='constructors')

CONTEXT = Name(value='context')

DERIVING = Name(value='deriving')

HEAD = Name(value='head')

KEYWORD = Name(value='keyword')

TYPE_ = Name(value='hydra.haskell.syntax.DataDeclaration')

static builder()

comments: Annotated[object, 'Optional comments']

constructors: Annotated[Sequence[Constructor], 'The data constructors']

context: Annotated[Sequence[Constraint], 'Type class constraints']

deriving: Annotated[Sequence[DerivingClause], 'Derived type class instances']

head: Annotated[DeclarationHead, 'The declaration head']

keyword: Annotated[DataKeyword, "The 'data' or 'newtype' keyword"]

with_comments(comments)

with_constructors(constructors)

with_context(context)

with_deriving(deriving)

with_head(head)

with_keyword(keyword)

class hydra.haskell.syntax.DataKeyword(*values)

Bases: Enum

The ‘data’ versus ‘newtype keyword.

DATA = Name(value='data')

NEWTYPE = Name(value='newtype')

TYPE_ = Name(value='hydra.haskell.syntax.DataKeyword')

class hydra.haskell.syntax.Declaration

Bases: object

DeclarationData | DeclarationType | DeclarationValueBinding | DeclarationTypedBinding

DATA = Name(value='data')

TYPE = Name(value='type')

TYPED_BINDING = Name(value='typedBinding')

TYPE_ = Name(value='hydra.haskell.syntax.Declaration')

VALUE_BINDING = Name(value='valueBinding')

class hydra.haskell.syntax.DeclarationData(value: T)

Bases: Node[DataDeclaration]

A data type declaration

class hydra.haskell.syntax.DeclarationHead

Bases: object

DeclarationHeadApplication | DeclarationHeadSimple

APPLICATION = Name(value='application')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.haskell.syntax.DeclarationHead')

class hydra.haskell.syntax.DeclarationHeadApplication(value: T)

Bases: Node[ApplicationDeclarationHead]

An application-style declaration head

class hydra.haskell.syntax.DeclarationHeadSimple(value: T)

Bases: Node[Name]

A simple name

class hydra.haskell.syntax.DeclarationType(value: T)

Bases: Node[TypeSynonymDeclaration]

A type synonym declaration

class hydra.haskell.syntax.DeclarationTypedBinding(value: T)

Bases: Node[TypedBinding]

A typed binding

class hydra.haskell.syntax.DeclarationValueBinding(value: T)

Bases: Node[ValueBinding]

A value binding

class hydra.haskell.syntax.DerivingClause(value: T)

Bases: Node[Sequence[Name]]

A ‘deriving’ clause.

TYPE_ = Name(value='hydra.haskell.syntax.DerivingClause')

class hydra.haskell.syntax.Export

Bases: object

ExportDeclaration | ExportModule

DECLARATION = Name(value='declaration')

MODULE = Name(value='module')

TYPE_ = Name(value='hydra.haskell.syntax.Export')

class hydra.haskell.syntax.ExportDeclaration(value: T)

Bases: Node[NamedImportExport]

An exported declaration

class hydra.haskell.syntax.ExportModule(value: T)

Bases: Node[ModuleName]

An exported module

class hydra.haskell.syntax.Expression

Bases: object

APPLICATION = Name(value='application')

CASE = Name(value='case')

CONSTRUCT_RECORD = Name(value='constructRecord')

DO = Name(value='do')

IF = Name(value='if')

INFIX_APPLICATION = Name(value='infixApplication')

LAMBDA = Name(value='lambda')

LEFT_SECTION = Name(value='leftSection')

LET = Name(value='let')

LIST = Name(value='list')

LITERAL = Name(value='literal')

RIGHT_SECTION = Name(value='rightSection')

TUPLE = Name(value='tuple')

TYPE_ = Name(value='hydra.haskell.syntax.Expression')

TYPE_SIGNATURE = Name(value='typeSignature')

UPDATE_RECORD = Name(value='updateRecord')

VARIABLE = Name(value='variable')

class hydra.haskell.syntax.ExpressionApplication(value: T)

Bases: Node[ApplicationExpression]

A function application

class hydra.haskell.syntax.ExpressionCase(value: T)

Bases: Node[CaseExpression]

A case expression

class hydra.haskell.syntax.ExpressionConstructRecord(value: T)

Bases: Node[RecordExpression]

A record constructor expression

class hydra.haskell.syntax.ExpressionDo(value: T)

Bases: Node[Sequence[Statement]]

A ‘do’ expression

class hydra.haskell.syntax.ExpressionIf(value: T)

Bases: Node[IfExpression]

An ‘if’ expression

class hydra.haskell.syntax.ExpressionInfixApplication(value: T)

Bases: Node[InfixExpression]

An infix application

class hydra.haskell.syntax.ExpressionLambda(value: T)

Bases: Node[LambdaExpression]

A lambda expression

class hydra.haskell.syntax.ExpressionLeftSection(value: T)

Bases: Node[SectionExpression]

A left section expression

class hydra.haskell.syntax.ExpressionLet(value: T)

Bases: Node[LetExpression]

A ‘let’ expression

class hydra.haskell.syntax.ExpressionList(value: T)

Bases: Node[Sequence[Expression]]

A list expression

class hydra.haskell.syntax.ExpressionLiteral(value: T)

Bases: Node[Literal]

A literal value

class hydra.haskell.syntax.ExpressionRightSection(value: T)

Bases: Node[SectionExpression]

A right section expression

class hydra.haskell.syntax.ExpressionTuple(value: T)

Bases: Node[Sequence[Expression]]

A tuple expression

class hydra.haskell.syntax.ExpressionTypeSignature(value: T)

Bases: Node[TypedExpression]

A type signature expression

class hydra.haskell.syntax.ExpressionUpdateRecord(value: T)

Bases: Node[RecordUpdateExpression]

A record update expression

class hydra.haskell.syntax.ExpressionVariable(value: T)

Bases: Node[Name]

A variable reference

class hydra.haskell.syntax.Field(name: Annotated[Name, 'The field name'], type: Annotated[Type, 'The field type'], comments: Annotated[object, 'Optional comments'])

Bases: object

A field (name/type pair).

class Builder(_name: 'Name' = None, _type: 'Type' = None, _comments: 'Optional[str]' = None)

Bases: object

build()

comments(comments)

name(name)

type(type)

COMMENTS = Name(value='comments')

NAME = Name(value='name')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.haskell.syntax.Field')

static builder()

comments: Annotated[object, 'Optional comments']

name: Annotated[Name, 'The field name']

type: Annotated[Type, 'The field type']

with_comments(comments)

with_name(name)

with_type(type)

class hydra.haskell.syntax.FieldUpdate(name: Annotated[Name, 'The field name'], value: Annotated[Expression, 'The field value'])

Bases: object

A field name and value.

class Builder(_name: 'Name' = None, _value: 'Expression' = None)

Bases: object

build()

name(name)

value(value)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.haskell.syntax.FieldUpdate')

VALUE = Name(value='value')

static builder()

name: Annotated[Name, 'The field name']

value: Annotated[Expression, 'The field value']

with_name(name)

with_value(value)

class hydra.haskell.syntax.FunctionType(domain: Annotated[Type, 'The domain type'], codomain: Annotated[Type, 'The codomain type'])

Bases: object

A function type.

class Builder(_domain: 'Type' = None, _codomain: 'Type' = None)

Bases: object

build()

codomain(codomain)

domain(domain)

CODOMAIN = Name(value='codomain')

DOMAIN = Name(value='domain')

TYPE_ = Name(value='hydra.haskell.syntax.FunctionType')

static builder()

codomain: Annotated[Type, 'The codomain type']

domain: Annotated[Type, 'The domain type']

with_codomain(codomain)

with_domain(domain)

class hydra.haskell.syntax.IfExpression(condition: Annotated[Expression, 'The condition expression'], then: Annotated[Expression, "The 'then' branch"], else_: Annotated[Expression, "The 'else' branch"])

Bases: object

An ‘if’ expression.

class Builder(_condition: 'Expression' = None, _then: 'Expression' = None, _else_: 'Expression' = None)

Bases: object

build()

condition(condition)

else_(else_)

then(then)

CONDITION = Name(value='condition')

ELSE = Name(value='else')

THEN = Name(value='then')

TYPE_ = Name(value='hydra.haskell.syntax.IfExpression')

static builder()

condition: Annotated[Expression, 'The condition expression']

else_: Annotated[Expression, "The 'else' branch"]

then: Annotated[Expression, "The 'then' branch"]

with_condition(condition)

with_else_(else_)

with_then(then)

class hydra.haskell.syntax.Import(qualified: Annotated[bool, 'Whether the import is qualified'], module: Annotated[ModuleName, 'The module being imported'], as_: Annotated[object, 'Optional alias for the module'], spec: Annotated[object, 'Optional import specification'])

Bases: object

An import statement.

AS = Name(value='as')

class Builder(_qualified: 'bool' = None, _module: 'ModuleName' = None, _as_: 'Optional[ModuleName]' = None, _spec: 'Optional[ImportSpec]' = None)

Bases: object

as_(as_)

build()

module(module)

qualified(qualified)

spec(spec)

MODULE = Name(value='module')

QUALIFIED = Name(value='qualified')

SPEC = Name(value='spec')

TYPE_ = Name(value='hydra.haskell.syntax.Import')

as_: Annotated[object, 'Optional alias for the module']

static builder()

module: Annotated[ModuleName, 'The module being imported']

qualified: Annotated[bool, 'Whether the import is qualified']

spec: Annotated[object, 'Optional import specification']

with_as_(as_)

with_module(module)

with_qualified(qualified)

with_spec(spec)

class hydra.haskell.syntax.ImportExportSubspec

Bases: object

ImportExportSubspecAll | ImportExportSubspecList

ALL = Name(value='all')

LIST = Name(value='list')

TYPE_ = Name(value='hydra.haskell.syntax.ImportExportSubspec')

class hydra.haskell.syntax.ImportExportSubspecAll

Bases: object

Import/export all

class hydra.haskell.syntax.ImportExportSubspecList(value: T)

Bases: Node[Sequence[Name]]

Import/export specific names

class hydra.haskell.syntax.ImportModifier(*values)

Bases: Enum

An import modifier (‘pattern’ or ‘type’).

PATTERN = Name(value='pattern')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.haskell.syntax.ImportModifier')

class hydra.haskell.syntax.ImportSpec

Bases: object

ImportSpecList | ImportSpecHiding

HIDING = Name(value='hiding')

LIST = Name(value='list')

TYPE_ = Name(value='hydra.haskell.syntax.ImportSpec')

class hydra.haskell.syntax.ImportSpecHiding(value: T)

Bases: Node[Sequence[NamedImportExport]]

A list of imports to exclude

class hydra.haskell.syntax.ImportSpecList(value: T)

Bases: Node[Sequence[NamedImportExport]]

A list of imports to include

class hydra.haskell.syntax.InfixExpression(lhs: Annotated[Expression, 'The left-hand operand'], operator: Annotated[Operator, 'The infix operator'], rhs: Annotated[Expression, 'The right-hand operand'])

Bases: object

An infix application expression.

class Builder(_lhs: 'Expression' = None, _operator: 'Operator' = None, _rhs: 'Expression' = None)

Bases: object

build()

lhs(lhs)

operator(operator)

rhs(rhs)

LHS = Name(value='lhs')

OPERATOR = Name(value='operator')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.haskell.syntax.InfixExpression')

static builder()

lhs: Annotated[Expression, 'The left-hand operand']

operator: Annotated[Operator, 'The infix operator']

rhs: Annotated[Expression, 'The right-hand operand']

with_lhs(lhs)

with_operator(operator)

with_rhs(rhs)

class hydra.haskell.syntax.InfixType(lhs: Annotated[Type, 'The left-hand type'], operator: Annotated[Operator, 'The type operator'], rhs: Annotated[Type, 'The right-hand type'])

Bases: object

An infix type application.

class Builder(_lhs: 'Type' = None, _operator: 'Operator' = None, _rhs: 'Type' = None)

Bases: object

build()

lhs(lhs)

operator(operator)

rhs(rhs)

LHS = Name(value='lhs')

OPERATOR = Name(value='operator')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.haskell.syntax.InfixType')

static builder()

lhs: Annotated[Type, 'The left-hand type']

operator: Annotated[Operator, 'The type operator']

rhs: Annotated[Type, 'The right-hand type']

with_lhs(lhs)

with_operator(operator)

with_rhs(rhs)

class hydra.haskell.syntax.LambdaExpression(bindings: Annotated[Sequence[Pattern], 'The patterns binding parameters'], inner: Annotated[Expression, 'The body of the lambda'])

Bases: object

A lambda expression.

BINDINGS = Name(value='bindings')

class Builder(_bindings: 'Sequence[Pattern]' = None, _inner: 'Expression' = None)

Bases: object

bindings(bindings)

build()

inner(inner)

INNER = Name(value='inner')

TYPE_ = Name(value='hydra.haskell.syntax.LambdaExpression')

bindings: Annotated[Sequence[Pattern], 'The patterns binding parameters']

static builder()

inner: Annotated[Expression, 'The body of the lambda']

with_bindings(bindings)

with_inner(inner)

class hydra.haskell.syntax.LetExpression(bindings: Annotated[Sequence[LocalBinding], 'The local bindings'], inner: Annotated[Expression, 'The body of the let expression'])

Bases: object

A ‘let’ expression.

BINDINGS = Name(value='bindings')

class Builder(_bindings: 'Sequence[LocalBinding]' = None, _inner: 'Expression' = None)

Bases: object

bindings(bindings)

build()

inner(inner)

INNER = Name(value='inner')

TYPE_ = Name(value='hydra.haskell.syntax.LetExpression')

bindings: Annotated[Sequence[LocalBinding], 'The local bindings']

static builder()

inner: Annotated[Expression, 'The body of the let expression']

with_bindings(bindings)

with_inner(inner)

class hydra.haskell.syntax.Literal

Bases: object

CHAR = Name(value='char')

DOUBLE = Name(value='double')

FLOAT = Name(value='float')

INT = Name(value='int')

INTEGER = Name(value='integer')

STRING = Name(value='string')

TYPE_ = Name(value='hydra.haskell.syntax.Literal')

class hydra.haskell.syntax.LiteralChar(value: T)

Bases: Node[int]

A character literal

class hydra.haskell.syntax.LiteralDouble(value: T)

Bases: Node[float]

A double-precision floating point literal

class hydra.haskell.syntax.LiteralFloat(value: T)

Bases: Node[float]

A single-precision floating point literal

class hydra.haskell.syntax.LiteralInt(value: T)

Bases: Node[int]

A 32-bit integer literal

class hydra.haskell.syntax.LiteralInteger(value: T)

Bases: Node[int]

An arbitrary-precision integer literal

class hydra.haskell.syntax.LiteralString(value: T)

Bases: Node[str]

A string literal

class hydra.haskell.syntax.LocalBinding

Bases: object

LocalBindingSignature | LocalBindingValue

SIGNATURE = Name(value='signature')

TYPE_ = Name(value='hydra.haskell.syntax.LocalBinding')

VALUE = Name(value='value')

class hydra.haskell.syntax.LocalBindingSignature(value: T)

Bases: Node[TypeSignature]

A type signature

class hydra.haskell.syntax.LocalBindingValue(value: T)

Bases: Node[ValueBinding]

A value binding

class hydra.haskell.syntax.LocalBindings(value: T)

Bases: Node[Sequence[LocalBinding]]

A collection of local bindings.

TYPE_ = Name(value='hydra.haskell.syntax.LocalBindings')

class hydra.haskell.syntax.Module(head: Annotated[object, 'Optional module head'], imports: Annotated[Sequence[Import], 'Import statements'], declarations: Annotated[Sequence[Declaration], 'Module declarations'])

Bases: object

A Haskell module.

class Builder(_head: 'Optional[ModuleHead]' = None, _imports: 'Sequence[Import]' = None, _declarations: 'Sequence[Declaration]' = None)

Bases: object

build()

declarations(declarations)

head(head)

imports(imports)

DECLARATIONS = Name(value='declarations')

HEAD = Name(value='head')

IMPORTS = Name(value='imports')

TYPE_ = Name(value='hydra.haskell.syntax.Module')

static builder()

declarations: Annotated[Sequence[Declaration], 'Module declarations']

head: Annotated[object, 'Optional module head']

imports: Annotated[Sequence[Import], 'Import statements']

with_declarations(declarations)

with_head(head)

with_imports(imports)

class hydra.haskell.syntax.ModuleHead(comments: Annotated[object, 'Optional module-level comments'], name: Annotated[ModuleName, 'The module name'], exports: Annotated[Sequence[Export], 'Export list'])

Bases: object

A module head.

class Builder(_comments: 'Optional[str]' = None, _name: 'ModuleName' = None, _exports: 'Sequence[Export]' = None)

Bases: object

build()

comments(comments)

exports(exports)

name(name)

COMMENTS = Name(value='comments')

EXPORTS = Name(value='exports')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.haskell.syntax.ModuleHead')

static builder()

comments: Annotated[object, 'Optional module-level comments']

exports: Annotated[Sequence[Export], 'Export list']

name: Annotated[ModuleName, 'The module name']

with_comments(comments)

with_exports(exports)

with_name(name)

class hydra.haskell.syntax.ModuleName(value: T)

Bases: Node[str]

A module name.

TYPE_ = Name(value='hydra.haskell.syntax.ModuleName')

class hydra.haskell.syntax.Name

Bases: object

NameImplicit | NameNormal

IMPLICIT = Name(value='implicit')

NORMAL = Name(value='normal')

TYPE_ = Name(value='hydra.haskell.syntax.Name')

class hydra.haskell.syntax.NameImplicit(value: T)

Bases: Node[QualifiedName]

An implicit name

class hydra.haskell.syntax.NameNormal(value: T)

Bases: Node[QualifiedName]

A normal name

class hydra.haskell.syntax.NamePart(value: T)

Bases: Node[str]

A component of a qualified name.

TYPE_ = Name(value='hydra.haskell.syntax.NamePart')

class hydra.haskell.syntax.NamedImportExport(modifier: Annotated[object, 'Optional import modifier'], name: Annotated[Name, 'The name being imported or exported'], subspec: Annotated[object, 'Optional subspecification'])

Bases: object

An import or export specification.

class Builder(_modifier: 'Optional[ImportModifier]' = None, _name: 'Name' = None, _subspec: 'Optional[ImportExportSubspec]' = None)

Bases: object

build()

modifier(modifier)

name(name)

subspec(subspec)

MODIFIER = Name(value='modifier')

NAME = Name(value='name')

SUBSPEC = Name(value='subspec')

TYPE_ = Name(value='hydra.haskell.syntax.NamedImportExport')

static builder()

modifier: Annotated[object, 'Optional import modifier']

name: Annotated[Name, 'The name being imported or exported']

subspec: Annotated[object, 'Optional subspecification']

with_modifier(modifier)

with_name(name)

with_subspec(subspec)

class hydra.haskell.syntax.Operator

Bases: object

OperatorBacktick | OperatorNormal

BACKTICK = Name(value='backtick')

NORMAL = Name(value='normal')

TYPE_ = Name(value='hydra.haskell.syntax.Operator')

class hydra.haskell.syntax.OperatorBacktick(value: T)

Bases: Node[QualifiedName]

A function used as an infix operator

class hydra.haskell.syntax.OperatorNormal(value: T)

Bases: Node[QualifiedName]

A normal infix operator

class hydra.haskell.syntax.Pattern

Bases: object

APPLICATION = Name(value='application')

AS = Name(value='as')

LIST = Name(value='list')

LITERAL = Name(value='literal')

NAME = Name(value='name')

RECORD = Name(value='record')

TUPLE = Name(value='tuple')

TYPED = Name(value='typed')

TYPE_ = Name(value='hydra.haskell.syntax.Pattern')

WILDCARD = Name(value='wildcard')

class hydra.haskell.syntax.PatternApplication(value: T)

Bases: Node[ApplicationPattern]

An application pattern

class hydra.haskell.syntax.PatternAs(value: T)

Bases: Node[AsPattern]

An ‘as’ pattern

class hydra.haskell.syntax.PatternField(name: Annotated[Name, 'The field name'], pattern: Annotated[Pattern, 'The field pattern'])

Bases: object

A pattern field.

class Builder(_name: 'Name' = None, _pattern: 'Pattern' = None)

Bases: object

build()

name(name)

pattern(pattern)

NAME = Name(value='name')

PATTERN = Name(value='pattern')

TYPE_ = Name(value='hydra.haskell.syntax.PatternField')

static builder()

name: Annotated[Name, 'The field name']

pattern: Annotated[Pattern, 'The field pattern']

with_name(name)

with_pattern(pattern)

class hydra.haskell.syntax.PatternList(value: T)

Bases: Node[Sequence[Pattern]]

A list pattern

class hydra.haskell.syntax.PatternLiteral(value: T)

Bases: Node[Literal]

A literal pattern

class hydra.haskell.syntax.PatternName(value: T)

Bases: Node[Name]

A name pattern

class hydra.haskell.syntax.PatternRecord(value: T)

Bases: Node[RecordPattern]

A record pattern

class hydra.haskell.syntax.PatternTuple(value: T)

Bases: Node[Sequence[Pattern]]

A tuple pattern

class hydra.haskell.syntax.PatternTyped(value: T)

Bases: Node[TypedPattern]

A typed pattern

class hydra.haskell.syntax.PatternWildcard

Bases: object

A wildcard pattern

class hydra.haskell.syntax.PositionalConstructor(name: Annotated[Name, 'The name of the constructor'], fields: Annotated[Sequence[Type], 'The types of the positional fields'], comments: Annotated[object, 'Optional comments'])

Bases: object

An ordinary (positional) data constructor.

class Builder(_name: 'Name' = None, _fields: 'Sequence[Type]' = None, _comments: 'Optional[str]' = None)

Bases: object

build()

comments(comments)

fields(fields)

name(name)

COMMENTS = Name(value='comments')

FIELDS = Name(value='fields')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.haskell.syntax.PositionalConstructor')

static builder()

comments: Annotated[object, 'Optional comments']

fields: Annotated[Sequence[Type], 'The types of the positional fields']

name: Annotated[Name, 'The name of the constructor']

with_comments(comments)

with_fields(fields)

with_name(name)

class hydra.haskell.syntax.QualifiedName(qualifiers: Annotated[Sequence[NamePart], 'The qualifier parts'], unqualified: Annotated[NamePart, 'The unqualified name part'])

Bases: object

A qualified name.

class Builder(_qualifiers: 'Sequence[NamePart]' = None, _unqualified: 'NamePart' = None)

Bases: object

build()

qualifiers(qualifiers)

unqualified(unqualified)

QUALIFIERS = Name(value='qualifiers')

TYPE_ = Name(value='hydra.haskell.syntax.QualifiedName')

UNQUALIFIED = Name(value='unqualified')

static builder()

qualifiers: Annotated[Sequence[NamePart], 'The qualifier parts']

unqualified: Annotated[NamePart, 'The unqualified name part']

with_qualifiers(qualifiers)

with_unqualified(unqualified)

class hydra.haskell.syntax.RecordConstructor(name: Annotated[Name, 'The name of the constructor'], fields: Annotated[Sequence[Field], 'The named fields of the record'], comments: Annotated[object, 'Optional comments'])

Bases: object

A record-style data constructor.

class Builder(_name: 'Name' = None, _fields: 'Sequence[Field]' = None, _comments: 'Optional[str]' = None)

Bases: object

build()

comments(comments)

fields(fields)

name(name)

COMMENTS = Name(value='comments')

FIELDS = Name(value='fields')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.haskell.syntax.RecordConstructor')

static builder()

comments: Annotated[object, 'Optional comments']

fields: Annotated[Sequence[Field], 'The named fields of the record']

name: Annotated[Name, 'The name of the constructor']

with_comments(comments)

with_fields(fields)

with_name(name)

class hydra.haskell.syntax.RecordExpression(name: Annotated[Name, 'The constructor name'], fields: Annotated[Sequence[FieldUpdate], 'The field assignments'])

Bases: object

A record constructor expression.

class Builder(_name: 'Name' = None, _fields: 'Sequence[FieldUpdate]' = None)

Bases: object

build()

fields(fields)

name(name)

FIELDS = Name(value='fields')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.haskell.syntax.RecordExpression')

static builder()

fields: Annotated[Sequence[FieldUpdate], 'The field assignments']

name: Annotated[Name, 'The constructor name']

with_fields(fields)

with_name(name)

class hydra.haskell.syntax.RecordPattern(name: Annotated[Name, 'The constructor name'], fields: Annotated[Sequence[PatternField], 'The field patterns'])

Bases: object

A record pattern.

class Builder(_name: 'Name' = None, _fields: 'Sequence[PatternField]' = None)

Bases: object

build()

fields(fields)

name(name)

FIELDS = Name(value='fields')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.haskell.syntax.RecordPattern')

static builder()

fields: Annotated[Sequence[PatternField], 'The field patterns']

name: Annotated[Name, 'The constructor name']

with_fields(fields)

with_name(name)

class hydra.haskell.syntax.RecordUpdateExpression(inner: Annotated[Expression, 'The record being updated'], fields: Annotated[Sequence[FieldUpdate], 'The field updates'])

Bases: object

An update record expression.

class Builder(_inner: 'Expression' = None, _fields: 'Sequence[FieldUpdate]' = None)

Bases: object

build()

fields(fields)

inner(inner)

FIELDS = Name(value='fields')

INNER = Name(value='inner')

TYPE_ = Name(value='hydra.haskell.syntax.RecordUpdateExpression')

static builder()

fields: Annotated[Sequence[FieldUpdate], 'The field updates']

inner: Annotated[Expression, 'The record being updated']

with_fields(fields)

with_inner(inner)

class hydra.haskell.syntax.RightHandSide(value: T)

Bases: Node[Expression]

A right-hand side of a binding.

TYPE_ = Name(value='hydra.haskell.syntax.RightHandSide')

class hydra.haskell.syntax.SectionExpression(operator: Annotated[Operator, 'The operator'], expression: Annotated[Expression, 'The operand'])

Bases: object

A section expression.

class Builder(_operator: 'Operator' = None, _expression: 'Expression' = None)

Bases: object

build()

expression(expression)

operator(operator)

EXPRESSION = Name(value='expression')

OPERATOR = Name(value='operator')

TYPE_ = Name(value='hydra.haskell.syntax.SectionExpression')

static builder()

expression: Annotated[Expression, 'The operand']

operator: Annotated[Operator, 'The operator']

with_expression(expression)

with_operator(operator)

class hydra.haskell.syntax.SimpleValueBinding(pattern: Annotated[Pattern, 'The pattern being bound'], rhs: Annotated[RightHandSide, 'The right-hand side'], local_bindings: Annotated[object, 'Optional local bindings (where clause)'], comments: Annotated[object, 'Optional comments'])

Bases: object

A simple value binding.

class Builder(_pattern: 'Pattern' = None, _rhs: 'RightHandSide' = None, _local_bindings: 'Optional[LocalBindings]' = None, _comments: 'Optional[str]' = None)

Bases: object

build()

comments(comments)

local_bindings(local_bindings)

pattern(pattern)

rhs(rhs)

COMMENTS = Name(value='comments')

LOCAL_BINDINGS = Name(value='localBindings')

PATTERN = Name(value='pattern')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.haskell.syntax.SimpleValueBinding')

static builder()

comments: Annotated[object, 'Optional comments']

local_bindings: Annotated[object, 'Optional local bindings (where clause)']

pattern: Annotated[Pattern, 'The pattern being bound']

rhs: Annotated[RightHandSide, 'The right-hand side']

with_comments(comments)

with_local_bindings(local_bindings)

with_pattern(pattern)

with_rhs(rhs)

class hydra.haskell.syntax.Statement(value: T)

Bases: Node[Expression]

A do-notation statement.

TYPE_ = Name(value='hydra.haskell.syntax.Statement')

class hydra.haskell.syntax.Type

Bases: object

APPLICATION = Name(value='application')

CTX = Name(value='ctx')

FUNCTION = Name(value='function')

INFIX = Name(value='infix')

LIST = Name(value='list')

TUPLE = Name(value='tuple')

TYPE_ = Name(value='hydra.haskell.syntax.Type')

VARIABLE = Name(value='variable')

class hydra.haskell.syntax.TypeApplication(value: T)

Bases: Node[ApplicationType]

An application type

class hydra.haskell.syntax.TypeCtx(value: T)

Bases: Node[ConstrainedType]

A context type

class hydra.haskell.syntax.TypeFunction(value: T)

Bases: Node[FunctionType]

A function type

class hydra.haskell.syntax.TypeInfix(value: T)

Bases: Node[InfixType]

An infix type

class hydra.haskell.syntax.TypeList(value: T)

Bases: Node[Type]

A list type

class hydra.haskell.syntax.TypeSignature(name: Annotated[Name, 'The name being typed'], type: Annotated[Type, 'The type'])

Bases: object

A type signature.

class Builder(_name: 'Name' = None, _type: 'Type' = None)

Bases: object

build()

name(name)

type(type)

NAME = Name(value='name')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.haskell.syntax.TypeSignature')

static builder()

name: Annotated[Name, 'The name being typed']

type: Annotated[Type, 'The type']

with_name(name)

with_type(type)

class hydra.haskell.syntax.TypeSynonymDeclaration(name: Annotated[DeclarationHead, 'The declaration head'], type: Annotated[Type, 'The type being defined'], comments: Annotated[object, 'Optional comments'])

Bases: object

A type synonym declaration.

class Builder(_name: 'DeclarationHead' = None, _type: 'Type' = None, _comments: 'Optional[str]' = None)

Bases: object

build()

comments(comments)

name(name)

type(type)

COMMENTS = Name(value='comments')

NAME = Name(value='name')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.haskell.syntax.TypeSynonymDeclaration')

static builder()

comments: Annotated[object, 'Optional comments']

name: Annotated[DeclarationHead, 'The declaration head']

type: Annotated[Type, 'The type being defined']

with_comments(comments)

with_name(name)

with_type(type)

class hydra.haskell.syntax.TypeTuple(value: T)

Bases: Node[Sequence[Type]]

A tuple type

class hydra.haskell.syntax.TypeVariable(value: T)

Bases: Node[Name]

A type variable or type name

class hydra.haskell.syntax.TypedBinding(type_signature: Annotated[TypeSignature, 'The type signature'], value_binding: Annotated[ValueBinding, 'The value binding'], comments: Annotated[object, 'Optional comments'])

Bases: object

A binding with its type signature.

class Builder(_type_signature: 'TypeSignature' = None, _value_binding: 'ValueBinding' = None, _comments: 'Optional[str]' = None)

Bases: object

build()

comments(comments)

type_signature(type_signature)

value_binding(value_binding)

COMMENTS = Name(value='comments')

TYPE_ = Name(value='hydra.haskell.syntax.TypedBinding')

TYPE_SIGNATURE = Name(value='typeSignature')

VALUE_BINDING = Name(value='valueBinding')

static builder()

comments: Annotated[object, 'Optional comments']

type_signature: Annotated[TypeSignature, 'The type signature']

value_binding: Annotated[ValueBinding, 'The value binding']

with_comments(comments)

with_type_signature(type_signature)

with_value_binding(value_binding)

class hydra.haskell.syntax.TypedExpression(inner: Annotated[Expression, 'The expression being typed'], type: Annotated[Type, 'The type signature'])

Bases: object

A type signature expression.

class Builder(_inner: 'Expression' = None, _type: 'Type' = None)

Bases: object

build()

inner(inner)

type(type)

INNER = Name(value='inner')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.haskell.syntax.TypedExpression')

static builder()

inner: Annotated[Expression, 'The expression being typed']

type: Annotated[Type, 'The type signature']

with_inner(inner)

with_type(type)

class hydra.haskell.syntax.TypedPattern(inner: Annotated[Pattern, 'The inner pattern'], type: Annotated[Type, 'The type annotation'])

Bases: object

A typed pattern.

class Builder(_inner: 'Pattern' = None, _type: 'Type' = None)

Bases: object

build()

inner(inner)

type(type)

INNER = Name(value='inner')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.haskell.syntax.TypedPattern')

static builder()

inner: Annotated[Pattern, 'The inner pattern']

type: Annotated[Type, 'The type annotation']

with_inner(inner)

with_type(type)

class hydra.haskell.syntax.ValueBinding

Bases: object

ValueBindingSimple

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.haskell.syntax.ValueBinding')

class hydra.haskell.syntax.ValueBindingSimple(value: T)

Bases: Node[SimpleValueBinding]

A simple value binding

class hydra.haskell.syntax.Variable(value: T)

Bases: Node[Name]

A type variable.

TYPE_ = Name(value='hydra.haskell.syntax.Variable')