hydra-typescript 0.17.0 → 0.17.1

raw patch · 5 files changed

+1164/−8 lines, 5 filesdep ~hydra-kernelPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: hydra-kernel

API changes (from Hackage documentation)

Files

• CHANGELOG.md +139/−0
• hydra-typescript.cabal +4/−3
• src/main/haskell/Hydra/Dsl/TypeScript/Syntax.hs +328/−0
• src/main/haskell/Hydra/Overlay/Haskell/Dsl/TypeScript/Helpers.hs +623/−0
• src/main/haskell/Hydra/TypeScript/Coder.hs +70/−5

@@ -15,6 +15,145 @@  --- +## [0.17.1] - unreleased++Development version. Opens the 0.17.x line — the first release built entirely against+published 0.17.0 hosts (Hackage / PyPI / Maven Central), with the `hostOverrides` shims+that were needed while 0.16.1 lacked the effect type and I/O primitives removed.++### New features++- **Generated term-reference DSLs** ([#467](https://github.com/CategoricalData/hydra/issues/467)):+  kernel *term* modules now project generated DSL surfaces, completing the story begun with+  type-module DSLs and the generated primitive wrappers (`hydra.dsl.lib.*`, 0.17.0). A+  signature read-back in the DSL pass reuses the main pass's inference, and a demand-curated+  set of 19 kernel term modules (plus the json/test/extract modules) emits one typed,+  rename-safe reference per definition into every target language — e.g. Haskell+  `Hydra.Dsl.Strip.deannotateType`, Java `hydra.dsl.Strip.deannotateType(...)`, Python+  `hydra.dsl.strip.deannotate_type(...)`. The Java and Python coder sources were pivoted onto+  the generated references, retiring ~700 stringly-typed inline `var("hydra....")` references+  and shrinking Python's hand registry to the non-generatable remainder (byte-identical+  generated output before and after). Follow-ups:+  [#555](https://github.com/CategoricalData/hydra/issues/555) (typed references to derived+  encode/decode/show functions via `TypedName`),+  [#556](https://github.com/CategoricalData/hydra/issues/556) (non-kernel packages).+- **Package validation** ([#574](https://github.com/CategoricalData/hydra/issues/574),+  [#575](https://github.com/CategoricalData/hydra/issues/575)): a translingual `hydra.validate.*`+  framework carries per-package `ValidationProfile`s (error/warning rules, error/warning caps) and a+  catalog of checks — undeclared-package-dependency detection (now a fatal gate, #574),+  definition-name convention (PascalCase), definition ordering, documentation completeness, and+  conflicting-variant-name detection — layered on the existing core term/type well-formedness rules.+  A kernel-strict / others-relaxed policy keeps `/sync` green fleet-wide while the documentation+  backlog drains. See the new [Validation](https://github.com/CategoricalData/hydra/wiki/Validation)+  wiki page for the full per-package constraint specification.+- **DSL-authoring registration guards** ([#554](https://github.com/CategoricalData/hydra/issues/554)):+  fail-fast authoring-time validation for the host-native DSL sources — every DSL-authoring module in+  Java/`hydra-jvm`, Python, and Scala now asserts its definitions are fully registered+  (`Defs.checkComplete` / `check_complete`), backed by a Haskell kernel-source registration-completeness+  scanner, so a definition added to a source file but omitted from its `definitions` list fails loudly+  instead of silently vanishing from the generated output.+- **`hydra-build` package** ([#546](https://github.com/CategoricalData/hydra/issues/546),+  [#529](https://github.com/CategoricalData/hydra/issues/529),+  [#530](https://github.com/CategoricalData/hydra/issues/530)): the build-orchestration logic that had+  lived only in host scripts is now translingual Hydra. Pure module-list utilities became+  `hydra.build.modules` (#529) and the orphan-reconcile decision became `hydra.build.reconcile` (#530),+  each with a translingual test suite; the `hydra.build.*` modules were then extracted into a dedicated+  `hydra-build` package (#546), separate from the kernel.+- **Metadata sidecar + content/version-addressed freshness**+  ([#415](https://github.com/CategoricalData/hydra/issues/415)): dist manifests now carry a+  `moduleFormatVersion` field, and the generator's freshness basis is content/version-addressed — the+  groundwork for reproducible, cache-correct incremental generation.+- **Structured generation-provenance record**+  ([#523](https://github.com/CategoricalData/hydra/issues/523)): each generation run now records a+  structured `Generation` provenance entry (digest v2), replacing the ad-hoc shell threading of+  generation metadata.+- **Worker + issue hierarchy** ([#557](https://github.com/CategoricalData/hydra/issues/557)): a+  principled agent/worker framework — roles and parentage mirroring the GitHub issue tree, a+  cross-worktree message transport with a verify-after-copy protocol, a blocking-aware design-question+  (`decisions/`) channel, an issue-proposal queue with the `/issues` command, an autonomy-dial banner,+  and cross-machine staging coordination. Contributor-facing process only; no change to generated code.++### API and usability++- **DSL usability passes** ([#430](https://github.com/CategoricalData/hydra/issues/430),+  [#553](https://github.com/CategoricalData/hydra/issues/553)): reviewed the host-native Java, Python,+  and Scala DSL surfaces for ergonomics and cross-host parity (documented def shapes, added a Scala+  projection helper), bringing the three authoring dialects into closer alignment.++### Fixed++Bug fixes landed this cycle, grouped by area (see each issue for detail):++- **TypeScript** — reactivated `hydra.lib.*` primitive tests surfaced encoder gaps: lazy show-calling+  let bindings and compact bare-string `LiteralType` expansion in the test converter+  ([#564](https://github.com/CategoricalData/hydra/issues/564)),+  `binaryToBytes` registration + base64 binary decode in `decodeUtf8`+  ([#561](https://github.com/CategoricalData/hydra/issues/561)),+  `hydra.test.build.*` emission after the #546 split+  ([#570](https://github.com/CategoricalData/hydra/issues/570)), and `HYDRA_DEFAULT_IMPLS` support in+  the test runner ([#536](https://github.com/CategoricalData/hydra/issues/536)).+- **Tests and CI** — restored the default-primitive-implementation testing solution+  ([#388](https://github.com/CategoricalData/hydra/issues/388),+  [#549](https://github.com/CategoricalData/hydra/issues/549)), reactivated previously-ignored kernel+  test cases ([#513](https://github.com/CategoricalData/hydra/issues/513),+  [#550](https://github.com/CategoricalData/hydra/issues/550)), wired the regression harnesses into CI+  and split them out of the monolithic Haskell job for timeout headroom+  ([#535](https://github.com/CategoricalData/hydra/issues/535),+  [#563](https://github.com/CategoricalData/hydra/issues/563)), added Scala/Go/Lisp+  self-containment gates to `verify-distribution.sh`+  ([#537](https://github.com/CategoricalData/hydra/issues/537)), a manifest-JSON-tracked CI check+  ([#541](https://github.com/CategoricalData/hydra/issues/541)), a per-package test-digest freshness+  fix ([#551](https://github.com/CategoricalData/hydra/issues/551)), overlay-file restoration in+  `test-stale-output-prune.sh` ([#558](https://github.com/CategoricalData/hydra/issues/558)), and a+  sync-freshness fingerprint that now sees host-native DSL sources+  ([#562](https://github.com/CategoricalData/hydra/issues/562)).+- **Kernel and coders** — Java binary-literal signed-byte emission+  ([#528](https://github.com/CategoricalData/hydra/issues/528)), `hydra.json.Decode.fromJson`+  parametric-type (Application/Forall) support+  ([#531](https://github.com/CategoricalData/hydra/issues/531)), stale 2-param `Coder` shape in+  Java/Scala test bootstrap ([#552](https://github.com/CategoricalData/hydra/issues/552)), and a+  kernel dead-code/TODO cleanup ([#538](https://github.com/CategoricalData/hydra/issues/538)).+- **Lib and build** — `hydra.lib.files` copy/removeDirectory/status overlays across all nine hosts+  ([#525](https://github.com/CategoricalData/hydra/issues/525)), `hydra.build.*` regeneration into the+  Lisp dialects ([#544](https://github.com/CategoricalData/hydra/issues/544)), Scheme maps+  last-writer-wins in `union` ([#545](https://github.com/CategoricalData/hydra/issues/545)),+  standalone-kernel SHA dependency ([#542](https://github.com/CategoricalData/hydra/issues/542)),+  the lexicon's empty Types section ([#539](https://github.com/CategoricalData/hydra/issues/539)), and+  a duplicated generated-file header in `generate-head-haskell-build.py`+  ([#540](https://github.com/CategoricalData/hydra/issues/540)).++- **TypeScript overlay-import rewrite** ([#565](https://github.com/CategoricalData/hydra/issues/565)):+  the TypeScript coder's lib overlay-import rewrite no longer captures `hydra.lib.defaults`, which is a+  generated (not overlaid) module; excluding it fixes spurious import references in generated TypeScript.++- **Lexicon generation** (`bin/regenerate-lexicon.sh`): the generator had been failing+  silently since the encoder/decoder modules moved to in-memory synthesis+  ([#448](https://github.com/CategoricalData/hydra/issues/448)) — the script masked the+  failure and left a stale `docs/hydra-lexicon.txt` missing the four effectful primitive+  libraries (`hydra.lib.{effects,files,system,text}`). The synthesized coder modules are+  now included in the lexicon universe, the script fails loudly, and the regenerated+  lexicon covers all 267 primitives across 17 library modules.+- **`bin/prepare-release.sh`**: the non-blocking Java quality check invoked Gradle+  subprojects (`:hydra-rdf4j:test` etc.) that were removed in+  [#511](https://github.com/CategoricalData/hydra/issues/511), so it always warned without+  checking anything; it now runs the `dist/java/hydra-pg` package tests (the current home+  of the former binding tests).+- **`.gitignore`**: the ignore rules for the overlaid hand-written Haskell runtime still+  named pre-[#501](https://github.com/CategoricalData/hydra/issues/501) paths, so 41+  duplicate copies under `dist/haskell/` had become tracked; the rules now match the+  `Hydra/Overlay/` location and the duplicates are untracked.++### Documentation++- Corrected the 0.17.0 Maven coordinates throughout (Java artifacts publish under group+  `net.fortytwo.hydra.java`, Scala under `net.fortytwo.hydra.scala`,+  [#519](https://github.com/CategoricalData/hydra/issues/519)); added the npm and Scala+  release channels to the README; added TypeScript/Scala/Lisp sections to Getting started;+  repointed stale pre-#418/#501 DSL paths in the architecture docs; added GitHub issue and+  PR templates.++---+ ## [0.17.0] - 2026-07-01  Major themes: first-class support for effects and I/O in the kernel, TypeScript and

@@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.39.1.+-- This file has been generated from package.yaml by hpack version 0.38.1. -- -- see: https://github.com/sol/hpack  name:           hydra-typescript-version:        0.17.0+version:        0.17.1 synopsis:       Hydra's TypeScript coder: emit TypeScript 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". TypeScript support for Hydra category:       Data@@ -28,6 +28,7 @@ library   exposed-modules:       Hydra.Dsl.TypeScript.Syntax+      Hydra.Overlay.Haskell.Dsl.TypeScript.Helpers       Hydra.TypeScript.Coder       Hydra.TypeScript.Language       Hydra.TypeScript.Operators@@ -40,6 +41,6 @@   build-depends:       base >=4.19.0 && <4.22     , containers >=0.6.7 && <0.8-    , hydra-kernel ==0.17.0+    , hydra-kernel ==0.17.1     , scientific >=0.3.7 && <0.4   default-language: Haskell2010

@@ -12,6 +12,10 @@ import qualified Data.Scientific as Sci import qualified Data.Int as I +-- | DSL name token for hydra.typeScript.syntax.ArrayElement+arrayElementArrayElement :: Typed.TypedName Syntax.ArrayElement+arrayElementArrayElement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ArrayElement")+ -- | DSL injection for the expression variant of hydra.typeScript.syntax.ArrayElement arrayElementExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ArrayElement arrayElementExpression x =@@ -46,6 +50,14 @@       Core.wrappedTermTypeName = (Core.Name "hydra.typeScript.syntax.ArrayTypeExpression"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ArrayTypeExpression+arrayTypeExpressionArrayTypeExpression :: Typed.TypedName Syntax.ArrayTypeExpression+arrayTypeExpressionArrayTypeExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ArrayTypeExpression")++-- | DSL name token for hydra.typeScript.syntax.ArrowFunctionBody+arrowFunctionBodyArrowFunctionBody :: Typed.TypedName Syntax.ArrowFunctionBody+arrowFunctionBodyArrowFunctionBody = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ArrowFunctionBody")+ -- | DSL injection for the block variant of hydra.typeScript.syntax.ArrowFunctionBody arrowFunctionBodyBlock :: Typed.TypedTerm Syntax.BlockStatement -> Typed.TypedTerm Syntax.ArrowFunctionBody arrowFunctionBodyBlock x =@@ -80,6 +92,11 @@           Core.fieldName = (Core.Name "async"),           Core.fieldTerm = (Typed.unTypedTerm async)}]})) +-- | DSL name token for hydra.typeScript.syntax.ArrowFunctionExpression+arrowFunctionExpressionArrowFunctionExpression :: Typed.TypedName Syntax.ArrowFunctionExpression+arrowFunctionExpressionArrowFunctionExpression =+    Typed.TypedName (Core.Name "hydra.typeScript.syntax.ArrowFunctionExpression")+ -- | DSL accessor for the async field of hydra.typeScript.syntax.ArrowFunctionExpression arrowFunctionExpressionAsync :: Typed.TypedTerm Syntax.ArrowFunctionExpression -> Typed.TypedTerm Bool arrowFunctionExpressionAsync x =@@ -192,6 +209,10 @@           Core.fieldName = (Core.Name "type"),           Core.fieldTerm = (Typed.unTypedTerm type_)}]})) +-- | DSL name token for hydra.typeScript.syntax.AsExpression+asExpressionAsExpression :: Typed.TypedName Syntax.AsExpression+asExpressionAsExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.AsExpression")+ -- | DSL accessor for the expression field of hydra.typeScript.syntax.AsExpression asExpressionExpression :: Typed.TypedTerm Syntax.AsExpression -> Typed.TypedTerm Syntax.Expression asExpressionExpression x =@@ -260,6 +281,10 @@           Core.fieldName = (Core.Name "right"),           Core.fieldTerm = (Typed.unTypedTerm right)}]})) +-- | DSL name token for hydra.typeScript.syntax.AssignmentExpression+assignmentExpressionAssignmentExpression :: Typed.TypedName Syntax.AssignmentExpression+assignmentExpressionAssignmentExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.AssignmentExpression")+ -- | DSL accessor for the left field of hydra.typeScript.syntax.AssignmentExpression assignmentExpressionLeft :: Typed.TypedTerm Syntax.AssignmentExpression -> Typed.TypedTerm Syntax.Pattern assignmentExpressionLeft x =@@ -386,6 +411,10 @@         Core.fieldName = (Core.Name "assign"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.typeScript.syntax.AssignmentOperator+assignmentOperatorAssignmentOperator :: Typed.TypedName Syntax.AssignmentOperator+assignmentOperatorAssignmentOperator = Typed.TypedName (Core.Name "hydra.typeScript.syntax.AssignmentOperator")+ -- | DSL injection for the bitwiseAndAssign variant of hydra.typeScript.syntax.AssignmentOperator assignmentOperatorBitwiseAndAssign :: Typed.TypedTerm Syntax.AssignmentOperator assignmentOperatorBitwiseAndAssign =@@ -516,6 +545,10 @@           Core.fieldName = (Core.Name "right"),           Core.fieldTerm = (Typed.unTypedTerm right)}]})) +-- | DSL name token for hydra.typeScript.syntax.AssignmentPattern+assignmentPatternAssignmentPattern :: Typed.TypedName Syntax.AssignmentPattern+assignmentPatternAssignmentPattern = Typed.TypedName (Core.Name "hydra.typeScript.syntax.AssignmentPattern")+ -- | DSL accessor for the left field of hydra.typeScript.syntax.AssignmentPattern assignmentPatternLeft :: Typed.TypedTerm Syntax.AssignmentPattern -> Typed.TypedTerm Syntax.Pattern assignmentPatternLeft x =@@ -584,6 +617,10 @@           Core.fieldName = (Core.Name "right"),           Core.fieldTerm = (Typed.unTypedTerm right)}]})) +-- | DSL name token for hydra.typeScript.syntax.BinaryExpression+binaryExpressionBinaryExpression :: Typed.TypedName Syntax.BinaryExpression+binaryExpressionBinaryExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.BinaryExpression")+ -- | DSL accessor for the left field of hydra.typeScript.syntax.BinaryExpression binaryExpressionLeft :: Typed.TypedTerm Syntax.BinaryExpression -> Typed.TypedTerm Syntax.Expression binaryExpressionLeft x =@@ -701,6 +738,10 @@         Core.fieldName = (Core.Name "and"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.typeScript.syntax.BinaryOperator+binaryOperatorBinaryOperator :: Typed.TypedName Syntax.BinaryOperator+binaryOperatorBinaryOperator = Typed.TypedName (Core.Name "hydra.typeScript.syntax.BinaryOperator")+ -- | DSL injection for the bitwiseAnd variant of hydra.typeScript.syntax.BinaryOperator binaryOperatorBitwiseAnd :: Typed.TypedTerm Syntax.BinaryOperator binaryOperatorBitwiseAnd =@@ -933,6 +974,10 @@         Core.projectionFieldName = (Core.Name "arguments")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.CallExpression+callExpressionCallExpression :: Typed.TypedName Syntax.CallExpression+callExpressionCallExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.CallExpression")+ -- | DSL accessor for the callee field of hydra.typeScript.syntax.CallExpression callExpressionCallee :: Typed.TypedTerm Syntax.CallExpression -> Typed.TypedTerm Syntax.Expression callExpressionCallee x =@@ -1045,6 +1090,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.CatchClause+catchClauseCatchClause :: Typed.TypedName Syntax.CatchClause+catchClauseCatchClause = Typed.TypedName (Core.Name "hydra.typeScript.syntax.CatchClause")+ -- | DSL accessor for the param field of hydra.typeScript.syntax.CatchClause catchClauseParam :: Typed.TypedTerm Syntax.CatchClause -> Typed.TypedTerm (Maybe Syntax.Pattern) catchClauseParam x =@@ -1113,6 +1162,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ClassDeclaration+classDeclarationClassDeclaration :: Typed.TypedName Syntax.ClassDeclaration+classDeclarationClassDeclaration = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ClassDeclaration")+ -- | DSL accessor for the id field of hydra.typeScript.syntax.ClassDeclaration classDeclarationId :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.Identifier classDeclarationId x =@@ -1177,6 +1230,11 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ClassDeclarationWithComments+classDeclarationWithCommentsClassDeclarationWithComments :: Typed.TypedName Syntax.ClassDeclarationWithComments+classDeclarationWithCommentsClassDeclarationWithComments =+    Typed.TypedName (Core.Name "hydra.typeScript.syntax.ClassDeclarationWithComments")+ -- | DSL accessor for the comments field of hydra.typeScript.syntax.ClassDeclarationWithComments classDeclarationWithCommentsComments :: Typed.TypedTerm Syntax.ClassDeclarationWithComments -> Typed.TypedTerm (Maybe Syntax.DocumentationComment) classDeclarationWithCommentsComments x =@@ -1277,6 +1335,10 @@         Core.fieldName = (Core.Name "block"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.Comment+commentComment :: Typed.TypedName Syntax.Comment+commentComment = Typed.TypedName (Core.Name "hydra.typeScript.syntax.Comment")+ -- | DSL injection for the documentation variant of hydra.typeScript.syntax.Comment commentDocumentation :: Typed.TypedTerm Syntax.DocumentationComment -> Typed.TypedTerm Syntax.Comment commentDocumentation x =@@ -1320,6 +1382,10 @@         Core.projectionFieldName = (Core.Name "alternate")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ConditionalExpression+conditionalExpressionConditionalExpression :: Typed.TypedName Syntax.ConditionalExpression+conditionalExpressionConditionalExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ConditionalExpression")+ -- | DSL accessor for the consequent field of hydra.typeScript.syntax.ConditionalExpression conditionalExpressionConsequent :: Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.Expression conditionalExpressionConsequent x =@@ -1432,6 +1498,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.DoWhileStatement+doWhileStatementDoWhileStatement :: Typed.TypedName Syntax.DoWhileStatement+doWhileStatementDoWhileStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.DoWhileStatement")+ -- | DSL accessor for the test field of hydra.typeScript.syntax.DoWhileStatement doWhileStatementTest :: Typed.TypedTerm Syntax.DoWhileStatement -> Typed.TypedTerm Syntax.Expression doWhileStatementTest x =@@ -1497,6 +1567,10 @@         Core.projectionFieldName = (Core.Name "description")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.DocumentationComment+documentationCommentDocumentationComment :: Typed.TypedName Syntax.DocumentationComment+documentationCommentDocumentationComment = Typed.TypedName (Core.Name "hydra.typeScript.syntax.DocumentationComment")+ -- | DSL accessor for the tags field of hydra.typeScript.syntax.DocumentationComment documentationCommentTags :: Typed.TypedTerm Syntax.DocumentationComment -> Typed.TypedTerm [Syntax.DocumentationTag] documentationCommentTags x =@@ -1568,6 +1642,10 @@         Core.projectionFieldName = (Core.Name "description")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.DocumentationTag+documentationTagDocumentationTag :: Typed.TypedName Syntax.DocumentationTag+documentationTagDocumentationTag = Typed.TypedName (Core.Name "hydra.typeScript.syntax.DocumentationTag")+ -- | DSL accessor for the name field of hydra.typeScript.syntax.DocumentationTag documentationTagName :: Typed.TypedTerm Syntax.DocumentationTag -> Typed.TypedTerm String documentationTagName x =@@ -1732,6 +1810,10 @@           Core.fieldName = (Core.Name "source"),           Core.fieldTerm = (Typed.unTypedTerm source)}]})) +-- | DSL name token for hydra.typeScript.syntax.ExportAllDeclaration+exportAllDeclarationExportAllDeclaration :: Typed.TypedName Syntax.ExportAllDeclaration+exportAllDeclarationExportAllDeclaration = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ExportAllDeclaration")+ -- | DSL accessor for the exported field of hydra.typeScript.syntax.ExportAllDeclaration exportAllDeclarationExported :: Typed.TypedTerm Syntax.ExportAllDeclaration -> Typed.TypedTerm (Maybe Syntax.Identifier) exportAllDeclarationExported x =@@ -1811,6 +1893,10 @@         Core.fieldName = (Core.Name "default"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.ExportDeclaration+exportDeclarationExportDeclaration :: Typed.TypedName Syntax.ExportDeclaration+exportDeclarationExportDeclaration = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ExportDeclaration")+ -- | DSL injection for the named variant of hydra.typeScript.syntax.ExportDeclaration exportDeclarationNamed :: Typed.TypedTerm Syntax.NamedExport -> Typed.TypedTerm Syntax.ExportDeclaration exportDeclarationNamed x =@@ -1833,6 +1919,10 @@           Core.fieldName = (Core.Name "exported"),           Core.fieldTerm = (Typed.unTypedTerm exported)}]})) +-- | DSL name token for hydra.typeScript.syntax.ExportSpecifier+exportSpecifierExportSpecifier :: Typed.TypedName Syntax.ExportSpecifier+exportSpecifierExportSpecifier = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ExportSpecifier")+ -- | DSL accessor for the exported field of hydra.typeScript.syntax.ExportSpecifier exportSpecifierExported :: Typed.TypedTerm Syntax.ExportSpecifier -> Typed.TypedTerm Syntax.Identifier exportSpecifierExported x =@@ -1957,6 +2047,10 @@         Core.fieldName = (Core.Name "conditional"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.Expression+expressionExpression :: Typed.TypedName Syntax.Expression+expressionExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.Expression")+ -- | DSL injection for the function variant of hydra.typeScript.syntax.Expression expressionFunction :: Typed.TypedTerm Syntax.FunctionExpression -> Typed.TypedTerm Syntax.Expression expressionFunction x =@@ -2065,6 +2159,10 @@         Core.fieldName = (Core.Name "yield"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.ForInLeft+forInLeftForInLeft :: Typed.TypedName Syntax.ForInLeft+forInLeftForInLeft = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ForInLeft")+ -- | DSL injection for the pattern variant of hydra.typeScript.syntax.ForInLeft forInLeftPattern :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.ForInLeft forInLeftPattern x =@@ -2108,6 +2206,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ForInStatement+forInStatementForInStatement :: Typed.TypedName Syntax.ForInStatement+forInStatementForInStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ForInStatement")+ -- | DSL accessor for the left field of hydra.typeScript.syntax.ForInStatement forInStatementLeft :: Typed.TypedTerm Syntax.ForInStatement -> Typed.TypedTerm Syntax.ForInLeft forInStatementLeft x =@@ -2207,6 +2309,10 @@         Core.fieldName = (Core.Name "expression"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.ForInit+forInitForInit :: Typed.TypedName Syntax.ForInit+forInitForInit = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ForInit")+ -- | DSL injection for the variable variant of hydra.typeScript.syntax.ForInit forInitVariable :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm Syntax.ForInit forInitVariable x =@@ -2253,6 +2359,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ForOfStatement+forOfStatementForOfStatement :: Typed.TypedName Syntax.ForOfStatement+forOfStatementForOfStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ForOfStatement")+ -- | DSL accessor for the left field of hydra.typeScript.syntax.ForOfStatement forOfStatementLeft :: Typed.TypedTerm Syntax.ForOfStatement -> Typed.TypedTerm Syntax.ForInLeft forOfStatementLeft x =@@ -2423,6 +2533,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ForStatement+forStatementForStatement :: Typed.TypedName Syntax.ForStatement+forStatementForStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ForStatement")+ -- | DSL accessor for the init field of hydra.typeScript.syntax.ForStatement forStatementInit :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.ForInit) forStatementInit x =@@ -2614,6 +2728,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.FunctionDeclaration+functionDeclarationFunctionDeclaration :: Typed.TypedName Syntax.FunctionDeclaration+functionDeclarationFunctionDeclaration = Typed.TypedName (Core.Name "hydra.typeScript.syntax.FunctionDeclaration")+ -- | DSL accessor for the generator field of hydra.typeScript.syntax.FunctionDeclaration functionDeclarationGenerator :: Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Bool functionDeclarationGenerator x =@@ -2748,6 +2866,11 @@         Core.projectionFieldName = (Core.Name "comments")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.FunctionDeclarationWithComments+functionDeclarationWithCommentsFunctionDeclarationWithComments :: Typed.TypedName Syntax.FunctionDeclarationWithComments+functionDeclarationWithCommentsFunctionDeclarationWithComments =+    Typed.TypedName (Core.Name "hydra.typeScript.syntax.FunctionDeclarationWithComments")+ -- | DSL updater for the body field of hydra.typeScript.syntax.FunctionDeclarationWithComments functionDeclarationWithCommentsWithBody :: Typed.TypedTerm Syntax.FunctionDeclarationWithComments -> Typed.TypedTerm Syntax.FunctionDeclaration -> Typed.TypedTerm Syntax.FunctionDeclarationWithComments functionDeclarationWithCommentsWithBody original newVal =@@ -2936,6 +3059,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.FunctionExpression+functionExpressionFunctionExpression :: Typed.TypedName Syntax.FunctionExpression+functionExpressionFunctionExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.FunctionExpression")+ -- | DSL accessor for the generator field of hydra.typeScript.syntax.FunctionExpression functionExpressionGenerator :: Typed.TypedTerm Syntax.FunctionExpression -> Typed.TypedTerm Bool functionExpressionGenerator x =@@ -3169,6 +3296,11 @@           Core.fieldName = (Core.Name "returnType"),           Core.fieldTerm = (Typed.unTypedTerm returnType)}]})) +-- | DSL name token for hydra.typeScript.syntax.FunctionTypeExpression+functionTypeExpressionFunctionTypeExpression :: Typed.TypedName Syntax.FunctionTypeExpression+functionTypeExpressionFunctionTypeExpression =+    Typed.TypedName (Core.Name "hydra.typeScript.syntax.FunctionTypeExpression")+ -- | DSL accessor for the parameters field of hydra.typeScript.syntax.FunctionTypeExpression functionTypeExpressionParameters :: Typed.TypedTerm Syntax.FunctionTypeExpression -> Typed.TypedTerm [Syntax.TypeExpression] functionTypeExpressionParameters x =@@ -3275,6 +3407,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.typeScript.syntax.Identifier"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.Identifier+identifierIdentifier :: Typed.TypedName Syntax.Identifier+identifierIdentifier = Typed.TypedName (Core.Name "hydra.typeScript.syntax.Identifier")+ -- | DSL constructor for hydra.typeScript.syntax.IfStatement ifStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm (Maybe Syntax.Statement) -> Typed.TypedTerm Syntax.IfStatement ifStatement test consequent alternate =@@ -3309,6 +3445,10 @@         Core.projectionFieldName = (Core.Name "consequent")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.IfStatement+ifStatementIfStatement :: Typed.TypedName Syntax.IfStatement+ifStatementIfStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.IfStatement")+ -- | DSL accessor for the test field of hydra.typeScript.syntax.IfStatement ifStatementTest :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.Expression ifStatementTest x =@@ -3399,6 +3539,10 @@         Core.fieldName = (Core.Name "default"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.ImportClause+importClauseImportClause :: Typed.TypedName Syntax.ImportClause+importClauseImportClause = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ImportClause")+ -- | DSL injection for the named variant of hydra.typeScript.syntax.ImportClause importClauseNamed :: Typed.TypedTerm Syntax.ImportSpecifier -> Typed.TypedTerm Syntax.ImportClause importClauseNamed x =@@ -3430,6 +3574,10 @@           Core.fieldName = (Core.Name "source"),           Core.fieldTerm = (Typed.unTypedTerm source)}]})) +-- | DSL name token for hydra.typeScript.syntax.ImportDeclaration+importDeclarationImportDeclaration :: Typed.TypedName Syntax.ImportDeclaration+importDeclarationImportDeclaration = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ImportDeclaration")+ -- | DSL accessor for the source field of hydra.typeScript.syntax.ImportDeclaration importDeclarationSource :: Typed.TypedTerm Syntax.ImportDeclaration -> Typed.TypedTerm Syntax.StringLiteral importDeclarationSource x =@@ -3489,6 +3637,11 @@       Core.wrappedTermTypeName = (Core.Name "hydra.typeScript.syntax.ImportDefaultSpecifier"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ImportDefaultSpecifier+importDefaultSpecifierImportDefaultSpecifier :: Typed.TypedName Syntax.ImportDefaultSpecifier+importDefaultSpecifierImportDefaultSpecifier =+    Typed.TypedName (Core.Name "hydra.typeScript.syntax.ImportDefaultSpecifier")+ -- | DSL constructor for the hydra.typeScript.syntax.ImportNamespaceSpecifier wrapper importNamespaceSpecifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ImportNamespaceSpecifier importNamespaceSpecifier x =@@ -3496,6 +3649,11 @@       Core.wrappedTermTypeName = (Core.Name "hydra.typeScript.syntax.ImportNamespaceSpecifier"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ImportNamespaceSpecifier+importNamespaceSpecifierImportNamespaceSpecifier :: Typed.TypedName Syntax.ImportNamespaceSpecifier+importNamespaceSpecifierImportNamespaceSpecifier =+    Typed.TypedName (Core.Name "hydra.typeScript.syntax.ImportNamespaceSpecifier")+ -- | DSL constructor for hydra.typeScript.syntax.ImportSpecifier importSpecifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ImportSpecifier importSpecifier imported local =@@ -3509,6 +3667,10 @@           Core.fieldName = (Core.Name "local"),           Core.fieldTerm = (Typed.unTypedTerm local)}]})) +-- | DSL name token for hydra.typeScript.syntax.ImportSpecifier+importSpecifierImportSpecifier :: Typed.TypedName Syntax.ImportSpecifier+importSpecifierImportSpecifier = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ImportSpecifier")+ -- | DSL accessor for the imported field of hydra.typeScript.syntax.ImportSpecifier importSpecifierImported :: Typed.TypedTerm Syntax.ImportSpecifier -> Typed.TypedTerm Syntax.Identifier importSpecifierImported x =@@ -3589,6 +3751,10 @@         Core.projectionFieldName = (Core.Name "extends")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.InterfaceDeclaration+interfaceDeclarationInterfaceDeclaration :: Typed.TypedName Syntax.InterfaceDeclaration+interfaceDeclarationInterfaceDeclaration = Typed.TypedName (Core.Name "hydra.typeScript.syntax.InterfaceDeclaration")+ -- | DSL accessor for the members field of hydra.typeScript.syntax.InterfaceDeclaration interfaceDeclarationMembers :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.PropertySignature] interfaceDeclarationMembers x =@@ -3771,6 +3937,10 @@         Core.projectionFieldName = (Core.Name "label")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.LabeledStatement+labeledStatementLabeledStatement :: Typed.TypedName Syntax.LabeledStatement+labeledStatementLabeledStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.LabeledStatement")+ -- | DSL updater for the body field of hydra.typeScript.syntax.LabeledStatement labeledStatementWithBody :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStatement labeledStatementWithBody original newVal =@@ -3823,6 +3993,10 @@         Core.fieldName = (Core.Name "boolean"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.Literal+literalLiteral :: Typed.TypedName Syntax.Literal+literalLiteral = Typed.TypedName (Core.Name "hydra.typeScript.syntax.Literal")+ -- | DSL injection for the null variant of hydra.typeScript.syntax.Literal literalNull :: Typed.TypedTerm Syntax.Literal literalNull =@@ -3896,6 +4070,10 @@         Core.projectionFieldName = (Core.Name "computed")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.MemberExpression+memberExpressionMemberExpression :: Typed.TypedName Syntax.MemberExpression+memberExpressionMemberExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.MemberExpression")+ -- | DSL accessor for the object field of hydra.typeScript.syntax.MemberExpression memberExpressionObject :: Typed.TypedTerm Syntax.MemberExpression -> Typed.TypedTerm Syntax.Expression memberExpressionObject x =@@ -4096,6 +4274,10 @@         Core.projectionFieldName = (Core.Name "kind")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.MethodDefinition+methodDefinitionMethodDefinition :: Typed.TypedName Syntax.MethodDefinition+methodDefinitionMethodDefinition = Typed.TypedName (Core.Name "hydra.typeScript.syntax.MethodDefinition")+ -- | DSL accessor for the static field of hydra.typeScript.syntax.MethodDefinition methodDefinitionStatic :: Typed.TypedTerm Syntax.MethodDefinition -> Typed.TypedTerm Bool methodDefinitionStatic x =@@ -4331,6 +4513,10 @@         Core.fieldName = (Core.Name "method"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.typeScript.syntax.MethodKind+methodKindMethodKind :: Typed.TypedName Syntax.MethodKind+methodKindMethodKind = Typed.TypedName (Core.Name "hydra.typeScript.syntax.MethodKind")+ -- | DSL injection for the set variant of hydra.typeScript.syntax.MethodKind methodKindSet :: Typed.TypedTerm Syntax.MethodKind methodKindSet =@@ -4367,6 +4553,10 @@         Core.fieldName = (Core.Name "interface"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.ModuleItem+moduleItemModuleItem :: Typed.TypedName Syntax.ModuleItem+moduleItemModuleItem = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ModuleItem")+ -- | DSL injection for the statement variant of hydra.typeScript.syntax.ModuleItem moduleItemStatement :: Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.ModuleItem moduleItemStatement x =@@ -4416,6 +4606,11 @@         Core.projectionFieldName = (Core.Name "comments")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ModuleItemWithComments+moduleItemWithCommentsModuleItemWithComments :: Typed.TypedName Syntax.ModuleItemWithComments+moduleItemWithCommentsModuleItemWithComments =+    Typed.TypedName (Core.Name "hydra.typeScript.syntax.ModuleItemWithComments")+ -- | DSL updater for the body field of hydra.typeScript.syntax.ModuleItemWithComments moduleItemWithCommentsWithBody :: Typed.TypedTerm Syntax.ModuleItemWithComments -> Typed.TypedTerm Syntax.ModuleItem -> Typed.TypedTerm Syntax.ModuleItemWithComments moduleItemWithCommentsWithBody original newVal =@@ -4463,6 +4658,10 @@           Core.fieldName = (Core.Name "source"),           Core.fieldTerm = (Typed.unTypedTerm source)}]})) +-- | DSL name token for hydra.typeScript.syntax.NamedExport+namedExportNamedExport :: Typed.TypedName Syntax.NamedExport+namedExportNamedExport = Typed.TypedName (Core.Name "hydra.typeScript.syntax.NamedExport")+ -- | DSL accessor for the source field of hydra.typeScript.syntax.NamedExport namedExportSource :: Typed.TypedTerm Syntax.NamedExport -> Typed.TypedTerm (Maybe Syntax.StringLiteral) namedExportSource x =@@ -4533,6 +4732,10 @@         Core.fieldName = (Core.Name "integer"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.NumericLiteral+numericLiteralNumericLiteral :: Typed.TypedName Syntax.NumericLiteral+numericLiteralNumericLiteral = Typed.TypedName (Core.Name "hydra.typeScript.syntax.NumericLiteral")+ -- | DSL constructor for hydra.typeScript.syntax.ObjectPattern objectPattern :: Typed.TypedTerm [Syntax.ObjectPatternProperty] -> Typed.TypedTerm Syntax.ObjectPattern objectPattern properties =@@ -4543,6 +4746,10 @@           Core.fieldName = (Core.Name "properties"),           Core.fieldTerm = (Typed.unTypedTerm properties)}]})) +-- | DSL name token for hydra.typeScript.syntax.ObjectPattern+objectPatternObjectPattern :: Typed.TypedName Syntax.ObjectPattern+objectPatternObjectPattern = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ObjectPattern")+ -- | DSL accessor for the properties field of hydra.typeScript.syntax.ObjectPattern objectPatternProperties :: Typed.TypedTerm Syntax.ObjectPattern -> Typed.TypedTerm [Syntax.ObjectPatternProperty] objectPatternProperties x =@@ -4552,6 +4759,10 @@         Core.projectionFieldName = (Core.Name "properties")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ObjectPatternProperty+objectPatternPropertyObjectPatternProperty :: Typed.TypedName Syntax.ObjectPatternProperty+objectPatternPropertyObjectPatternProperty = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ObjectPatternProperty")+ -- | DSL injection for the property variant of hydra.typeScript.syntax.ObjectPatternProperty objectPatternPropertyProperty :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm Syntax.ObjectPatternProperty objectPatternPropertyProperty x =@@ -4611,6 +4822,11 @@         Core.projectionFieldName = (Core.Name "base")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ParameterizedTypeExpression+parameterizedTypeExpressionParameterizedTypeExpression :: Typed.TypedName Syntax.ParameterizedTypeExpression+parameterizedTypeExpressionParameterizedTypeExpression =+    Typed.TypedName (Core.Name "hydra.typeScript.syntax.ParameterizedTypeExpression")+ -- | DSL updater for the arguments field of hydra.typeScript.syntax.ParameterizedTypeExpression parameterizedTypeExpressionWithArguments :: Typed.TypedTerm Syntax.ParameterizedTypeExpression -> Typed.TypedTerm [Syntax.TypeExpression] -> Typed.TypedTerm Syntax.ParameterizedTypeExpression parameterizedTypeExpressionWithArguments original newVal =@@ -4681,6 +4897,10 @@         Core.fieldName = (Core.Name "object"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.Pattern+patternPattern :: Typed.TypedName Syntax.Pattern+patternPattern = Typed.TypedName (Core.Name "hydra.typeScript.syntax.Pattern")+ -- | DSL injection for the rest variant of hydra.typeScript.syntax.Pattern patternRest :: Typed.TypedTerm Syntax.RestElement -> Typed.TypedTerm Syntax.Pattern patternRest x =@@ -4721,6 +4941,10 @@         Core.projectionFieldName = (Core.Name "body")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.Program+programProgram :: Typed.TypedName Syntax.Program+programProgram = Typed.TypedName (Core.Name "hydra.typeScript.syntax.Program")+ -- | DSL accessor for the sourceType field of hydra.typeScript.syntax.Program programSourceType :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm Syntax.SourceType programSourceType x =@@ -4831,6 +5055,10 @@         Core.fieldName = (Core.Name "init"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.typeScript.syntax.PropertyKind+propertyKindPropertyKind :: Typed.TypedName Syntax.PropertyKind+propertyKindPropertyKind = Typed.TypedName (Core.Name "hydra.typeScript.syntax.PropertyKind")+ -- | DSL injection for the set variant of hydra.typeScript.syntax.PropertyKind propertyKindSet :: Typed.TypedTerm Syntax.PropertyKind propertyKindSet =@@ -4840,6 +5068,10 @@         Core.fieldName = (Core.Name "set"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.typeScript.syntax.Property+propertyProperty :: Typed.TypedName Syntax.Property+propertyProperty = Typed.TypedName (Core.Name "hydra.typeScript.syntax.Property")+ -- | DSL accessor for the shorthand field of hydra.typeScript.syntax.Property propertyShorthand :: Typed.TypedTerm Syntax.Property -> Typed.TypedTerm Bool propertyShorthand x =@@ -4898,6 +5130,10 @@         Core.projectionFieldName = (Core.Name "optional")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.PropertySignature+propertySignaturePropertySignature :: Typed.TypedName Syntax.PropertySignature+propertySignaturePropertySignature = Typed.TypedName (Core.Name "hydra.typeScript.syntax.PropertySignature")+ -- | DSL accessor for the readonly field of hydra.typeScript.syntax.PropertySignature propertySignatureReadonly :: Typed.TypedTerm Syntax.PropertySignature -> Typed.TypedTerm Bool propertySignatureReadonly x =@@ -5312,6 +5548,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.typeScript.syntax.RestElement"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.RestElement+restElementRestElement :: Typed.TypedName Syntax.RestElement+restElementRestElement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.RestElement")+ -- | DSL injection for the module variant of hydra.typeScript.syntax.SourceType sourceTypeModule :: Typed.TypedTerm Syntax.SourceType sourceTypeModule =@@ -5330,6 +5570,10 @@         Core.fieldName = (Core.Name "script"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.typeScript.syntax.SourceType+sourceTypeSourceType :: Typed.TypedName Syntax.SourceType+sourceTypeSourceType = Typed.TypedName (Core.Name "hydra.typeScript.syntax.SourceType")+ -- | DSL constructor for the hydra.typeScript.syntax.SpreadElement wrapper spreadElement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SpreadElement spreadElement x =@@ -5337,6 +5581,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.typeScript.syntax.SpreadElement"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.SpreadElement+spreadElementSpreadElement :: Typed.TypedName Syntax.SpreadElement+spreadElementSpreadElement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.SpreadElement")+ -- | DSL injection for the block variant of hydra.typeScript.syntax.Statement statementBlock :: Typed.TypedTerm Syntax.BlockStatement -> Typed.TypedTerm Syntax.Statement statementBlock x =@@ -5472,6 +5720,10 @@         Core.fieldName = (Core.Name "return"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.Statement+statementStatement :: Typed.TypedName Syntax.Statement+statementStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.Statement")+ -- | DSL injection for the switch variant of hydra.typeScript.syntax.Statement statementSwitch :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Statement statementSwitch x =@@ -5548,6 +5800,10 @@         Core.projectionFieldName = (Core.Name "comments")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.StatementWithComments+statementWithCommentsStatementWithComments :: Typed.TypedName Syntax.StatementWithComments+statementWithCommentsStatementWithComments = Typed.TypedName (Core.Name "hydra.typeScript.syntax.StatementWithComments")+ -- | DSL updater for the body field of hydra.typeScript.syntax.StatementWithComments statementWithCommentsWithBody :: Typed.TypedTerm Syntax.StatementWithComments -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.StatementWithComments statementWithCommentsWithBody original newVal =@@ -5604,6 +5860,10 @@         Core.projectionFieldName = (Core.Name "singleQuote")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.StringLiteral+stringLiteralStringLiteral :: Typed.TypedName Syntax.StringLiteral+stringLiteralStringLiteral = Typed.TypedName (Core.Name "hydra.typeScript.syntax.StringLiteral")+ -- | DSL accessor for the value field of hydra.typeScript.syntax.StringLiteral stringLiteralValue :: Typed.TypedTerm Syntax.StringLiteral -> Typed.TypedTerm String stringLiteralValue x =@@ -5669,6 +5929,10 @@         Core.projectionFieldName = (Core.Name "consequent")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.SwitchCase+switchCaseSwitchCase :: Typed.TypedName Syntax.SwitchCase+switchCaseSwitchCase = Typed.TypedName (Core.Name "hydra.typeScript.syntax.SwitchCase")+ -- | DSL accessor for the test field of hydra.typeScript.syntax.SwitchCase switchCaseTest :: Typed.TypedTerm Syntax.SwitchCase -> Typed.TypedTerm (Maybe Syntax.Expression) switchCaseTest x =@@ -5743,6 +6007,10 @@         Core.projectionFieldName = (Core.Name "discriminant")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.SwitchStatement+switchStatementSwitchStatement :: Typed.TypedName Syntax.SwitchStatement+switchStatementSwitchStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.SwitchStatement")+ -- | DSL updater for the cases field of hydra.typeScript.syntax.SwitchStatement switchStatementWithCases :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm [Syntax.SwitchCase] -> Typed.TypedTerm Syntax.SwitchStatement switchStatementWithCases original newVal =@@ -5799,6 +6067,10 @@         Core.projectionFieldName = (Core.Name "tail")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.TemplateElement+templateElementTemplateElement :: Typed.TypedName Syntax.TemplateElement+templateElementTemplateElement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.TemplateElement")+ -- | DSL accessor for the value field of hydra.typeScript.syntax.TemplateElement templateElementValue :: Typed.TypedTerm Syntax.TemplateElement -> Typed.TypedTerm String templateElementValue x =@@ -5873,6 +6145,10 @@         Core.projectionFieldName = (Core.Name "quasis")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.TemplateLiteral+templateLiteralTemplateLiteral :: Typed.TypedName Syntax.TemplateLiteral+templateLiteralTemplateLiteral = Typed.TypedName (Core.Name "hydra.typeScript.syntax.TemplateLiteral")+ -- | DSL updater for the expressions field of hydra.typeScript.syntax.TemplateLiteral templateLiteralWithExpressions :: Typed.TypedTerm Syntax.TemplateLiteral -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.TemplateLiteral templateLiteralWithExpressions original newVal =@@ -5914,6 +6190,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.typeScript.syntax.ThrowStatement"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.ThrowStatement+throwStatementThrowStatement :: Typed.TypedName Syntax.ThrowStatement+throwStatementThrowStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.ThrowStatement")+ -- | DSL constructor for hydra.typeScript.syntax.TryStatement tryStatement :: Typed.TypedTerm Syntax.BlockStatement -> Typed.TypedTerm (Maybe Syntax.CatchClause) -> Typed.TypedTerm (Maybe Syntax.BlockStatement) -> Typed.TypedTerm Syntax.TryStatement tryStatement block handler finalizer =@@ -5957,6 +6237,10 @@         Core.projectionFieldName = (Core.Name "handler")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.TryStatement+tryStatementTryStatement :: Typed.TypedName Syntax.TryStatement+tryStatementTryStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.TryStatement")+ -- | DSL updater for the block field of hydra.typeScript.syntax.TryStatement tryStatementWithBlock :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.BlockStatement -> Typed.TypedTerm Syntax.TryStatement tryStatementWithBlock original newVal =@@ -6063,6 +6347,10 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.TypeAliasDeclaration+typeAliasDeclarationTypeAliasDeclaration :: Typed.TypedName Syntax.TypeAliasDeclaration+typeAliasDeclarationTypeAliasDeclaration = Typed.TypedName (Core.Name "hydra.typeScript.syntax.TypeAliasDeclaration")+ -- | DSL accessor for the typeParameters field of hydra.typeScript.syntax.TypeAliasDeclaration typeAliasDeclarationTypeParameters :: Typed.TypedTerm Syntax.TypeAliasDeclaration -> Typed.TypedTerm [Syntax.TypeParameter] typeAliasDeclarationTypeParameters x =@@ -6151,6 +6439,10 @@       Core.wrappedTermTypeName = (Core.Name "hydra.typeScript.syntax.TypeAnnotation"),       Core.wrappedTermBody = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.TypeAnnotation+typeAnnotationTypeAnnotation :: Typed.TypedName Syntax.TypeAnnotation+typeAnnotationTypeAnnotation = Typed.TypedName (Core.Name "hydra.typeScript.syntax.TypeAnnotation")+ -- | DSL injection for the any variant of hydra.typeScript.syntax.TypeExpression typeExpressionAny :: Typed.TypedTerm Syntax.TypeExpression typeExpressionAny =@@ -6259,6 +6551,10 @@         Core.fieldName = (Core.Name "tuple"),         Core.fieldTerm = (Typed.unTypedTerm x)}})) +-- | DSL name token for hydra.typeScript.syntax.TypeExpression+typeExpressionTypeExpression :: Typed.TypedName Syntax.TypeExpression+typeExpressionTypeExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.TypeExpression")+ -- | DSL injection for the union variant of hydra.typeScript.syntax.TypeExpression typeExpressionUnion :: Typed.TypedTerm Syntax.UnionTypeExpression -> Typed.TypedTerm Syntax.TypeExpression typeExpressionUnion x =@@ -6329,6 +6625,10 @@         Core.projectionFieldName = (Core.Name "name")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.TypeParameter+typeParameterTypeParameter :: Typed.TypedName Syntax.TypeParameter+typeParameterTypeParameter = Typed.TypedName (Core.Name "hydra.typeScript.syntax.TypeParameter")+ -- | DSL updater for the constraint field of hydra.typeScript.syntax.TypeParameter typeParameterWithConstraint :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm (Maybe Syntax.TypeExpression) -> Typed.TypedTerm Syntax.TypeParameter typeParameterWithConstraint original newVal =@@ -6432,6 +6732,10 @@         Core.projectionFieldName = (Core.Name "type")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.TypedPattern+typedPatternTypedPattern :: Typed.TypedName Syntax.TypedPattern+typedPatternTypedPattern = Typed.TypedName (Core.Name "hydra.typeScript.syntax.TypedPattern")+ -- | DSL updater for the pattern field of hydra.typeScript.syntax.TypedPattern typedPatternWithPattern :: Typed.TypedTerm Syntax.TypedPattern -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.TypedPattern typedPatternWithPattern original newVal =@@ -6565,6 +6869,10 @@         Core.projectionFieldName = (Core.Name "prefix")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.UnaryExpression+unaryExpressionUnaryExpression :: Typed.TypedName Syntax.UnaryExpression+unaryExpressionUnaryExpression = Typed.TypedName (Core.Name "hydra.typeScript.syntax.UnaryExpression")+ -- | DSL updater for the argument field of hydra.typeScript.syntax.UnaryExpression unaryExpressionWithArgument :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.UnaryExpression unaryExpressionWithArgument original newVal =@@ -6709,6 +7017,10 @@         Core.fieldName = (Core.Name "typeof"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.typeScript.syntax.UnaryOperator+unaryOperatorUnaryOperator :: Typed.TypedName Syntax.UnaryOperator+unaryOperatorUnaryOperator = Typed.TypedName (Core.Name "hydra.typeScript.syntax.UnaryOperator")+ -- | DSL injection for the void variant of hydra.typeScript.syntax.UnaryOperator unaryOperatorVoid :: Typed.TypedTerm Syntax.UnaryOperator unaryOperatorVoid =@@ -6749,6 +7061,10 @@         Core.projectionFieldName = (Core.Name "kind")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.VariableDeclaration+variableDeclarationVariableDeclaration :: Typed.TypedName Syntax.VariableDeclaration+variableDeclarationVariableDeclaration = Typed.TypedName (Core.Name "hydra.typeScript.syntax.VariableDeclaration")+ -- | DSL updater for the declarations field of hydra.typeScript.syntax.VariableDeclaration variableDeclarationWithDeclarations :: Typed.TypedTerm Syntax.VariableDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.VariableDeclaration variableDeclarationWithDeclarations original newVal =@@ -6814,6 +7130,10 @@         Core.projectionFieldName = (Core.Name "init")})),       Core.applicationArgument = (Typed.unTypedTerm x)})) +-- | DSL name token for hydra.typeScript.syntax.VariableDeclarator+variableDeclaratorVariableDeclarator :: Typed.TypedName Syntax.VariableDeclarator+variableDeclaratorVariableDeclarator = Typed.TypedName (Core.Name "hydra.typeScript.syntax.VariableDeclarator")+ -- | DSL updater for the id field of hydra.typeScript.syntax.VariableDeclarator variableDeclaratorWithId :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.VariableDeclarator variableDeclaratorWithId original newVal =@@ -6875,6 +7195,10 @@         Core.fieldName = (Core.Name "var"),         Core.fieldTerm = Core.TermUnit}})) +-- | DSL name token for hydra.typeScript.syntax.VariableKind+variableKindVariableKind :: Typed.TypedName Syntax.VariableKind+variableKindVariableKind = Typed.TypedName (Core.Name "hydra.typeScript.syntax.VariableKind")+ -- | DSL constructor for hydra.typeScript.syntax.WhileStatement whileStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.WhileStatement whileStatement test body =@@ -6905,6 +7229,10 @@         Core.projectionTypeName = (Core.Name "hydra.typeScript.syntax.WhileStatement"),         Core.projectionFieldName = (Core.Name "test")})),       Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.typeScript.syntax.WhileStatement+whileStatementWhileStatement :: Typed.TypedName Syntax.WhileStatement+whileStatementWhileStatement = Typed.TypedName (Core.Name "hydra.typeScript.syntax.WhileStatement")  -- | DSL updater for the body field of hydra.typeScript.syntax.WhileStatement whileStatementWithBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.WhileStatement

@@ -0,0 +1,623 @@+-- | A DSL for constructing TypeScript syntax trees in Haskell.+module Hydra.Overlay.Haskell.Dsl.TypeScript.Helpers where++import Hydra.TypeScript.Syntax+import qualified Data.Int as I+++-- * Identifiers++-- | Create an identifier+-- Example: ident "foo"+ident :: String -> Identifier+ident = Identifier++-- | Create a qualified name from a list of strings+-- Example: qualifiedName ["module", "submodule", "name"]+qualifiedName :: [String] -> QualifiedName+qualifiedName = fmap Identifier+++-- * Literals++-- | Create a string literal with double quotes+-- Example: stringLit "hello"+stringLit :: String -> Literal+stringLit s = LiteralString $ StringLiteral s False++-- | Create a string literal with single quotes+-- Example: stringLitSingle "hello"+stringLitSingle :: String -> Literal+stringLitSingle s = LiteralString $ StringLiteral s True++-- | Create an integer literal+-- Example: intLit 42+intLit :: I.Int64 -> Literal+intLit = LiteralNumber . NumericLiteralInteger++-- | Create a floating-point literal+-- Example: floatLit 3.14+floatLit :: Double -> Literal+floatLit = LiteralNumber . NumericLiteralFloat++-- | Create a boolean literal+-- Example: boolLit True+boolLit :: Bool -> Literal+boolLit = LiteralBoolean++-- | The null literal+nullLit :: Literal+nullLit = LiteralNull++-- | The undefined literal+undefinedLit :: Literal+undefinedLit = LiteralUndefined++-- | Create a BigInt literal+-- Example: bigIntLit 123+bigIntLit :: Integer -> Literal+bigIntLit = LiteralBigInt+++-- * Expressions++-- | Create an identifier expression+-- Example: identExpr "foo"+identExpr :: String -> Expression+identExpr = ExpressionIdentifier . ident++-- | Create a literal expression+-- Example: litExpr (stringLit "hello")+litExpr :: Literal -> Expression+litExpr = ExpressionLiteral++-- | Create a string expression+-- Example: stringExpr "hello"+stringExpr :: String -> Expression+stringExpr = litExpr . stringLit++-- | Create an integer expression+-- Example: intExpr 42+intExpr :: I.Int64 -> Expression+intExpr = litExpr . intLit++-- | Create a floating-point expression+-- Example: floatExpr 3.14+floatExpr :: Double -> Expression+floatExpr = litExpr . floatLit++-- | Create a boolean expression+-- Example: boolExpr True+boolExpr :: Bool -> Expression+boolExpr = litExpr . boolLit++-- | The null expression+nullExpr :: Expression+nullExpr = litExpr nullLit++-- | The undefined expression+undefinedExpr :: Expression+undefinedExpr = litExpr undefinedLit++-- | Create an array expression+-- Example: arrayExpr [intExpr 1, intExpr 2, intExpr 3]+arrayExpr :: [Expression] -> Expression+arrayExpr = ExpressionArray . fmap ArrayElementExpression++-- | Create an object expression from key-value pairs+-- Example: objectExpr [("name", stringExpr "John"), ("age", intExpr 30)]+objectExpr :: [(String, Expression)] -> Expression+objectExpr pairs = ExpressionObject $ fmap toProperty pairs+  where+    toProperty (k, v) = Property (identExpr k) v PropertyKindInit False False++-- | Create a function call expression+-- Example: callExpr (identExpr "foo") [intExpr 1, intExpr 2]+callExpr :: Expression -> [Expression] -> Expression+callExpr callee args = ExpressionCall $ CallExpression callee args False++-- | Create an optional chaining call expression+-- Example: optionalCallExpr (identExpr "foo") [intExpr 1]+optionalCallExpr :: Expression -> [Expression] -> Expression+optionalCallExpr callee args = ExpressionCall $ CallExpression callee args True++-- | Create a member access expression (obj.prop)+-- Example: memberExpr (identExpr "obj") "prop"+memberExpr :: Expression -> String -> Expression+memberExpr obj prop = ExpressionMember $ MemberExpression obj (identExpr prop) False False++-- | Create a computed member access expression (obj[expr])+-- Example: computedMemberExpr (identExpr "arr") (intExpr 0)+computedMemberExpr :: Expression -> Expression -> Expression+computedMemberExpr obj prop = ExpressionMember $ MemberExpression obj prop True False++-- | Create an optional chaining member expression (obj?.prop)+-- Example: optionalMemberExpr (identExpr "obj") "prop"+optionalMemberExpr :: Expression -> String -> Expression+optionalMemberExpr obj prop = ExpressionMember $ MemberExpression obj (identExpr prop) False True++-- | Create a conditional (ternary) expression+-- Example: condExpr (identExpr "x") (intExpr 1) (intExpr 0)+condExpr :: Expression -> Expression -> Expression -> Expression+condExpr test consequent alternate = ExpressionConditional $+  ConditionalExpression test consequent alternate++-- | Create a binary expression+-- Example: binaryExpr BinaryOperatorAdd (intExpr 1) (intExpr 2)+binaryExpr :: BinaryOperator -> Expression -> Expression -> Expression+binaryExpr op left right = ExpressionBinary $ BinaryExpression op left right++-- | Create an addition expression+-- Example: addExpr (intExpr 1) (intExpr 2)+addExpr :: Expression -> Expression -> Expression+addExpr = binaryExpr BinaryOperatorAdd++-- | Create a subtraction expression+-- Example: subExpr (intExpr 5) (intExpr 3)+subExpr :: Expression -> Expression -> Expression+subExpr = binaryExpr BinaryOperatorSubtract++-- | Create a multiplication expression+-- Example: mulExpr (intExpr 3) (intExpr 4)+mulExpr :: Expression -> Expression -> Expression+mulExpr = binaryExpr BinaryOperatorMultiply++-- | Create a division expression+-- Example: divExpr (intExpr 10) (intExpr 2)+divExpr :: Expression -> Expression -> Expression+divExpr = binaryExpr BinaryOperatorDivide++-- | Create a strict equality expression (===)+-- Example: eqExpr (identExpr "x") (intExpr 1)+eqExpr :: Expression -> Expression -> Expression+eqExpr = binaryExpr BinaryOperatorStrictEqual++-- | Create a strict inequality expression (!==)+-- Example: neqExpr (identExpr "x") (intExpr 1)+neqExpr :: Expression -> Expression -> Expression+neqExpr = binaryExpr BinaryOperatorStrictNotEqual++-- | Create a logical AND expression+-- Example: andExpr (identExpr "a") (identExpr "b")+andExpr :: Expression -> Expression -> Expression+andExpr = binaryExpr BinaryOperatorAnd++-- | Create a logical OR expression+-- Example: orExpr (identExpr "a") (identExpr "b")+orExpr :: Expression -> Expression -> Expression+orExpr = binaryExpr BinaryOperatorOr++-- | Create a unary expression+-- Example: unaryExpr UnaryOperatorNot (identExpr "x")+unaryExpr :: UnaryOperator -> Expression -> Expression+unaryExpr op arg = ExpressionUnary $ UnaryExpression op arg True++-- | Create a logical NOT expression+-- Example: notExpr (identExpr "x")+notExpr :: Expression -> Expression+notExpr = unaryExpr UnaryOperatorNot++-- | Create a negation expression+-- Example: negateExpr (identExpr "x")+negateExpr :: Expression -> Expression+negateExpr = unaryExpr UnaryOperatorNegate++-- | Create an assignment expression+-- Example: assignExpr (identPattern "x") (intExpr 42)+assignExpr :: Pattern -> Expression -> Expression+assignExpr left right = ExpressionAssignment $+  AssignmentExpression AssignmentOperatorAssign left right++-- | The 'this' expression+thisExpr :: Expression+thisExpr = ExpressionThis++-- | Create a 'new' expression+-- Example: newExpr (identExpr "Date") []+newExpr :: Expression -> [Expression] -> Expression+newExpr callee args = ExpressionNew $ CallExpression callee args False++-- | Create an await expression+-- Example: awaitExpr (callExpr (identExpr "fetch") [stringExpr "url"])+awaitExpr :: Expression -> Expression+awaitExpr = ExpressionAwait++-- | Create a yield expression+-- Example: yieldExpr (Just (intExpr 1))+yieldExpr :: Maybe Expression -> Expression+yieldExpr = ExpressionYield++-- | Create a spread expression+-- Example: spreadExpr (identExpr "arr")+spreadExpr :: Expression -> Expression+spreadExpr = ExpressionSpread . SpreadElement++-- | Create a parenthesized expression+-- Example: parenExpr (addExpr (intExpr 1) (intExpr 2))+parenExpr :: Expression -> Expression+parenExpr = ExpressionParenthesized+++-- * Arrow Functions++-- | Create an arrow function with an expression body+-- Example: arrowExpr ["x", "y"] (addExpr (identExpr "x") (identExpr "y"))+arrowExpr :: [String] -> Expression -> Expression+arrowExpr params body = ExpressionArrow $ ArrowFunctionExpression+  (fmap identPattern params)+  (ArrowFunctionBodyExpression body)+  False++-- | Create an async arrow function with an expression body+-- Example: asyncArrowExpr ["x"] (awaitExpr (callExpr (identExpr "fetch") [identExpr "x"]))+asyncArrowExpr :: [String] -> Expression -> Expression+asyncArrowExpr params body = ExpressionArrow $ ArrowFunctionExpression+  (fmap identPattern params)+  (ArrowFunctionBodyExpression body)+  True++-- | Create an arrow function with a block body+-- Example: arrowBlockExpr ["x"] [returnStmt (Just (identExpr "x"))]+arrowBlockExpr :: [String] -> [Statement] -> Expression+arrowBlockExpr params body = ExpressionArrow $ ArrowFunctionExpression+  (fmap identPattern params)+  (ArrowFunctionBodyBlock body)+  False+++-- * Patterns++-- | Create an identifier pattern+-- Example: identPattern "x"+identPattern :: String -> Pattern+identPattern = PatternIdentifier . ident++-- | Create an object destructuring pattern+-- Example: objectPattern [identPattern "a", identPattern "b"]+objectPattern :: [Pattern] -> Pattern+objectPattern ps = PatternObject $ ObjectPattern $ fmap toProperty ps+  where+    toProperty p = case p of+      PatternIdentifier i -> ObjectPatternPropertyProperty $+        Property (ExpressionIdentifier i) (ExpressionIdentifier i) PropertyKindInit False True+      _ -> ObjectPatternPropertyProperty $+        Property nullExpr (patternToExpr p) PropertyKindInit False False+    patternToExpr (PatternIdentifier i) = ExpressionIdentifier i+    patternToExpr _ = nullExpr++-- | Create an array destructuring pattern+-- Example: arrayPattern [Just (identPattern "a"), Nothing, Just (identPattern "b")]+arrayPattern :: [Maybe Pattern] -> Pattern+arrayPattern = PatternArray++-- | Create a rest pattern+-- Example: restPattern "args"+restPattern :: String -> Pattern+restPattern = PatternRest . RestElement . identPattern++-- | Create a pattern with a default value+-- Example: defaultPattern "x" (intExpr 0)+defaultPattern :: String -> Expression -> Pattern+defaultPattern name def = PatternAssignment $+  AssignmentPattern (identPattern name) def+++-- * Statements++-- | Create an expression statement+-- Example: exprStmt (callExpr (identExpr "console.log") [stringExpr "hello"])+exprStmt :: Expression -> Statement+exprStmt = StatementExpression++-- | Create a block statement+-- Example: blockStmt [exprStmt (intExpr 1), exprStmt (intExpr 2)]+blockStmt :: [Statement] -> Statement+blockStmt = StatementBlock++-- | Create a return statement+-- Example: returnStmt (Just (intExpr 42))+returnStmt :: Maybe Expression -> Statement+returnStmt = StatementReturn++-- | Create a throw statement+-- Example: throwStmt (newExpr (identExpr "Error") [stringExpr "oops"])+throwStmt :: Expression -> Statement+throwStmt = StatementThrow . ThrowStatement++-- | Create a break statement+-- Example: breakStmt Nothing+breakStmt :: Maybe String -> Statement+breakStmt = StatementBreak . fmap ident++-- | Create a continue statement+-- Example: continueStmt Nothing+continueStmt :: Maybe String -> Statement+continueStmt = StatementContinue . fmap ident++-- | Create an if statement+-- Example: ifStmt (identExpr "x") (returnStmt (Just (intExpr 1))) Nothing+ifStmt :: Expression -> Statement -> Maybe Statement -> Statement+ifStmt test consequent alternate = StatementIf $ IfStatement test consequent alternate++-- | Create a while statement+-- Example: whileStmt (boolExpr True) (blockStmt [breakStmt Nothing])+whileStmt :: Expression -> Statement -> Statement+whileStmt test body = StatementWhile $ WhileStatement test body++-- | Create a for statement+-- Example: forStmt (Just (ForInitVariable (constDecl "i" (intExpr 0)))) (Just (binaryExpr BinaryOperatorLessThan (identExpr "i") (intExpr 10))) (Just (unaryExpr UnaryOperatorIncrement (identExpr "i"))) (blockStmt [])+forStmt :: Maybe ForInit -> Maybe Expression -> Maybe Expression -> Statement -> Statement+forStmt init test update body = StatementFor $ ForStatement init test update body++-- | Create a for-of statement+-- Example: forOfStmt False (ForInLeftVariable (constDecl "item" Nothing)) (identExpr "items") (blockStmt [])+forOfStmt :: Bool -> ForInLeft -> Expression -> Statement -> Statement+forOfStmt await left right body = StatementForOf $ ForOfStatement await left right body++-- | Create a try statement+-- Example: tryStmt [exprStmt (callExpr (identExpr "riskyOp") [])] (Just (catchClause (Just (identPattern "e")) [throwStmt (identExpr "e")])) Nothing+tryStmt :: [Statement] -> Maybe CatchClause -> Maybe [Statement] -> Statement+tryStmt block handler finalizer = StatementTry $ TryStatement block handler finalizer++-- | Create a catch clause+-- Example: catchClause (Just (identPattern "e")) [throwStmt (identExpr "e")]+catchClause :: Maybe Pattern -> [Statement] -> CatchClause+catchClause = CatchClause++-- | Create a switch statement+-- Example: switchStmt (identExpr "x") [switchCase (Just (intExpr 1)) [returnStmt (Just (stringExpr "one"))], switchCase Nothing [returnStmt (Just (stringExpr "default"))]]+switchStmt :: Expression -> [SwitchCase] -> Statement+switchStmt discriminant cases = StatementSwitch $ SwitchStatement discriminant cases++-- | Create a switch case+-- Example: switchCase (Just (intExpr 1)) [returnStmt (Just (stringExpr "one"))]+switchCase :: Maybe Expression -> [Statement] -> SwitchCase+switchCase = SwitchCase++-- | An empty statement+emptyStmt :: Statement+emptyStmt = StatementEmpty++-- | A debugger statement+debuggerStmt :: Statement+debuggerStmt = StatementDebugger+++-- * Variable Declarations++-- | Create a const declaration+-- Example: constDecl "x" (Just (intExpr 42))+constDecl :: String -> Maybe Expression -> VariableDeclaration+constDecl name init = VariableDeclaration VariableKindConst+  [VariableDeclarator (identPattern name) init]++-- | Create a let declaration+-- Example: letDecl "x" (Just (intExpr 42))+letDecl :: String -> Maybe Expression -> VariableDeclaration+letDecl name init = VariableDeclaration VariableKindLet+  [VariableDeclarator (identPattern name) init]++-- | Create a var declaration+-- Example: varDecl "x" (Just (intExpr 42))+varDecl :: String -> Maybe Expression -> VariableDeclaration+varDecl name init = VariableDeclaration VariableKindVar+  [VariableDeclarator (identPattern name) init]++-- | Create a variable declaration statement+-- Example: varDeclStmt (constDecl "x" (Just (intExpr 42)))+varDeclStmt :: VariableDeclaration -> Statement+varDeclStmt = StatementVariableDeclaration+++-- * Function Declarations++-- | Create a function declaration+-- Example: funcDecl "add" ["x", "y"] [returnStmt (Just (addExpr (identExpr "x") (identExpr "y")))]+funcDecl :: String -> [String] -> [Statement] -> FunctionDeclaration+funcDecl name params body = FunctionDeclaration+  (ident name)+  (fmap identPattern params)+  body+  False+  False++-- | Create an async function declaration+-- Example: asyncFuncDecl "fetchData" ["url"] [returnStmt (Just (awaitExpr (callExpr (identExpr "fetch") [identExpr "url"])))]+asyncFuncDecl :: String -> [String] -> [Statement] -> FunctionDeclaration+asyncFuncDecl name params body = FunctionDeclaration+  (ident name)+  (fmap identPattern params)+  body+  True+  False++-- | Create a function declaration statement+-- Example: funcDeclStmt (funcDecl "add" ["x", "y"] [returnStmt (Just (addExpr (identExpr "x") (identExpr "y")))])+funcDeclStmt :: FunctionDeclaration -> Statement+funcDeclStmt = StatementFunctionDeclaration+++-- * Class Declarations++-- | Create a class declaration+-- Example: classDecl "Person" Nothing [methodDef "greet" [] [returnStmt (Just (stringExpr "hello"))]]+classDecl :: String -> Maybe Expression -> [MethodDefinition] -> ClassDeclaration+classDecl name superClass body = ClassDeclaration (ident name) superClass body++-- | Create a method definition+-- Example: methodDef "greet" [] [returnStmt (Just (stringExpr "hello"))]+methodDef :: String -> [String] -> [Statement] -> MethodDefinition+methodDef name params body = MethodDefinition+  (identExpr name)+  (FunctionExpression Nothing (fmap identPattern params) body False False)+  MethodKindMethod+  False+  False++-- | Create a constructor definition+-- Example: constructorDef ["name"] [exprStmt (assignExpr (PatternIdentifier (ident "this.name")) (identExpr "name"))]+constructorDef :: [String] -> [Statement] -> MethodDefinition+constructorDef params body = MethodDefinition+  (identExpr "constructor")+  (FunctionExpression Nothing (fmap identPattern params) body False False)+  MethodKindConstructor+  False+  False++-- | Create a static method definition+-- Example: staticMethodDef "create" [] [returnStmt (Just (newExpr (identExpr "Person") []))]+staticMethodDef :: String -> [String] -> [Statement] -> MethodDefinition+staticMethodDef name params body = MethodDefinition+  (identExpr name)+  (FunctionExpression Nothing (fmap identPattern params) body False False)+  MethodKindMethod+  False+  True++-- | Create a class declaration statement+-- Example: classDeclStmt (classDecl "Person" Nothing [])+classDeclStmt :: ClassDeclaration -> Statement+classDeclStmt = StatementClassDeclaration+++-- * Module Items++-- | Create a statement module item+-- Example: stmtItem (varDeclStmt (constDecl "x" (Just (intExpr 42))))+stmtItem :: Statement -> ModuleItem+stmtItem = ModuleItemStatement++-- | Create an import declaration+-- Example: importDecl [importNamed "foo" "foo"] "./module.js"+importDecl :: [ImportClause] -> String -> ImportDeclaration+importDecl specifiers source = ImportDeclaration specifiers (StringLiteral source False)++-- | Create a named import+-- Example: importNamed "foo" "bar"  -- import { foo as bar }+importNamed :: String -> String -> ImportClause+importNamed imported local = ImportClauseNamed $+  ImportSpecifier (ident imported) (ident local)++-- | Create a default import+-- Example: importDefault "foo"  -- import foo from ...+importDefault :: String -> ImportClause+importDefault = ImportClauseDefault . ImportDefaultSpecifier . ident++-- | Create a namespace import+-- Example: importNamespace "foo"  -- import * as foo from ...+importNamespace :: String -> ImportClause+importNamespace = ImportClauseNamespace . ImportNamespaceSpecifier . ident++-- | Create an import module item+-- Example: importItem (importDecl [importDefault "React"] "react")+importItem :: ImportDeclaration -> ModuleItem+importItem = ModuleItemImport++-- | Create a named export declaration+-- Example: namedExportDecl [("foo", "foo")] Nothing+namedExportDecl :: [(String, String)] -> Maybe String -> ExportDeclaration+namedExportDecl specifiers source = ExportDeclarationNamed $ NamedExport+  (fmap (\(local, exported) -> ExportSpecifier (ident local) (ident exported)) specifiers)+  (fmap (\s -> StringLiteral s False) source)++-- | Create a default export declaration+-- Example: defaultExportDecl (identExpr "foo")+defaultExportDecl :: Expression -> ExportDeclaration+defaultExportDecl = ExportDeclarationDefault++-- | Create an export declaration for a statement+-- Example: exportDeclStmt (varDeclStmt (constDecl "x" (Just (intExpr 42))))+exportDeclStmt :: Statement -> ExportDeclaration+exportDeclStmt = ExportDeclarationDeclaration++-- | Create an export module item+-- Example: exportItem (defaultExportDecl (identExpr "foo"))+exportItem :: ExportDeclaration -> ModuleItem+exportItem = ModuleItemExport+++-- * Programs++-- | Create a module program+-- Example: moduleProgram [importItem (importDecl [importDefault "foo"] "./foo.js"), stmtItem (varDeclStmt (constDecl "x" (Just (intExpr 42))))]+moduleProgram :: [ModuleItem] -> Program+moduleProgram body = Program body SourceTypeModule++-- | Create a script program+-- Example: scriptProgram [stmtItem (varDeclStmt (constDecl "x" (Just (intExpr 42))))]+scriptProgram :: [ModuleItem] -> Program+scriptProgram body = Program body SourceTypeScript+++-- * Type Expressions++-- | Create an identifier type expression+-- Example: identType "string"+identType :: String -> TypeExpression+identType = TypeExpressionIdentifier . ident++-- | Create an array type expression+-- Example: arrayType (identType "number")+arrayType :: TypeExpression -> TypeExpression+arrayType = TypeExpressionArray . ArrayTypeExpression++-- | Create a union type expression+-- Example: unionType [identType "string", identType "number"]+unionType :: [TypeExpression] -> TypeExpression+unionType = TypeExpressionUnion++-- | Create an optional type expression+-- Example: optionalType (identType "string")+optionalType :: TypeExpression -> TypeExpression+optionalType = TypeExpressionOptional++-- | Create a parameterized type expression+-- Example: paramType (identType "Array") [identType "string"]+paramType :: TypeExpression -> [TypeExpression] -> TypeExpression+paramType base args = TypeExpressionParameterized $+  ParameterizedTypeExpression base args++-- | The 'any' type+anyType :: TypeExpression+anyType = TypeExpressionAny++-- | The 'void' type+voidType :: TypeExpression+voidType = TypeExpressionVoid++-- | The 'never' type+neverType :: TypeExpression+neverType = TypeExpressionNever+++-- * Comments and Documentation++-- | Create a line comment+-- Example: lineComment "This is a comment"+lineComment :: String -> Comment+lineComment = CommentLine++-- | Create a block comment+-- Example: blockComment "This is a\nmultiline comment"+blockComment :: String -> Comment+blockComment = CommentBlock++-- | Create a documentation comment+-- Example: docComment "Description of the function" [paramTag "x" (Just (identType "number")) "The input value"]+docComment :: String -> [DocumentationTag] -> Comment+docComment desc tags = CommentDocumentation $ DocumentationComment desc tags++-- | Create a @param documentation tag+-- Example: paramTag "x" (Just (identType "number")) "The input value"+paramTag :: String -> Maybe TypeExpression -> String -> DocumentationTag+paramTag name typ desc = DocumentationTag "param" typ (Just $ ident name) desc++-- | Create a @returns documentation tag+-- Example: returnsTag (Just (identType "number")) "The result"+returnsTag :: Maybe TypeExpression -> String -> DocumentationTag+returnsTag typ desc = DocumentationTag "returns" typ Nothing desc++-- | Create a @type documentation tag+-- Example: typeTag (identType "number")+typeTag :: TypeExpression -> DocumentationTag+typeTag typ = DocumentationTag "type" (Just typ) Nothing ""

@@ -68,6 +68,7 @@ analyzeTypeScriptFunction :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either t0 (Typing.FunctionStructure Graph.Graph) analyzeTypeScriptFunction cx g term = Analysis.analyzeFunctionTerm cx tsEnvGetGraph tsEnvSetGraph g term +-- | Collect the bound parameter names from a chain of nested foralls, in outer-to-inner order; stops at the first non-forall type collectForallParams :: Core.Type -> [Core.Name] collectForallParams t = @@ -76,12 +77,14 @@         Core.TypeForall v0 -> Lists.cons (Core.forallTypeParameter v0) (collectForallParams (Core.forallTypeBody v0))         _ -> [] +-- | Collect the names of every type referenced in a type tree that belongs to a different namespace than the current module, for computing the imports needed at the top of the emitted .ts file collectImports :: Packaging.ModuleName -> Core.Type -> S.Set Core.Name collectImports currentNs t =        let vars = Variables.freeVariablesInType t       in (filterNonLocalNames currentNs vars) +-- | Collect type imports referenced inside a term tree (lambda bodies, type applications, let-binding schemes), supplementing the top-level typeScheme walk collectInnerTypeImports :: Packaging.ModuleName -> Core.Term -> S.Set Core.Name collectInnerTypeImports currentNs term = @@ -96,6 +99,7 @@           childVars = Lists.foldl (\acc -> \s -> Sets.union acc (collectInnerTypeImports currentNs s)) Sets.empty subs       in (filterNonLocalNames currentNs (Sets.union ownVars childVars)) +-- | Like collectImports but walks a Term, gathering free term-level variables that resolve to a different module collectTermImports :: Packaging.ModuleName -> Core.Term -> S.Set Core.Name collectTermImports currentNs t = @@ -322,8 +326,9 @@       Core.TermWrap v0 -> tsObject [         ("value", (encodeTerm cx g currentNs (Core.wrappedTermBody v0)))]       Core.TermLet v0 ->-        let bindings = sortBindingsTopologically (Core.letBindings v0)-            body = Core.letBody v0+        let lt2 = thunkLazyLet v0+            bindings = sortBindingsTopologically (Core.letBindings lt2)+            body = Core.letBody lt2             encodedBody = encodeTerm cx g currentNs body             bindingStmts = Lists.map (\b -> encodeBindingAsStatement cx g currentNs b) bindings             returnStmt = Syntax.StatementReturn (Just encodedBody)@@ -580,6 +585,21 @@           in (head_, (Lists.concat2 prevArgs (Lists.singleton (Core.applicationArgument v0))))         _ -> (t, []) +forceLazyRefs :: S.Set Core.Name -> Core.Term -> Core.Term+forceLazyRefs targets0 term0 =+    Rewriting.rewriteTermWithContext (\recurse0 -> \targets -> \term -> case term of+      Core.TermVariable v0 -> Logic.ifElse (Sets.member v0 targets) (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable v0),+        Core.applicationArgument = Core.TermUnit})) term+      Core.TermLambda v0 ->+        let innerTargets = Sets.delete (Core.lambdaParameter v0) targets+        in (recurse0 innerTargets term)+      Core.TermLet v0 ->+        let boundNames = Sets.fromList (Lists.map Core.bindingName (Core.letBindings v0))+            innerTargets = Sets.difference targets boundNames+        in (recurse0 innerTargets term)+      _ -> recurse0 targets term) targets0 term0+ functionDeclarationFromTerm :: Typing.InferenceContext -> Graph.Graph -> Packaging.ModuleName -> String -> Core.Term -> Maybe Core.Type -> Syntax.FunctionDeclaration functionDeclarationFromTerm cx g currentNs lname term _mScheme = @@ -595,8 +615,11 @@                     Typing.functionStructureEnvironment = g}) (\ok -> ok) fsE           fsParams = Typing.functionStructureParams fs           fsDoms = Typing.functionStructureDomains fs-          fsBindings = Typing.functionStructureBindings fs-          fsBody = Typing.functionStructureBody fs+          fsBindings0 = Typing.functionStructureBindings fs+          fsBody0 = Typing.functionStructureBody fs+          thunked = thunkLazyBindings fsBindings0 fsBody0+          fsBindings = Pairs.first thunked+          fsBody = Pairs.second thunked           fsEnv = Typing.functionStructureEnvironment fs           domPad = Core.TypeVariable (Core.Name "_")           fsDomsPadded = Lists.concat2 fsDoms (Lists.replicate (Math.sub (Lists.length fsParams) (Lists.length fsDoms)) domPad)@@ -643,7 +666,7 @@                         targetIsTest =                                 Logic.and (Logic.not (Lists.null targetSegs)) (Equality.equal (Optionals.fromOptional "" (Lists.maybeHead targetSegs)) "test")                         targetPathSegs =-                                Logic.ifElse (Equality.equal (Optionals.fromOptional "" (Lists.maybeHead targetSegs)) "lib") (Lists.concat2 [+                                Logic.ifElse (Logic.and (Equality.equal (Optionals.fromOptional "" (Lists.maybeHead targetSegs)) "lib") (Logic.not (Equality.equal (Packaging.unModuleName ns) "hydra.lib.defaults"))) (Lists.concat2 [                                   "overlay",                                   "typescript"] targetSegs) targetSegs                         targetPath = Strings.intercalate "/" targetPathSegs@@ -665,6 +688,21 @@ lazyFlagsForPrimitive g name =     Optionals.cases (Maps.lookup name (Graph.graphPrimitives g)) [] (\prim -> Lists.map (\p -> Typing.parameterIsLazy p) (Typing.termSignatureParameters (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition prim)))) +letBindingIsThunkCandidate :: Core.Binding -> Bool+letBindingIsThunkCandidate b =++      let dterm = Strip.deannotateAndDetypeTerm (Core.bindingTerm b)+          isLambda =+                  case dterm of+                    Core.TermLambda _ -> True+                    _ -> False+          freeVars = Variables.freeVariablesInTerm (Core.bindingTerm b)+          callsShow =+                  Lists.foldl (\acc -> \n -> Logic.or acc (Optionals.cases (Names.moduleNameOf n) False (\mn -> Equality.equal (Lists.take 2 (Strings.splitOn "." (Packaging.unModuleName mn))) [+                    "hydra",+                    "show"]))) False (Sets.toList freeVars)+      in (Logic.and (Logic.not isLambda) callsShow)+ mkDocComment :: Maybe String -> Maybe Syntax.DocumentationComment mkDocComment mdesc =     Optionals.cases mdesc Nothing (\d -> Logic.ifElse (Equality.equal d "") Nothing (Just (Syntax.DocumentationComment {@@ -887,6 +925,33 @@         Core.TermVariable v0 -> Just v0         Core.TermTypeApplication v0 -> termHeadVariable (Core.typeApplicationTermBody v0)         _ -> Nothing++thunkLazyBindings :: [Core.Binding] -> Core.Term -> ([Core.Binding], Core.Term)+thunkLazyBindings bindings body =++      let candidates = Lists.filter (\b -> letBindingIsThunkCandidate b) bindings+      in (Logic.ifElse (Lists.null candidates) (bindings, body) (+        let targets = Sets.fromList (Lists.map Core.bindingName candidates)+            wrapCandidate =+                    \b -> Logic.ifElse (letBindingIsThunkCandidate b) (Core.Binding {+                      Core.bindingName = (Core.bindingName b),+                      Core.bindingTerm = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "_"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (forceLazyRefs targets (Core.bindingTerm b))})),+                      Core.bindingTypeScheme = (Core.bindingTypeScheme b)}) (Core.Binding {+                      Core.bindingName = (Core.bindingName b),+                      Core.bindingTerm = (forceLazyRefs targets (Core.bindingTerm b)),+                      Core.bindingTypeScheme = (Core.bindingTypeScheme b)})+        in (Lists.map wrapCandidate bindings, (forceLazyRefs targets body))))++thunkLazyLet :: Core.Let -> Core.Let+thunkLazyLet lt =++      let result = thunkLazyBindings (Core.letBindings lt) (Core.letBody lt)+      in Core.Let {+        Core.letBindings = (Pairs.first result),+        Core.letBody = (Pairs.second result)}  tsArray :: [Syntax.Expression] -> Syntax.Expression tsArray elems = Syntax.ExpressionArray (Lists.map (\e -> Syntax.ArrayElementExpression e) elems)