diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,74 @@ --- +## [0.17.0] - 2026-07-01 + +Major themes: first-class support for effects and I/O in the kernel, TypeScript and +Scala reaching publishable parity with the other hosts, and continued maturation of +the published-host build model. + +### Highlights + +- **Effects and I/O** ([#286](https://github.com/CategoricalData/hydra/issues/286), + [#288](https://github.com/CategoricalData/hydra/issues/288), + [#494](https://github.com/CategoricalData/hydra/issues/494)): a new `effect` variant + on `hydra.core.Type` for representing effectful computations; new kernel modules + `hydra.file` (`FilePath`, `FileType`, `FileStatus`, `FileExtension`), `hydra.time` + (`Timespec`), and `hydra.error.file`; new primitive libraries `hydra.lib.effects`, + `hydra.lib.files`, and `hydra.lib.text` with byte-level I/O; and a new + `EffectfulTestCase` mechanism so the common test suite can exercise effectful + primitives across hosts. +- **TypeScript is a complete implementation** + ([#462](https://github.com/CategoricalData/hydra/issues/462)): self-hosts and passes + the common test suite, with a per-package npm publish pipeline + ([#492](https://github.com/CategoricalData/hydra/issues/492)). +- **Scala publishing**: per-package Maven Central publish infrastructure + ([#491](https://github.com/CategoricalData/hydra/issues/491)). +- **Published-host build model**: published mode now compiles the kernel from the + co-generated `dist/haskell` rather than Hackage, removing the need for a + `haskell=local` shim ([#500](https://github.com/CategoricalData/hydra/issues/500)); + the oil-and-water principle and cold-build workflow for `dist/haskell` are documented + ([#376](https://github.com/CategoricalData/hydra/issues/376)). +- **Kernel hygiene**: `uniqueLabel` (apostrophe suffixes) replaced by `chooseUniqueLabel` + (numeric suffixes) in `hydra.names` + ([#436](https://github.com/CategoricalData/hydra/issues/436)). + +### Implementations + +Eight hosts self-host and pass the common test suite across five families: Haskell, +Java, Python, Scala, and the four Lisp dialects (Clojure, Common Lisp, Scheme, Emacs +Lisp), with TypeScript now joining as a complete host/target. Go remains a "head bud" +(the coder still has emission bugs and the head's runtime is largely placeholder; it +does not yet host the test suite). + +### New Features + +- Translingual cross-reference convention for `doc` strings: doc-escape tags render to + each host's native doc syntax (Javadoc, Haddock, Sphinx, TSDoc) + ([#433](https://github.com/CategoricalData/hydra/issues/433)). +- Neo4j JSON-artifact validation demo, exercised across Java, Python, Haskell, and + TypeScript ([#510](https://github.com/CategoricalData/hydra/issues/510)). + +### Improvements + +- The Java/Maven publish set now covers every official Hydra target language, one coder + package per implementation family + ([#468](https://github.com/CategoricalData/hydra/issues/468)). +- JVM Maven artifact groups are bifurcated to `net.fortytwo.hydra.java` and + `net.fortytwo.hydra.scala`, so the Java and Scala (and future Clojure) publish sets + never collide on coordinates + ([#519](https://github.com/CategoricalData/hydra/issues/519)). +- Host-specific third-party integrations (the former `bindings/` tree) are folded into + `overlay/`, unifying hand-written host-native source under one tree + ([#511](https://github.com/CategoricalData/hydra/issues/511)). +- The coder de-parameterizes context and error types, simplifying generated coder + signatures ([#518](https://github.com/CategoricalData/hydra/issues/518)). +- TypeScript-to-Java generation now emits the `hydra.lib.*` aggregate namespace + interfaces (`Maps`, `Strings`, etc.) + ([#499](https://github.com/CategoricalData/hydra/issues/499)). + +--- + ## [0.16.1] - 2026-06-16 Major themes: the first release built by bootstrapping from previously published diff --git a/hydra-haskell.cabal b/hydra-haskell.cabal --- a/hydra-haskell.cabal +++ b/hydra-haskell.cabal @@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack name: hydra-haskell -version: 0.16.1 +version: 0.17.0 synopsis: Hydra's Haskell coder: emit Haskell source from Hydra modules description: Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". This package is Hydra's Haskell coder: it translates Hydra modules into Haskell source. The top-level entry point is moduleToHaskell (and moduleToHaskellModule for the structured AST). It builds on hydra-kernel. category: Data @@ -44,6 +44,6 @@ build-depends: base >=4.19.0 && <4.22 , containers >=0.6.7 && <0.8 - , hydra-kernel ==0.16.1 + , hydra-kernel ==0.17.0 , scientific >=0.3.7 && <0.4 default-language: Haskell2010 diff --git a/src/main/haskell/Hydra/Dsl/Haskell/Environment.hs b/src/main/haskell/Hydra/Dsl/Haskell/Environment.hs --- a/src/main/haskell/Hydra/Dsl/Haskell/Environment.hs +++ b/src/main/haskell/Hydra/Dsl/Haskell/Environment.hs @@ -1,12 +1,15 @@ -- Note: this is an automatically generated file. Do not edit. + -- | DSL functions for hydra.haskell.environment module Hydra.Dsl.Haskell.Environment where + import qualified Hydra.Core as Core import qualified Hydra.Haskell.Environment as Environment import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci + -- | DSL constructor for hydra.haskell.environment.HaskellModuleMetadata haskellModuleMetadata :: Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.HaskellModuleMetadata haskellModuleMetadata usesByteString usesInt usesMap usesSet = @@ -25,6 +28,7 @@ Core.Field { Core.fieldName = (Core.Name "usesSet"), Core.fieldTerm = (Typed.unTypedTerm usesSet)}]})) + -- | DSL accessor for the usesByteString field of hydra.haskell.environment.HaskellModuleMetadata haskellModuleMetadataUsesByteString :: Typed.TypedTerm Environment.HaskellModuleMetadata -> Typed.TypedTerm Bool haskellModuleMetadataUsesByteString x = @@ -33,6 +37,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.environment.HaskellModuleMetadata"), Core.projectionFieldName = (Core.Name "usesByteString")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the usesInt field of hydra.haskell.environment.HaskellModuleMetadata haskellModuleMetadataUsesInt :: Typed.TypedTerm Environment.HaskellModuleMetadata -> Typed.TypedTerm Bool haskellModuleMetadataUsesInt x = @@ -41,6 +46,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.environment.HaskellModuleMetadata"), Core.projectionFieldName = (Core.Name "usesInt")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the usesMap field of hydra.haskell.environment.HaskellModuleMetadata haskellModuleMetadataUsesMap :: Typed.TypedTerm Environment.HaskellModuleMetadata -> Typed.TypedTerm Bool haskellModuleMetadataUsesMap x = @@ -49,6 +55,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.environment.HaskellModuleMetadata"), Core.projectionFieldName = (Core.Name "usesMap")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the usesSet field of hydra.haskell.environment.HaskellModuleMetadata haskellModuleMetadataUsesSet :: Typed.TypedTerm Environment.HaskellModuleMetadata -> Typed.TypedTerm Bool haskellModuleMetadataUsesSet x = @@ -57,6 +64,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.environment.HaskellModuleMetadata"), Core.projectionFieldName = (Core.Name "usesSet")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the usesByteString field of hydra.haskell.environment.HaskellModuleMetadata haskellModuleMetadataWithUsesByteString :: Typed.TypedTerm Environment.HaskellModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.HaskellModuleMetadata haskellModuleMetadataWithUsesByteString original newVal = @@ -87,6 +95,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.environment.HaskellModuleMetadata"), Core.projectionFieldName = (Core.Name "usesSet")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the usesInt field of hydra.haskell.environment.HaskellModuleMetadata haskellModuleMetadataWithUsesInt :: Typed.TypedTerm Environment.HaskellModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.HaskellModuleMetadata haskellModuleMetadataWithUsesInt original newVal = @@ -117,6 +126,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.environment.HaskellModuleMetadata"), Core.projectionFieldName = (Core.Name "usesSet")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the usesMap field of hydra.haskell.environment.HaskellModuleMetadata haskellModuleMetadataWithUsesMap :: Typed.TypedTerm Environment.HaskellModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.HaskellModuleMetadata haskellModuleMetadataWithUsesMap original newVal = @@ -147,6 +157,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.environment.HaskellModuleMetadata"), Core.projectionFieldName = (Core.Name "usesSet")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the usesSet field of hydra.haskell.environment.HaskellModuleMetadata haskellModuleMetadataWithUsesSet :: Typed.TypedTerm Environment.HaskellModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.HaskellModuleMetadata haskellModuleMetadataWithUsesSet original newVal = diff --git a/src/main/haskell/Hydra/Dsl/Haskell/Syntax.hs b/src/main/haskell/Hydra/Dsl/Haskell/Syntax.hs --- a/src/main/haskell/Hydra/Dsl/Haskell/Syntax.hs +++ b/src/main/haskell/Hydra/Dsl/Haskell/Syntax.hs @@ -1,13 +1,16 @@ -- Note: this is an automatically generated file. Do not edit. + -- | DSL functions for hydra.haskell.syntax module Hydra.Dsl.Haskell.Syntax where + import qualified Hydra.Core as Core import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Haskell.Syntax as Syntax import qualified Hydra.Typed as Typed import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci + -- | DSL constructor for hydra.haskell.syntax.Alternative alternative :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.CaseRhs -> Typed.TypedTerm (Maybe Syntax.LocalBindings) -> Typed.TypedTerm Syntax.Alternative alternative pattern rhs binds = @@ -23,6 +26,7 @@ Core.Field { Core.fieldName = (Core.Name "binds"), Core.fieldTerm = (Typed.unTypedTerm binds)}]})) + -- | DSL accessor for the binds field of hydra.haskell.syntax.Alternative alternativeBinds :: Typed.TypedTerm Syntax.Alternative -> Typed.TypedTerm (Maybe Syntax.LocalBindings) alternativeBinds x = @@ -31,6 +35,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Alternative"), Core.projectionFieldName = (Core.Name "binds")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the pattern field of hydra.haskell.syntax.Alternative alternativePattern :: Typed.TypedTerm Syntax.Alternative -> Typed.TypedTerm Syntax.Pattern alternativePattern x = @@ -39,6 +44,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Alternative"), Core.projectionFieldName = (Core.Name "pattern")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the rhs field of hydra.haskell.syntax.Alternative alternativeRhs :: Typed.TypedTerm Syntax.Alternative -> Typed.TypedTerm Syntax.CaseRhs alternativeRhs x = @@ -47,6 +53,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Alternative"), Core.projectionFieldName = (Core.Name "rhs")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the binds field of hydra.haskell.syntax.Alternative alternativeWithBinds :: Typed.TypedTerm Syntax.Alternative -> Typed.TypedTerm (Maybe Syntax.LocalBindings) -> Typed.TypedTerm Syntax.Alternative alternativeWithBinds original newVal = @@ -70,6 +77,7 @@ Core.Field { Core.fieldName = (Core.Name "binds"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the pattern field of hydra.haskell.syntax.Alternative alternativeWithPattern :: Typed.TypedTerm Syntax.Alternative -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.Alternative alternativeWithPattern original newVal = @@ -93,6 +101,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Alternative"), Core.projectionFieldName = (Core.Name "binds")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the rhs field of hydra.haskell.syntax.Alternative alternativeWithRhs :: Typed.TypedTerm Syntax.Alternative -> Typed.TypedTerm Syntax.CaseRhs -> Typed.TypedTerm Syntax.Alternative alternativeWithRhs original newVal = @@ -116,6 +125,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Alternative"), Core.projectionFieldName = (Core.Name "binds")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.ApplicationDeclarationHead applicationDeclarationHead :: Typed.TypedTerm Syntax.DeclarationHead -> Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm Syntax.ApplicationDeclarationHead applicationDeclarationHead function operand = @@ -128,6 +138,7 @@ Core.Field { Core.fieldName = (Core.Name "operand"), Core.fieldTerm = (Typed.unTypedTerm operand)}]})) + -- | DSL accessor for the function field of hydra.haskell.syntax.ApplicationDeclarationHead applicationDeclarationHeadFunction :: Typed.TypedTerm Syntax.ApplicationDeclarationHead -> Typed.TypedTerm Syntax.DeclarationHead applicationDeclarationHeadFunction x = @@ -136,6 +147,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead"), Core.projectionFieldName = (Core.Name "function")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the operand field of hydra.haskell.syntax.ApplicationDeclarationHead applicationDeclarationHeadOperand :: Typed.TypedTerm Syntax.ApplicationDeclarationHead -> Typed.TypedTerm Syntax.Variable applicationDeclarationHeadOperand x = @@ -144,6 +156,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead"), Core.projectionFieldName = (Core.Name "operand")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the function field of hydra.haskell.syntax.ApplicationDeclarationHead applicationDeclarationHeadWithFunction :: Typed.TypedTerm Syntax.ApplicationDeclarationHead -> Typed.TypedTerm Syntax.DeclarationHead -> Typed.TypedTerm Syntax.ApplicationDeclarationHead applicationDeclarationHeadWithFunction original newVal = @@ -160,6 +173,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead"), Core.projectionFieldName = (Core.Name "operand")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the operand field of hydra.haskell.syntax.ApplicationDeclarationHead applicationDeclarationHeadWithOperand :: Typed.TypedTerm Syntax.ApplicationDeclarationHead -> Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm Syntax.ApplicationDeclarationHead applicationDeclarationHeadWithOperand original newVal = @@ -176,6 +190,7 @@ Core.Field { Core.fieldName = (Core.Name "operand"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL constructor for hydra.haskell.syntax.ApplicationExpression applicationExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ApplicationExpression applicationExpression function argument = @@ -188,6 +203,7 @@ Core.Field { Core.fieldName = (Core.Name "argument"), Core.fieldTerm = (Typed.unTypedTerm argument)}]})) + -- | DSL accessor for the argument field of hydra.haskell.syntax.ApplicationExpression applicationExpressionArgument :: Typed.TypedTerm Syntax.ApplicationExpression -> Typed.TypedTerm Syntax.Expression applicationExpressionArgument x = @@ -196,6 +212,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationExpression"), Core.projectionFieldName = (Core.Name "argument")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the function field of hydra.haskell.syntax.ApplicationExpression applicationExpressionFunction :: Typed.TypedTerm Syntax.ApplicationExpression -> Typed.TypedTerm Syntax.Expression applicationExpressionFunction x = @@ -204,6 +221,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationExpression"), Core.projectionFieldName = (Core.Name "function")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the argument field of hydra.haskell.syntax.ApplicationExpression applicationExpressionWithArgument :: Typed.TypedTerm Syntax.ApplicationExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ApplicationExpression applicationExpressionWithArgument original newVal = @@ -220,6 +238,7 @@ Core.Field { Core.fieldName = (Core.Name "argument"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the function field of hydra.haskell.syntax.ApplicationExpression applicationExpressionWithFunction :: Typed.TypedTerm Syntax.ApplicationExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ApplicationExpression applicationExpressionWithFunction original newVal = @@ -236,6 +255,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationExpression"), Core.projectionFieldName = (Core.Name "argument")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.ApplicationPattern applicationPattern :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.ApplicationPattern applicationPattern name args = @@ -248,6 +268,7 @@ Core.Field { Core.fieldName = (Core.Name "args"), Core.fieldTerm = (Typed.unTypedTerm args)}]})) + -- | DSL accessor for the args field of hydra.haskell.syntax.ApplicationPattern applicationPatternArgs :: Typed.TypedTerm Syntax.ApplicationPattern -> Typed.TypedTerm [Syntax.Pattern] applicationPatternArgs x = @@ -256,6 +277,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationPattern"), Core.projectionFieldName = (Core.Name "args")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the name field of hydra.haskell.syntax.ApplicationPattern applicationPatternName :: Typed.TypedTerm Syntax.ApplicationPattern -> Typed.TypedTerm Syntax.Name applicationPatternName x = @@ -264,6 +286,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationPattern"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the args field of hydra.haskell.syntax.ApplicationPattern applicationPatternWithArgs :: Typed.TypedTerm Syntax.ApplicationPattern -> Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.ApplicationPattern applicationPatternWithArgs original newVal = @@ -280,6 +303,7 @@ Core.Field { Core.fieldName = (Core.Name "args"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the name field of hydra.haskell.syntax.ApplicationPattern applicationPatternWithName :: Typed.TypedTerm Syntax.ApplicationPattern -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ApplicationPattern applicationPatternWithName original newVal = @@ -296,6 +320,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationPattern"), Core.projectionFieldName = (Core.Name "args")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.ApplicationType applicationType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplicationType applicationType context argument = @@ -308,6 +333,7 @@ Core.Field { Core.fieldName = (Core.Name "argument"), Core.fieldTerm = (Typed.unTypedTerm argument)}]})) + -- | DSL accessor for the argument field of hydra.haskell.syntax.ApplicationType applicationTypeArgument :: Typed.TypedTerm Syntax.ApplicationType -> Typed.TypedTerm Syntax.Type applicationTypeArgument x = @@ -316,6 +342,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationType"), Core.projectionFieldName = (Core.Name "argument")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the context field of hydra.haskell.syntax.ApplicationType applicationTypeContext :: Typed.TypedTerm Syntax.ApplicationType -> Typed.TypedTerm Syntax.Type applicationTypeContext x = @@ -324,6 +351,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationType"), Core.projectionFieldName = (Core.Name "context")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the argument field of hydra.haskell.syntax.ApplicationType applicationTypeWithArgument :: Typed.TypedTerm Syntax.ApplicationType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplicationType applicationTypeWithArgument original newVal = @@ -340,6 +368,7 @@ Core.Field { Core.fieldName = (Core.Name "argument"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the context field of hydra.haskell.syntax.ApplicationType applicationTypeWithContext :: Typed.TypedTerm Syntax.ApplicationType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ApplicationType applicationTypeWithContext original newVal = @@ -356,6 +385,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ApplicationType"), Core.projectionFieldName = (Core.Name "argument")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.AsPattern asPattern :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.AsPattern asPattern name inner = @@ -368,6 +398,7 @@ Core.Field { Core.fieldName = (Core.Name "inner"), Core.fieldTerm = (Typed.unTypedTerm inner)}]})) + -- | DSL accessor for the inner field of hydra.haskell.syntax.AsPattern asPatternInner :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.Pattern asPatternInner x = @@ -376,6 +407,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.AsPattern"), Core.projectionFieldName = (Core.Name "inner")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the name field of hydra.haskell.syntax.AsPattern asPatternName :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.Name asPatternName x = @@ -384,6 +416,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.AsPattern"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the inner field of hydra.haskell.syntax.AsPattern asPatternWithInner :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.AsPattern asPatternWithInner original newVal = @@ -400,6 +433,7 @@ Core.Field { Core.fieldName = (Core.Name "inner"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the name field of hydra.haskell.syntax.AsPattern asPatternWithName :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.AsPattern asPatternWithName original newVal = @@ -416,6 +450,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.AsPattern"), Core.projectionFieldName = (Core.Name "inner")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.CaseExpression caseExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm [Syntax.Alternative] -> Typed.TypedTerm Syntax.CaseExpression caseExpression case_ alternatives = @@ -428,6 +463,7 @@ Core.Field { Core.fieldName = (Core.Name "alternatives"), Core.fieldTerm = (Typed.unTypedTerm alternatives)}]})) + -- | DSL accessor for the alternatives field of hydra.haskell.syntax.CaseExpression caseExpressionAlternatives :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm [Syntax.Alternative] caseExpressionAlternatives x = @@ -436,6 +472,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.CaseExpression"), Core.projectionFieldName = (Core.Name "alternatives")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the case field of hydra.haskell.syntax.CaseExpression caseExpressionCase :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm Syntax.Expression caseExpressionCase x = @@ -444,6 +481,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.CaseExpression"), Core.projectionFieldName = (Core.Name "case")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the alternatives field of hydra.haskell.syntax.CaseExpression caseExpressionWithAlternatives :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm [Syntax.Alternative] -> Typed.TypedTerm Syntax.CaseExpression caseExpressionWithAlternatives original newVal = @@ -460,6 +498,7 @@ Core.Field { Core.fieldName = (Core.Name "alternatives"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the case field of hydra.haskell.syntax.CaseExpression caseExpressionWithCase :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.CaseExpression caseExpressionWithCase original newVal = @@ -476,12 +515,14 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.CaseExpression"), Core.projectionFieldName = (Core.Name "alternatives")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for the hydra.haskell.syntax.CaseRhs wrapper caseRhs :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.CaseRhs caseRhs x = Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.CaseRhs"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + -- | DSL constructor for hydra.haskell.syntax.ClassConstraint classConstraint :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ClassConstraint classConstraint name types = @@ -494,6 +535,7 @@ Core.Field { Core.fieldName = (Core.Name "types"), Core.fieldTerm = (Typed.unTypedTerm types)}]})) + -- | DSL accessor for the name field of hydra.haskell.syntax.ClassConstraint classConstraintName :: Typed.TypedTerm Syntax.ClassConstraint -> Typed.TypedTerm Syntax.Name classConstraintName x = @@ -502,6 +544,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ClassConstraint"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the types field of hydra.haskell.syntax.ClassConstraint classConstraintTypes :: Typed.TypedTerm Syntax.ClassConstraint -> Typed.TypedTerm [Syntax.Type] classConstraintTypes x = @@ -510,6 +553,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ClassConstraint"), Core.projectionFieldName = (Core.Name "types")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the name field of hydra.haskell.syntax.ClassConstraint classConstraintWithName :: Typed.TypedTerm Syntax.ClassConstraint -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.ClassConstraint classConstraintWithName original newVal = @@ -526,6 +570,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ClassConstraint"), Core.projectionFieldName = (Core.Name "types")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the types field of hydra.haskell.syntax.ClassConstraint classConstraintWithTypes :: Typed.TypedTerm Syntax.ClassConstraint -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ClassConstraint classConstraintWithTypes original newVal = @@ -542,6 +587,7 @@ Core.Field { Core.fieldName = (Core.Name "types"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL constructor for hydra.haskell.syntax.ConstrainedType constrainedType :: Typed.TypedTerm Syntax.Constraint -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ConstrainedType constrainedType ctx type_ = @@ -554,6 +600,7 @@ Core.Field { Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm type_)}]})) + -- | DSL accessor for the ctx field of hydra.haskell.syntax.ConstrainedType constrainedTypeCtx :: Typed.TypedTerm Syntax.ConstrainedType -> Typed.TypedTerm Syntax.Constraint constrainedTypeCtx x = @@ -562,6 +609,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ConstrainedType"), Core.projectionFieldName = (Core.Name "ctx")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the type field of hydra.haskell.syntax.ConstrainedType constrainedTypeType :: Typed.TypedTerm Syntax.ConstrainedType -> Typed.TypedTerm Syntax.Type constrainedTypeType x = @@ -570,6 +618,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ConstrainedType"), Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the ctx field of hydra.haskell.syntax.ConstrainedType constrainedTypeWithCtx :: Typed.TypedTerm Syntax.ConstrainedType -> Typed.TypedTerm Syntax.Constraint -> Typed.TypedTerm Syntax.ConstrainedType constrainedTypeWithCtx original newVal = @@ -586,6 +635,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ConstrainedType"), Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the type field of hydra.haskell.syntax.ConstrainedType constrainedTypeWithType :: Typed.TypedTerm Syntax.ConstrainedType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ConstrainedType constrainedTypeWithType original newVal = @@ -602,6 +652,7 @@ Core.Field { Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL injection for the class variant of hydra.haskell.syntax.Constraint constraintClass :: Typed.TypedTerm Syntax.ClassConstraint -> Typed.TypedTerm Syntax.Constraint constraintClass x = @@ -610,6 +661,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "class"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the tuple variant of hydra.haskell.syntax.Constraint constraintTuple :: Typed.TypedTerm [Syntax.Constraint] -> Typed.TypedTerm Syntax.Constraint constraintTuple x = @@ -618,6 +670,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "tuple"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the ordinary variant of hydra.haskell.syntax.Constructor constructorOrdinary :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm Syntax.Constructor constructorOrdinary x = @@ -626,6 +679,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "ordinary"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the record variant of hydra.haskell.syntax.Constructor constructorRecord :: Typed.TypedTerm Syntax.RecordConstructor -> Typed.TypedTerm Syntax.Constructor constructorRecord x = @@ -634,6 +688,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "record"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL constructor for hydra.haskell.syntax.DataDeclaration dataDeclaration :: Typed.TypedTerm Syntax.DataKeyword -> Typed.TypedTerm [Syntax.Constraint] -> Typed.TypedTerm Syntax.DeclarationHead -> Typed.TypedTerm [Syntax.Constructor] -> Typed.TypedTerm [Syntax.DerivingClause] -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.DataDeclaration dataDeclaration keyword context head constructors deriving_ comments = @@ -658,6 +713,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm comments)}]})) + -- | DSL accessor for the comments field of hydra.haskell.syntax.DataDeclaration dataDeclarationComments :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm (Maybe String) dataDeclarationComments x = @@ -666,6 +722,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the constructors field of hydra.haskell.syntax.DataDeclaration dataDeclarationConstructors :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm [Syntax.Constructor] dataDeclarationConstructors x = @@ -674,6 +731,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "constructors")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the context field of hydra.haskell.syntax.DataDeclaration dataDeclarationContext :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm [Syntax.Constraint] dataDeclarationContext x = @@ -682,6 +740,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "context")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the deriving field of hydra.haskell.syntax.DataDeclaration dataDeclarationDeriving :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm [Syntax.DerivingClause] dataDeclarationDeriving x = @@ -690,6 +749,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "deriving")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the head field of hydra.haskell.syntax.DataDeclaration dataDeclarationHead :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm Syntax.DeclarationHead dataDeclarationHead x = @@ -698,6 +758,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "head")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the keyword field of hydra.haskell.syntax.DataDeclaration dataDeclarationKeyword :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm Syntax.DataKeyword dataDeclarationKeyword x = @@ -706,6 +767,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "keyword")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the comments field of hydra.haskell.syntax.DataDeclaration dataDeclarationWithComments :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.DataDeclaration dataDeclarationWithComments original newVal = @@ -750,6 +812,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the constructors field of hydra.haskell.syntax.DataDeclaration dataDeclarationWithConstructors :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm [Syntax.Constructor] -> Typed.TypedTerm Syntax.DataDeclaration dataDeclarationWithConstructors original newVal = @@ -794,6 +857,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the context field of hydra.haskell.syntax.DataDeclaration dataDeclarationWithContext :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm [Syntax.Constraint] -> Typed.TypedTerm Syntax.DataDeclaration dataDeclarationWithContext original newVal = @@ -838,6 +902,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the deriving field of hydra.haskell.syntax.DataDeclaration dataDeclarationWithDeriving :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm [Syntax.DerivingClause] -> Typed.TypedTerm Syntax.DataDeclaration dataDeclarationWithDeriving original newVal = @@ -882,6 +947,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the head field of hydra.haskell.syntax.DataDeclaration dataDeclarationWithHead :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm Syntax.DeclarationHead -> Typed.TypedTerm Syntax.DataDeclaration dataDeclarationWithHead original newVal = @@ -926,6 +992,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the keyword field of hydra.haskell.syntax.DataDeclaration dataDeclarationWithKeyword :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm Syntax.DataKeyword -> Typed.TypedTerm Syntax.DataDeclaration dataDeclarationWithKeyword original newVal = @@ -970,6 +1037,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.DataDeclaration"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL injection for the data variant of hydra.haskell.syntax.DataKeyword dataKeywordData :: Typed.TypedTerm Syntax.DataKeyword dataKeywordData = @@ -978,6 +1046,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "data"), Core.fieldTerm = Core.TermUnit}})) + -- | DSL injection for the newtype variant of hydra.haskell.syntax.DataKeyword dataKeywordNewtype :: Typed.TypedTerm Syntax.DataKeyword dataKeywordNewtype = @@ -986,6 +1055,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "newtype"), Core.fieldTerm = Core.TermUnit}})) + -- | DSL injection for the data variant of hydra.haskell.syntax.Declaration declarationData :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm Syntax.Declaration declarationData x = @@ -994,6 +1064,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "data"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the application variant of hydra.haskell.syntax.DeclarationHead declarationHeadApplication :: Typed.TypedTerm Syntax.ApplicationDeclarationHead -> Typed.TypedTerm Syntax.DeclarationHead declarationHeadApplication x = @@ -1002,6 +1073,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "application"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the simple variant of hydra.haskell.syntax.DeclarationHead declarationHeadSimple :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.DeclarationHead declarationHeadSimple x = @@ -1010,6 +1082,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "simple"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the type variant of hydra.haskell.syntax.Declaration declarationType :: Typed.TypedTerm Syntax.TypeSynonymDeclaration -> Typed.TypedTerm Syntax.Declaration declarationType x = @@ -1018,6 +1091,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the typedBinding variant of hydra.haskell.syntax.Declaration declarationTypedBinding :: Typed.TypedTerm Syntax.TypedBinding -> Typed.TypedTerm Syntax.Declaration declarationTypedBinding x = @@ -1026,6 +1100,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "typedBinding"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the valueBinding variant of hydra.haskell.syntax.Declaration declarationValueBinding :: Typed.TypedTerm Syntax.ValueBinding -> Typed.TypedTerm Syntax.Declaration declarationValueBinding x = @@ -1034,12 +1109,14 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "valueBinding"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL constructor for the hydra.haskell.syntax.DerivingClause wrapper derivingClause :: Typed.TypedTerm [Syntax.Name] -> Typed.TypedTerm Syntax.DerivingClause derivingClause x = Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.DerivingClause"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + -- | DSL injection for the declaration variant of hydra.haskell.syntax.Export exportDeclaration :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm Syntax.Export exportDeclaration x = @@ -1048,6 +1125,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "declaration"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the module variant of hydra.haskell.syntax.Export exportModule :: Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm Syntax.Export exportModule x = @@ -1056,6 +1134,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "module"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the application variant of hydra.haskell.syntax.Expression expressionApplication :: Typed.TypedTerm Syntax.ApplicationExpression -> Typed.TypedTerm Syntax.Expression expressionApplication x = @@ -1064,6 +1143,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "application"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the case variant of hydra.haskell.syntax.Expression expressionCase :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm Syntax.Expression expressionCase x = @@ -1072,6 +1152,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "case"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the constructRecord variant of hydra.haskell.syntax.Expression expressionConstructRecord :: Typed.TypedTerm Syntax.RecordExpression -> Typed.TypedTerm Syntax.Expression expressionConstructRecord x = @@ -1080,6 +1161,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "constructRecord"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the do variant of hydra.haskell.syntax.Expression expressionDo :: Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.Expression expressionDo x = @@ -1088,6 +1170,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "do"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the if variant of hydra.haskell.syntax.Expression expressionIf :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression expressionIf x = @@ -1096,6 +1179,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "if"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the infixApplication variant of hydra.haskell.syntax.Expression expressionInfixApplication :: Typed.TypedTerm Syntax.InfixExpression -> Typed.TypedTerm Syntax.Expression expressionInfixApplication x = @@ -1104,6 +1188,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "infixApplication"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the lambda variant of hydra.haskell.syntax.Expression expressionLambda :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.Expression expressionLambda x = @@ -1112,6 +1197,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "lambda"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the leftSection variant of hydra.haskell.syntax.Expression expressionLeftSection :: Typed.TypedTerm Syntax.SectionExpression -> Typed.TypedTerm Syntax.Expression expressionLeftSection x = @@ -1120,6 +1206,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "leftSection"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the let variant of hydra.haskell.syntax.Expression expressionLet :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm Syntax.Expression expressionLet x = @@ -1128,6 +1215,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "let"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the list variant of hydra.haskell.syntax.Expression expressionList :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Expression expressionList x = @@ -1136,6 +1224,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "list"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the literal variant of hydra.haskell.syntax.Expression expressionLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.Expression expressionLiteral x = @@ -1144,6 +1233,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "literal"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the rightSection variant of hydra.haskell.syntax.Expression expressionRightSection :: Typed.TypedTerm Syntax.SectionExpression -> Typed.TypedTerm Syntax.Expression expressionRightSection x = @@ -1152,6 +1242,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "rightSection"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the tuple variant of hydra.haskell.syntax.Expression expressionTuple :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.Expression expressionTuple x = @@ -1160,6 +1251,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "tuple"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the typeSignature variant of hydra.haskell.syntax.Expression expressionTypeSignature :: Typed.TypedTerm Syntax.TypedExpression -> Typed.TypedTerm Syntax.Expression expressionTypeSignature x = @@ -1168,6 +1260,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "typeSignature"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the updateRecord variant of hydra.haskell.syntax.Expression expressionUpdateRecord :: Typed.TypedTerm Syntax.RecordUpdateExpression -> Typed.TypedTerm Syntax.Expression expressionUpdateRecord x = @@ -1176,6 +1269,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "updateRecord"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the variable variant of hydra.haskell.syntax.Expression expressionVariable :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Expression expressionVariable x = @@ -1184,6 +1278,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "variable"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL constructor for hydra.haskell.syntax.Field field :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.Field field name type_ comments = @@ -1199,6 +1294,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm comments)}]})) + -- | DSL accessor for the comments field of hydra.haskell.syntax.Field fieldComments :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm (Maybe String) fieldComments x = @@ -1207,6 +1303,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Field"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the name field of hydra.haskell.syntax.Field fieldName :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm Syntax.Name fieldName x = @@ -1215,6 +1312,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Field"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the type field of hydra.haskell.syntax.Field fieldType :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm Syntax.Type fieldType x = @@ -1223,6 +1321,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Field"), Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL constructor for hydra.haskell.syntax.FieldUpdate fieldUpdate :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FieldUpdate fieldUpdate name value = @@ -1235,6 +1334,7 @@ Core.Field { Core.fieldName = (Core.Name "value"), Core.fieldTerm = (Typed.unTypedTerm value)}]})) + -- | DSL accessor for the name field of hydra.haskell.syntax.FieldUpdate fieldUpdateName :: Typed.TypedTerm Syntax.FieldUpdate -> Typed.TypedTerm Syntax.Name fieldUpdateName x = @@ -1243,6 +1343,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.FieldUpdate"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the value field of hydra.haskell.syntax.FieldUpdate fieldUpdateValue :: Typed.TypedTerm Syntax.FieldUpdate -> Typed.TypedTerm Syntax.Expression fieldUpdateValue x = @@ -1251,6 +1352,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.FieldUpdate"), Core.projectionFieldName = (Core.Name "value")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the name field of hydra.haskell.syntax.FieldUpdate fieldUpdateWithName :: Typed.TypedTerm Syntax.FieldUpdate -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.FieldUpdate fieldUpdateWithName original newVal = @@ -1267,6 +1369,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.FieldUpdate"), Core.projectionFieldName = (Core.Name "value")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the value field of hydra.haskell.syntax.FieldUpdate fieldUpdateWithValue :: Typed.TypedTerm Syntax.FieldUpdate -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FieldUpdate fieldUpdateWithValue original newVal = @@ -1283,6 +1386,7 @@ Core.Field { Core.fieldName = (Core.Name "value"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the comments field of hydra.haskell.syntax.Field fieldWithComments :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.Field fieldWithComments original newVal = @@ -1306,6 +1410,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the name field of hydra.haskell.syntax.Field fieldWithName :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Field fieldWithName original newVal = @@ -1329,6 +1434,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Field"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the type field of hydra.haskell.syntax.Field fieldWithType :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Field fieldWithType original newVal = @@ -1352,6 +1458,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Field"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.FunctionType functionType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FunctionType functionType domain codomain = @@ -1364,6 +1471,7 @@ Core.Field { Core.fieldName = (Core.Name "codomain"), Core.fieldTerm = (Typed.unTypedTerm codomain)}]})) + -- | DSL accessor for the codomain field of hydra.haskell.syntax.FunctionType functionTypeCodomain :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type functionTypeCodomain x = @@ -1372,6 +1480,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.FunctionType"), Core.projectionFieldName = (Core.Name "codomain")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the domain field of hydra.haskell.syntax.FunctionType functionTypeDomain :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type functionTypeDomain x = @@ -1380,6 +1489,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.FunctionType"), Core.projectionFieldName = (Core.Name "domain")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the codomain field of hydra.haskell.syntax.FunctionType functionTypeWithCodomain :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FunctionType functionTypeWithCodomain original newVal = @@ -1396,6 +1506,7 @@ Core.Field { Core.fieldName = (Core.Name "codomain"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the domain field of hydra.haskell.syntax.FunctionType functionTypeWithDomain :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FunctionType functionTypeWithDomain original newVal = @@ -1412,6 +1523,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.FunctionType"), Core.projectionFieldName = (Core.Name "codomain")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.IfExpression ifExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IfExpression ifExpression condition then_ else_ = @@ -1427,6 +1539,7 @@ Core.Field { Core.fieldName = (Core.Name "else"), Core.fieldTerm = (Typed.unTypedTerm else_)}]})) + -- | DSL accessor for the condition field of hydra.haskell.syntax.IfExpression ifExpressionCondition :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression ifExpressionCondition x = @@ -1435,6 +1548,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.IfExpression"), Core.projectionFieldName = (Core.Name "condition")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the else field of hydra.haskell.syntax.IfExpression ifExpressionElse :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression ifExpressionElse x = @@ -1443,6 +1557,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.IfExpression"), Core.projectionFieldName = (Core.Name "else")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the then field of hydra.haskell.syntax.IfExpression ifExpressionThen :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression ifExpressionThen x = @@ -1451,6 +1566,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.IfExpression"), Core.projectionFieldName = (Core.Name "then")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the condition field of hydra.haskell.syntax.IfExpression ifExpressionWithCondition :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IfExpression ifExpressionWithCondition original newVal = @@ -1474,6 +1590,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.IfExpression"), Core.projectionFieldName = (Core.Name "else")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the else field of hydra.haskell.syntax.IfExpression ifExpressionWithElse :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IfExpression ifExpressionWithElse original newVal = @@ -1497,6 +1614,7 @@ Core.Field { Core.fieldName = (Core.Name "else"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the then field of hydra.haskell.syntax.IfExpression ifExpressionWithThen :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IfExpression ifExpressionWithThen original newVal = @@ -1520,6 +1638,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.IfExpression"), Core.projectionFieldName = (Core.Name "else")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.Import import_ :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm (Maybe Syntax.ModuleName) -> Typed.TypedTerm (Maybe Syntax.ImportSpec) -> Typed.TypedTerm Syntax.Import import_ qualified module_ as spec = @@ -1538,6 +1657,7 @@ Core.Field { Core.fieldName = (Core.Name "spec"), Core.fieldTerm = (Typed.unTypedTerm spec)}]})) + -- | DSL accessor for the as field of hydra.haskell.syntax.Import importAs :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm (Maybe Syntax.ModuleName) importAs x = @@ -1546,6 +1666,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Import"), Core.projectionFieldName = (Core.Name "as")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL injection for the all variant of hydra.haskell.syntax.ImportExportSubspec importExportSubspecAll :: Typed.TypedTerm Syntax.ImportExportSubspec importExportSubspecAll = @@ -1554,6 +1675,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "all"), Core.fieldTerm = Core.TermUnit}})) + -- | DSL injection for the list variant of hydra.haskell.syntax.ImportExportSubspec importExportSubspecList :: Typed.TypedTerm [Syntax.Name] -> Typed.TypedTerm Syntax.ImportExportSubspec importExportSubspecList x = @@ -1562,6 +1684,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "list"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the pattern variant of hydra.haskell.syntax.ImportModifier importModifierPattern :: Typed.TypedTerm Syntax.ImportModifier importModifierPattern = @@ -1570,6 +1693,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "pattern"), Core.fieldTerm = Core.TermUnit}})) + -- | DSL injection for the type variant of hydra.haskell.syntax.ImportModifier importModifierType :: Typed.TypedTerm Syntax.ImportModifier importModifierType = @@ -1578,6 +1702,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "type"), Core.fieldTerm = Core.TermUnit}})) + -- | DSL accessor for the module field of hydra.haskell.syntax.Import importModule :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm Syntax.ModuleName importModule x = @@ -1586,6 +1711,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Import"), Core.projectionFieldName = (Core.Name "module")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the qualified field of hydra.haskell.syntax.Import importQualified :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm Bool importQualified x = @@ -1594,6 +1720,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Import"), Core.projectionFieldName = (Core.Name "qualified")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the spec field of hydra.haskell.syntax.Import importSpec :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm (Maybe Syntax.ImportSpec) importSpec x = @@ -1602,6 +1729,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Import"), Core.projectionFieldName = (Core.Name "spec")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL injection for the hiding variant of hydra.haskell.syntax.ImportSpec importSpecHiding :: Typed.TypedTerm [Syntax.NamedImportExport] -> Typed.TypedTerm Syntax.ImportSpec importSpecHiding x = @@ -1610,6 +1738,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "hiding"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the list variant of hydra.haskell.syntax.ImportSpec importSpecList :: Typed.TypedTerm [Syntax.NamedImportExport] -> Typed.TypedTerm Syntax.ImportSpec importSpecList x = @@ -1618,6 +1747,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "list"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL updater for the as field of hydra.haskell.syntax.Import importWithAs :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm (Maybe Syntax.ModuleName) -> Typed.TypedTerm Syntax.Import importWithAs original newVal = @@ -1648,6 +1778,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Import"), Core.projectionFieldName = (Core.Name "spec")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the module field of hydra.haskell.syntax.Import importWithModule :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm Syntax.Import importWithModule original newVal = @@ -1678,6 +1809,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Import"), Core.projectionFieldName = (Core.Name "spec")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the qualified field of hydra.haskell.syntax.Import importWithQualified :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Import importWithQualified original newVal = @@ -1708,6 +1840,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Import"), Core.projectionFieldName = (Core.Name "spec")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the spec field of hydra.haskell.syntax.Import importWithSpec :: Typed.TypedTerm Syntax.Import -> Typed.TypedTerm (Maybe Syntax.ImportSpec) -> Typed.TypedTerm Syntax.Import importWithSpec original newVal = @@ -1738,6 +1871,7 @@ Core.Field { Core.fieldName = (Core.Name "spec"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL constructor for hydra.haskell.syntax.InfixExpression infixExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Operator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.InfixExpression infixExpression lhs operator rhs = @@ -1753,6 +1887,7 @@ Core.Field { Core.fieldName = (Core.Name "rhs"), Core.fieldTerm = (Typed.unTypedTerm rhs)}]})) + -- | DSL accessor for the lhs field of hydra.haskell.syntax.InfixExpression infixExpressionLhs :: Typed.TypedTerm Syntax.InfixExpression -> Typed.TypedTerm Syntax.Expression infixExpressionLhs x = @@ -1761,6 +1896,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.InfixExpression"), Core.projectionFieldName = (Core.Name "lhs")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the operator field of hydra.haskell.syntax.InfixExpression infixExpressionOperator :: Typed.TypedTerm Syntax.InfixExpression -> Typed.TypedTerm Syntax.Operator infixExpressionOperator x = @@ -1769,6 +1905,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.InfixExpression"), Core.projectionFieldName = (Core.Name "operator")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the rhs field of hydra.haskell.syntax.InfixExpression infixExpressionRhs :: Typed.TypedTerm Syntax.InfixExpression -> Typed.TypedTerm Syntax.Expression infixExpressionRhs x = @@ -1777,6 +1914,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.InfixExpression"), Core.projectionFieldName = (Core.Name "rhs")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the lhs field of hydra.haskell.syntax.InfixExpression infixExpressionWithLhs :: Typed.TypedTerm Syntax.InfixExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.InfixExpression infixExpressionWithLhs original newVal = @@ -1800,6 +1938,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.InfixExpression"), Core.projectionFieldName = (Core.Name "rhs")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the operator field of hydra.haskell.syntax.InfixExpression infixExpressionWithOperator :: Typed.TypedTerm Syntax.InfixExpression -> Typed.TypedTerm Syntax.Operator -> Typed.TypedTerm Syntax.InfixExpression infixExpressionWithOperator original newVal = @@ -1823,6 +1962,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.InfixExpression"), Core.projectionFieldName = (Core.Name "rhs")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the rhs field of hydra.haskell.syntax.InfixExpression infixExpressionWithRhs :: Typed.TypedTerm Syntax.InfixExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.InfixExpression infixExpressionWithRhs original newVal = @@ -1846,6 +1986,7 @@ Core.Field { Core.fieldName = (Core.Name "rhs"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL constructor for hydra.haskell.syntax.InfixType infixType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Operator -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.InfixType infixType lhs operator rhs = @@ -1861,6 +2002,7 @@ Core.Field { Core.fieldName = (Core.Name "rhs"), Core.fieldTerm = (Typed.unTypedTerm rhs)}]})) + -- | DSL accessor for the lhs field of hydra.haskell.syntax.InfixType infixTypeLhs :: Typed.TypedTerm Syntax.InfixType -> Typed.TypedTerm Syntax.Type infixTypeLhs x = @@ -1869,6 +2011,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.InfixType"), Core.projectionFieldName = (Core.Name "lhs")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the operator field of hydra.haskell.syntax.InfixType infixTypeOperator :: Typed.TypedTerm Syntax.InfixType -> Typed.TypedTerm Syntax.Operator infixTypeOperator x = @@ -1877,6 +2020,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.InfixType"), Core.projectionFieldName = (Core.Name "operator")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the rhs field of hydra.haskell.syntax.InfixType infixTypeRhs :: Typed.TypedTerm Syntax.InfixType -> Typed.TypedTerm Syntax.Type infixTypeRhs x = @@ -1885,6 +2029,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.InfixType"), Core.projectionFieldName = (Core.Name "rhs")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the lhs field of hydra.haskell.syntax.InfixType infixTypeWithLhs :: Typed.TypedTerm Syntax.InfixType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.InfixType infixTypeWithLhs original newVal = @@ -1908,6 +2053,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.InfixType"), Core.projectionFieldName = (Core.Name "rhs")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the operator field of hydra.haskell.syntax.InfixType infixTypeWithOperator :: Typed.TypedTerm Syntax.InfixType -> Typed.TypedTerm Syntax.Operator -> Typed.TypedTerm Syntax.InfixType infixTypeWithOperator original newVal = @@ -1931,6 +2077,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.InfixType"), Core.projectionFieldName = (Core.Name "rhs")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the rhs field of hydra.haskell.syntax.InfixType infixTypeWithRhs :: Typed.TypedTerm Syntax.InfixType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.InfixType infixTypeWithRhs original newVal = @@ -1954,6 +2101,7 @@ Core.Field { Core.fieldName = (Core.Name "rhs"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL constructor for hydra.haskell.syntax.LambdaExpression lambdaExpression :: Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LambdaExpression lambdaExpression bindings inner = @@ -1966,6 +2114,7 @@ Core.Field { Core.fieldName = (Core.Name "inner"), Core.fieldTerm = (Typed.unTypedTerm inner)}]})) + -- | DSL accessor for the bindings field of hydra.haskell.syntax.LambdaExpression lambdaExpressionBindings :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm [Syntax.Pattern] lambdaExpressionBindings x = @@ -1974,6 +2123,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.LambdaExpression"), Core.projectionFieldName = (Core.Name "bindings")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the inner field of hydra.haskell.syntax.LambdaExpression lambdaExpressionInner :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.Expression lambdaExpressionInner x = @@ -1982,6 +2132,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.LambdaExpression"), Core.projectionFieldName = (Core.Name "inner")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the bindings field of hydra.haskell.syntax.LambdaExpression lambdaExpressionWithBindings :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.LambdaExpression lambdaExpressionWithBindings original newVal = @@ -1998,6 +2149,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.LambdaExpression"), Core.projectionFieldName = (Core.Name "inner")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the inner field of hydra.haskell.syntax.LambdaExpression lambdaExpressionWithInner :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LambdaExpression lambdaExpressionWithInner original newVal = @@ -2014,6 +2166,7 @@ Core.Field { Core.fieldName = (Core.Name "inner"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL constructor for hydra.haskell.syntax.LetExpression letExpression :: Typed.TypedTerm [Syntax.LocalBinding] -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LetExpression letExpression bindings inner = @@ -2026,6 +2179,7 @@ Core.Field { Core.fieldName = (Core.Name "inner"), Core.fieldTerm = (Typed.unTypedTerm inner)}]})) + -- | DSL accessor for the bindings field of hydra.haskell.syntax.LetExpression letExpressionBindings :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm [Syntax.LocalBinding] letExpressionBindings x = @@ -2034,6 +2188,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.LetExpression"), Core.projectionFieldName = (Core.Name "bindings")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the inner field of hydra.haskell.syntax.LetExpression letExpressionInner :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm Syntax.Expression letExpressionInner x = @@ -2042,6 +2197,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.LetExpression"), Core.projectionFieldName = (Core.Name "inner")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the bindings field of hydra.haskell.syntax.LetExpression letExpressionWithBindings :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm [Syntax.LocalBinding] -> Typed.TypedTerm Syntax.LetExpression letExpressionWithBindings original newVal = @@ -2058,6 +2214,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.LetExpression"), Core.projectionFieldName = (Core.Name "inner")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the inner field of hydra.haskell.syntax.LetExpression letExpressionWithInner :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LetExpression letExpressionWithInner original newVal = @@ -2074,6 +2231,7 @@ Core.Field { Core.fieldName = (Core.Name "inner"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL injection for the char variant of hydra.haskell.syntax.Literal literalChar :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.Literal literalChar x = @@ -2082,6 +2240,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "char"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the double variant of hydra.haskell.syntax.Literal literalDouble :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.Literal literalDouble x = @@ -2090,6 +2249,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "double"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the float variant of hydra.haskell.syntax.Literal literalFloat :: Typed.TypedTerm Float -> Typed.TypedTerm Syntax.Literal literalFloat x = @@ -2098,6 +2258,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "float"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the int variant of hydra.haskell.syntax.Literal literalInt :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.Literal literalInt x = @@ -2106,6 +2267,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "int"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the integer variant of hydra.haskell.syntax.Literal literalInteger :: Typed.TypedTerm Integer -> Typed.TypedTerm Syntax.Literal literalInteger x = @@ -2114,6 +2276,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "integer"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the string variant of hydra.haskell.syntax.Literal literalString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Literal literalString x = @@ -2122,6 +2285,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "string"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the signature variant of hydra.haskell.syntax.LocalBinding localBindingSignature :: Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.LocalBinding localBindingSignature x = @@ -2130,6 +2294,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "signature"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the value variant of hydra.haskell.syntax.LocalBinding localBindingValue :: Typed.TypedTerm Syntax.ValueBinding -> Typed.TypedTerm Syntax.LocalBinding localBindingValue x = @@ -2138,12 +2303,14 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "value"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL constructor for the hydra.haskell.syntax.LocalBindings wrapper localBindings :: Typed.TypedTerm [Syntax.LocalBinding] -> Typed.TypedTerm Syntax.LocalBindings localBindings x = Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.LocalBindings"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + -- | DSL constructor for hydra.haskell.syntax.Module module_ :: Typed.TypedTerm (Maybe Syntax.ModuleHead) -> Typed.TypedTerm [Syntax.Import] -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.Module module_ head imports declarations = @@ -2159,6 +2326,7 @@ Core.Field { Core.fieldName = (Core.Name "declarations"), Core.fieldTerm = (Typed.unTypedTerm declarations)}]})) + -- | DSL accessor for the declarations field of hydra.haskell.syntax.Module moduleDeclarations :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [Syntax.Declaration] moduleDeclarations x = @@ -2167,6 +2335,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Module"), Core.projectionFieldName = (Core.Name "declarations")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the head field of hydra.haskell.syntax.Module moduleHead :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm (Maybe Syntax.ModuleHead) moduleHead x = @@ -2175,6 +2344,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Module"), Core.projectionFieldName = (Core.Name "head")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL constructor for hydra.haskell.syntax.ModuleHead moduleHead2 :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm [Syntax.Export] -> Typed.TypedTerm Syntax.ModuleHead moduleHead2 comments name exports = @@ -2190,6 +2360,7 @@ Core.Field { Core.fieldName = (Core.Name "exports"), Core.fieldTerm = (Typed.unTypedTerm exports)}]})) + -- | DSL accessor for the comments field of hydra.haskell.syntax.ModuleHead moduleHeadComments :: Typed.TypedTerm Syntax.ModuleHead -> Typed.TypedTerm (Maybe String) moduleHeadComments x = @@ -2198,6 +2369,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ModuleHead"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the exports field of hydra.haskell.syntax.ModuleHead moduleHeadExports :: Typed.TypedTerm Syntax.ModuleHead -> Typed.TypedTerm [Syntax.Export] moduleHeadExports x = @@ -2206,6 +2378,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ModuleHead"), Core.projectionFieldName = (Core.Name "exports")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the name field of hydra.haskell.syntax.ModuleHead moduleHeadName :: Typed.TypedTerm Syntax.ModuleHead -> Typed.TypedTerm Syntax.ModuleName moduleHeadName x = @@ -2214,6 +2387,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ModuleHead"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the comments field of hydra.haskell.syntax.ModuleHead moduleHeadWithComments :: Typed.TypedTerm Syntax.ModuleHead -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.ModuleHead moduleHeadWithComments original newVal = @@ -2237,6 +2411,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ModuleHead"), Core.projectionFieldName = (Core.Name "exports")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the exports field of hydra.haskell.syntax.ModuleHead moduleHeadWithExports :: Typed.TypedTerm Syntax.ModuleHead -> Typed.TypedTerm [Syntax.Export] -> Typed.TypedTerm Syntax.ModuleHead moduleHeadWithExports original newVal = @@ -2260,6 +2435,7 @@ Core.Field { Core.fieldName = (Core.Name "exports"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the name field of hydra.haskell.syntax.ModuleHead moduleHeadWithName :: Typed.TypedTerm Syntax.ModuleHead -> Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm Syntax.ModuleHead moduleHeadWithName original newVal = @@ -2283,6 +2459,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.ModuleHead"), Core.projectionFieldName = (Core.Name "exports")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL accessor for the imports field of hydra.haskell.syntax.Module moduleImports :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [Syntax.Import] moduleImports x = @@ -2291,12 +2468,14 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Module"), Core.projectionFieldName = (Core.Name "imports")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL constructor for the hydra.haskell.syntax.ModuleName wrapper moduleName :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ModuleName moduleName x = Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.ModuleName"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + -- | DSL updater for the declarations field of hydra.haskell.syntax.Module moduleWithDeclarations :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.Module moduleWithDeclarations original newVal = @@ -2320,6 +2499,7 @@ Core.Field { Core.fieldName = (Core.Name "declarations"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the head field of hydra.haskell.syntax.Module moduleWithHead :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm (Maybe Syntax.ModuleHead) -> Typed.TypedTerm Syntax.Module moduleWithHead original newVal = @@ -2343,6 +2523,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Module"), Core.projectionFieldName = (Core.Name "declarations")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the imports field of hydra.haskell.syntax.Module moduleWithImports :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [Syntax.Import] -> Typed.TypedTerm Syntax.Module moduleWithImports original newVal = @@ -2366,6 +2547,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.Module"), Core.projectionFieldName = (Core.Name "declarations")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL injection for the implicit variant of hydra.haskell.syntax.Name nameImplicit :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm Syntax.Name nameImplicit x = @@ -2374,6 +2556,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "implicit"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the normal variant of hydra.haskell.syntax.Name nameNormal :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm Syntax.Name nameNormal x = @@ -2382,12 +2565,14 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "normal"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL constructor for the hydra.haskell.syntax.NamePart wrapper namePart :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.NamePart namePart x = Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.NamePart"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + -- | DSL constructor for hydra.haskell.syntax.NamedImportExport namedImportExport :: Typed.TypedTerm (Maybe Syntax.ImportModifier) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ImportExportSubspec) -> Typed.TypedTerm Syntax.NamedImportExport namedImportExport modifier name subspec = @@ -2403,6 +2588,7 @@ Core.Field { Core.fieldName = (Core.Name "subspec"), Core.fieldTerm = (Typed.unTypedTerm subspec)}]})) + -- | DSL accessor for the modifier field of hydra.haskell.syntax.NamedImportExport namedImportExportModifier :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm (Maybe Syntax.ImportModifier) namedImportExportModifier x = @@ -2411,6 +2597,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.NamedImportExport"), Core.projectionFieldName = (Core.Name "modifier")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the name field of hydra.haskell.syntax.NamedImportExport namedImportExportName :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm Syntax.Name namedImportExportName x = @@ -2419,6 +2606,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.NamedImportExport"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the subspec field of hydra.haskell.syntax.NamedImportExport namedImportExportSubspec :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm (Maybe Syntax.ImportExportSubspec) namedImportExportSubspec x = @@ -2427,6 +2615,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.NamedImportExport"), Core.projectionFieldName = (Core.Name "subspec")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the modifier field of hydra.haskell.syntax.NamedImportExport namedImportExportWithModifier :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm (Maybe Syntax.ImportModifier) -> Typed.TypedTerm Syntax.NamedImportExport namedImportExportWithModifier original newVal = @@ -2450,6 +2639,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.NamedImportExport"), Core.projectionFieldName = (Core.Name "subspec")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the name field of hydra.haskell.syntax.NamedImportExport namedImportExportWithName :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.NamedImportExport namedImportExportWithName original newVal = @@ -2473,6 +2663,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.NamedImportExport"), Core.projectionFieldName = (Core.Name "subspec")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the subspec field of hydra.haskell.syntax.NamedImportExport namedImportExportWithSubspec :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm (Maybe Syntax.ImportExportSubspec) -> Typed.TypedTerm Syntax.NamedImportExport namedImportExportWithSubspec original newVal = @@ -2496,6 +2687,7 @@ Core.Field { Core.fieldName = (Core.Name "subspec"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL injection for the backtick variant of hydra.haskell.syntax.Operator operatorBacktick :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm Syntax.Operator operatorBacktick x = @@ -2504,6 +2696,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "backtick"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the normal variant of hydra.haskell.syntax.Operator operatorNormal :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm Syntax.Operator operatorNormal x = @@ -2512,6 +2705,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "normal"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the application variant of hydra.haskell.syntax.Pattern patternApplication :: Typed.TypedTerm Syntax.ApplicationPattern -> Typed.TypedTerm Syntax.Pattern patternApplication x = @@ -2520,6 +2714,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "application"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the as variant of hydra.haskell.syntax.Pattern patternAs :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.Pattern patternAs x = @@ -2528,6 +2723,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "as"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL constructor for hydra.haskell.syntax.PatternField patternField :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.PatternField patternField name pattern = @@ -2540,6 +2736,7 @@ Core.Field { Core.fieldName = (Core.Name "pattern"), Core.fieldTerm = (Typed.unTypedTerm pattern)}]})) + -- | DSL accessor for the name field of hydra.haskell.syntax.PatternField patternFieldName :: Typed.TypedTerm Syntax.PatternField -> Typed.TypedTerm Syntax.Name patternFieldName x = @@ -2548,6 +2745,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.PatternField"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the pattern field of hydra.haskell.syntax.PatternField patternFieldPattern :: Typed.TypedTerm Syntax.PatternField -> Typed.TypedTerm Syntax.Pattern patternFieldPattern x = @@ -2556,6 +2754,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.PatternField"), Core.projectionFieldName = (Core.Name "pattern")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the name field of hydra.haskell.syntax.PatternField patternFieldWithName :: Typed.TypedTerm Syntax.PatternField -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.PatternField patternFieldWithName original newVal = @@ -2572,6 +2771,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.PatternField"), Core.projectionFieldName = (Core.Name "pattern")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the pattern field of hydra.haskell.syntax.PatternField patternFieldWithPattern :: Typed.TypedTerm Syntax.PatternField -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.PatternField patternFieldWithPattern original newVal = @@ -2588,6 +2788,7 @@ Core.Field { Core.fieldName = (Core.Name "pattern"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL injection for the list variant of hydra.haskell.syntax.Pattern patternList :: Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.Pattern patternList x = @@ -2596,6 +2797,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "list"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the literal variant of hydra.haskell.syntax.Pattern patternLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.Pattern patternLiteral x = @@ -2604,6 +2806,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "literal"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the name variant of hydra.haskell.syntax.Pattern patternName :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Pattern patternName x = @@ -2612,6 +2815,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "name"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the record variant of hydra.haskell.syntax.Pattern patternRecord :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm Syntax.Pattern patternRecord x = @@ -2620,6 +2824,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "record"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the tuple variant of hydra.haskell.syntax.Pattern patternTuple :: Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.Pattern patternTuple x = @@ -2628,6 +2833,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "tuple"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the typed variant of hydra.haskell.syntax.Pattern patternTyped :: Typed.TypedTerm Syntax.TypedPattern -> Typed.TypedTerm Syntax.Pattern patternTyped x = @@ -2636,6 +2842,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "typed"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the wildcard variant of hydra.haskell.syntax.Pattern patternWildcard :: Typed.TypedTerm Syntax.Pattern patternWildcard = @@ -2644,6 +2851,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "wildcard"), Core.fieldTerm = Core.TermUnit}})) + -- | DSL constructor for hydra.haskell.syntax.PositionalConstructor positionalConstructor :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.PositionalConstructor positionalConstructor name fields comments = @@ -2659,6 +2867,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm comments)}]})) + -- | DSL accessor for the comments field of hydra.haskell.syntax.PositionalConstructor positionalConstructorComments :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm (Maybe String) positionalConstructorComments x = @@ -2667,6 +2876,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.PositionalConstructor"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the fields field of hydra.haskell.syntax.PositionalConstructor positionalConstructorFields :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm [Syntax.Type] positionalConstructorFields x = @@ -2675,6 +2885,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.PositionalConstructor"), Core.projectionFieldName = (Core.Name "fields")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the name field of hydra.haskell.syntax.PositionalConstructor positionalConstructorName :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm Syntax.Name positionalConstructorName x = @@ -2683,6 +2894,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.PositionalConstructor"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the comments field of hydra.haskell.syntax.PositionalConstructor positionalConstructorWithComments :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.PositionalConstructor positionalConstructorWithComments original newVal = @@ -2706,6 +2918,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the fields field of hydra.haskell.syntax.PositionalConstructor positionalConstructorWithFields :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.PositionalConstructor positionalConstructorWithFields original newVal = @@ -2729,6 +2942,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.PositionalConstructor"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the name field of hydra.haskell.syntax.PositionalConstructor positionalConstructorWithName :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.PositionalConstructor positionalConstructorWithName original newVal = @@ -2752,6 +2966,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.PositionalConstructor"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.QualifiedName qualifiedName :: Typed.TypedTerm [Syntax.NamePart] -> Typed.TypedTerm Syntax.NamePart -> Typed.TypedTerm Syntax.QualifiedName qualifiedName qualifiers unqualified = @@ -2764,6 +2979,7 @@ Core.Field { Core.fieldName = (Core.Name "unqualified"), Core.fieldTerm = (Typed.unTypedTerm unqualified)}]})) + -- | DSL accessor for the qualifiers field of hydra.haskell.syntax.QualifiedName qualifiedNameQualifiers :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm [Syntax.NamePart] qualifiedNameQualifiers x = @@ -2772,6 +2988,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.QualifiedName"), Core.projectionFieldName = (Core.Name "qualifiers")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the unqualified field of hydra.haskell.syntax.QualifiedName qualifiedNameUnqualified :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm Syntax.NamePart qualifiedNameUnqualified x = @@ -2780,6 +2997,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.QualifiedName"), Core.projectionFieldName = (Core.Name "unqualified")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the qualifiers field of hydra.haskell.syntax.QualifiedName qualifiedNameWithQualifiers :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm [Syntax.NamePart] -> Typed.TypedTerm Syntax.QualifiedName qualifiedNameWithQualifiers original newVal = @@ -2796,6 +3014,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.QualifiedName"), Core.projectionFieldName = (Core.Name "unqualified")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the unqualified field of hydra.haskell.syntax.QualifiedName qualifiedNameWithUnqualified :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm Syntax.NamePart -> Typed.TypedTerm Syntax.QualifiedName qualifiedNameWithUnqualified original newVal = @@ -2812,6 +3031,7 @@ Core.Field { Core.fieldName = (Core.Name "unqualified"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL constructor for hydra.haskell.syntax.RecordConstructor recordConstructor :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.Field] -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.RecordConstructor recordConstructor name fields comments = @@ -2827,6 +3047,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm comments)}]})) + -- | DSL accessor for the comments field of hydra.haskell.syntax.RecordConstructor recordConstructorComments :: Typed.TypedTerm Syntax.RecordConstructor -> Typed.TypedTerm (Maybe String) recordConstructorComments x = @@ -2835,6 +3056,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordConstructor"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the fields field of hydra.haskell.syntax.RecordConstructor recordConstructorFields :: Typed.TypedTerm Syntax.RecordConstructor -> Typed.TypedTerm [Syntax.Field] recordConstructorFields x = @@ -2843,6 +3065,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordConstructor"), Core.projectionFieldName = (Core.Name "fields")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the name field of hydra.haskell.syntax.RecordConstructor recordConstructorName :: Typed.TypedTerm Syntax.RecordConstructor -> Typed.TypedTerm Syntax.Name recordConstructorName x = @@ -2851,6 +3074,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordConstructor"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the comments field of hydra.haskell.syntax.RecordConstructor recordConstructorWithComments :: Typed.TypedTerm Syntax.RecordConstructor -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.RecordConstructor recordConstructorWithComments original newVal = @@ -2874,6 +3098,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the fields field of hydra.haskell.syntax.RecordConstructor recordConstructorWithFields :: Typed.TypedTerm Syntax.RecordConstructor -> Typed.TypedTerm [Syntax.Field] -> Typed.TypedTerm Syntax.RecordConstructor recordConstructorWithFields original newVal = @@ -2897,6 +3122,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordConstructor"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the name field of hydra.haskell.syntax.RecordConstructor recordConstructorWithName :: Typed.TypedTerm Syntax.RecordConstructor -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.RecordConstructor recordConstructorWithName original newVal = @@ -2920,6 +3146,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordConstructor"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.RecordExpression recordExpression :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.FieldUpdate] -> Typed.TypedTerm Syntax.RecordExpression recordExpression name fields = @@ -2932,6 +3159,7 @@ Core.Field { Core.fieldName = (Core.Name "fields"), Core.fieldTerm = (Typed.unTypedTerm fields)}]})) + -- | DSL accessor for the fields field of hydra.haskell.syntax.RecordExpression recordExpressionFields :: Typed.TypedTerm Syntax.RecordExpression -> Typed.TypedTerm [Syntax.FieldUpdate] recordExpressionFields x = @@ -2940,6 +3168,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordExpression"), Core.projectionFieldName = (Core.Name "fields")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the name field of hydra.haskell.syntax.RecordExpression recordExpressionName :: Typed.TypedTerm Syntax.RecordExpression -> Typed.TypedTerm Syntax.Name recordExpressionName x = @@ -2948,6 +3177,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordExpression"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the fields field of hydra.haskell.syntax.RecordExpression recordExpressionWithFields :: Typed.TypedTerm Syntax.RecordExpression -> Typed.TypedTerm [Syntax.FieldUpdate] -> Typed.TypedTerm Syntax.RecordExpression recordExpressionWithFields original newVal = @@ -2964,6 +3194,7 @@ Core.Field { Core.fieldName = (Core.Name "fields"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the name field of hydra.haskell.syntax.RecordExpression recordExpressionWithName :: Typed.TypedTerm Syntax.RecordExpression -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.RecordExpression recordExpressionWithName original newVal = @@ -2980,6 +3211,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordExpression"), Core.projectionFieldName = (Core.Name "fields")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.RecordPattern recordPattern :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.PatternField] -> Typed.TypedTerm Syntax.RecordPattern recordPattern name fields = @@ -2992,6 +3224,7 @@ Core.Field { Core.fieldName = (Core.Name "fields"), Core.fieldTerm = (Typed.unTypedTerm fields)}]})) + -- | DSL accessor for the fields field of hydra.haskell.syntax.RecordPattern recordPatternFields :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm [Syntax.PatternField] recordPatternFields x = @@ -3000,6 +3233,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordPattern"), Core.projectionFieldName = (Core.Name "fields")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the name field of hydra.haskell.syntax.RecordPattern recordPatternName :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm Syntax.Name recordPatternName x = @@ -3008,6 +3242,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordPattern"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the fields field of hydra.haskell.syntax.RecordPattern recordPatternWithFields :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm [Syntax.PatternField] -> Typed.TypedTerm Syntax.RecordPattern recordPatternWithFields original newVal = @@ -3024,6 +3259,7 @@ Core.Field { Core.fieldName = (Core.Name "fields"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the name field of hydra.haskell.syntax.RecordPattern recordPatternWithName :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.RecordPattern recordPatternWithName original newVal = @@ -3040,6 +3276,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordPattern"), Core.projectionFieldName = (Core.Name "fields")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.RecordUpdateExpression recordUpdateExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm [Syntax.FieldUpdate] -> Typed.TypedTerm Syntax.RecordUpdateExpression recordUpdateExpression inner fields = @@ -3052,6 +3289,7 @@ Core.Field { Core.fieldName = (Core.Name "fields"), Core.fieldTerm = (Typed.unTypedTerm fields)}]})) + -- | DSL accessor for the fields field of hydra.haskell.syntax.RecordUpdateExpression recordUpdateExpressionFields :: Typed.TypedTerm Syntax.RecordUpdateExpression -> Typed.TypedTerm [Syntax.FieldUpdate] recordUpdateExpressionFields x = @@ -3060,6 +3298,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordUpdateExpression"), Core.projectionFieldName = (Core.Name "fields")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the inner field of hydra.haskell.syntax.RecordUpdateExpression recordUpdateExpressionInner :: Typed.TypedTerm Syntax.RecordUpdateExpression -> Typed.TypedTerm Syntax.Expression recordUpdateExpressionInner x = @@ -3068,6 +3307,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordUpdateExpression"), Core.projectionFieldName = (Core.Name "inner")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the fields field of hydra.haskell.syntax.RecordUpdateExpression recordUpdateExpressionWithFields :: Typed.TypedTerm Syntax.RecordUpdateExpression -> Typed.TypedTerm [Syntax.FieldUpdate] -> Typed.TypedTerm Syntax.RecordUpdateExpression recordUpdateExpressionWithFields original newVal = @@ -3084,6 +3324,7 @@ Core.Field { Core.fieldName = (Core.Name "fields"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the inner field of hydra.haskell.syntax.RecordUpdateExpression recordUpdateExpressionWithInner :: Typed.TypedTerm Syntax.RecordUpdateExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.RecordUpdateExpression recordUpdateExpressionWithInner original newVal = @@ -3100,12 +3341,14 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.RecordUpdateExpression"), Core.projectionFieldName = (Core.Name "fields")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for the hydra.haskell.syntax.RightHandSide wrapper rightHandSide :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.RightHandSide rightHandSide x = Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.RightHandSide"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + -- | DSL constructor for hydra.haskell.syntax.SectionExpression sectionExpression :: Typed.TypedTerm Syntax.Operator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SectionExpression sectionExpression operator expression = @@ -3118,6 +3361,7 @@ Core.Field { Core.fieldName = (Core.Name "expression"), Core.fieldTerm = (Typed.unTypedTerm expression)}]})) + -- | DSL accessor for the expression field of hydra.haskell.syntax.SectionExpression sectionExpressionExpression :: Typed.TypedTerm Syntax.SectionExpression -> Typed.TypedTerm Syntax.Expression sectionExpressionExpression x = @@ -3126,6 +3370,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.SectionExpression"), Core.projectionFieldName = (Core.Name "expression")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the operator field of hydra.haskell.syntax.SectionExpression sectionExpressionOperator :: Typed.TypedTerm Syntax.SectionExpression -> Typed.TypedTerm Syntax.Operator sectionExpressionOperator x = @@ -3134,6 +3379,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.SectionExpression"), Core.projectionFieldName = (Core.Name "operator")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the expression field of hydra.haskell.syntax.SectionExpression sectionExpressionWithExpression :: Typed.TypedTerm Syntax.SectionExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SectionExpression sectionExpressionWithExpression original newVal = @@ -3150,6 +3396,7 @@ Core.Field { Core.fieldName = (Core.Name "expression"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the operator field of hydra.haskell.syntax.SectionExpression sectionExpressionWithOperator :: Typed.TypedTerm Syntax.SectionExpression -> Typed.TypedTerm Syntax.Operator -> Typed.TypedTerm Syntax.SectionExpression sectionExpressionWithOperator original newVal = @@ -3166,6 +3413,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.SectionExpression"), Core.projectionFieldName = (Core.Name "expression")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.SimpleValueBinding simpleValueBinding :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.RightHandSide -> Typed.TypedTerm (Maybe Syntax.LocalBindings) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.SimpleValueBinding simpleValueBinding pattern rhs localBindings comments = @@ -3184,6 +3432,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm comments)}]})) + -- | DSL accessor for the comments field of hydra.haskell.syntax.SimpleValueBinding simpleValueBindingComments :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm (Maybe String) simpleValueBindingComments x = @@ -3192,6 +3441,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.SimpleValueBinding"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the localBindings field of hydra.haskell.syntax.SimpleValueBinding simpleValueBindingLocalBindings :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm (Maybe Syntax.LocalBindings) simpleValueBindingLocalBindings x = @@ -3200,6 +3450,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.SimpleValueBinding"), Core.projectionFieldName = (Core.Name "localBindings")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the pattern field of hydra.haskell.syntax.SimpleValueBinding simpleValueBindingPattern :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm Syntax.Pattern simpleValueBindingPattern x = @@ -3208,6 +3459,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.SimpleValueBinding"), Core.projectionFieldName = (Core.Name "pattern")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the rhs field of hydra.haskell.syntax.SimpleValueBinding simpleValueBindingRhs :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm Syntax.RightHandSide simpleValueBindingRhs x = @@ -3216,6 +3468,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.SimpleValueBinding"), Core.projectionFieldName = (Core.Name "rhs")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the comments field of hydra.haskell.syntax.SimpleValueBinding simpleValueBindingWithComments :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.SimpleValueBinding simpleValueBindingWithComments original newVal = @@ -3246,6 +3499,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the localBindings field of hydra.haskell.syntax.SimpleValueBinding simpleValueBindingWithLocalBindings :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm (Maybe Syntax.LocalBindings) -> Typed.TypedTerm Syntax.SimpleValueBinding simpleValueBindingWithLocalBindings original newVal = @@ -3276,6 +3530,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.SimpleValueBinding"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the pattern field of hydra.haskell.syntax.SimpleValueBinding simpleValueBindingWithPattern :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.SimpleValueBinding simpleValueBindingWithPattern original newVal = @@ -3306,6 +3561,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.SimpleValueBinding"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the rhs field of hydra.haskell.syntax.SimpleValueBinding simpleValueBindingWithRhs :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm Syntax.RightHandSide -> Typed.TypedTerm Syntax.SimpleValueBinding simpleValueBindingWithRhs original newVal = @@ -3336,12 +3592,14 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.SimpleValueBinding"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for the hydra.haskell.syntax.Statement wrapper statement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement statement x = Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm { Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.Statement"), Core.wrappedTermBody = (Typed.unTypedTerm x)})) + -- | DSL injection for the application variant of hydra.haskell.syntax.Type typeApplication :: Typed.TypedTerm Syntax.ApplicationType -> Typed.TypedTerm Syntax.Type typeApplication x = @@ -3350,6 +3608,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "application"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the ctx variant of hydra.haskell.syntax.Type typeCtx :: Typed.TypedTerm Syntax.ConstrainedType -> Typed.TypedTerm Syntax.Type typeCtx x = @@ -3358,6 +3617,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "ctx"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the function variant of hydra.haskell.syntax.Type typeFunction :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type typeFunction x = @@ -3366,6 +3626,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "function"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the infix variant of hydra.haskell.syntax.Type typeInfix :: Typed.TypedTerm Syntax.InfixType -> Typed.TypedTerm Syntax.Type typeInfix x = @@ -3374,6 +3635,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "infix"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the list variant of hydra.haskell.syntax.Type typeList :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Type typeList x = @@ -3382,6 +3644,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "list"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL constructor for hydra.haskell.syntax.TypeSignature typeSignature :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeSignature typeSignature name type_ = @@ -3394,6 +3657,7 @@ Core.Field { Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm type_)}]})) + -- | DSL accessor for the name field of hydra.haskell.syntax.TypeSignature typeSignatureName :: Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.Name typeSignatureName x = @@ -3402,6 +3666,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypeSignature"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the type field of hydra.haskell.syntax.TypeSignature typeSignatureType :: Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.Type typeSignatureType x = @@ -3410,6 +3675,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypeSignature"), Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the name field of hydra.haskell.syntax.TypeSignature typeSignatureWithName :: Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.TypeSignature typeSignatureWithName original newVal = @@ -3426,6 +3692,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypeSignature"), Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the type field of hydra.haskell.syntax.TypeSignature typeSignatureWithType :: Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeSignature typeSignatureWithType original newVal = @@ -3442,6 +3709,7 @@ Core.Field { Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL constructor for hydra.haskell.syntax.TypeSynonymDeclaration typeSynonymDeclaration :: Typed.TypedTerm Syntax.DeclarationHead -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.TypeSynonymDeclaration typeSynonymDeclaration name type_ comments = @@ -3457,6 +3725,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm comments)}]})) + -- | DSL accessor for the comments field of hydra.haskell.syntax.TypeSynonymDeclaration typeSynonymDeclarationComments :: Typed.TypedTerm Syntax.TypeSynonymDeclaration -> Typed.TypedTerm (Maybe String) typeSynonymDeclarationComments x = @@ -3465,6 +3734,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypeSynonymDeclaration"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the name field of hydra.haskell.syntax.TypeSynonymDeclaration typeSynonymDeclarationName :: Typed.TypedTerm Syntax.TypeSynonymDeclaration -> Typed.TypedTerm Syntax.DeclarationHead typeSynonymDeclarationName x = @@ -3473,6 +3743,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypeSynonymDeclaration"), Core.projectionFieldName = (Core.Name "name")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the type field of hydra.haskell.syntax.TypeSynonymDeclaration typeSynonymDeclarationType :: Typed.TypedTerm Syntax.TypeSynonymDeclaration -> Typed.TypedTerm Syntax.Type typeSynonymDeclarationType x = @@ -3481,6 +3752,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypeSynonymDeclaration"), Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the comments field of hydra.haskell.syntax.TypeSynonymDeclaration typeSynonymDeclarationWithComments :: Typed.TypedTerm Syntax.TypeSynonymDeclaration -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.TypeSynonymDeclaration typeSynonymDeclarationWithComments original newVal = @@ -3504,6 +3776,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the name field of hydra.haskell.syntax.TypeSynonymDeclaration typeSynonymDeclarationWithName :: Typed.TypedTerm Syntax.TypeSynonymDeclaration -> Typed.TypedTerm Syntax.DeclarationHead -> Typed.TypedTerm Syntax.TypeSynonymDeclaration typeSynonymDeclarationWithName original newVal = @@ -3527,6 +3800,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypeSynonymDeclaration"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the type field of hydra.haskell.syntax.TypeSynonymDeclaration typeSynonymDeclarationWithType :: Typed.TypedTerm Syntax.TypeSynonymDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeSynonymDeclaration typeSynonymDeclarationWithType original newVal = @@ -3550,6 +3824,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypeSynonymDeclaration"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL injection for the tuple variant of hydra.haskell.syntax.Type typeTuple :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.Type typeTuple x = @@ -3558,6 +3833,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "tuple"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL injection for the variable variant of hydra.haskell.syntax.Type typeVariable :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Type typeVariable x = @@ -3566,6 +3842,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "variable"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL constructor for hydra.haskell.syntax.TypedBinding typedBinding :: Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.ValueBinding -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.TypedBinding typedBinding typeSignature valueBinding comments = @@ -3581,6 +3858,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm comments)}]})) + -- | DSL accessor for the comments field of hydra.haskell.syntax.TypedBinding typedBindingComments :: Typed.TypedTerm Syntax.TypedBinding -> Typed.TypedTerm (Maybe String) typedBindingComments x = @@ -3589,6 +3867,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedBinding"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the typeSignature field of hydra.haskell.syntax.TypedBinding typedBindingTypeSignature :: Typed.TypedTerm Syntax.TypedBinding -> Typed.TypedTerm Syntax.TypeSignature typedBindingTypeSignature x = @@ -3597,6 +3876,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedBinding"), Core.projectionFieldName = (Core.Name "typeSignature")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the valueBinding field of hydra.haskell.syntax.TypedBinding typedBindingValueBinding :: Typed.TypedTerm Syntax.TypedBinding -> Typed.TypedTerm Syntax.ValueBinding typedBindingValueBinding x = @@ -3605,6 +3885,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedBinding"), Core.projectionFieldName = (Core.Name "valueBinding")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the comments field of hydra.haskell.syntax.TypedBinding typedBindingWithComments :: Typed.TypedTerm Syntax.TypedBinding -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.TypedBinding typedBindingWithComments original newVal = @@ -3628,6 +3909,7 @@ Core.Field { Core.fieldName = (Core.Name "comments"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL updater for the typeSignature field of hydra.haskell.syntax.TypedBinding typedBindingWithTypeSignature :: Typed.TypedTerm Syntax.TypedBinding -> Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.TypedBinding typedBindingWithTypeSignature original newVal = @@ -3651,6 +3933,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedBinding"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the valueBinding field of hydra.haskell.syntax.TypedBinding typedBindingWithValueBinding :: Typed.TypedTerm Syntax.TypedBinding -> Typed.TypedTerm Syntax.ValueBinding -> Typed.TypedTerm Syntax.TypedBinding typedBindingWithValueBinding original newVal = @@ -3674,6 +3957,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedBinding"), Core.projectionFieldName = (Core.Name "comments")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL constructor for hydra.haskell.syntax.TypedExpression typedExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedExpression typedExpression inner type_ = @@ -3686,6 +3970,7 @@ Core.Field { Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm type_)}]})) + -- | DSL accessor for the inner field of hydra.haskell.syntax.TypedExpression typedExpressionInner :: Typed.TypedTerm Syntax.TypedExpression -> Typed.TypedTerm Syntax.Expression typedExpressionInner x = @@ -3694,6 +3979,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedExpression"), Core.projectionFieldName = (Core.Name "inner")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the type field of hydra.haskell.syntax.TypedExpression typedExpressionType :: Typed.TypedTerm Syntax.TypedExpression -> Typed.TypedTerm Syntax.Type typedExpressionType x = @@ -3702,6 +3988,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedExpression"), Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the inner field of hydra.haskell.syntax.TypedExpression typedExpressionWithInner :: Typed.TypedTerm Syntax.TypedExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypedExpression typedExpressionWithInner original newVal = @@ -3718,6 +4005,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedExpression"), Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the type field of hydra.haskell.syntax.TypedExpression typedExpressionWithType :: Typed.TypedTerm Syntax.TypedExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedExpression typedExpressionWithType original newVal = @@ -3734,6 +4022,7 @@ Core.Field { Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL constructor for hydra.haskell.syntax.TypedPattern typedPattern :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedPattern typedPattern inner type_ = @@ -3746,6 +4035,7 @@ Core.Field { Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm type_)}]})) + -- | DSL accessor for the inner field of hydra.haskell.syntax.TypedPattern typedPatternInner :: Typed.TypedTerm Syntax.TypedPattern -> Typed.TypedTerm Syntax.Pattern typedPatternInner x = @@ -3754,6 +4044,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedPattern"), Core.projectionFieldName = (Core.Name "inner")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the type field of hydra.haskell.syntax.TypedPattern typedPatternType :: Typed.TypedTerm Syntax.TypedPattern -> Typed.TypedTerm Syntax.Type typedPatternType x = @@ -3762,6 +4053,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedPattern"), Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL updater for the inner field of hydra.haskell.syntax.TypedPattern typedPatternWithInner :: Typed.TypedTerm Syntax.TypedPattern -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.TypedPattern typedPatternWithInner original newVal = @@ -3778,6 +4070,7 @@ Core.projectionTypeName = (Core.Name "hydra.haskell.syntax.TypedPattern"), Core.projectionFieldName = (Core.Name "type")})), Core.applicationArgument = (Typed.unTypedTerm original)}))}]})) + -- | DSL updater for the type field of hydra.haskell.syntax.TypedPattern typedPatternWithType :: Typed.TypedTerm Syntax.TypedPattern -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypedPattern typedPatternWithType original newVal = @@ -3794,54 +4087,63 @@ Core.Field { Core.fieldName = (Core.Name "type"), Core.fieldTerm = (Typed.unTypedTerm newVal)}]})) + -- | DSL accessor for the body of hydra.haskell.syntax.CaseRhs unCaseRhs :: Typed.TypedTerm Syntax.CaseRhs -> Typed.TypedTerm Syntax.Expression unCaseRhs x = Typed.TypedTerm (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.haskell.syntax.CaseRhs")), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the body of hydra.haskell.syntax.DerivingClause unDerivingClause :: Typed.TypedTerm Syntax.DerivingClause -> Typed.TypedTerm [Syntax.Name] unDerivingClause x = Typed.TypedTerm (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.haskell.syntax.DerivingClause")), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the body of hydra.haskell.syntax.LocalBindings unLocalBindings :: Typed.TypedTerm Syntax.LocalBindings -> Typed.TypedTerm [Syntax.LocalBinding] unLocalBindings x = Typed.TypedTerm (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.haskell.syntax.LocalBindings")), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the body of hydra.haskell.syntax.ModuleName unModuleName :: Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm String unModuleName x = Typed.TypedTerm (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.haskell.syntax.ModuleName")), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the body of hydra.haskell.syntax.NamePart unNamePart :: Typed.TypedTerm Syntax.NamePart -> Typed.TypedTerm String unNamePart x = Typed.TypedTerm (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.haskell.syntax.NamePart")), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the body of hydra.haskell.syntax.RightHandSide unRightHandSide :: Typed.TypedTerm Syntax.RightHandSide -> Typed.TypedTerm Syntax.Expression unRightHandSide x = Typed.TypedTerm (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.haskell.syntax.RightHandSide")), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the body of hydra.haskell.syntax.Statement unStatement :: Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.Expression unStatement x = Typed.TypedTerm (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.haskell.syntax.Statement")), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL accessor for the body of hydra.haskell.syntax.Variable unVariable :: Typed.TypedTerm Syntax.Variable -> Typed.TypedTerm Syntax.Name unVariable x = Typed.TypedTerm (Core.TermApplication (Core.Application { Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.haskell.syntax.Variable")), Core.applicationArgument = (Typed.unTypedTerm x)})) + -- | DSL injection for the simple variant of hydra.haskell.syntax.ValueBinding valueBindingSimple :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm Syntax.ValueBinding valueBindingSimple x = @@ -3850,6 +4152,7 @@ Core.injectionField = Core.Field { Core.fieldName = (Core.Name "simple"), Core.fieldTerm = (Typed.unTypedTerm x)}})) + -- | DSL constructor for the hydra.haskell.syntax.Variable wrapper variable :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Variable variable x = diff --git a/src/main/haskell/Hydra/Haskell/Coder.hs b/src/main/haskell/Hydra/Haskell/Coder.hs --- a/src/main/haskell/Hydra/Haskell/Coder.hs +++ b/src/main/haskell/Hydra/Haskell/Coder.hs @@ -1,7 +1,9 @@ -- Note: this is an automatically generated file. Do not edit. + -- | Functions for encoding Hydra modules as Haskell modules module Hydra.Haskell.Coder where + import qualified Hydra.Adapt as Adapt import qualified Hydra.Analysis as Analysis import qualified Hydra.Annotations as Annotations @@ -10,11 +12,15 @@ import qualified Hydra.Constants as Constants import qualified Hydra.Core as Core import qualified Hydra.Dependencies as Dependencies +import qualified Hydra.Docs as Docs import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors +import qualified Hydra.File as File import qualified Hydra.Formatting as Formatting import qualified Hydra.Graph as Graph import qualified Hydra.Haskell.Environment as Environment @@ -24,17 +30,17 @@ import qualified Hydra.Haskell.Utils as Utils import qualified Hydra.Json.Model as Model import qualified Hydra.Lexical as Lexical -import qualified Hydra.Haskell.Lib.Eithers as Eithers -import qualified Hydra.Haskell.Lib.Equality as Equality -import qualified Hydra.Haskell.Lib.Lists as Lists -import qualified Hydra.Haskell.Lib.Literals as Literals -import qualified Hydra.Haskell.Lib.Logic as Logic -import qualified Hydra.Haskell.Lib.Maps as Maps -import qualified Hydra.Haskell.Lib.Math as Math -import qualified Hydra.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Haskell.Lib.Sets as Sets -import qualified Hydra.Haskell.Lib.Strings as Strings +import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Overlay.Haskell.Lib.Math as Math +import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Names as Names import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing @@ -49,8 +55,10 @@ import qualified Hydra.Show.Core as ShowCore import qualified Hydra.Show.Errors as ShowErrors import qualified Hydra.Strip as Strip +import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -62,6 +70,7 @@ import qualified Data.Scientific as Sci import qualified Data.Map as M import qualified Data.Set as S + -- | Adapt a Hydra type to Haskell's type system and encode it adaptTypeToHaskellAndEncode :: Util.ModuleNames Syntax.ModuleName -> Core.Type -> t0 -> t1 -> Either Errors.Error Syntax.Type adaptTypeToHaskellAndEncode namespaces typ cx g = @@ -70,6 +79,7 @@ in case (Strip.deannotateType typ) of Core.TypeVariable _ -> enc typ _ -> Eithers.bind (Adapt.adaptTypeForLanguage Language.haskellLanguage typ) (\adaptedType -> enc adaptedType) + -- | Generate a constant name for a field (e.g., '_TypeName_fieldName') constantForFieldName :: Core.Name -> Core.Name -> String constantForFieldName tname fname = @@ -78,9 +88,11 @@ (Names.localNameOf tname), "_", (Core.unName fname)] + -- | Generate a constant name for a type (e.g., '_TypeName') constantForTypeName :: Core.Name -> String constantForTypeName tname = Strings.cat2 "_" (Names.localNameOf tname) + -- | Construct a Haskell module from a Hydra module and its definitions constructModule :: Util.ModuleNames Syntax.ModuleName -> Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Module constructModule namespaces mod defs cx g = @@ -92,7 +104,7 @@ parts = Strings.splitOn "." raw in (Logic.ifElse (Logic.and (Equality.equal (Lists.length parts) 3) (Equality.equal (Lists.take 2 parts) [ "hydra", - "lib"])) (Strings.cat2 "hydra.haskell.lib." (Strings.intercalate "." (Lists.drop 2 parts))) raw) + "lib"])) (Strings.cat2 "hydra.overlay.haskell.lib." (Strings.intercalate "." (Lists.drop 2 parts))) raw) createDeclarations = \def -> case def of Packaging.DefinitionType v0 -> @@ -157,7 +169,7 @@ (condImport (Environment.haskellModuleMetadataUsesMap meta) (("Data.Map", (Just "M")), [])), (condImport (Environment.haskellModuleMetadataUsesSet meta) (("Data.Set", (Just "S")), [])), (Logic.ifElse (Logic.or (Analysis.moduleContainsBinaryLiterals mod) (Analysis.moduleContainsDecimalLiterals mod)) [ - (("Hydra.Haskell.Lib.Literals", (Just "Literals")), [])] [])])) + (("Hydra.Overlay.Haskell.Lib.Literals", (Just "Literals")), [])] [])])) in (Eithers.bind (Eithers.mapList createDeclarations defs) (\declLists -> let decls = Lists.concat declLists mc = Optionals.bind (Packaging.moduleMetadata mod) (\em -> Packaging.entityMetadataDescription em) @@ -168,6 +180,7 @@ Syntax.moduleHeadExports = []})), Syntax.moduleImports = imports, Syntax.moduleDeclarations = decls})))) + -- | Create an initial empty metadata record with all flags set to false emptyMetadata :: Environment.HaskellModuleMetadata emptyMetadata = @@ -176,6 +189,7 @@ Environment.haskellModuleMetadataUsesInt = False, Environment.haskellModuleMetadataUsesMap = False, Environment.haskellModuleMetadataUsesSet = False} + -- | Encode a Hydra case statement as a Haskell case expression with a given scrutinee encodeCaseExpression :: Int -> Util.ModuleNames Syntax.ModuleName -> Core.CaseStatement -> Syntax.Expression -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Expression encodeCaseExpression depth namespaces stmt scrutinee cx g = @@ -224,6 +238,7 @@ alt])))) (\dcases -> Right (Syntax.ExpressionCase (Syntax.CaseExpression { Syntax.caseExpressionCase = scrutinee, Syntax.caseExpressionAlternatives = (Lists.concat2 ecases dcases)}))))))) + -- | Encode a Hydra lambda as a Haskell expression encodeLambdaTerm :: Int -> Util.ModuleNames Syntax.ModuleName -> Core.Lambda -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Expression encodeLambdaTerm depth namespaces lam cx g = @@ -231,6 +246,7 @@ let v = Core.lambdaParameter lam body = Core.lambdaBody lam in (Eithers.bind (encodeTerm depth namespaces body cx g) (\hbody -> Right (Utils.hslambda (Utils.elementReference namespaces v) hbody))) + -- | Encode a Hydra literal as a Haskell expression encodeLiteral :: Core.Literal -> t0 -> Either Errors.Error Syntax.Expression encodeLiteral l cx = @@ -255,6 +271,7 @@ _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError { Errors.unexpectedShapeErrorExpected = "supported literal", Errors.unexpectedShapeErrorActual = (ShowCore.literal l)}))) + -- | Encode a record projection as a Haskell expression encodeProjection :: Util.ModuleNames Syntax.ModuleName -> Core.Projection -> Either t0 Syntax.Expression encodeProjection namespaces proj = @@ -262,10 +279,12 @@ let dn = Core.projectionTypeName proj fname = Core.projectionFieldName proj in (Right (Syntax.ExpressionVariable (Utils.recordFieldReference namespaces dn fname))) + -- | Encode a standalone (un-applied) case statement as a Haskell lambda over a case expression encodeStandaloneCases :: Int -> Util.ModuleNames Syntax.ModuleName -> Core.CaseStatement -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Expression encodeStandaloneCases depth namespaces stmt cx g = Eithers.map (Utils.hslambda (Utils.rawName "x")) (encodeCaseExpression depth namespaces stmt (Utils.hsvar "x") cx g) + -- | Encode a Hydra term as a Haskell expression encodeTerm :: Int -> Util.ModuleNames Syntax.ModuleName -> Core.Term -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Expression encodeTerm depth namespaces term cx g = @@ -371,6 +390,7 @@ _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError { Errors.unexpectedShapeErrorExpected = "supported term", Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))) + -- | Encode a Hydra type as a Haskell type encodeType :: Util.ModuleNames Syntax.ModuleName -> Core.Type -> t0 -> t1 -> Either Errors.Error Syntax.Type encodeType namespaces typ cx g = @@ -392,6 +412,9 @@ Syntax.TypeVariable (Utils.rawName "Either"), hleft, hright])))) + Core.TypeEffect v0 -> Eithers.bind (encode v0) (\het -> Right (Utils.toTypeApplication [ + Syntax.TypeVariable (Utils.rawName "IO"), + het])) Core.TypeFunction v0 -> let dom = Core.functionTypeDomain v0 cod = Core.functionTypeCodomain v0 @@ -448,6 +471,7 @@ _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError { Errors.unexpectedShapeErrorExpected = "supported type", Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)}))) + -- | Encode a Hydra type as a Haskell type with typeclass assertions encodeTypeWithClassAssertions :: Util.ModuleNames Syntax.ModuleName -> M.Map Core.Name (S.Set Core.Name) -> Core.Type -> t0 -> t1 -> Either Errors.Error Syntax.Type encodeTypeWithClassAssertions namespaces explicitClasses typ cx g = @@ -480,10 +504,12 @@ in (Right (Syntax.TypeCtx (Syntax.ConstrainedType { Syntax.constrainedTypeCtx = hassert, Syntax.constrainedTypeType = htyp})))))) + -- | Encode an unwrap term as a Haskell expression encodeUnwrap :: Util.ModuleNames Syntax.ModuleName -> Core.Name -> Either t0 Syntax.Expression encodeUnwrap namespaces name = Right (Syntax.ExpressionVariable (Utils.elementReference namespaces (Names.qname (Optionals.fromOptional (Packaging.ModuleName "") (Names.moduleNameOf name)) (Utils.newtypeAccessorName name)))) + -- | Extend metadata by analyzing a term for standard import usage (bottom-up step function) extendMetaForTerm :: Environment.HaskellModuleMetadata -> Core.Term -> Environment.HaskellModuleMetadata extendMetaForTerm meta term = @@ -491,6 +517,7 @@ Core.TermMap _ -> setMetaUsesMap True meta Core.TermSet _ -> setMetaUsesSet True meta _ -> meta + -- | Extend metadata by analyzing a type for standard import usage (bottom-up step function) extendMetaForType :: Environment.HaskellModuleMetadata -> Core.Type -> Environment.HaskellModuleMetadata extendMetaForType meta typ = @@ -506,6 +533,7 @@ Core.TypeMap _ -> setMetaUsesMap True meta Core.TypeSet _ -> setMetaUsesSet True meta _ -> meta + -- | Find type variables that require an Ord constraint (used in maps or sets) findOrdVariables :: Core.Type -> S.Set Core.Name findOrdVariables typ = @@ -523,6 +551,7 @@ Core.TypeVariable v0 -> Logic.ifElse (isTypeVariable v0) (Sets.insert v0 names) names _ -> names in (Rewriting.foldOverType Coders.TraversalOrderPre fold Sets.empty typ) + -- | Gather metadata from definitions by bottom-up traversal of all terms and types gatherMetadata :: [Packaging.Definition] -> Environment.HaskellModuleMetadata gatherMetadata defs = @@ -537,6 +566,7 @@ let typ = Core.typeSchemeBody (Packaging.typeDefinitionBody v0) in (Rewriting.foldOverType Coders.TraversalOrderPre (\m -> \t -> extendMetaForType m t) meta typ) in (Lists.foldl addDef emptyMetadata defs) + -- | Get implicit typeclass constraints for type variables that need Ord getImplicitTypeClasses :: Core.Type -> M.Map Core.Name (S.Set Core.Name) getImplicitTypeClasses typ = @@ -544,23 +574,28 @@ let toPair = \name -> (name, (Sets.fromList [ Core.Name "ordering"])) in (Maps.fromList (Lists.map toPair (Sets.toList (findOrdVariables typ)))) + -- | Whether to include type definitions in generated Haskell modules includeTypeDefinitions :: Bool includeTypeDefinitions = False + -- | The key used to track Haskell variable depth in annotations keyHaskellVar :: Core.Name keyHaskellVar = Core.Name "haskellVar" + -- | Convert a Hydra module to Haskell source code as a filepath-to-content map moduleToHaskell :: Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either Errors.Error (M.Map String String) moduleToHaskell mod defs cx g = Eithers.bind (moduleToHaskellModule mod defs cx g) (\hsmod -> let s = Serialization.printExpr (Serialization.parenthesize (Serde.moduleToExpr hsmod)) - filepath = Names.moduleNameToFilePath Util.CaseConventionPascal (Util.FileExtension "hs") (Packaging.moduleName mod) + filepath = Names.moduleNameToFilePath Util.CaseConventionPascal (File.FileExtension "hs") (Packaging.moduleName mod) in (Right (Maps.singleton filepath s))) + -- | Convert a Hydra module and definitions to a Haskell module AST moduleToHaskellModule :: Packaging.Module -> [Packaging.Definition] -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Module moduleToHaskellModule mod defs cx g = Eithers.bind (Utils.namespacesForModule mod cx g) (\namespaces -> constructModule namespaces mod defs cx g) + -- | Generate Haskell declarations for type and field name constants nameDecls :: Util.ModuleNames Syntax.ModuleName -> Core.Name -> Core.Type -> [Syntax.Declaration] nameDecls namespaces name typ = @@ -584,6 +619,7 @@ let fname = Core.fieldTypeName fieldType in (constantForFieldName name fname, (Core.unName fname)) in (Logic.ifElse useCoreImport (Lists.cons (toDecl (Core.Name "hydra.core.Name") nameDecl) (Lists.map (toDecl (Core.Name "hydra.core.Name")) fieldDecls)) []) + setMetaUsesByteString :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata setMetaUsesByteString b m = Environment.HaskellModuleMetadata { @@ -591,6 +627,7 @@ Environment.haskellModuleMetadataUsesInt = (Environment.haskellModuleMetadataUsesInt m), Environment.haskellModuleMetadataUsesMap = (Environment.haskellModuleMetadataUsesMap m), Environment.haskellModuleMetadataUsesSet = (Environment.haskellModuleMetadataUsesSet m)} + setMetaUsesInt :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata setMetaUsesInt b m = Environment.HaskellModuleMetadata { @@ -598,6 +635,7 @@ Environment.haskellModuleMetadataUsesInt = b, Environment.haskellModuleMetadataUsesMap = (Environment.haskellModuleMetadataUsesMap m), Environment.haskellModuleMetadataUsesSet = (Environment.haskellModuleMetadataUsesSet m)} + setMetaUsesMap :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata setMetaUsesMap b m = Environment.HaskellModuleMetadata { @@ -605,6 +643,7 @@ Environment.haskellModuleMetadataUsesInt = (Environment.haskellModuleMetadataUsesInt m), Environment.haskellModuleMetadataUsesMap = b, Environment.haskellModuleMetadataUsesSet = (Environment.haskellModuleMetadataUsesSet m)} + setMetaUsesSet :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata setMetaUsesSet b m = Environment.HaskellModuleMetadata { @@ -612,6 +651,7 @@ Environment.haskellModuleMetadataUsesInt = (Environment.haskellModuleMetadataUsesInt m), Environment.haskellModuleMetadataUsesMap = (Environment.haskellModuleMetadataUsesMap m), Environment.haskellModuleMetadataUsesSet = b} + -- | Convert a Hydra term definition to a Haskell declaration with comments toDataDeclaration :: Util.ModuleNames Syntax.ModuleName -> Packaging.TermDefinition -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Declaration toDataDeclaration namespaces def cx g = @@ -674,6 +714,7 @@ Syntax.typedBindingComments = comments}) in (Right decl)))))) in (Eithers.bind (Annotations.getTermDescription cx g term) (\comments -> toDecl comments hname term Nothing)) + -- | Convert a Hydra type definition to Haskell declarations toTypeDeclarationsFrom :: Util.ModuleNames Syntax.ModuleName -> Core.Name -> Core.Type -> t0 -> Graph.Graph -> Either Errors.Error [Syntax.Declaration] toTypeDeclarationsFrom namespaces elementName typ cx g = @@ -785,6 +826,7 @@ decl], nameDecls_, tdecls])))))))) + -- | Generate a Haskell declaration for a type definition constant typeDecl :: Util.ModuleNames Syntax.ModuleName -> Core.Name -> Core.Type -> t0 -> Graph.Graph -> Either Errors.Error Syntax.Declaration typeDecl namespaces name typ cx g = @@ -839,6 +881,7 @@ Syntax.simpleValueBindingLocalBindings = Nothing, Syntax.simpleValueBindingComments = Nothing})) in (Right decl))) + -- | Project type scheme constraints to a map of type variables to typeclass names typeSchemeConstraintsToClassMap :: Ord t0 => (Maybe (M.Map t0 Core.TypeVariableConstraints) -> M.Map t0 (S.Set Core.Name)) typeSchemeConstraintsToClassMap maybeConstraints = @@ -847,6 +890,7 @@ \tcc -> case tcc of Core.TypeClassConstraintSimple v0 -> Just v0 in (Optionals.cases maybeConstraints Maps.empty (\constraints -> Maps.map (\meta -> Sets.fromList (Optionals.cat (Lists.map constraintToName (Core.typeVariableConstraintsClasses meta)))) constraints)) + -- | Whether to use the Hydra core import in generated modules useCoreImport :: Bool useCoreImport = True diff --git a/src/main/haskell/Hydra/Haskell/Environment.hs b/src/main/haskell/Hydra/Haskell/Environment.hs --- a/src/main/haskell/Hydra/Haskell/Environment.hs +++ b/src/main/haskell/Hydra/Haskell/Environment.hs @@ -1,10 +1,13 @@ -- Note: this is an automatically generated file. Do not edit. + -- | Environment types for Haskell code generation module Hydra.Haskell.Environment where + import qualified Hydra.Core as Core import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci + -- | Metadata used to determine which standard imports are needed in a generated Haskell module data HaskellModuleMetadata = HaskellModuleMetadata { @@ -17,8 +20,13 @@ -- | Whether the module uses Data.Set (S.Set, S.fromList, S.empty) haskellModuleMetadataUsesSet :: Bool} deriving (Eq, Ord, Read, Show) + _HaskellModuleMetadata = Core.Name "hydra.haskell.environment.HaskellModuleMetadata" + _HaskellModuleMetadata_usesByteString = Core.Name "usesByteString" + _HaskellModuleMetadata_usesInt = Core.Name "usesInt" + _HaskellModuleMetadata_usesMap = Core.Name "usesMap" + _HaskellModuleMetadata_usesSet = Core.Name "usesSet" diff --git a/src/main/haskell/Hydra/Haskell/Language.hs b/src/main/haskell/Hydra/Haskell/Language.hs --- a/src/main/haskell/Hydra/Haskell/Language.hs +++ b/src/main/haskell/Hydra/Haskell/Language.hs @@ -1,25 +1,33 @@ -- Note: this is an automatically generated file. Do not edit. + -- | Language constraints and reserved words for Haskell module Hydra.Haskell.Language where + import qualified Hydra.Ast as Ast import qualified Hydra.Coders as Coders import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors +import qualified Hydra.File as File import qualified Hydra.Graph as Graph import qualified Hydra.Json.Model as Model -import qualified Hydra.Haskell.Lib.Lists as Lists -import qualified Hydra.Haskell.Lib.Sets as Sets +import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query import qualified Hydra.Relational as Relational +import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -29,6 +37,7 @@ import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci import qualified Data.Set as S + -- | Language constraints for Haskell haskellLanguage :: Coders.Language haskellLanguage = @@ -56,7 +65,7 @@ Coders.caseConventionsTermVariable = Util.CaseConventionCamel, Coders.caseConventionsType = Util.CaseConventionPascal, Coders.caseConventionsTypeVariable = Util.CaseConventionCamel}, - Coders.languageDefaultFileExtension = (Util.FileExtension "hs")} + Coders.languageDefaultFileExtension = (File.FileExtension "hs")} where literalVariants = Sets.fromList [ @@ -105,6 +114,7 @@ Variants.TypeVariantAnnotated, Variants.TypeVariantApplication, Variants.TypeVariantEither, + Variants.TypeVariantEffect, Variants.TypeVariantFunction, Variants.TypeVariantForall, Variants.TypeVariantList, @@ -120,6 +130,7 @@ Variants.TypeVariantVoid, Variants.TypeVariantWrap] typePredicate = \_ -> True + -- | Created on 2025-02-28 using GHCi 9.6.6 -- | -- | You can reproduce these lists of symbols by issuing the command `:browse Prelude` in GHCi, pasting the results into diff --git a/src/main/haskell/Hydra/Haskell/Operators.hs b/src/main/haskell/Hydra/Haskell/Operators.hs --- a/src/main/haskell/Hydra/Haskell/Operators.hs +++ b/src/main/haskell/Hydra/Haskell/Operators.hs @@ -1,25 +1,33 @@ -- Note: this is an automatically generated file. Do not edit. + -- | AST operators for Haskell module Hydra.Haskell.Operators where + import qualified Hydra.Ast as Ast import qualified Hydra.Coders as Coders import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors +import qualified Hydra.File as File import qualified Hydra.Graph as Graph import qualified Hydra.Json.Model as Model -import qualified Hydra.Haskell.Lib.Math as Math +import qualified Hydra.Overlay.Haskell.Lib.Math as Math import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query import qualified Hydra.Relational as Relational import qualified Hydra.Serialization as Serialization +import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -28,12 +36,15 @@ import qualified Hydra.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci + -- | Logical AND operator (&&) andOp :: Ast.Op andOp = Serialization.op "&&" 3 Ast.AssociativityRight + -- | Applicative apply operator (<*>) apOp :: Ast.Op apOp = Serialization.op "<*>" 4 Ast.AssociativityLeft + -- | Function application operator (whitespace) appOp :: Ast.Op appOp = @@ -44,96 +55,127 @@ Ast.paddingRight = Ast.WsSpace}, Ast.opPrecedence = (Ast.Precedence 0), Ast.opAssociativity = Ast.AssociativityLeft} + -- | Low-precedence function application ($) applyOp :: Ast.Op applyOp = Serialization.op "$" 0 Ast.AssociativityRight + -- | Function type arrow (->) arrowOp :: Ast.Op arrowOp = Serialization.op "->" (Math.negate 1) Ast.AssociativityRight + -- | Type class constraint arrow (=>) assertOp :: Ast.Op assertOp = Serialization.op "=>" 0 Ast.AssociativityNone + -- | Monadic bind operator (>>=) bindOp :: Ast.Op bindOp = Serialization.op ">>=" 1 Ast.AssociativityLeft + -- | Case alternative arrow (->) caseOp :: Ast.Op caseOp = Serialization.op "->" 0 Ast.AssociativityNone + -- | Function composition (.) composeOp :: Ast.Op composeOp = Serialization.op "." 9 Ast.AssociativityLeft + -- | List concatenation (++) concatOp :: Ast.Op concatOp = Serialization.op "++" 5 Ast.AssociativityRight + -- | List cons (:) consOp :: Ast.Op consOp = Serialization.op ":" 5 Ast.AssociativityRight + -- | Definition operator (=) defineOp :: Ast.Op defineOp = Serialization.op "=" 0 Ast.AssociativityNone + -- | Semigroup append (<>) diamondOp :: Ast.Op diamondOp = Serialization.op "<>" 6 Ast.AssociativityRight + -- | Integer division (`div`) divOp :: Ast.Op divOp = Serialization.op "`div`" 7 Ast.AssociativityLeft + -- | Fractional division (/) divideOp :: Ast.Op divideOp = Serialization.op "/" 7 Ast.AssociativityLeft + -- | List membership (`elem`) elemOp :: Ast.Op elemOp = Serialization.op "`elem`" 4 Ast.AssociativityNone + -- | Equality comparison (==) equalOp :: Ast.Op equalOp = Serialization.op "==" 4 Ast.AssociativityNone + -- | Functor map (<$>) fmapOp :: Ast.Op fmapOp = Serialization.op "<$>" 4 Ast.AssociativityLeft + -- | Greater than (>) gtOp :: Ast.Op gtOp = Serialization.op ">" 4 Ast.AssociativityNone + -- | Greater than or equal (>=) gteOp :: Ast.Op gteOp = Serialization.op ">=" 4 Ast.AssociativityNone + -- | List indexing (!!) indexOp :: Ast.Op indexOp = Serialization.op "!!" 9 Ast.AssociativityLeft + -- | Lambda body arrow (->) lambdaOp :: Ast.Op lambdaOp = Serialization.op "->" (Math.negate 1) Ast.AssociativityRight + -- | Less than (<) ltOp :: Ast.Op ltOp = Serialization.op "<" 4 Ast.AssociativityNone + -- | Less than or equal (<=) lteOp :: Ast.Op lteOp = Serialization.op ">=" 4 Ast.AssociativityNone + -- | Subtraction (-). Originally: associativityLeft minusOp :: Ast.Op minusOp = Serialization.op "-" 6 Ast.AssociativityBoth + -- | Modulo (`mod`) modOp :: Ast.Op modOp = Serialization.op "`mod`" 7 Ast.AssociativityLeft + -- | Multiplication (*). Originally: associativityLeft multOp :: Ast.Op multOp = Serialization.op "*" 7 Ast.AssociativityBoth + -- | Not equal (/=) neqOp :: Ast.Op neqOp = Serialization.op "/=" 4 Ast.AssociativityNone + -- | List non-membership (`notElem`) notElemOp :: Ast.Op notElemOp = Serialization.op "`notElem`" 4 Ast.AssociativityNone + -- | Logical OR (||) orOp :: Ast.Op orOp = Serialization.op "||" 2 Ast.AssociativityRight + -- | Addition (+). Originally: associativityLeft plusOp :: Ast.Op plusOp = Serialization.op "+" 6 Ast.AssociativityBoth + -- | Integer quotient (`quot`) quotOp :: Ast.Op quotOp = Serialization.op "`quot`" 7 Ast.AssociativityLeft + -- | Integer remainder (`rem`) remOp :: Ast.Op remOp = Serialization.op "`rem`" 7 Ast.AssociativityLeft + -- | Type annotation (::) typeOp :: Ast.Op typeOp = Serialization.op "::" 0 Ast.AssociativityNone diff --git a/src/main/haskell/Hydra/Haskell/Serde.hs b/src/main/haskell/Hydra/Haskell/Serde.hs --- a/src/main/haskell/Hydra/Haskell/Serde.hs +++ b/src/main/haskell/Hydra/Haskell/Serde.hs @@ -1,4 +1,5 @@ -- Note: this is an automatically generated file. Do not edit. + -- | Haskell operator precendence and associativity are drawn from: -- | https://self-learning-java-tutorial.blogspot.com/2016/04/haskell-operator-precedence.html -- | Other operators were investigated using GHCi, e.g. ":info (->)" @@ -6,32 +7,41 @@ -- | https://stackoverflow.com/questions/7746894/are-there-pronounceable-names-for-common-haskell-operators module Hydra.Haskell.Serde where + import qualified Hydra.Ast as Ast import qualified Hydra.Coders as Coders import qualified Hydra.Constants as Constants import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors +import qualified Hydra.File as File import qualified Hydra.Graph as Graph import qualified Hydra.Haskell.Operators as Operators import qualified Hydra.Haskell.Syntax as Syntax import qualified Hydra.Json.Model as Model -import qualified Hydra.Haskell.Lib.Equality as Equality -import qualified Hydra.Haskell.Lib.Lists as Lists -import qualified Hydra.Haskell.Lib.Literals as Literals -import qualified Hydra.Haskell.Lib.Logic as Logic -import qualified Hydra.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Haskell.Lib.Strings as Strings +import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings +import qualified Hydra.Names as Names import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query import qualified Hydra.Relational as Relational import qualified Hydra.Serialization as Serialization +import qualified Hydra.Show.Docs as ShowDocs +import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -40,6 +50,7 @@ import qualified Hydra.Variants as Variants import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci + -- | Convert a pattern-matching alternative to an AST expression alternativeToExpr :: Syntax.Alternative -> Ast.Expr alternativeToExpr alt = @@ -47,10 +58,12 @@ patternToExpr (Syntax.alternativePattern alt), (Serialization.cst "->"), (caseRhsToExpr (Syntax.alternativeRhs alt))] + -- | Convert a function application expression to an AST expression applicationExpressionToExpr :: Syntax.ApplicationExpression -> Ast.Expr applicationExpressionToExpr app = Serialization.ifx Operators.appOp (expressionToExpr (Syntax.applicationExpressionFunction app)) (expressionToExpr (Syntax.applicationExpressionArgument app)) + -- | Convert an application pattern to an AST expression applicationPatternToExpr :: Syntax.ApplicationPattern -> Ast.Expr applicationPatternToExpr appPat = @@ -58,6 +71,7 @@ let name = Syntax.applicationPatternName appPat pats = Syntax.applicationPatternArgs appPat in (Serialization.spaceSep (Lists.cons (nameToExpr name) (Lists.map patternToExpr pats))) + -- | Convert a case expression to an AST expression caseExpressionToExpr :: Syntax.CaseExpression -> Ast.Expr caseExpressionToExpr caseExpr = @@ -78,9 +92,11 @@ (expressionToExpr cs)] rhs = Serialization.newlineSep (Lists.map alternativeToExpr alts) in (Serialization.ifx ofOp lhs rhs) + -- | Convert a case right-hand side to an AST expression caseRhsToExpr :: Syntax.CaseRhs -> Ast.Expr caseRhsToExpr rhs = expressionToExpr (Syntax.unCaseRhs rhs) + -- | Convert a class constraint to an AST expression classConstraintToExpr :: Syntax.ClassConstraint -> Ast.Expr classConstraintToExpr clsAsrt = @@ -89,12 +105,14 @@ types = Syntax.classConstraintTypes clsAsrt in (Serialization.spaceSep (Lists.cons (nameToExpr name) [ Serialization.commaSep Serialization.halfBlockStyle (Lists.map typeToExpr types)])) + -- | Convert a type class constraint to an AST expression constraintToExpr :: Syntax.Constraint -> Ast.Expr constraintToExpr sert = case sert of Syntax.ConstraintClass v0 -> classConstraintToExpr v0 Syntax.ConstraintTuple v0 -> Serialization.parenList False (Lists.map constraintToExpr v0) + -- | Convert a data constructor to an AST expression constructorToExpr :: Syntax.Constructor -> Ast.Expr constructorToExpr cons = @@ -117,12 +135,14 @@ Serialization.curlyBracesList Nothing Serialization.halfBlockStyle (Lists.map fieldToExpr fields)])) in (Optionals.cases mc body (\c -> Serialization.newlineSep (Lists.cons (Serialization.cst (toHaskellComments c)) [ body]))) + -- | Convert a data/newtype keyword to an AST expression dataKeywordToExpr :: Syntax.DataKeyword -> Ast.Expr dataKeywordToExpr kw = case kw of Syntax.DataKeywordData -> Serialization.cst "data" Syntax.DataKeywordNewtype -> Serialization.cst "newtype" + -- | Convert a declaration head to an AST expression declarationHeadToExpr :: Syntax.DeclarationHead -> Ast.Expr declarationHeadToExpr hd = @@ -133,6 +153,7 @@ in (Serialization.spaceSep (Lists.cons (declarationHeadToExpr fun) [ variableToExpr op])) Syntax.DeclarationHeadSimple v0 -> nameToExpr v0 + -- | Convert a declaration to an AST expression declarationToExpr :: Syntax.Declaration -> Ast.Expr declarationToExpr decl = @@ -181,6 +202,7 @@ valueBindingToExpr vb])) in (Optionals.cases mc body (\c -> Serialization.newlineSep (Lists.cons (Serialization.cst (toHaskellComments c)) [ body]))) + -- | Convert a Haskell expression to an AST expression expressionToExpr :: Syntax.Expression -> Ast.Expr expressionToExpr expr = @@ -203,6 +225,7 @@ Syntax.ExpressionList v0 -> Serialization.bracketList Serialization.halfBlockStyle (Lists.map expressionToExpr v0) Syntax.ExpressionTuple v0 -> Serialization.parenListAdaptive (Lists.map expressionToExpr v0) Syntax.ExpressionVariable v0 -> nameToExpr v0 + -- | Convert a field declaration to an AST expression fieldToExpr :: Syntax.Field -> Ast.Expr fieldToExpr field = @@ -214,6 +237,20 @@ typeToExpr typ])) in (Optionals.cases mc body (\c -> Serialization.newlineSep (Lists.cons (Serialization.cst (toHaskellComments c)) [ body]))) + +-- | Render a 'EntityReference' as Haddock link syntax +haddockEntityRef :: Packaging.EntityReference -> String +haddockEntityRef x = + case x of + Packaging.EntityReferenceDefinition v0 -> Strings.cat2 "'" (Strings.cat2 (case v0 of + Packaging.DefinitionReferencePrimitive v1 -> Names.localNameOf v1 + Packaging.DefinitionReferenceTerm v1 -> Names.localNameOf v1 + Packaging.DefinitionReferenceType v1 -> Names.localNameOf v1) "'") + Packaging.EntityReferenceModule v0 -> Packaging.unModuleName v0 + Packaging.EntityReferencePackage v0 -> Packaging.unPackageName v0 + Packaging.EntityReferenceTermExpr v0 -> Strings.cat2 "@" (Strings.cat2 v0 "@") + Packaging.EntityReferenceTypeExpr v0 -> Strings.cat2 "@" (Strings.cat2 v0 "@") + -- | Convert an if-then-else expression to an AST expression ifExpressionToExpr :: Syntax.IfExpression -> Ast.Expr ifExpressionToExpr ifExpr = @@ -236,6 +273,7 @@ expressionToExpr eelse])]) in (Serialization.ifx ifOp (Serialization.spaceSep (Lists.cons (Serialization.cst "if") [ expressionToExpr eif])) body) + -- | Convert an import statement to an AST expression importToExpr :: Syntax.Import -> Ast.Expr importToExpr import_ = @@ -257,6 +295,7 @@ (Optionals.map (\m -> Serialization.cst (Strings.cat2 "as " (Syntax.unModuleName m))) mod), (Optionals.map hidingSec mspec)] in (Serialization.spaceSep parts) + -- | Convert a lambda expression to an AST expression lambdaExpressionToExpr :: Syntax.LambdaExpression -> Ast.Expr lambdaExpressionToExpr lambdaExpr = @@ -266,6 +305,7 @@ head = Serialization.spaceSep (Lists.map patternToExpr bindings) body = expressionToExpr inner in (Serialization.ifx Operators.lambdaOp (Serialization.prefix "\\" head) body) + -- | Convert a literal value to an AST expression literalToExpr :: Syntax.Literal -> Ast.Expr literalToExpr lit = @@ -286,12 +326,14 @@ Syntax.LiteralInt v0 -> parensIfNeg (Equality.lt v0 0) (Literals.showInt32 v0) Syntax.LiteralInteger v0 -> parensIfNeg (Equality.lt v0 0) (Literals.showBigint v0) Syntax.LiteralString v0 -> Literals.showString v0)) + -- | Convert a local binding to an AST expression localBindingToExpr :: Syntax.LocalBinding -> Ast.Expr localBindingToExpr binding = case binding of Syntax.LocalBindingSignature v0 -> typeSignatureToExpr v0 Syntax.LocalBindingValue v0 -> valueBindingToExpr v0 + -- | Convert a module head to an AST expression moduleHeadToExpr :: Syntax.ModuleHead -> Ast.Expr moduleHeadToExpr moduleHead = @@ -304,6 +346,7 @@ Serialization.cst "where"])) in (Optionals.cases mc head (\c -> Serialization.newlineSep (Lists.cons (Serialization.cst (toHaskellComments c)) (Lists.cons (Serialization.cst "") [ head])))) + -- | Convert a Haskell module to an AST expression moduleToExpr :: Syntax.Module -> Ast.Expr moduleToExpr module_ = @@ -323,15 +366,18 @@ headerLine, importLines, declLines])) + -- | Convert a Haskell name to an AST expression nameToExpr :: Syntax.Name -> Ast.Expr nameToExpr name = Serialization.cst (case name of Syntax.NameImplicit v0 -> Strings.cat2 "?" (writeQualifiedName v0) Syntax.NameNormal v0 -> writeQualifiedName v0) + -- | Convert an import/export specification to an AST expression namedImportExportToExpr :: Syntax.NamedImportExport -> Ast.Expr namedImportExportToExpr spec = nameToExpr (Syntax.namedImportExportName spec) + -- | Convert a pattern to an AST expression patternToExpr :: Syntax.Pattern -> Ast.Expr patternToExpr pat = @@ -342,6 +388,7 @@ Syntax.PatternName v0 -> nameToExpr v0 Syntax.PatternTuple v0 -> Serialization.parenListAdaptive (Lists.map patternToExpr v0) Syntax.PatternWildcard -> Serialization.cst "_" + -- | Convert a record construction expression to an AST expression recordExpressionToExpr :: Syntax.RecordExpression -> Ast.Expr recordExpressionToExpr constructRecord = @@ -356,20 +403,25 @@ body = Serialization.commaSep Serialization.halfBlockStyle (Lists.map fromUpdate updates) in (Serialization.spaceSep (Lists.cons (nameToExpr name) [ Serialization.brackets Serialization.curlyBraces Serialization.halfBlockStyle body])) + -- | Convert a right-hand side to an AST expression rightHandSideToExpr :: Syntax.RightHandSide -> Ast.Expr rightHandSideToExpr rhs = expressionToExpr (Syntax.unRightHandSide rhs) + -- | Convert a statement to an AST expression statementToExpr :: Syntax.Statement -> Ast.Expr statementToExpr stmt = expressionToExpr (Syntax.unStatement stmt) --- | Convert a string to Haddock documentation comments. Empty source lines emit `-- |` (no trailing space) so blank doc lines don't carry trailing whitespace into the generated file. + +-- | Convert a string to Haddock documentation comments. Empty source lines emit `-- |` (no trailing space) so blank doc lines don't carry trailing whitespace into the generated file. Doc-escape tags are rendered as Haddock links via haddockEntityRef. toHaskellComments :: String -> String toHaskellComments c = - Strings.intercalate "\n" (Lists.map (\s -> Logic.ifElse (Equality.equal s "") "-- |" (Strings.cat2 "-- | " s)) (Strings.lines c)) + Strings.intercalate "\n" (Lists.map (\s -> Logic.ifElse (Equality.equal s "") "-- |" (Strings.cat2 "-- | " s)) (Strings.lines (ShowDocs.renderDocStringWith haddockEntityRef c))) + -- | Convert a string to simple line comments. Empty source lines emit `--` (no trailing space) for the same reason as toHaskellComments. toSimpleComments :: String -> String toSimpleComments c = Strings.intercalate "\n" (Lists.map (\s -> Logic.ifElse (Equality.equal s "") "--" (Strings.cat2 "-- " s)) (Strings.lines c)) + -- | Convert a type signature to an AST expression typeSignatureToExpr :: Syntax.TypeSignature -> Ast.Expr typeSignatureToExpr typeSig = @@ -388,6 +440,7 @@ nameExpr, (Serialization.cst "::")], (Serialization.tabIndent typeExpr)])) + -- | Convert a Haskell type to an AST expression typeToExpr :: Syntax.Type -> Ast.Expr typeToExpr htype = @@ -408,6 +461,7 @@ typeToExpr v0] Syntax.TypeTuple v0 -> Serialization.parenListAdaptive (Lists.map typeToExpr v0) Syntax.TypeVariable v0 -> nameToExpr v0 + -- | Convert a value binding to an AST expression valueBindingToExpr :: Syntax.ValueBinding -> Ast.Expr valueBindingToExpr vb = @@ -433,9 +487,11 @@ let bindings = Syntax.unLocalBindings localBindings in (Serialization.indentBlock (Lists.cons body [ Serialization.indentBlock (Lists.cons (Serialization.cst "where") (Lists.map localBindingToExpr bindings))])))) + -- | Convert a type variable to an AST expression variableToExpr :: Syntax.Variable -> Ast.Expr variableToExpr variable = nameToExpr (Syntax.unVariable variable) + -- | Write a qualified name as a string writeQualifiedName :: Syntax.QualifiedName -> String writeQualifiedName qname = diff --git a/src/main/haskell/Hydra/Haskell/Syntax.hs b/src/main/haskell/Hydra/Haskell/Syntax.hs --- a/src/main/haskell/Hydra/Haskell/Syntax.hs +++ b/src/main/haskell/Hydra/Haskell/Syntax.hs @@ -1,10 +1,13 @@ -- Note: this is an automatically generated file. Do not edit. + -- | A Haskell syntax model for Hydra. Originally inspired by Language.Haskell.Tools.AST, but now diverges freely to suit Hydra's needs. module Hydra.Haskell.Syntax where + import qualified Hydra.Core as Core import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci + -- | A pattern-matching alternative data Alternative = Alternative { @@ -15,10 +18,15 @@ -- | Optional local bindings alternativeBinds :: (Maybe LocalBindings)} deriving (Eq, Ord, Read, Show) + _Alternative = Core.Name "hydra.haskell.syntax.Alternative" + _Alternative_pattern = Core.Name "pattern" + _Alternative_rhs = Core.Name "rhs" + _Alternative_binds = Core.Name "binds" + -- | A type constraint data Constraint = -- | A class constraint @@ -26,9 +34,13 @@ -- | A tuple of constraints ConstraintTuple [Constraint] deriving (Eq, Ord, Read, Show) + _Constraint = Core.Name "hydra.haskell.syntax.Constraint" + _Constraint_class = Core.Name "class" + _Constraint_tuple = Core.Name "tuple" + -- | A class constraint data ClassConstraint = ClassConstraint { @@ -37,15 +49,21 @@ -- | The types to which the class is applied classConstraintTypes :: [Type]} deriving (Eq, Ord, Read, Show) + _ClassConstraint = Core.Name "hydra.haskell.syntax.ClassConstraint" + _ClassConstraint_name = Core.Name "name" + _ClassConstraint_types = Core.Name "types" + -- | The right-hand side of a pattern-matching alternative newtype CaseRhs = CaseRhs { unCaseRhs :: Expression} deriving (Eq, Ord, Read, Show) + _CaseRhs = Core.Name "hydra.haskell.syntax.CaseRhs" + -- | A data constructor data Constructor = -- | An ordinary (positional) constructor @@ -53,9 +71,13 @@ -- | A record constructor ConstructorRecord RecordConstructor deriving (Eq, Ord, Read, Show) + _Constructor = Core.Name "hydra.haskell.syntax.Constructor" + _Constructor_ordinary = Core.Name "ordinary" + _Constructor_record = Core.Name "record" + -- | An ordinary (positional) data constructor data PositionalConstructor = PositionalConstructor { @@ -66,10 +88,15 @@ -- | Optional comments positionalConstructorComments :: (Maybe String)} deriving (Eq, Ord, Read, Show) + _PositionalConstructor = Core.Name "hydra.haskell.syntax.PositionalConstructor" + _PositionalConstructor_name = Core.Name "name" + _PositionalConstructor_fields = Core.Name "fields" + _PositionalConstructor_comments = Core.Name "comments" + -- | A record-style data constructor data RecordConstructor = RecordConstructor { @@ -80,10 +107,15 @@ -- | Optional comments recordConstructorComments :: (Maybe String)} deriving (Eq, Ord, Read, Show) + _RecordConstructor = Core.Name "hydra.haskell.syntax.RecordConstructor" + _RecordConstructor_name = Core.Name "name" + _RecordConstructor_fields = Core.Name "fields" + _RecordConstructor_comments = Core.Name "comments" + -- | A data type declaration data DataDeclaration = DataDeclaration { @@ -100,21 +132,33 @@ -- | Optional comments dataDeclarationComments :: (Maybe String)} deriving (Eq, Ord, Read, Show) + _DataDeclaration = Core.Name "hydra.haskell.syntax.DataDeclaration" + _DataDeclaration_keyword = Core.Name "keyword" + _DataDeclaration_context = Core.Name "context" + _DataDeclaration_head = Core.Name "head" + _DataDeclaration_constructors = Core.Name "constructors" + _DataDeclaration_deriving = Core.Name "deriving" + _DataDeclaration_comments = Core.Name "comments" + -- | The 'data' versus 'newtype keyword data DataKeyword = DataKeywordData | DataKeywordNewtype deriving (Eq, Ord, Read, Show) + _DataKeyword = Core.Name "hydra.haskell.syntax.DataKeyword" + _DataKeyword_data = Core.Name "data" + _DataKeyword_newtype = Core.Name "newtype" + -- | A data or value declaration data Declaration = -- | A data type declaration @@ -126,11 +170,17 @@ -- | A typed binding DeclarationTypedBinding TypedBinding deriving (Eq, Ord, Read, Show) + _Declaration = Core.Name "hydra.haskell.syntax.Declaration" + _Declaration_data = Core.Name "data" + _Declaration_type = Core.Name "type" + _Declaration_valueBinding = Core.Name "valueBinding" + _Declaration_typedBinding = Core.Name "typedBinding" + -- | The left-hand side of a declaration data DeclarationHead = -- | An application-style declaration head @@ -138,9 +188,13 @@ -- | A simple name DeclarationHeadSimple Name deriving (Eq, Ord, Read, Show) + _DeclarationHead = Core.Name "hydra.haskell.syntax.DeclarationHead" + _DeclarationHead_application = Core.Name "application" + _DeclarationHead_simple = Core.Name "simple" + -- | An application-style declaration head data ApplicationDeclarationHead = ApplicationDeclarationHead { @@ -149,15 +203,21 @@ -- | The type variable operand applicationDeclarationHeadOperand :: Variable} deriving (Eq, Ord, Read, Show) + _ApplicationDeclarationHead = Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead" + _ApplicationDeclarationHead_function = Core.Name "function" + _ApplicationDeclarationHead_operand = Core.Name "operand" + -- | A 'deriving' clause newtype DerivingClause = DerivingClause { unDerivingClause :: [Name]} deriving (Eq, Ord, Read, Show) + _DerivingClause = Core.Name "hydra.haskell.syntax.DerivingClause" + -- | An export statement data Export = -- | An exported declaration @@ -165,9 +225,13 @@ -- | An exported module ExportModule ModuleName deriving (Eq, Ord, Read, Show) + _Export = Core.Name "hydra.haskell.syntax.Export" + _Export_declaration = Core.Name "declaration" + _Export_module = Core.Name "module" + -- | A data expression data Expression = -- | A function application @@ -203,23 +267,41 @@ -- | A variable reference ExpressionVariable Name deriving (Eq, Ord, Read, Show) + _Expression = Core.Name "hydra.haskell.syntax.Expression" + _Expression_application = Core.Name "application" + _Expression_case = Core.Name "case" + _Expression_constructRecord = Core.Name "constructRecord" + _Expression_do = Core.Name "do" + _Expression_if = Core.Name "if" + _Expression_infixApplication = Core.Name "infixApplication" + _Expression_literal = Core.Name "literal" + _Expression_lambda = Core.Name "lambda" + _Expression_leftSection = Core.Name "leftSection" + _Expression_let = Core.Name "let" + _Expression_list = Core.Name "list" + _Expression_rightSection = Core.Name "rightSection" + _Expression_tuple = Core.Name "tuple" + _Expression_typeSignature = Core.Name "typeSignature" + _Expression_updateRecord = Core.Name "updateRecord" + _Expression_variable = Core.Name "variable" + -- | An application expression data ApplicationExpression = ApplicationExpression { @@ -228,9 +310,13 @@ -- | The argument applicationExpressionArgument :: Expression} deriving (Eq, Ord, Read, Show) + _ApplicationExpression = Core.Name "hydra.haskell.syntax.ApplicationExpression" + _ApplicationExpression_function = Core.Name "function" + _ApplicationExpression_argument = Core.Name "argument" + -- | A case expression data CaseExpression = CaseExpression { @@ -239,9 +325,13 @@ -- | The pattern-matching alternatives caseExpressionAlternatives :: [Alternative]} deriving (Eq, Ord, Read, Show) + _CaseExpression = Core.Name "hydra.haskell.syntax.CaseExpression" + _CaseExpression_case = Core.Name "case" + _CaseExpression_alternatives = Core.Name "alternatives" + -- | A record constructor expression data RecordExpression = RecordExpression { @@ -250,9 +340,13 @@ -- | The field assignments recordExpressionFields :: [FieldUpdate]} deriving (Eq, Ord, Read, Show) + _RecordExpression = Core.Name "hydra.haskell.syntax.RecordExpression" + _RecordExpression_name = Core.Name "name" + _RecordExpression_fields = Core.Name "fields" + -- | An 'if' expression data IfExpression = IfExpression { @@ -263,10 +357,15 @@ -- | The 'else' branch ifExpressionElse :: Expression} deriving (Eq, Ord, Read, Show) + _IfExpression = Core.Name "hydra.haskell.syntax.IfExpression" + _IfExpression_condition = Core.Name "condition" + _IfExpression_then = Core.Name "then" + _IfExpression_else = Core.Name "else" + -- | An infix application expression data InfixExpression = InfixExpression { @@ -277,10 +376,15 @@ -- | The right-hand operand infixExpressionRhs :: Expression} deriving (Eq, Ord, Read, Show) + _InfixExpression = Core.Name "hydra.haskell.syntax.InfixExpression" + _InfixExpression_lhs = Core.Name "lhs" + _InfixExpression_operator = Core.Name "operator" + _InfixExpression_rhs = Core.Name "rhs" + -- | A lambda expression data LambdaExpression = LambdaExpression { @@ -289,9 +393,13 @@ -- | The body of the lambda lambdaExpressionInner :: Expression} deriving (Eq, Ord, Read, Show) + _LambdaExpression = Core.Name "hydra.haskell.syntax.LambdaExpression" + _LambdaExpression_bindings = Core.Name "bindings" + _LambdaExpression_inner = Core.Name "inner" + -- | A 'let' expression data LetExpression = LetExpression { @@ -300,9 +408,13 @@ -- | The body of the let expression letExpressionInner :: Expression} deriving (Eq, Ord, Read, Show) + _LetExpression = Core.Name "hydra.haskell.syntax.LetExpression" + _LetExpression_bindings = Core.Name "bindings" + _LetExpression_inner = Core.Name "inner" + -- | A section expression data SectionExpression = SectionExpression { @@ -311,9 +423,13 @@ -- | The operand sectionExpressionExpression :: Expression} deriving (Eq, Ord, Read, Show) + _SectionExpression = Core.Name "hydra.haskell.syntax.SectionExpression" + _SectionExpression_operator = Core.Name "operator" + _SectionExpression_expression = Core.Name "expression" + -- | A type signature expression data TypedExpression = TypedExpression { @@ -322,9 +438,13 @@ -- | The type signature typedExpressionType :: Type} deriving (Eq, Ord, Read, Show) + _TypedExpression = Core.Name "hydra.haskell.syntax.TypedExpression" + _TypedExpression_inner = Core.Name "inner" + _TypedExpression_type = Core.Name "type" + -- | An update record expression data RecordUpdateExpression = RecordUpdateExpression { @@ -333,9 +453,13 @@ -- | The field updates recordUpdateExpressionFields :: [FieldUpdate]} deriving (Eq, Ord, Read, Show) + _RecordUpdateExpression = Core.Name "hydra.haskell.syntax.RecordUpdateExpression" + _RecordUpdateExpression_inner = Core.Name "inner" + _RecordUpdateExpression_fields = Core.Name "fields" + -- | A field (name/type pair) data Field = Field { @@ -346,10 +470,15 @@ -- | Optional comments fieldComments :: (Maybe String)} deriving (Eq, Ord, Read, Show) + _Field = Core.Name "hydra.haskell.syntax.Field" + _Field_name = Core.Name "name" + _Field_type = Core.Name "type" + _Field_comments = Core.Name "comments" + -- | A field name and value data FieldUpdate = FieldUpdate { @@ -358,9 +487,13 @@ -- | The field value fieldUpdateValue :: Expression} deriving (Eq, Ord, Read, Show) + _FieldUpdate = Core.Name "hydra.haskell.syntax.FieldUpdate" + _FieldUpdate_name = Core.Name "name" + _FieldUpdate_value = Core.Name "value" + -- | An import statement data Import = Import { @@ -373,11 +506,17 @@ -- | Optional import specification importSpec :: (Maybe ImportSpec)} deriving (Eq, Ord, Read, Show) + _Import = Core.Name "hydra.haskell.syntax.Import" + _Import_qualified = Core.Name "qualified" + _Import_module = Core.Name "module" + _Import_as = Core.Name "as" + _Import_spec = Core.Name "spec" + -- | An import specification data ImportSpec = -- | A list of imports to include @@ -385,17 +524,25 @@ -- | A list of imports to exclude ImportSpecHiding [NamedImportExport] deriving (Eq, Ord, Read, Show) + _ImportSpec = Core.Name "hydra.haskell.syntax.ImportSpec" + _ImportSpec_list = Core.Name "list" + _ImportSpec_hiding = Core.Name "hiding" + -- | An import modifier ('pattern' or 'type') data ImportModifier = ImportModifierPattern | ImportModifierType deriving (Eq, Ord, Read, Show) + _ImportModifier = Core.Name "hydra.haskell.syntax.ImportModifier" + _ImportModifier_pattern = Core.Name "pattern" + _ImportModifier_type = Core.Name "type" + -- | An import or export specification data NamedImportExport = NamedImportExport { @@ -406,10 +553,15 @@ -- | Optional subspecification namedImportExportSubspec :: (Maybe ImportExportSubspec)} deriving (Eq, Ord, Read, Show) + _NamedImportExport = Core.Name "hydra.haskell.syntax.NamedImportExport" + _NamedImportExport_modifier = Core.Name "modifier" + _NamedImportExport_name = Core.Name "name" + _NamedImportExport_subspec = Core.Name "subspec" + -- | A subspecification within an import/export data ImportExportSubspec = -- | Import/export all @@ -417,9 +569,13 @@ -- | Import/export specific names ImportExportSubspecList [Name] deriving (Eq, Ord, Read, Show) + _ImportExportSubspec = Core.Name "hydra.haskell.syntax.ImportExportSubspec" + _ImportExportSubspec_all = Core.Name "all" + _ImportExportSubspec_list = Core.Name "list" + -- | A literal value data Literal = -- | A character literal @@ -435,13 +591,21 @@ -- | A string literal LiteralString String deriving (Eq, Ord, Read, Show) + _Literal = Core.Name "hydra.haskell.syntax.Literal" + _Literal_char = Core.Name "char" + _Literal_double = Core.Name "double" + _Literal_float = Core.Name "float" + _Literal_int = Core.Name "int" + _Literal_integer = Core.Name "integer" + _Literal_string = Core.Name "string" + -- | A local binding data LocalBinding = -- | A type signature @@ -449,15 +613,21 @@ -- | A value binding LocalBindingValue ValueBinding deriving (Eq, Ord, Read, Show) + _LocalBinding = Core.Name "hydra.haskell.syntax.LocalBinding" + _LocalBinding_signature = Core.Name "signature" + _LocalBinding_value = Core.Name "value" + -- | A collection of local bindings newtype LocalBindings = LocalBindings { unLocalBindings :: [LocalBinding]} deriving (Eq, Ord, Read, Show) + _LocalBindings = Core.Name "hydra.haskell.syntax.LocalBindings" + -- | A Haskell module data Module = Module { @@ -468,10 +638,15 @@ -- | Module declarations moduleDeclarations :: [Declaration]} deriving (Eq, Ord, Read, Show) + _Module = Core.Name "hydra.haskell.syntax.Module" + _Module_head = Core.Name "head" + _Module_imports = Core.Name "imports" + _Module_declarations = Core.Name "declarations" + -- | A module head data ModuleHead = ModuleHead { @@ -482,16 +657,23 @@ -- | Export list moduleHeadExports :: [Export]} deriving (Eq, Ord, Read, Show) + _ModuleHead = Core.Name "hydra.haskell.syntax.ModuleHead" + _ModuleHead_comments = Core.Name "comments" + _ModuleHead_name = Core.Name "name" + _ModuleHead_exports = Core.Name "exports" + -- | A module name newtype ModuleName = ModuleName { unModuleName :: String} deriving (Eq, Ord, Read, Show) + _ModuleName = Core.Name "hydra.haskell.syntax.ModuleName" + -- | A name data Name = -- | An implicit name @@ -499,15 +681,21 @@ -- | A normal name NameNormal QualifiedName deriving (Eq, Ord, Read, Show) + _Name = Core.Name "hydra.haskell.syntax.Name" + _Name_implicit = Core.Name "implicit" + _Name_normal = Core.Name "normal" + -- | A component of a qualified name newtype NamePart = NamePart { unNamePart :: String} deriving (Eq, Ord, Read, Show) + _NamePart = Core.Name "hydra.haskell.syntax.NamePart" + -- | An operator data Operator = -- | A function used as an infix operator @@ -515,9 +703,13 @@ -- | A normal infix operator OperatorNormal QualifiedName deriving (Eq, Ord, Read, Show) + _Operator = Core.Name "hydra.haskell.syntax.Operator" + _Operator_backtick = Core.Name "backtick" + _Operator_normal = Core.Name "normal" + -- | A pattern data Pattern = -- | An application pattern @@ -539,16 +731,27 @@ -- | A wildcard pattern PatternWildcard deriving (Eq, Ord, Read, Show) + _Pattern = Core.Name "hydra.haskell.syntax.Pattern" + _Pattern_application = Core.Name "application" + _Pattern_as = Core.Name "as" + _Pattern_list = Core.Name "list" + _Pattern_literal = Core.Name "literal" + _Pattern_name = Core.Name "name" + _Pattern_record = Core.Name "record" + _Pattern_tuple = Core.Name "tuple" + _Pattern_typed = Core.Name "typed" + _Pattern_wildcard = Core.Name "wildcard" + -- | An application pattern data ApplicationPattern = ApplicationPattern { @@ -557,9 +760,13 @@ -- | The pattern arguments applicationPatternArgs :: [Pattern]} deriving (Eq, Ord, Read, Show) + _ApplicationPattern = Core.Name "hydra.haskell.syntax.ApplicationPattern" + _ApplicationPattern_name = Core.Name "name" + _ApplicationPattern_args = Core.Name "args" + -- | An 'as' pattern data AsPattern = AsPattern { @@ -568,9 +775,13 @@ -- | The inner pattern asPatternInner :: Pattern} deriving (Eq, Ord, Read, Show) + _AsPattern = Core.Name "hydra.haskell.syntax.AsPattern" + _AsPattern_name = Core.Name "name" + _AsPattern_inner = Core.Name "inner" + -- | A record pattern data RecordPattern = RecordPattern { @@ -579,9 +790,13 @@ -- | The field patterns recordPatternFields :: [PatternField]} deriving (Eq, Ord, Read, Show) + _RecordPattern = Core.Name "hydra.haskell.syntax.RecordPattern" + _RecordPattern_name = Core.Name "name" + _RecordPattern_fields = Core.Name "fields" + -- | A typed pattern data TypedPattern = TypedPattern { @@ -590,9 +805,13 @@ -- | The type annotation typedPatternType :: Type} deriving (Eq, Ord, Read, Show) + _TypedPattern = Core.Name "hydra.haskell.syntax.TypedPattern" + _TypedPattern_inner = Core.Name "inner" + _TypedPattern_type = Core.Name "type" + -- | A pattern field data PatternField = PatternField { @@ -601,9 +820,13 @@ -- | The field pattern patternFieldPattern :: Pattern} deriving (Eq, Ord, Read, Show) + _PatternField = Core.Name "hydra.haskell.syntax.PatternField" + _PatternField_name = Core.Name "name" + _PatternField_pattern = Core.Name "pattern" + -- | A qualified name data QualifiedName = QualifiedName { @@ -612,21 +835,29 @@ -- | The unqualified name part qualifiedNameUnqualified :: NamePart} deriving (Eq, Ord, Read, Show) + _QualifiedName = Core.Name "hydra.haskell.syntax.QualifiedName" + _QualifiedName_qualifiers = Core.Name "qualifiers" + _QualifiedName_unqualified = Core.Name "unqualified" + -- | A right-hand side of a binding newtype RightHandSide = RightHandSide { unRightHandSide :: Expression} deriving (Eq, Ord, Read, Show) + _RightHandSide = Core.Name "hydra.haskell.syntax.RightHandSide" + -- | A do-notation statement newtype Statement = Statement { unStatement :: Expression} deriving (Eq, Ord, Read, Show) + _Statement = Core.Name "hydra.haskell.syntax.Statement" + -- | A type expression data Type = -- | An application type @@ -644,14 +875,23 @@ -- | A type variable or type name TypeVariable Name deriving (Eq, Ord, Read, Show) + _Type = Core.Name "hydra.haskell.syntax.Type" + _Type_application = Core.Name "application" + _Type_ctx = Core.Name "ctx" + _Type_function = Core.Name "function" + _Type_infix = Core.Name "infix" + _Type_list = Core.Name "list" + _Type_tuple = Core.Name "tuple" + _Type_variable = Core.Name "variable" + -- | An application type data ApplicationType = ApplicationType { @@ -660,9 +900,13 @@ -- | The type argument applicationTypeArgument :: Type} deriving (Eq, Ord, Read, Show) + _ApplicationType = Core.Name "hydra.haskell.syntax.ApplicationType" + _ApplicationType_context = Core.Name "context" + _ApplicationType_argument = Core.Name "argument" + -- | A type with a context (type class constraints) data ConstrainedType = ConstrainedType { @@ -671,9 +915,13 @@ -- | The constrained type constrainedTypeType :: Type} deriving (Eq, Ord, Read, Show) + _ConstrainedType = Core.Name "hydra.haskell.syntax.ConstrainedType" + _ConstrainedType_ctx = Core.Name "ctx" + _ConstrainedType_type = Core.Name "type" + -- | A function type data FunctionType = FunctionType { @@ -682,9 +930,13 @@ -- | The codomain type functionTypeCodomain :: Type} deriving (Eq, Ord, Read, Show) + _FunctionType = Core.Name "hydra.haskell.syntax.FunctionType" + _FunctionType_domain = Core.Name "domain" + _FunctionType_codomain = Core.Name "codomain" + -- | An infix type application data InfixType = InfixType { @@ -695,10 +947,15 @@ -- | The right-hand type infixTypeRhs :: Type} deriving (Eq, Ord, Read, Show) + _InfixType = Core.Name "hydra.haskell.syntax.InfixType" + _InfixType_lhs = Core.Name "lhs" + _InfixType_operator = Core.Name "operator" + _InfixType_rhs = Core.Name "rhs" + -- | A type synonym declaration data TypeSynonymDeclaration = TypeSynonymDeclaration { @@ -709,10 +966,15 @@ -- | Optional comments typeSynonymDeclarationComments :: (Maybe String)} deriving (Eq, Ord, Read, Show) + _TypeSynonymDeclaration = Core.Name "hydra.haskell.syntax.TypeSynonymDeclaration" + _TypeSynonymDeclaration_name = Core.Name "name" + _TypeSynonymDeclaration_type = Core.Name "type" + _TypeSynonymDeclaration_comments = Core.Name "comments" + -- | A type signature data TypeSignature = TypeSignature { @@ -721,9 +983,13 @@ -- | The type typeSignatureType :: Type} deriving (Eq, Ord, Read, Show) + _TypeSignature = Core.Name "hydra.haskell.syntax.TypeSignature" + _TypeSignature_name = Core.Name "name" + _TypeSignature_type = Core.Name "type" + -- | A binding with its type signature data TypedBinding = TypedBinding { @@ -734,17 +1000,25 @@ -- | Optional comments typedBindingComments :: (Maybe String)} deriving (Eq, Ord, Read, Show) + _TypedBinding = Core.Name "hydra.haskell.syntax.TypedBinding" + _TypedBinding_typeSignature = Core.Name "typeSignature" + _TypedBinding_valueBinding = Core.Name "valueBinding" + _TypedBinding_comments = Core.Name "comments" + -- | A value binding data ValueBinding = -- | A simple value binding ValueBindingSimple SimpleValueBinding deriving (Eq, Ord, Read, Show) + _ValueBinding = Core.Name "hydra.haskell.syntax.ValueBinding" + _ValueBinding_simple = Core.Name "simple" + -- | A simple value binding data SimpleValueBinding = SimpleValueBinding { @@ -757,14 +1031,21 @@ -- | Optional comments simpleValueBindingComments :: (Maybe String)} deriving (Eq, Ord, Read, Show) + _SimpleValueBinding = Core.Name "hydra.haskell.syntax.SimpleValueBinding" + _SimpleValueBinding_pattern = Core.Name "pattern" + _SimpleValueBinding_rhs = Core.Name "rhs" + _SimpleValueBinding_localBindings = Core.Name "localBindings" + _SimpleValueBinding_comments = Core.Name "comments" + -- | A type variable newtype Variable = Variable { unVariable :: Name} deriving (Eq, Ord, Read, Show) + _Variable = Core.Name "hydra.haskell.syntax.Variable" diff --git a/src/main/haskell/Hydra/Haskell/Testing.hs b/src/main/haskell/Hydra/Haskell/Testing.hs --- a/src/main/haskell/Hydra/Haskell/Testing.hs +++ b/src/main/haskell/Hydra/Haskell/Testing.hs @@ -1,34 +1,40 @@ -- Note: this is an automatically generated file. Do not edit. + -- | Haskell test code generation for HSpec-based generation tests module Hydra.Haskell.Testing where + import qualified Hydra.Ast as Ast import qualified Hydra.Coders as Coders import qualified Hydra.Constants as Constants import qualified Hydra.Core as Core import qualified Hydra.Decode.Core as DecodeCore import qualified Hydra.Dependencies as Dependencies +import qualified Hydra.Docs as Docs import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors +import qualified Hydra.File as File import qualified Hydra.Formatting as Formatting import qualified Hydra.Graph as Graph import qualified Hydra.Haskell.Syntax as Syntax import qualified Hydra.Haskell.Utils as Utils import qualified Hydra.Json.Model as Model import qualified Hydra.Lexical as Lexical -import qualified Hydra.Haskell.Lib.Eithers as Eithers -import qualified Hydra.Haskell.Lib.Equality as Equality -import qualified Hydra.Haskell.Lib.Lists as Lists -import qualified Hydra.Haskell.Lib.Literals as Literals -import qualified Hydra.Haskell.Lib.Logic as Logic -import qualified Hydra.Haskell.Lib.Maps as Maps -import qualified Hydra.Haskell.Lib.Math as Math -import qualified Hydra.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Haskell.Lib.Sets as Sets -import qualified Hydra.Haskell.Lib.Strings as Strings +import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals +import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Overlay.Haskell.Lib.Math as Math +import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Names as Names import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing @@ -40,8 +46,10 @@ import qualified Hydra.Scoping as Scoping import qualified Hydra.Show.Errors as ShowErrors import qualified Hydra.Strip as Strip +import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -51,6 +59,7 @@ import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci import qualified Data.Set as S + -- | Add namespaces from a set of names to existing namespaces addNamespacesToNamespaces :: Util.ModuleNames Syntax.ModuleName -> S.Set Core.Name -> Util.ModuleNames Syntax.ModuleName addNamespacesToNamespaces ns0 names = @@ -62,6 +71,7 @@ in Util.ModuleNames { Util.moduleNamesFocus = (Util.moduleNamesFocus ns0), Util.moduleNamesMapping = (Maps.union (Util.moduleNamesMapping ns0) newMappings)} + -- | Build namespaces for a test group including encoded term references buildNamespacesForTestGroup :: Packaging.Module -> Testing.TestGroup -> Graph.Graph -> Either String (Util.ModuleNames Syntax.ModuleName) buildNamespacesForTestGroup mod tgroup graph_ = @@ -86,6 +96,7 @@ in (Eithers.bind (Eithers.bimap (\e -> ShowErrors.error e) (\a -> a) (Utils.namespacesForModule tempModule Lexical.emptyInferenceContext graph_)) (\baseNamespaces -> let encodedNames = Sets.unions (Lists.map (\t -> extractEncodedTermVariableNames graph_ t) testTerms) in (Right (addNamespacesToNamespaces baseNamespaces encodedNames)))) + -- | Build the complete test module for Haskell HSpec buildTestModule :: Packaging.Module -> Testing.TestGroup -> String -> Util.ModuleNames Syntax.ModuleName -> String buildTestModule testModule testGroup testBody namespaces = @@ -129,21 +140,26 @@ "\n", testBody, "\n"]) + -- | Collect variable names from encoded terms within a single term node collectNames :: Graph.Graph -> S.Set Core.Name -> Core.Term -> S.Set Core.Name collectNames graf names t = Logic.ifElse (Predicates.isEncodedTerm (Strip.deannotateTerm t)) (Eithers.either (\_ -> names) (\decodedTerm -> Sets.union names (Dependencies.termDependencyNames True True True decodedTerm)) (Eithers.bimap (\_e -> _e) (\_a -> _a) (DecodeCore.term graf t))) names + -- | Collect all test cases from a test group recursively collectTestCases :: Testing.TestGroup -> [Testing.TestCaseWithMetadata] collectTestCases tg = Lists.concat2 (Testing.testGroupCases tg) (Lists.concat (Lists.map collectTestCases (Testing.testGroupSubgroups tg))) + -- | Extract all variable names from term-encoded terms in a given term extractEncodedTermVariableNames :: Graph.Graph -> Core.Term -> S.Set Core.Name extractEncodedTermVariableNames graf term = Rewriting.foldOverTerm Coders.TraversalOrderPre (collectNames graf) Sets.empty term + -- | Extract input and output terms from a test case extractTestTerms :: t0 -> [t1] extractTestTerms tcm = [] + -- | Find necessary imports for Haskell based on referenced names findHaskellImports :: Util.ModuleNames Syntax.ModuleName -> t0 -> [String] findHaskellImports namespaces names_ = @@ -156,10 +172,12 @@ (Strings.intercalate "." (Lists.map Formatting.capitalize (Strings.splitOn "." (Packaging.unModuleName (Pairs.first entry))))), " as ", (Syntax.unModuleName (Pairs.second entry))]) (Maps.toList filtered)) + -- | Generate a Haskell test file for a test group, with type inference and namespace building generateHaskellTestFile :: Packaging.Module -> Testing.TestGroup -> Graph.Graph -> Either String (String, String) generateHaskellTestFile testModule testGroup g = Eithers.bind (buildNamespacesForTestGroup testModule testGroup g) (\namespaces -> generateTestFile testModule testGroup namespaces) + -- | Generate a single HSpec test case from a universal test case generateTestCase :: t0 -> Testing.TestCaseWithMetadata -> Either t1 [String] generateTestCase depth tcm = @@ -184,6 +202,7 @@ " (", expected_, ")"])]) + -- | Generate a complete Haskell test file generateTestFile :: Packaging.Module -> Testing.TestGroup -> Util.ModuleNames Syntax.ModuleName -> Either t0 (String, String) generateTestFile testModule testGroup namespaces = @@ -191,8 +210,9 @@ let testModuleContent = buildTestModule testModule testGroup testBody namespaces ns_ = Packaging.moduleName testModule specNs = Packaging.ModuleName (Strings.cat2 (Packaging.unModuleName ns_) "Spec") - filePath = Names.moduleNameToFilePath Util.CaseConventionPascal (Util.FileExtension "hs") specNs + filePath = Names.moduleNameToFilePath Util.CaseConventionPascal (File.FileExtension "hs") specNs in (filePath, testModuleContent)) (generateTestGroupHierarchy 1 testGroup) + -- | Generate test hierarchy preserving the structure with H.describe blocks for subgroups generateTestGroupHierarchy :: Int -> Testing.TestGroup -> Either t0 String generateTestGroupHierarchy depth testGroup = @@ -214,6 +234,7 @@ (Literals.showString groupName_), " $ do\n", content]) (generateTestGroupHierarchy (Math.add depth 1) subgroup))) subgroups))))) + -- | Convert namespace to Haskell module name namespaceToModuleName :: Packaging.ModuleName -> String namespaceToModuleName ns_ = diff --git a/src/main/haskell/Hydra/Haskell/Utils.hs b/src/main/haskell/Hydra/Haskell/Utils.hs --- a/src/main/haskell/Hydra/Haskell/Utils.hs +++ b/src/main/haskell/Hydra/Haskell/Utils.hs @@ -1,30 +1,36 @@ -- Note: this is an automatically generated file. Do not edit. + -- | Utilities for working with Haskell syntax trees module Hydra.Haskell.Utils where + import qualified Hydra.Analysis as Analysis import qualified Hydra.Ast as Ast import qualified Hydra.Coders as Coders import qualified Hydra.Core as Core +import qualified Hydra.Docs as Docs import qualified Hydra.Error.Checking as Checking import qualified Hydra.Error.Core as ErrorCore +import qualified Hydra.Error.File as ErrorFile import qualified Hydra.Error.Packaging as ErrorPackaging +import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors +import qualified Hydra.File as File import qualified Hydra.Formatting as Formatting import qualified Hydra.Graph as Graph import qualified Hydra.Haskell.Language as Language import qualified Hydra.Haskell.Syntax as Syntax import qualified Hydra.Json.Model as Model -import qualified Hydra.Haskell.Lib.Eithers as Eithers -import qualified Hydra.Haskell.Lib.Equality as Equality -import qualified Hydra.Haskell.Lib.Lists as Lists -import qualified Hydra.Haskell.Lib.Logic as Logic -import qualified Hydra.Haskell.Lib.Maps as Maps -import qualified Hydra.Haskell.Lib.Math as Math -import qualified Hydra.Haskell.Lib.Optionals as Optionals -import qualified Hydra.Haskell.Lib.Pairs as Pairs -import qualified Hydra.Haskell.Lib.Sets as Sets -import qualified Hydra.Haskell.Lib.Strings as Strings +import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers +import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality +import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists +import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic +import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps +import qualified Hydra.Overlay.Haskell.Lib.Math as Math +import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals +import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs +import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets +import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Names as Names import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing @@ -32,8 +38,10 @@ import qualified Hydra.Query as Query import qualified Hydra.Relational as Relational import qualified Hydra.Strip as Strip +import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing +import qualified Hydra.Time as Time import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing @@ -43,12 +51,14 @@ import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) import qualified Data.Scientific as Sci import qualified Data.Set as S + -- | Create an application pattern from a name and argument patterns applicationPattern :: Syntax.Name -> [Syntax.Pattern] -> Syntax.Pattern applicationPattern name args = Syntax.PatternApplication (Syntax.ApplicationPattern { Syntax.applicationPatternName = name, Syntax.applicationPatternArgs = args}) + -- | Generate a Haskell name reference for a Hydra element elementReference :: Util.ModuleNames Syntax.ModuleName -> Core.Name -> Syntax.Name elementReference namespaces name = @@ -67,12 +77,14 @@ aliasStr, ".", (sanitizeHaskellName local)])))))) + -- | Create a Haskell function application expression hsapp :: Syntax.Expression -> Syntax.Expression -> Syntax.Expression hsapp l r = Syntax.ExpressionApplication (Syntax.ApplicationExpression { Syntax.applicationExpressionFunction = l, Syntax.applicationExpressionArgument = r}) + -- | Create a Haskell lambda expression hslambda :: Syntax.Name -> Syntax.Expression -> Syntax.Expression hslambda name rhs = @@ -80,12 +92,15 @@ Syntax.lambdaExpressionBindings = [ Syntax.PatternName name], Syntax.lambdaExpressionInner = rhs}) + -- | Create a Haskell literal expression hslit :: Syntax.Literal -> Syntax.Expression hslit lit = Syntax.ExpressionLiteral lit + -- | Create a Haskell variable expression from a string hsvar :: String -> Syntax.Expression hsvar s = Syntax.ExpressionVariable (rawName s) + -- | Compute the Haskell module namespaces for a Hydra module namespacesForModule :: Packaging.Module -> t0 -> Graph.Graph -> Either Errors.Error (Util.ModuleNames Syntax.ModuleName) namespacesForModule mod cx g = @@ -155,15 +170,18 @@ in (Right (Util.ModuleNames { Util.moduleNamesFocus = focusPair, Util.moduleNamesMapping = resultMap}))) + -- | Generate an accessor name for a newtype wrapper (e.g., 'unFoo' for Foo) newtypeAccessorName :: Core.Name -> String newtypeAccessorName name = Strings.cat2 "un" (Names.localNameOf name) + -- | Create a raw Haskell name from a string without sanitization rawName :: String -> Syntax.Name rawName n = Syntax.NameNormal (Syntax.QualifiedName { Syntax.qualifiedNameQualifiers = [], Syntax.qualifiedNameUnqualified = (Syntax.NamePart n)}) + -- | Generate a Haskell name for a record field accessor recordFieldReference :: Util.ModuleNames Syntax.ModuleName -> Core.Name -> Core.Name -> Syntax.Name recordFieldReference namespaces sname fname = @@ -181,12 +199,15 @@ Util.qualifiedNameLocal = nm} unqualName = Names.unqualifyName qualName in (elementReference namespaces unqualName) + -- | Sanitize a string to be a valid Haskell identifier, escaping reserved words sanitizeHaskellName :: String -> String sanitizeHaskellName = Formatting.sanitizeWithUnderscores Language.reservedWords + -- | Create a sanitized Haskell name from a string simpleName :: String -> Syntax.Name simpleName arg_ = rawName (sanitizeHaskellName arg_) + -- | Create a simple value binding (e.g., 'foo = expr' or 'foo = expr where ...') simpleValueBinding :: Syntax.Name -> Syntax.Expression -> Maybe Syntax.LocalBindings -> Syntax.ValueBinding simpleValueBinding hname rhs bindings = @@ -201,6 +222,7 @@ Syntax.simpleValueBindingRhs = rightHandSide, Syntax.simpleValueBindingLocalBindings = bindings, Syntax.simpleValueBindingComments = Nothing})) + -- | Convert a list of types into a nested type application toTypeApplication :: [Syntax.Type] -> Syntax.Type toTypeApplication types = @@ -214,6 +236,7 @@ Syntax.applicationTypeContext = (app (Pairs.second p)), Syntax.applicationTypeArgument = (Pairs.first p)}))) (Lists.uncons l)) in (app (Lists.reverse types)) + -- | Extract the local type name from a fully qualified record type name typeNameForRecord :: Core.Name -> String typeNameForRecord sname = @@ -221,6 +244,7 @@ let snameStr = Core.unName sname parts = Strings.splitOn "." snameStr in (Optionals.fromOptional snameStr (Lists.maybeLast parts)) + -- | Generate a Haskell name for a union variant constructor, with disambiguation unionFieldReference :: S.Set Core.Name -> Util.ModuleNames Syntax.ModuleName -> Core.Name -> Core.Name -> Syntax.Name unionFieldReference boundNames namespaces sname fname = @@ -245,6 +269,7 @@ Util.qualifiedNameLocal = nm} unqualName = Names.unqualifyName qualName in (elementReference namespaces unqualName) + -- | Unpack nested forall types into a list of type variables and the inner type unpackForallType :: Core.Type -> ([Core.Name], Core.Type) unpackForallType t =