hydra.dsl.haskell.syntax module

DSL functions for hydra.haskell.syntax.

hydra.dsl.haskell.syntax.alternative(pattern: hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern], rhs: hydra.typed.TypedTerm[hydra.haskell.syntax.CaseRhs], binds: hydra.typed.TypedTerm[hydra.haskell.syntax.LocalBindings | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Alternative]

DSL constructor for hydra.haskell.syntax.Alternative.

hydra.dsl.haskell.syntax.alternative_binds(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Alternative]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LocalBindings | None]

DSL accessor for the binds field of hydra.haskell.syntax.Alternative.

hydra.dsl.haskell.syntax.alternative_pattern(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Alternative]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL accessor for the pattern field of hydra.haskell.syntax.Alternative.

hydra.dsl.haskell.syntax.alternative_rhs(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Alternative]) → hydra.typed.TypedTerm[hydra.haskell.syntax.CaseRhs]

DSL accessor for the rhs field of hydra.haskell.syntax.Alternative.

hydra.dsl.haskell.syntax.alternative_with_binds(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Alternative], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.LocalBindings | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Alternative]

DSL updater for the binds field of hydra.haskell.syntax.Alternative.

hydra.dsl.haskell.syntax.alternative_with_pattern(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Alternative], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Alternative]

DSL updater for the pattern field of hydra.haskell.syntax.Alternative.

hydra.dsl.haskell.syntax.alternative_with_rhs(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Alternative], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.CaseRhs]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Alternative]

DSL updater for the rhs field of hydra.haskell.syntax.Alternative.

hydra.dsl.haskell.syntax.application_declaration_head(function: hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead], operand: hydra.typed.TypedTerm[hydra.haskell.syntax.Variable]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationDeclarationHead]

DSL constructor for hydra.haskell.syntax.ApplicationDeclarationHead.

hydra.dsl.haskell.syntax.application_declaration_head_function(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationDeclarationHead]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead]

DSL accessor for the function field of hydra.haskell.syntax.ApplicationDeclarationHead.

hydra.dsl.haskell.syntax.application_declaration_head_operand(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationDeclarationHead]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Variable]

DSL accessor for the operand field of hydra.haskell.syntax.ApplicationDeclarationHead.

hydra.dsl.haskell.syntax.application_declaration_head_with_function(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationDeclarationHead], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationDeclarationHead]

DSL updater for the function field of hydra.haskell.syntax.ApplicationDeclarationHead.

hydra.dsl.haskell.syntax.application_declaration_head_with_operand(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationDeclarationHead], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Variable]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationDeclarationHead]

DSL updater for the operand field of hydra.haskell.syntax.ApplicationDeclarationHead.

hydra.dsl.haskell.syntax.application_expression(function: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression], argument: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationExpression]

DSL constructor for hydra.haskell.syntax.ApplicationExpression.

hydra.dsl.haskell.syntax.application_expression_argument(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the argument field of hydra.haskell.syntax.ApplicationExpression.

hydra.dsl.haskell.syntax.application_expression_function(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the function field of hydra.haskell.syntax.ApplicationExpression.

hydra.dsl.haskell.syntax.application_expression_with_argument(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationExpression]

DSL updater for the argument field of hydra.haskell.syntax.ApplicationExpression.

hydra.dsl.haskell.syntax.application_expression_with_function(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationExpression]

DSL updater for the function field of hydra.haskell.syntax.ApplicationExpression.

hydra.dsl.haskell.syntax.application_pattern(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], args: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Pattern]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationPattern]

DSL constructor for hydra.haskell.syntax.ApplicationPattern.

hydra.dsl.haskell.syntax.application_pattern_args(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationPattern]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Pattern]]

DSL accessor for the args field of hydra.haskell.syntax.ApplicationPattern.

hydra.dsl.haskell.syntax.application_pattern_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationPattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.ApplicationPattern.

hydra.dsl.haskell.syntax.application_pattern_with_args(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationPattern], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Pattern]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationPattern]

DSL updater for the args field of hydra.haskell.syntax.ApplicationPattern.

hydra.dsl.haskell.syntax.application_pattern_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationPattern], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationPattern]

DSL updater for the name field of hydra.haskell.syntax.ApplicationPattern.

hydra.dsl.haskell.syntax.application_type(context: hydra.typed.TypedTerm[hydra.haskell.syntax.Type], argument: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationType]

DSL constructor for hydra.haskell.syntax.ApplicationType.

hydra.dsl.haskell.syntax.application_type_argument(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the argument field of hydra.haskell.syntax.ApplicationType.

hydra.dsl.haskell.syntax.application_type_context(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the context field of hydra.haskell.syntax.ApplicationType.

hydra.dsl.haskell.syntax.application_type_with_argument(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationType], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationType]

DSL updater for the argument field of hydra.haskell.syntax.ApplicationType.

hydra.dsl.haskell.syntax.application_type_with_context(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationType], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationType]

DSL updater for the context field of hydra.haskell.syntax.ApplicationType.

hydra.dsl.haskell.syntax.as_pattern(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], inner: hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.AsPattern]

DSL constructor for hydra.haskell.syntax.AsPattern.

hydra.dsl.haskell.syntax.as_pattern_inner(x: hydra.typed.TypedTerm[hydra.haskell.syntax.AsPattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL accessor for the inner field of hydra.haskell.syntax.AsPattern.

hydra.dsl.haskell.syntax.as_pattern_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.AsPattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.AsPattern.

hydra.dsl.haskell.syntax.as_pattern_with_inner(original: hydra.typed.TypedTerm[hydra.haskell.syntax.AsPattern], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.AsPattern]

DSL updater for the inner field of hydra.haskell.syntax.AsPattern.

hydra.dsl.haskell.syntax.as_pattern_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.AsPattern], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.AsPattern]

DSL updater for the name field of hydra.haskell.syntax.AsPattern.

hydra.dsl.haskell.syntax.case_expression(case: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression], alternatives: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Alternative]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.CaseExpression]

DSL constructor for hydra.haskell.syntax.CaseExpression.

hydra.dsl.haskell.syntax.case_expression_alternatives(x: hydra.typed.TypedTerm[hydra.haskell.syntax.CaseExpression]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Alternative]]

DSL accessor for the alternatives field of hydra.haskell.syntax.CaseExpression.

hydra.dsl.haskell.syntax.case_expression_case(x: hydra.typed.TypedTerm[hydra.haskell.syntax.CaseExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the case field of hydra.haskell.syntax.CaseExpression.

hydra.dsl.haskell.syntax.case_expression_with_alternatives(original: hydra.typed.TypedTerm[hydra.haskell.syntax.CaseExpression], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Alternative]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.CaseExpression]

DSL updater for the alternatives field of hydra.haskell.syntax.CaseExpression.

hydra.dsl.haskell.syntax.case_expression_with_case(original: hydra.typed.TypedTerm[hydra.haskell.syntax.CaseExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.CaseExpression]

DSL updater for the case field of hydra.haskell.syntax.CaseExpression.

hydra.dsl.haskell.syntax.case_rhs(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.CaseRhs]

DSL constructor for the hydra.haskell.syntax.CaseRhs wrapper.

hydra.dsl.haskell.syntax.class_constraint(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], types: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Type]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ClassConstraint]

DSL constructor for hydra.haskell.syntax.ClassConstraint.

hydra.dsl.haskell.syntax.class_constraint_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ClassConstraint]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.ClassConstraint.

hydra.dsl.haskell.syntax.class_constraint_types(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ClassConstraint]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Type]]

DSL accessor for the types field of hydra.haskell.syntax.ClassConstraint.

hydra.dsl.haskell.syntax.class_constraint_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ClassConstraint], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ClassConstraint]

DSL updater for the name field of hydra.haskell.syntax.ClassConstraint.

hydra.dsl.haskell.syntax.class_constraint_with_types(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ClassConstraint], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Type]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ClassConstraint]

DSL updater for the types field of hydra.haskell.syntax.ClassConstraint.

hydra.dsl.haskell.syntax.constrained_type(ctx: hydra.typed.TypedTerm[hydra.haskell.syntax.Constraint], type: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ConstrainedType]

DSL constructor for hydra.haskell.syntax.ConstrainedType.

hydra.dsl.haskell.syntax.constrained_type_ctx(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ConstrainedType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Constraint]

DSL accessor for the ctx field of hydra.haskell.syntax.ConstrainedType.

hydra.dsl.haskell.syntax.constrained_type_type(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ConstrainedType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the type field of hydra.haskell.syntax.ConstrainedType.

hydra.dsl.haskell.syntax.constrained_type_with_ctx(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ConstrainedType], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Constraint]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ConstrainedType]

DSL updater for the ctx field of hydra.haskell.syntax.ConstrainedType.

hydra.dsl.haskell.syntax.constrained_type_with_type(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ConstrainedType], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ConstrainedType]

DSL updater for the type field of hydra.haskell.syntax.ConstrainedType.

hydra.dsl.haskell.syntax.constraint_class(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ClassConstraint]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Constraint]

DSL injection for the class variant of hydra.haskell.syntax.Constraint.

hydra.dsl.haskell.syntax.constraint_tuple(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Constraint]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Constraint]

DSL injection for the tuple variant of hydra.haskell.syntax.Constraint.

hydra.dsl.haskell.syntax.constructor_ordinary(x: hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Constructor]

DSL injection for the ordinary variant of hydra.haskell.syntax.Constructor.

hydra.dsl.haskell.syntax.constructor_record(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Constructor]

DSL injection for the record variant of hydra.haskell.syntax.Constructor.

hydra.dsl.haskell.syntax.data_declaration(keyword: hydra.typed.TypedTerm[hydra.haskell.syntax.DataKeyword], context: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Constraint]], head: hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead], constructors: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Constructor]], deriving: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.DerivingClause]], comments: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]

DSL constructor for hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_comments(x: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]) → hydra.typed.TypedTerm[str | None]

DSL accessor for the comments field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_constructors(x: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Constructor]]

DSL accessor for the constructors field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_context(x: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Constraint]]

DSL accessor for the context field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_deriving(x: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.DerivingClause]]

DSL accessor for the deriving field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_head(x: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead]

DSL accessor for the head field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_keyword(x: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DataKeyword]

DSL accessor for the keyword field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_with_comments(original: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration], new_val: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]

DSL updater for the comments field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_with_constructors(original: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Constructor]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]

DSL updater for the constructors field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_with_context(original: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Constraint]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]

DSL updater for the context field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_with_deriving(original: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.DerivingClause]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]

DSL updater for the deriving field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_with_head(original: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]

DSL updater for the head field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.data_declaration_with_keyword(original: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.DataKeyword]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]

DSL updater for the keyword field of hydra.haskell.syntax.DataDeclaration.

hydra.dsl.haskell.syntax.declaration_data(x: hydra.typed.TypedTerm[hydra.haskell.syntax.DataDeclaration]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Declaration]

DSL injection for the data variant of hydra.haskell.syntax.Declaration.

hydra.dsl.haskell.syntax.declaration_head_application(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationDeclarationHead]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead]

DSL injection for the application variant of hydra.haskell.syntax.DeclarationHead.

hydra.dsl.haskell.syntax.declaration_head_simple(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead]

DSL injection for the simple variant of hydra.haskell.syntax.DeclarationHead.

hydra.dsl.haskell.syntax.declaration_type(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Declaration]

DSL injection for the type variant of hydra.haskell.syntax.Declaration.

hydra.dsl.haskell.syntax.declaration_typed_binding(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Declaration]

DSL injection for the typedBinding variant of hydra.haskell.syntax.Declaration.

hydra.dsl.haskell.syntax.declaration_value_binding(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ValueBinding]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Declaration]

DSL injection for the valueBinding variant of hydra.haskell.syntax.Declaration.

hydra.dsl.haskell.syntax.deriving_clause(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Name]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DerivingClause]

DSL constructor for the hydra.haskell.syntax.DerivingClause wrapper.

hydra.dsl.haskell.syntax.export_declaration(x: hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Export]

DSL injection for the declaration variant of hydra.haskell.syntax.Export.

hydra.dsl.haskell.syntax.export_module(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Export]

DSL injection for the module variant of hydra.haskell.syntax.Export.

hydra.dsl.haskell.syntax.expression_application(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the application variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_case(x: hydra.typed.TypedTerm[hydra.haskell.syntax.CaseExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the case variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_construct_record(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the constructRecord variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_do(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Statement]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the do variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_if(x: hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the if variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_infix_application(x: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the infixApplication variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_lambda(x: hydra.typed.TypedTerm[hydra.haskell.syntax.LambdaExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the lambda variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_left_section(x: hydra.typed.TypedTerm[hydra.haskell.syntax.SectionExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the leftSection variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_let(x: hydra.typed.TypedTerm[hydra.haskell.syntax.LetExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the let variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_list(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Expression]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the list variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_literal(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Literal]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the literal variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_right_section(x: hydra.typed.TypedTerm[hydra.haskell.syntax.SectionExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the rightSection variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_tuple(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Expression]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the tuple variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_type_signature(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the typeSignature variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_update_record(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordUpdateExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the updateRecord variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.expression_variable(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL injection for the variable variant of hydra.haskell.syntax.Expression.

hydra.dsl.haskell.syntax.field(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], type: hydra.typed.TypedTerm[hydra.haskell.syntax.Type], comments: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Field]

DSL constructor for hydra.haskell.syntax.Field.

hydra.dsl.haskell.syntax.field_comments(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Field]) → hydra.typed.TypedTerm[str | None]

DSL accessor for the comments field of hydra.haskell.syntax.Field.

hydra.dsl.haskell.syntax.field_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Field]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.Field.

hydra.dsl.haskell.syntax.field_type(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Field]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the type field of hydra.haskell.syntax.Field.

hydra.dsl.haskell.syntax.field_update(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], value: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.FieldUpdate]

DSL constructor for hydra.haskell.syntax.FieldUpdate.

hydra.dsl.haskell.syntax.field_update_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.FieldUpdate]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.FieldUpdate.

hydra.dsl.haskell.syntax.field_update_value(x: hydra.typed.TypedTerm[hydra.haskell.syntax.FieldUpdate]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the value field of hydra.haskell.syntax.FieldUpdate.

hydra.dsl.haskell.syntax.field_update_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.FieldUpdate], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.FieldUpdate]

DSL updater for the name field of hydra.haskell.syntax.FieldUpdate.

hydra.dsl.haskell.syntax.field_update_with_value(original: hydra.typed.TypedTerm[hydra.haskell.syntax.FieldUpdate], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.FieldUpdate]

DSL updater for the value field of hydra.haskell.syntax.FieldUpdate.

hydra.dsl.haskell.syntax.field_with_comments(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Field], new_val: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Field]

DSL updater for the comments field of hydra.haskell.syntax.Field.

hydra.dsl.haskell.syntax.field_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Field], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Field]

DSL updater for the name field of hydra.haskell.syntax.Field.

hydra.dsl.haskell.syntax.field_with_type(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Field], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Field]

DSL updater for the type field of hydra.haskell.syntax.Field.

hydra.dsl.haskell.syntax.function_type(domain: hydra.typed.TypedTerm[hydra.haskell.syntax.Type], codomain: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.FunctionType]

DSL constructor for hydra.haskell.syntax.FunctionType.

hydra.dsl.haskell.syntax.function_type_codomain(x: hydra.typed.TypedTerm[hydra.haskell.syntax.FunctionType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the codomain field of hydra.haskell.syntax.FunctionType.

hydra.dsl.haskell.syntax.function_type_domain(x: hydra.typed.TypedTerm[hydra.haskell.syntax.FunctionType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the domain field of hydra.haskell.syntax.FunctionType.

hydra.dsl.haskell.syntax.function_type_with_codomain(original: hydra.typed.TypedTerm[hydra.haskell.syntax.FunctionType], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.FunctionType]

DSL updater for the codomain field of hydra.haskell.syntax.FunctionType.

hydra.dsl.haskell.syntax.function_type_with_domain(original: hydra.typed.TypedTerm[hydra.haskell.syntax.FunctionType], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.FunctionType]

DSL updater for the domain field of hydra.haskell.syntax.FunctionType.

hydra.dsl.haskell.syntax.if_expression(condition: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression], then: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression], else_: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression]

DSL constructor for hydra.haskell.syntax.IfExpression.

hydra.dsl.haskell.syntax.if_expression_condition(x: hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the condition field of hydra.haskell.syntax.IfExpression.

hydra.dsl.haskell.syntax.if_expression_else(x: hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the else field of hydra.haskell.syntax.IfExpression.

hydra.dsl.haskell.syntax.if_expression_then(x: hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the then field of hydra.haskell.syntax.IfExpression.

hydra.dsl.haskell.syntax.if_expression_with_condition(original: hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression]

DSL updater for the condition field of hydra.haskell.syntax.IfExpression.

hydra.dsl.haskell.syntax.if_expression_with_else(original: hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression]

DSL updater for the else field of hydra.haskell.syntax.IfExpression.

hydra.dsl.haskell.syntax.if_expression_with_then(original: hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.IfExpression]

DSL updater for the then field of hydra.haskell.syntax.IfExpression.

hydra.dsl.haskell.syntax.import_(qualified: hydra.typed.TypedTerm[bool], module: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName], as_: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName | None], spec: hydra.typed.TypedTerm[hydra.haskell.syntax.ImportSpec | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Import]

DSL constructor for hydra.haskell.syntax.Import.

hydra.dsl.haskell.syntax.import_as(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Import]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName | None]

DSL accessor for the as field of hydra.haskell.syntax.Import.

hydra.dsl.haskell.syntax.import_export_subspec_list(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Name]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ImportExportSubspec]

DSL injection for the list variant of hydra.haskell.syntax.ImportExportSubspec.

hydra.dsl.haskell.syntax.import_module(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Import]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName]

DSL accessor for the module field of hydra.haskell.syntax.Import.

hydra.dsl.haskell.syntax.import_qualified(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Import]) → hydra.typed.TypedTerm[bool]

DSL accessor for the qualified field of hydra.haskell.syntax.Import.

hydra.dsl.haskell.syntax.import_spec(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Import]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ImportSpec | None]

DSL accessor for the spec field of hydra.haskell.syntax.Import.

hydra.dsl.haskell.syntax.import_spec_hiding(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.NamedImportExport]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ImportSpec]

DSL injection for the hiding variant of hydra.haskell.syntax.ImportSpec.

hydra.dsl.haskell.syntax.import_spec_list(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.NamedImportExport]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ImportSpec]

DSL injection for the list variant of hydra.haskell.syntax.ImportSpec.

hydra.dsl.haskell.syntax.import_with_as(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Import], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Import]

DSL updater for the as field of hydra.haskell.syntax.Import.

hydra.dsl.haskell.syntax.import_with_module(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Import], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Import]

DSL updater for the module field of hydra.haskell.syntax.Import.

hydra.dsl.haskell.syntax.import_with_qualified(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Import], new_val: hydra.typed.TypedTerm[bool]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Import]

DSL updater for the qualified field of hydra.haskell.syntax.Import.

hydra.dsl.haskell.syntax.import_with_spec(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Import], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.ImportSpec | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Import]

DSL updater for the spec field of hydra.haskell.syntax.Import.

hydra.dsl.haskell.syntax.infix_expression(lhs: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression], operator: hydra.typed.TypedTerm[hydra.haskell.syntax.Operator], rhs: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression]

DSL constructor for hydra.haskell.syntax.InfixExpression.

hydra.dsl.haskell.syntax.infix_expression_lhs(x: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the lhs field of hydra.haskell.syntax.InfixExpression.

hydra.dsl.haskell.syntax.infix_expression_operator(x: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Operator]

DSL accessor for the operator field of hydra.haskell.syntax.InfixExpression.

hydra.dsl.haskell.syntax.infix_expression_rhs(x: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the rhs field of hydra.haskell.syntax.InfixExpression.

hydra.dsl.haskell.syntax.infix_expression_with_lhs(original: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression]

DSL updater for the lhs field of hydra.haskell.syntax.InfixExpression.

hydra.dsl.haskell.syntax.infix_expression_with_operator(original: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Operator]) → hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression]

DSL updater for the operator field of hydra.haskell.syntax.InfixExpression.

hydra.dsl.haskell.syntax.infix_expression_with_rhs(original: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.InfixExpression]

DSL updater for the rhs field of hydra.haskell.syntax.InfixExpression.

hydra.dsl.haskell.syntax.infix_type(lhs: hydra.typed.TypedTerm[hydra.haskell.syntax.Type], operator: hydra.typed.TypedTerm[hydra.haskell.syntax.Operator], rhs: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType]

DSL constructor for hydra.haskell.syntax.InfixType.

hydra.dsl.haskell.syntax.infix_type_lhs(x: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the lhs field of hydra.haskell.syntax.InfixType.

hydra.dsl.haskell.syntax.infix_type_operator(x: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Operator]

DSL accessor for the operator field of hydra.haskell.syntax.InfixType.

hydra.dsl.haskell.syntax.infix_type_rhs(x: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the rhs field of hydra.haskell.syntax.InfixType.

hydra.dsl.haskell.syntax.infix_type_with_lhs(original: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType]

DSL updater for the lhs field of hydra.haskell.syntax.InfixType.

hydra.dsl.haskell.syntax.infix_type_with_operator(original: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Operator]) → hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType]

DSL updater for the operator field of hydra.haskell.syntax.InfixType.

hydra.dsl.haskell.syntax.infix_type_with_rhs(original: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType]

DSL updater for the rhs field of hydra.haskell.syntax.InfixType.

hydra.dsl.haskell.syntax.lambda_expression(bindings: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Pattern]], inner: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LambdaExpression]

DSL constructor for hydra.haskell.syntax.LambdaExpression.

hydra.dsl.haskell.syntax.lambda_expression_bindings(x: hydra.typed.TypedTerm[hydra.haskell.syntax.LambdaExpression]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Pattern]]

DSL accessor for the bindings field of hydra.haskell.syntax.LambdaExpression.

hydra.dsl.haskell.syntax.lambda_expression_inner(x: hydra.typed.TypedTerm[hydra.haskell.syntax.LambdaExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the inner field of hydra.haskell.syntax.LambdaExpression.

hydra.dsl.haskell.syntax.lambda_expression_with_bindings(original: hydra.typed.TypedTerm[hydra.haskell.syntax.LambdaExpression], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Pattern]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LambdaExpression]

DSL updater for the bindings field of hydra.haskell.syntax.LambdaExpression.

hydra.dsl.haskell.syntax.lambda_expression_with_inner(original: hydra.typed.TypedTerm[hydra.haskell.syntax.LambdaExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LambdaExpression]

DSL updater for the inner field of hydra.haskell.syntax.LambdaExpression.

hydra.dsl.haskell.syntax.let_expression(bindings: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.LocalBinding]], inner: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LetExpression]

DSL constructor for hydra.haskell.syntax.LetExpression.

hydra.dsl.haskell.syntax.let_expression_bindings(x: hydra.typed.TypedTerm[hydra.haskell.syntax.LetExpression]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.LocalBinding]]

DSL accessor for the bindings field of hydra.haskell.syntax.LetExpression.

hydra.dsl.haskell.syntax.let_expression_inner(x: hydra.typed.TypedTerm[hydra.haskell.syntax.LetExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the inner field of hydra.haskell.syntax.LetExpression.

hydra.dsl.haskell.syntax.let_expression_with_bindings(original: hydra.typed.TypedTerm[hydra.haskell.syntax.LetExpression], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.LocalBinding]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LetExpression]

DSL updater for the bindings field of hydra.haskell.syntax.LetExpression.

hydra.dsl.haskell.syntax.let_expression_with_inner(original: hydra.typed.TypedTerm[hydra.haskell.syntax.LetExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LetExpression]

DSL updater for the inner field of hydra.haskell.syntax.LetExpression.

hydra.dsl.haskell.syntax.literal_char(x: hydra.typed.TypedTerm[int]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Literal]

DSL injection for the char variant of hydra.haskell.syntax.Literal.

hydra.dsl.haskell.syntax.literal_double(x: hydra.typed.TypedTerm[float]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Literal]

DSL injection for the double variant of hydra.haskell.syntax.Literal.

hydra.dsl.haskell.syntax.literal_float(x: hydra.typed.TypedTerm[float]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Literal]

DSL injection for the float variant of hydra.haskell.syntax.Literal.

hydra.dsl.haskell.syntax.literal_int(x: hydra.typed.TypedTerm[int]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Literal]

DSL injection for the int variant of hydra.haskell.syntax.Literal.

hydra.dsl.haskell.syntax.literal_integer(x: hydra.typed.TypedTerm[int]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Literal]

DSL injection for the integer variant of hydra.haskell.syntax.Literal.

hydra.dsl.haskell.syntax.literal_string(x: hydra.typed.TypedTerm[str]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Literal]

DSL injection for the string variant of hydra.haskell.syntax.Literal.

hydra.dsl.haskell.syntax.local_binding_signature(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LocalBinding]

DSL injection for the signature variant of hydra.haskell.syntax.LocalBinding.

hydra.dsl.haskell.syntax.local_binding_value(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ValueBinding]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LocalBinding]

DSL injection for the value variant of hydra.haskell.syntax.LocalBinding.

hydra.dsl.haskell.syntax.local_bindings(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.LocalBinding]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LocalBindings]

DSL constructor for the hydra.haskell.syntax.LocalBindings wrapper.

hydra.dsl.haskell.syntax.module(head: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead | None], imports: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Import]], declarations: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Declaration]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Module]

DSL constructor for hydra.haskell.syntax.Module.

hydra.dsl.haskell.syntax.module_declarations(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Module]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Declaration]]

DSL accessor for the declarations field of hydra.haskell.syntax.Module.

hydra.dsl.haskell.syntax.module_head(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Module]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead | None]

DSL accessor for the head field of hydra.haskell.syntax.Module.

hydra.dsl.haskell.syntax.module_head2(comments: hydra.typed.TypedTerm[str | None], name: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName], exports: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Export]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead]

DSL constructor for hydra.haskell.syntax.ModuleHead.

hydra.dsl.haskell.syntax.module_head_comments(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead]) → hydra.typed.TypedTerm[str | None]

DSL accessor for the comments field of hydra.haskell.syntax.ModuleHead.

hydra.dsl.haskell.syntax.module_head_exports(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Export]]

DSL accessor for the exports field of hydra.haskell.syntax.ModuleHead.

hydra.dsl.haskell.syntax.module_head_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName]

DSL accessor for the name field of hydra.haskell.syntax.ModuleHead.

hydra.dsl.haskell.syntax.module_head_with_comments(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead], new_val: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead]

DSL updater for the comments field of hydra.haskell.syntax.ModuleHead.

hydra.dsl.haskell.syntax.module_head_with_exports(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Export]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead]

DSL updater for the exports field of hydra.haskell.syntax.ModuleHead.

hydra.dsl.haskell.syntax.module_head_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead]

DSL updater for the name field of hydra.haskell.syntax.ModuleHead.

hydra.dsl.haskell.syntax.module_imports(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Module]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Import]]

DSL accessor for the imports field of hydra.haskell.syntax.Module.

hydra.dsl.haskell.syntax.module_name(x: hydra.typed.TypedTerm[str]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName]

DSL constructor for the hydra.haskell.syntax.ModuleName wrapper.

hydra.dsl.haskell.syntax.module_with_declarations(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Module], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Declaration]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Module]

DSL updater for the declarations field of hydra.haskell.syntax.Module.

hydra.dsl.haskell.syntax.module_with_head(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Module], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleHead | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Module]

DSL updater for the head field of hydra.haskell.syntax.Module.

hydra.dsl.haskell.syntax.module_with_imports(original: hydra.typed.TypedTerm[hydra.haskell.syntax.Module], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Import]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Module]

DSL updater for the imports field of hydra.haskell.syntax.Module.

hydra.dsl.haskell.syntax.name_implicit(x: hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL injection for the implicit variant of hydra.haskell.syntax.Name.

hydra.dsl.haskell.syntax.name_normal(x: hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL injection for the normal variant of hydra.haskell.syntax.Name.

hydra.dsl.haskell.syntax.name_part(x: hydra.typed.TypedTerm[str]) → hydra.typed.TypedTerm[hydra.haskell.syntax.NamePart]

DSL constructor for the hydra.haskell.syntax.NamePart wrapper.

hydra.dsl.haskell.syntax.named_import_export(modifier: hydra.typed.TypedTerm[hydra.haskell.syntax.ImportModifier | None], name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], subspec: hydra.typed.TypedTerm[hydra.haskell.syntax.ImportExportSubspec | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport]

DSL constructor for hydra.haskell.syntax.NamedImportExport.

hydra.dsl.haskell.syntax.named_import_export_modifier(x: hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ImportModifier | None]

DSL accessor for the modifier field of hydra.haskell.syntax.NamedImportExport.

hydra.dsl.haskell.syntax.named_import_export_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.NamedImportExport.

hydra.dsl.haskell.syntax.named_import_export_subspec(x: hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ImportExportSubspec | None]

DSL accessor for the subspec field of hydra.haskell.syntax.NamedImportExport.

hydra.dsl.haskell.syntax.named_import_export_with_modifier(original: hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.ImportModifier | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport]

DSL updater for the modifier field of hydra.haskell.syntax.NamedImportExport.

hydra.dsl.haskell.syntax.named_import_export_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport]

DSL updater for the name field of hydra.haskell.syntax.NamedImportExport.

hydra.dsl.haskell.syntax.named_import_export_with_subspec(original: hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.ImportExportSubspec | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.NamedImportExport]

DSL updater for the subspec field of hydra.haskell.syntax.NamedImportExport.

hydra.dsl.haskell.syntax.operator_backtick(x: hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Operator]

DSL injection for the backtick variant of hydra.haskell.syntax.Operator.

hydra.dsl.haskell.syntax.operator_normal(x: hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Operator]

DSL injection for the normal variant of hydra.haskell.syntax.Operator.

hydra.dsl.haskell.syntax.pattern_application(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationPattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL injection for the application variant of hydra.haskell.syntax.Pattern.

hydra.dsl.haskell.syntax.pattern_as(x: hydra.typed.TypedTerm[hydra.haskell.syntax.AsPattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL injection for the as variant of hydra.haskell.syntax.Pattern.

hydra.dsl.haskell.syntax.pattern_field(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], pattern: hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.PatternField]

DSL constructor for hydra.haskell.syntax.PatternField.

hydra.dsl.haskell.syntax.pattern_field_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.PatternField]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.PatternField.

hydra.dsl.haskell.syntax.pattern_field_pattern(x: hydra.typed.TypedTerm[hydra.haskell.syntax.PatternField]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL accessor for the pattern field of hydra.haskell.syntax.PatternField.

hydra.dsl.haskell.syntax.pattern_field_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.PatternField], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.PatternField]

DSL updater for the name field of hydra.haskell.syntax.PatternField.

hydra.dsl.haskell.syntax.pattern_field_with_pattern(original: hydra.typed.TypedTerm[hydra.haskell.syntax.PatternField], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.PatternField]

DSL updater for the pattern field of hydra.haskell.syntax.PatternField.

hydra.dsl.haskell.syntax.pattern_list(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Pattern]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL injection for the list variant of hydra.haskell.syntax.Pattern.

hydra.dsl.haskell.syntax.pattern_literal(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Literal]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL injection for the literal variant of hydra.haskell.syntax.Pattern.

hydra.dsl.haskell.syntax.pattern_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL injection for the name variant of hydra.haskell.syntax.Pattern.

hydra.dsl.haskell.syntax.pattern_record(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordPattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL injection for the record variant of hydra.haskell.syntax.Pattern.

hydra.dsl.haskell.syntax.pattern_tuple(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Pattern]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL injection for the tuple variant of hydra.haskell.syntax.Pattern.

hydra.dsl.haskell.syntax.pattern_typed(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedPattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL injection for the typed variant of hydra.haskell.syntax.Pattern.

hydra.dsl.haskell.syntax.positional_constructor(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], fields: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Type]], comments: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor]

DSL constructor for hydra.haskell.syntax.PositionalConstructor.

hydra.dsl.haskell.syntax.positional_constructor_comments(x: hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor]) → hydra.typed.TypedTerm[str | None]

DSL accessor for the comments field of hydra.haskell.syntax.PositionalConstructor.

hydra.dsl.haskell.syntax.positional_constructor_fields(x: hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Type]]

DSL accessor for the fields field of hydra.haskell.syntax.PositionalConstructor.

hydra.dsl.haskell.syntax.positional_constructor_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.PositionalConstructor.

hydra.dsl.haskell.syntax.positional_constructor_with_comments(original: hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor], new_val: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor]

DSL updater for the comments field of hydra.haskell.syntax.PositionalConstructor.

hydra.dsl.haskell.syntax.positional_constructor_with_fields(original: hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Type]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor]

DSL updater for the fields field of hydra.haskell.syntax.PositionalConstructor.

hydra.dsl.haskell.syntax.positional_constructor_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.PositionalConstructor]

DSL updater for the name field of hydra.haskell.syntax.PositionalConstructor.

hydra.dsl.haskell.syntax.qualified_name(qualifiers: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.NamePart]], unqualified: hydra.typed.TypedTerm[hydra.haskell.syntax.NamePart]) → hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName]

DSL constructor for hydra.haskell.syntax.QualifiedName.

hydra.dsl.haskell.syntax.qualified_name_qualifiers(x: hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.NamePart]]

DSL accessor for the qualifiers field of hydra.haskell.syntax.QualifiedName.

hydra.dsl.haskell.syntax.qualified_name_unqualified(x: hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName]) → hydra.typed.TypedTerm[hydra.haskell.syntax.NamePart]

DSL accessor for the unqualified field of hydra.haskell.syntax.QualifiedName.

hydra.dsl.haskell.syntax.qualified_name_with_qualifiers(original: hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.NamePart]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName]

DSL updater for the qualifiers field of hydra.haskell.syntax.QualifiedName.

hydra.dsl.haskell.syntax.qualified_name_with_unqualified(original: hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.NamePart]) → hydra.typed.TypedTerm[hydra.haskell.syntax.QualifiedName]

DSL updater for the unqualified field of hydra.haskell.syntax.QualifiedName.

hydra.dsl.haskell.syntax.record_constructor(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], fields: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Field]], comments: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor]

DSL constructor for hydra.haskell.syntax.RecordConstructor.

hydra.dsl.haskell.syntax.record_constructor_comments(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor]) → hydra.typed.TypedTerm[str | None]

DSL accessor for the comments field of hydra.haskell.syntax.RecordConstructor.

hydra.dsl.haskell.syntax.record_constructor_fields(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Field]]

DSL accessor for the fields field of hydra.haskell.syntax.RecordConstructor.

hydra.dsl.haskell.syntax.record_constructor_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.RecordConstructor.

hydra.dsl.haskell.syntax.record_constructor_with_comments(original: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor], new_val: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor]

DSL updater for the comments field of hydra.haskell.syntax.RecordConstructor.

hydra.dsl.haskell.syntax.record_constructor_with_fields(original: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Field]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor]

DSL updater for the fields field of hydra.haskell.syntax.RecordConstructor.

hydra.dsl.haskell.syntax.record_constructor_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordConstructor]

DSL updater for the name field of hydra.haskell.syntax.RecordConstructor.

hydra.dsl.haskell.syntax.record_expression(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], fields: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.FieldUpdate]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordExpression]

DSL constructor for hydra.haskell.syntax.RecordExpression.

hydra.dsl.haskell.syntax.record_expression_fields(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordExpression]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.FieldUpdate]]

DSL accessor for the fields field of hydra.haskell.syntax.RecordExpression.

hydra.dsl.haskell.syntax.record_expression_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.RecordExpression.

hydra.dsl.haskell.syntax.record_expression_with_fields(original: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordExpression], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.FieldUpdate]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordExpression]

DSL updater for the fields field of hydra.haskell.syntax.RecordExpression.

hydra.dsl.haskell.syntax.record_expression_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordExpression]

DSL updater for the name field of hydra.haskell.syntax.RecordExpression.

hydra.dsl.haskell.syntax.record_pattern(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], fields: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.PatternField]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordPattern]

DSL constructor for hydra.haskell.syntax.RecordPattern.

hydra.dsl.haskell.syntax.record_pattern_fields(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordPattern]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.PatternField]]

DSL accessor for the fields field of hydra.haskell.syntax.RecordPattern.

hydra.dsl.haskell.syntax.record_pattern_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordPattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.RecordPattern.

hydra.dsl.haskell.syntax.record_pattern_with_fields(original: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordPattern], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.PatternField]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordPattern]

DSL updater for the fields field of hydra.haskell.syntax.RecordPattern.

hydra.dsl.haskell.syntax.record_pattern_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordPattern], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordPattern]

DSL updater for the name field of hydra.haskell.syntax.RecordPattern.

hydra.dsl.haskell.syntax.record_update_expression(inner: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression], fields: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.FieldUpdate]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordUpdateExpression]

DSL constructor for hydra.haskell.syntax.RecordUpdateExpression.

hydra.dsl.haskell.syntax.record_update_expression_fields(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordUpdateExpression]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.FieldUpdate]]

DSL accessor for the fields field of hydra.haskell.syntax.RecordUpdateExpression.

hydra.dsl.haskell.syntax.record_update_expression_inner(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordUpdateExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the inner field of hydra.haskell.syntax.RecordUpdateExpression.

hydra.dsl.haskell.syntax.record_update_expression_with_fields(original: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordUpdateExpression], new_val: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.FieldUpdate]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordUpdateExpression]

DSL updater for the fields field of hydra.haskell.syntax.RecordUpdateExpression.

hydra.dsl.haskell.syntax.record_update_expression_with_inner(original: hydra.typed.TypedTerm[hydra.haskell.syntax.RecordUpdateExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RecordUpdateExpression]

DSL updater for the inner field of hydra.haskell.syntax.RecordUpdateExpression.

hydra.dsl.haskell.syntax.right_hand_side(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RightHandSide]

DSL constructor for the hydra.haskell.syntax.RightHandSide wrapper.

hydra.dsl.haskell.syntax.section_expression(operator: hydra.typed.TypedTerm[hydra.haskell.syntax.Operator], expression: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.SectionExpression]

DSL constructor for hydra.haskell.syntax.SectionExpression.

hydra.dsl.haskell.syntax.section_expression_expression(x: hydra.typed.TypedTerm[hydra.haskell.syntax.SectionExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the expression field of hydra.haskell.syntax.SectionExpression.

hydra.dsl.haskell.syntax.section_expression_operator(x: hydra.typed.TypedTerm[hydra.haskell.syntax.SectionExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Operator]

DSL accessor for the operator field of hydra.haskell.syntax.SectionExpression.

hydra.dsl.haskell.syntax.section_expression_with_expression(original: hydra.typed.TypedTerm[hydra.haskell.syntax.SectionExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.SectionExpression]

DSL updater for the expression field of hydra.haskell.syntax.SectionExpression.

hydra.dsl.haskell.syntax.section_expression_with_operator(original: hydra.typed.TypedTerm[hydra.haskell.syntax.SectionExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Operator]) → hydra.typed.TypedTerm[hydra.haskell.syntax.SectionExpression]

DSL updater for the operator field of hydra.haskell.syntax.SectionExpression.

hydra.dsl.haskell.syntax.simple_value_binding(pattern: hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern], rhs: hydra.typed.TypedTerm[hydra.haskell.syntax.RightHandSide], local_bindings: hydra.typed.TypedTerm[hydra.haskell.syntax.LocalBindings | None], comments: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding]

DSL constructor for hydra.haskell.syntax.SimpleValueBinding.

hydra.dsl.haskell.syntax.simple_value_binding_comments(x: hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding]) → hydra.typed.TypedTerm[str | None]

DSL accessor for the comments field of hydra.haskell.syntax.SimpleValueBinding.

hydra.dsl.haskell.syntax.simple_value_binding_local_bindings(x: hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding]) → hydra.typed.TypedTerm[hydra.haskell.syntax.LocalBindings | None]

DSL accessor for the localBindings field of hydra.haskell.syntax.SimpleValueBinding.

hydra.dsl.haskell.syntax.simple_value_binding_pattern(x: hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL accessor for the pattern field of hydra.haskell.syntax.SimpleValueBinding.

hydra.dsl.haskell.syntax.simple_value_binding_rhs(x: hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding]) → hydra.typed.TypedTerm[hydra.haskell.syntax.RightHandSide]

DSL accessor for the rhs field of hydra.haskell.syntax.SimpleValueBinding.

hydra.dsl.haskell.syntax.simple_value_binding_with_comments(original: hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding], new_val: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding]

DSL updater for the comments field of hydra.haskell.syntax.SimpleValueBinding.

hydra.dsl.haskell.syntax.simple_value_binding_with_local_bindings(original: hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.LocalBindings | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding]

DSL updater for the localBindings field of hydra.haskell.syntax.SimpleValueBinding.

hydra.dsl.haskell.syntax.simple_value_binding_with_pattern(original: hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding]

DSL updater for the pattern field of hydra.haskell.syntax.SimpleValueBinding.

hydra.dsl.haskell.syntax.simple_value_binding_with_rhs(original: hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.RightHandSide]) → hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding]

DSL updater for the rhs field of hydra.haskell.syntax.SimpleValueBinding.

hydra.dsl.haskell.syntax.statement(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Statement]

DSL constructor for the hydra.haskell.syntax.Statement wrapper.

hydra.dsl.haskell.syntax.type_application(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ApplicationType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL injection for the application variant of hydra.haskell.syntax.Type.

hydra.dsl.haskell.syntax.type_ctx(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ConstrainedType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL injection for the ctx variant of hydra.haskell.syntax.Type.

hydra.dsl.haskell.syntax.type_function(x: hydra.typed.TypedTerm[hydra.haskell.syntax.FunctionType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL injection for the function variant of hydra.haskell.syntax.Type.

hydra.dsl.haskell.syntax.type_infix(x: hydra.typed.TypedTerm[hydra.haskell.syntax.InfixType]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL injection for the infix variant of hydra.haskell.syntax.Type.

hydra.dsl.haskell.syntax.type_list(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL injection for the list variant of hydra.haskell.syntax.Type.

hydra.dsl.haskell.syntax.type_signature(name: hydra.typed.TypedTerm[hydra.haskell.syntax.Name], type: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature]

DSL constructor for hydra.haskell.syntax.TypeSignature.

hydra.dsl.haskell.syntax.type_signature_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the name field of hydra.haskell.syntax.TypeSignature.

hydra.dsl.haskell.syntax.type_signature_type(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the type field of hydra.haskell.syntax.TypeSignature.

hydra.dsl.haskell.syntax.type_signature_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature]

DSL updater for the name field of hydra.haskell.syntax.TypeSignature.

hydra.dsl.haskell.syntax.type_signature_with_type(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature]

DSL updater for the type field of hydra.haskell.syntax.TypeSignature.

hydra.dsl.haskell.syntax.type_synonym_declaration(name: hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead], type: hydra.typed.TypedTerm[hydra.haskell.syntax.Type], comments: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration]

DSL constructor for hydra.haskell.syntax.TypeSynonymDeclaration.

hydra.dsl.haskell.syntax.type_synonym_declaration_comments(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration]) → hydra.typed.TypedTerm[str | None]

DSL accessor for the comments field of hydra.haskell.syntax.TypeSynonymDeclaration.

hydra.dsl.haskell.syntax.type_synonym_declaration_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration]) → hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead]

DSL accessor for the name field of hydra.haskell.syntax.TypeSynonymDeclaration.

hydra.dsl.haskell.syntax.type_synonym_declaration_type(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the type field of hydra.haskell.syntax.TypeSynonymDeclaration.

hydra.dsl.haskell.syntax.type_synonym_declaration_with_comments(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration], new_val: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration]

DSL updater for the comments field of hydra.haskell.syntax.TypeSynonymDeclaration.

hydra.dsl.haskell.syntax.type_synonym_declaration_with_name(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.DeclarationHead]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration]

DSL updater for the name field of hydra.haskell.syntax.TypeSynonymDeclaration.

hydra.dsl.haskell.syntax.type_synonym_declaration_with_type(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSynonymDeclaration]

DSL updater for the type field of hydra.haskell.syntax.TypeSynonymDeclaration.

hydra.dsl.haskell.syntax.type_tuple(x: hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Type]]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL injection for the tuple variant of hydra.haskell.syntax.Type.

hydra.dsl.haskell.syntax.type_variable(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL injection for the variable variant of hydra.haskell.syntax.Type.

hydra.dsl.haskell.syntax.typed_binding(type_signature: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature], value_binding: hydra.typed.TypedTerm[hydra.haskell.syntax.ValueBinding], comments: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding]

DSL constructor for hydra.haskell.syntax.TypedBinding.

hydra.dsl.haskell.syntax.typed_binding_comments(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding]) → hydra.typed.TypedTerm[str | None]

DSL accessor for the comments field of hydra.haskell.syntax.TypedBinding.

hydra.dsl.haskell.syntax.typed_binding_type_signature(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature]

DSL accessor for the typeSignature field of hydra.haskell.syntax.TypedBinding.

hydra.dsl.haskell.syntax.typed_binding_value_binding(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ValueBinding]

DSL accessor for the valueBinding field of hydra.haskell.syntax.TypedBinding.

hydra.dsl.haskell.syntax.typed_binding_with_comments(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding], new_val: hydra.typed.TypedTerm[str | None]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding]

DSL updater for the comments field of hydra.haskell.syntax.TypedBinding.

hydra.dsl.haskell.syntax.typed_binding_with_type_signature(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.TypeSignature]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding]

DSL updater for the typeSignature field of hydra.haskell.syntax.TypedBinding.

hydra.dsl.haskell.syntax.typed_binding_with_value_binding(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.ValueBinding]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypedBinding]

DSL updater for the valueBinding field of hydra.haskell.syntax.TypedBinding.

hydra.dsl.haskell.syntax.typed_expression(inner: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression], type: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypedExpression]

DSL constructor for hydra.haskell.syntax.TypedExpression.

hydra.dsl.haskell.syntax.typed_expression_inner(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the inner field of hydra.haskell.syntax.TypedExpression.

hydra.dsl.haskell.syntax.typed_expression_type(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedExpression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the type field of hydra.haskell.syntax.TypedExpression.

hydra.dsl.haskell.syntax.typed_expression_with_inner(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypedExpression]

DSL updater for the inner field of hydra.haskell.syntax.TypedExpression.

hydra.dsl.haskell.syntax.typed_expression_with_type(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedExpression], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypedExpression]

DSL updater for the type field of hydra.haskell.syntax.TypedExpression.

hydra.dsl.haskell.syntax.typed_pattern(inner: hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern], type: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypedPattern]

DSL constructor for hydra.haskell.syntax.TypedPattern.

hydra.dsl.haskell.syntax.typed_pattern_inner(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedPattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]

DSL accessor for the inner field of hydra.haskell.syntax.TypedPattern.

hydra.dsl.haskell.syntax.typed_pattern_type(x: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedPattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Type]

DSL accessor for the type field of hydra.haskell.syntax.TypedPattern.

hydra.dsl.haskell.syntax.typed_pattern_with_inner(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedPattern], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Pattern]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypedPattern]

DSL updater for the inner field of hydra.haskell.syntax.TypedPattern.

hydra.dsl.haskell.syntax.typed_pattern_with_type(original: hydra.typed.TypedTerm[hydra.haskell.syntax.TypedPattern], new_val: hydra.typed.TypedTerm[hydra.haskell.syntax.Type]) → hydra.typed.TypedTerm[hydra.haskell.syntax.TypedPattern]

DSL updater for the type field of hydra.haskell.syntax.TypedPattern.

hydra.dsl.haskell.syntax.un_case_rhs(x: hydra.typed.TypedTerm[hydra.haskell.syntax.CaseRhs]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the body of hydra.haskell.syntax.CaseRhs.

hydra.dsl.haskell.syntax.un_deriving_clause(x: hydra.typed.TypedTerm[hydra.haskell.syntax.DerivingClause]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.Name]]

DSL accessor for the body of hydra.haskell.syntax.DerivingClause.

hydra.dsl.haskell.syntax.un_local_bindings(x: hydra.typed.TypedTerm[hydra.haskell.syntax.LocalBindings]) → hydra.typed.TypedTerm[Sequence[hydra.haskell.syntax.LocalBinding]]

DSL accessor for the body of hydra.haskell.syntax.LocalBindings.

hydra.dsl.haskell.syntax.un_module_name(x: hydra.typed.TypedTerm[hydra.haskell.syntax.ModuleName]) → hydra.typed.TypedTerm[str]

DSL accessor for the body of hydra.haskell.syntax.ModuleName.

hydra.dsl.haskell.syntax.un_name_part(x: hydra.typed.TypedTerm[hydra.haskell.syntax.NamePart]) → hydra.typed.TypedTerm[str]

DSL accessor for the body of hydra.haskell.syntax.NamePart.

hydra.dsl.haskell.syntax.un_right_hand_side(x: hydra.typed.TypedTerm[hydra.haskell.syntax.RightHandSide]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the body of hydra.haskell.syntax.RightHandSide.

hydra.dsl.haskell.syntax.un_statement(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Statement]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Expression]

DSL accessor for the body of hydra.haskell.syntax.Statement.

hydra.dsl.haskell.syntax.un_variable(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Variable]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Name]

DSL accessor for the body of hydra.haskell.syntax.Variable.

hydra.dsl.haskell.syntax.value_binding_simple(x: hydra.typed.TypedTerm[hydra.haskell.syntax.SimpleValueBinding]) → hydra.typed.TypedTerm[hydra.haskell.syntax.ValueBinding]

DSL injection for the simple variant of hydra.haskell.syntax.ValueBinding.

hydra.dsl.haskell.syntax.variable(x: hydra.typed.TypedTerm[hydra.haskell.syntax.Name]) → hydra.typed.TypedTerm[hydra.haskell.syntax.Variable]

DSL constructor for the hydra.haskell.syntax.Variable wrapper.