hydra-build 0.17.6 → 0.17.7

raw patch · 7 files changed

+309/−19 lines, 7 filesdep ~hydra-kernelPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: hydra-kernel

API changes (from Hackage documentation)

Files

• CHANGELOG.md +82/−0
• hydra-build.cabal +2/−2
• src/main/haskell/Hydra/Build/Format.hs +19/−0
• src/main/haskell/Hydra/Build/Registry.hs +47/−17
• src/main/haskell/Hydra/Decode/Build/Format.hs +24/−0
• src/main/haskell/Hydra/Dsl/Build/Format.hs +119/−0
• src/main/haskell/Hydra/Encode/Build/Format.hs +16/−0

@@ -15,6 +15,88 @@  --- +## [0.17.7] - 2026-09-14++Correctness-hardening point release on the 0.17.x line, consolidating the 0.17.6 breaking batch. It+closes a family of silent cross-host correctness bugs in the equality, ordering, integer-narrowing+and string primitives, and adds the systematic test coverage that exposed them. No kernel-surface+breaking changes.++### Highlights++- **Silent-wrong primitives corrected across hosts**+  ([#745](https://github.com/CategoricalData/hydra/issues/745),+  [#742](https://github.com/CategoricalData/hydra/issues/742)): new shared cross-host fixtures+  uncovered ~a dozen primitives (`equal`/`compare` on collections, float equality, `bigintToIntN`+  narrowing, `parseUint*` bounds, astral-plane string ops) that returned wrong results on one or more+  non-Haskell hosts while appearing to pass. All are now correct and verified per-host against the+  Haskell reference oracle.+- **Systematic test-coverage hardening**+  ([#749](https://github.com/CategoricalData/hydra/issues/749)): new kernel coverage for previously+  untested primitive behavior (equality/ordering collection depth, `notEqual`, `functions.const`/`flip`),+  which drove wiring those primitives into every host's default-implementation fallback.+- **Scale-preserving decimals across every lossy-double host**+  ([#727](https://github.com/CategoricalData/hydra/issues/727),+  [#719](https://github.com/CategoricalData/hydra/issues/719)): `Literal.decimal` gains a real+  scale-preserving representation (coefficient + scale) in the Scheme, Emacs Lisp, Common Lisp and+  TypeScript runtimes and coders, and the generated `Literal.Decimal` `equals`/`compareTo` on Java,+  Python and Scala stop ignoring scale. The `scaleDistinctTestNames` skip list — which had been+  masking the gap on five hosts — is deleted, so decimal scale is now verified everywhere rather+  than excused.++### Bug fixes++- **[#745](https://github.com/CategoricalData/hydra/issues/745)** silent-wrong equality/ordering,+  `bigintToIntN` narrowing, `parseUint32/64` bounds, and astral-plane `charAt`/`splitOn`/`compare`+  across the eight non-Haskell hosts.+- **[#742](https://github.com/CategoricalData/hydra/issues/742)** structural `equal`/`compare` on+  maps, sets and nested decimals no longer falls back to scale-blind or print-based comparison+  (including a hand-inlined Scala primitive that shadowed the overlay fix).+- **[#743](https://github.com/CategoricalData/hydra/issues/743)** kernel JSON decoder now rejects an+  `Either` object carrying both `left` and `right` keys instead of silently resolving one arm.+- **[#740](https://github.com/CategoricalData/hydra/issues/740)** the recursive parametric union decoder+  now emits an explicit type application instead of an untyped lambda, so recursive parametric-union+  types generate and compile on the Java host; also fixes `update-json-kernel` reconcile to build a+  complete inference universe so drifted kernel modules re-infer.+- **[#720](https://github.com/CategoricalData/hydra/issues/720)** Python's+  `hydra.lib.equality`/`ordering` did not satisfy IEEE `totalOrder` for floats, mis-ordering `NaN`+  and signed zero.+- **[#722](https://github.com/CategoricalData/hydra/issues/722)** two `kernelDefaultCoreProfile`+  correctness defects: rule ids that referred to rules no longer present, and a stubbed+  `isValidName` that accepted every name.++### Improvements++- **[#749](https://github.com/CategoricalData/hydra/issues/749)** `notEqual`/`const`/`flip` wired+  into each host's `#609` default-implementation fallback; orphaned Avro coder test suite recovered.+- **[#730](https://github.com/CategoricalData/hydra/issues/730)** a shared `~/.stack` build slot+  (`bin/with-stack-slot.sh`) replaces the pgrep slot mechanic, serializing concurrent GHC builds+  across the fleet behind a real mutex. The wrapper is now portable to macOS: `flock(1)` is+  util-linux and absent there, so it is emulated via Perl's `flock()` where missing, and the+  GNU-only `date -Is`/`date -d` calls are replaced with portable equivalents. Its bypass path also+  no longer re-execs forever. Without these, every entry point that routes through the slot —+  `bin/sync.sh`, `bin/test.sh`, `bin/run-bootstrapping-demo.sh` and `bin/prepare-release.sh` —+  failed immediately on macOS.+- **[#600](https://github.com/CategoricalData/hydra/issues/600)** the five published TypeScript+  packages are subpath-import-only (uniform export surface).+- **[#716](https://github.com/CategoricalData/hydra/issues/716)** `hydra.paths` reshaped onto the+  term-graph model (`TermGraph`/`TypeGraph`), aligning path steps with the term and type grammars+  and adding the link view of a graph; `mapKey`/`mapValue` collapse into a single `mapEntry` step.+- **[#701](https://github.com/CategoricalData/hydra/issues/701)** module cache freshness is now a+  Merkle hash over each module's dependency closure, so a change deep in the closure correctly+  invalidates dependents.+- **[#559](https://github.com/CategoricalData/hydra/issues/559)** host-agnostic build: the+  remaining hand-coded host build logic is promoted into `hydra.build.*`, with Java as the+  definitive second host.+- **[#721](https://github.com/CategoricalData/hydra/issues/721)** `checkNestedModuleNames` packaging+  check enforces the module-namespace no-prefix rule.++### Documentation++- **[#508](https://github.com/CategoricalData/hydra/issues/508)** de-Claude-speak documentation pass:+  style-guide section added, stale paths and dead links repaired, agent-operations wiki pages moved+  into `claude/`, and a `getting-started.md` guardrail against re-adding a TypeScript root export.+ ## [0.17.6] - 2026-08-30  Point release on the 0.17.x line, and the last backward-incompatible batch before the 1.0 surface

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-build-version:        0.17.6+version:        0.17.7 synopsis:       Hydra's build system, promoted into Hydra 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 build system, promoted into Hydra itself: the manifest-derived module-to-package router, kernel/host reconciliation utilities, and pure module-list helpers, expressed as Hydra modules and generated into every self-hosting dialect. It builds on hydra-kernel. category:       Data@@ -64,6 +64,6 @@   build-depends:       base >=4.19.0 && <4.22     , containers >=0.6.7 && <0.8-    , hydra-kernel ==0.17.6+    , hydra-kernel ==0.17.7     , scientific >=0.3.7 && <0.4   default-language: Haskell2010

@@ -203,6 +203,25 @@  _LanguageName = Core.Name "hydra.build.format.LanguageName" +-- | The build identity of a source/target language: how the build system treats it. See https://github.com/CategoricalData/hydra/issues/559+data LanguageProfile =+  LanguageProfile {+    -- | The canonical language token, e.g. "haskell", "java", "clojure"+    languageProfileName :: String,+    -- | The distribution package the language's coder lives in (the four Lisp dialects share hydra-lisp)+    languageProfileCoderPackage :: String,+    -- | The build-treatment group the language belongs to, e.g. "jvm", "python", "lisp" (an open string: adding a host must not edit a type)+    languageProfileFamily :: String}+  deriving (Eq, Ord, Read, Show)++_LanguageProfile = Core.Name "hydra.build.format.LanguageProfile"++_LanguageProfile_name = Core.Name "name"++_LanguageProfile_coderPackage = Core.Name "coderPackage"++_LanguageProfile_family = Core.Name "family"+ -- | Validation rules applying to a module as a whole. Absent fields mean the corresponding check is not configured. data ModuleValidationProfile =   ModuleValidationProfile {

@@ -1,10 +1,11 @@ -- Note: this is an automatically generated file. Do not edit. --- | The translingual language registry: per-language build identity (name, coder package, family) as data, so the build drivers read language properties instead of hardcoding name literals. See https://github.com/CategoricalData/hydra/issues/416+-- | The translingual language registry: per-language build identity (name, coder package, family) as LanguageProfile records, so the build drivers read language properties instead of hardcoding name literals. See https://github.com/CategoricalData/hydra/issues/416 and https://github.com/CategoricalData/hydra/issues/559  module Hydra.Build.Registry where  import qualified Hydra.Ast as Ast+import qualified Hydra.Build.Format as Format import qualified Hydra.Coders as Coders import qualified Hydra.Core as Core import qualified Hydra.Docs as Docs@@ -20,7 +21,6 @@ import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals-import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing@@ -45,7 +45,7 @@  -- | Every language name in the registry (the former ALL_LANGS constant) allLanguageNames :: [String]-allLanguageNames = Lists.map (\p -> Pairs.first p) languageProfiles+allLanguageNames = Lists.map (\p -> Format.languageProfileName p) languageProfiles  -- | Default bench scope (sync-bench.sh DEFAULT_HOSTS; the haskell/java/python triad) benchDefaultNames :: [String]@@ -70,12 +70,12 @@ -- | The distribution package for a language's coder (data-driven; hydra-<name> fallback) coderPackageFor :: String -> String coderPackageFor name =-    Optionals.match (Lists.head (Lists.filter (\p -> Equality.equal (Pairs.first p) name) languageProfiles)) (Strings.concat2 "hydra-" name) (\p -> Pairs.first (Pairs.second p))+    Optionals.match (Lists.head (Lists.filter (\p -> Equality.equal (Format.languageProfileName p) name) languageProfiles)) (Strings.concat2 "hydra-" name) (\p -> Format.languageProfileCoderPackage p)  -- | The build family of a language (jvm/python/lisp/haskell/typescript/go; empty for unknown) familyFor :: String -> String familyFor name =-    Optionals.match (Lists.head (Lists.filter (\p -> Equality.equal (Pairs.first p) name) languageProfiles)) "" (\p -> Pairs.second (Pairs.second p))+    Optionals.match (Lists.head (Lists.filter (\p -> Equality.equal (Format.languageProfileName p) name) languageProfiles)) "" (\p -> Format.languageProfileFamily p)  -- | Hosts with an inference benchmark (run-inference-bench.sh ALL_HOSTS; includes python-pypy pseudo-host) inferenceBenchHostNames :: [String]@@ -92,20 +92,50 @@ isLispDialect :: String -> Bool isLispDialect name = Equality.equal (familyFor name) "lisp" --- | Per-language build identity as (name, coderPackage, family) triples, in native ALL_LANGS order: the single source of language names-languageProfiles :: [(String, (String, String))]+-- | Per-language build identity as LanguageProfile records, in native ALL_LANGS order: the single source of language names+languageProfiles :: [Format.LanguageProfile] languageProfiles =     [-      ("haskell", ("hydra-haskell", "haskell")),-      ("java", ("hydra-java", "jvm")),-      ("python", ("hydra-python", "python")),-      ("scala", ("hydra-scala", "jvm")),-      ("go", ("hydra-go", "go")),-      ("typescript", ("hydra-typescript", "typescript")),-      ("clojure", ("hydra-lisp", "lisp")),-      ("scheme", ("hydra-lisp", "lisp")),-      ("common-lisp", ("hydra-lisp", "lisp")),-      ("emacs-lisp", ("hydra-lisp", "lisp"))]+      Format.LanguageProfile {+        Format.languageProfileName = "haskell",+        Format.languageProfileCoderPackage = "hydra-haskell",+        Format.languageProfileFamily = "haskell"},+      Format.LanguageProfile {+        Format.languageProfileName = "java",+        Format.languageProfileCoderPackage = "hydra-java",+        Format.languageProfileFamily = "jvm"},+      Format.LanguageProfile {+        Format.languageProfileName = "python",+        Format.languageProfileCoderPackage = "hydra-python",+        Format.languageProfileFamily = "python"},+      Format.LanguageProfile {+        Format.languageProfileName = "scala",+        Format.languageProfileCoderPackage = "hydra-scala",+        Format.languageProfileFamily = "jvm"},+      Format.LanguageProfile {+        Format.languageProfileName = "go",+        Format.languageProfileCoderPackage = "hydra-go",+        Format.languageProfileFamily = "go"},+      Format.LanguageProfile {+        Format.languageProfileName = "typescript",+        Format.languageProfileCoderPackage = "hydra-typescript",+        Format.languageProfileFamily = "typescript"},+      Format.LanguageProfile {+        Format.languageProfileName = "clojure",+        Format.languageProfileCoderPackage = "hydra-lisp",+        Format.languageProfileFamily = "lisp"},+      Format.LanguageProfile {+        Format.languageProfileName = "scheme",+        Format.languageProfileCoderPackage = "hydra-lisp",+        Format.languageProfileFamily = "lisp"},+      Format.LanguageProfile {+        Format.languageProfileName = "common-lisp",+        Format.languageProfileCoderPackage = "hydra-lisp",+        Format.languageProfileFamily = "lisp"},+      Format.LanguageProfile {+        Format.languageProfileName = "emacs-lisp",+        Format.languageProfileCoderPackage = "hydra-lisp",+        Format.languageProfileFamily = "lisp"}]  -- | The Lisp-dialect names in native 'lisp'-alias order (clojure, common-lisp, emacs-lisp, scheme) lispDialectNames :: [String]

@@ -197,6 +197,30 @@         _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx raw2)) (Core.wrappedTermBody v0))       _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw) +-- | Decoder for hydra.build.format.LanguageProfile+languageProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.LanguageProfile+languageProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "coderPackage" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_coderPackage -> Eithers.bind (ExtractCore.requireField "family" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_family -> Right (Format.LanguageProfile {+          Format.languageProfileName = field_name,+          Format.languageProfileCoderPackage = field_coderPackage,+          Format.languageProfileFamily = field_family})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.LanguageProfile")) (ExtractCore.stripWithDecodingError cx raw)+ -- | Decoder for hydra.build.format.ModuleValidationProfile moduleValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.ModuleValidationProfile moduleValidationProfile cx raw =

@@ -1204,6 +1204,125 @@ languageNameLanguageName :: Typed.TypedName Format.LanguageName languageNameLanguageName = Typed.TypedName (Core.Name "hydra.build.format.LanguageName") +-- | DSL constructor for hydra.build.format.LanguageProfile+languageProfile :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile+languageProfile name coderPackage family =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "coderPackage"),+          Core.fieldTerm = (Typed.unTypedTerm coderPackage)},+        Core.Field {+          Core.fieldName = (Core.Name "family"),+          Core.fieldTerm = (Typed.unTypedTerm family)}]}))++-- | DSL accessor for the coderPackage field of hydra.build.format.LanguageProfile+languageProfileCoderPackage :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String+languageProfileCoderPackage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+        Core.projectionFieldName = (Core.Name "coderPackage")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the family field of hydra.build.format.LanguageProfile+languageProfileFamily :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String+languageProfileFamily x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+        Core.projectionFieldName = (Core.Name "family")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.LanguageProfile+languageProfileLanguageProfile :: Typed.TypedName Format.LanguageProfile+languageProfileLanguageProfile = Typed.TypedName (Core.Name "hydra.build.format.LanguageProfile")++-- | DSL accessor for the name field of hydra.build.format.LanguageProfile+languageProfileName :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String+languageProfileName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the coderPackage field of hydra.build.format.LanguageProfile+languageProfileWithCoderPackage :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile+languageProfileWithCoderPackage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "coderPackage"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "family"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+              Core.projectionFieldName = (Core.Name "family")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the family field of hydra.build.format.LanguageProfile+languageProfileWithFamily :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile+languageProfileWithFamily original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "coderPackage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+              Core.projectionFieldName = (Core.Name "coderPackage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "family"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.build.format.LanguageProfile+languageProfileWithName :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile+languageProfileWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "coderPackage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+              Core.projectionFieldName = (Core.Name "coderPackage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "family"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+              Core.projectionFieldName = (Core.Name "family")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+ -- | DSL constructor for hydra.build.format.ModuleValidationProfile moduleValidationProfile :: Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile moduleValidationProfile definitions nameConvention conflictingVariantName =

@@ -189,6 +189,22 @@       Core.wrappedTermTypeName = (Core.Name "hydra.build.format.LanguageName"),       Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.unLanguageName x))}) +-- | Encoder for hydra.build.format.LanguageProfile+languageProfile :: Format.LanguageProfile -> Core.Term+languageProfile x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.languageProfileName x))},+        Core.Field {+          Core.fieldName = (Core.Name "coderPackage"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.languageProfileCoderPackage x))},+        Core.Field {+          Core.fieldName = (Core.Name "family"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.languageProfileFamily x))}]})+ -- | Encoder for hydra.build.format.ModuleValidationProfile moduleValidationProfile :: Format.ModuleValidationProfile -> Core.Term moduleValidationProfile x =