packages feed

hydra-scala 0.18.0 → 0.18.1

raw patch · 3 files changed

+340/−19 lines, 3 filesdep ~hydra-jvmdep ~hydra-kernelPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: hydra-jvm, hydra-kernel

API changes (from Hackage documentation)

+ Hydra.Scala.Coder: encodeComplexTermDefPlainBody :: Set String -> t0 -> t1 -> Graph -> String -> [ParamType] -> [ParamData] -> Type -> [Binding] -> [Name] -> Term -> Either Error Stat
+ Hydra.Scala.Coder: encodeComplexTermDefTcoBody :: Set String -> t0 -> Graph -> String -> [ParamType] -> [ParamData] -> Type -> [String] -> TcoLoopPlan -> Either Error Stat
+ Hydra.Scala.Coder: encodeTcoStep :: Set String -> t0 -> Graph -> String -> TcoStep -> Either Error Data
+ Hydra.Scala.Coder: extractTcoBody :: Term -> Term
- Hydra.Scala.Coder: encodeComplexTermDef :: Set String -> t0 -> Graph -> String -> Term -> Type -> Either Error Stat
+ Hydra.Scala.Coder: encodeComplexTermDef :: Set String -> t0 -> Graph -> Name -> String -> Term -> Type -> Either Error Stat

Files

CHANGELOG.md view
@@ -15,6 +15,144 @@  --- +## [0.18.1] - 2026-11-20++Textual-sources release: the whole `hydra-kernel` is now authored as textual `.hydra` files, including the+primitive library `hydra.core.lib.*`, and the textual syntax gains the sugar, parsers, and tooling needed to carry it.+Also lands translingual tail-call optimization for the Scala and TypeScript coders, named provisions and+primitive parameter names, the property-graph encoding of term graphs, and a large body of host-specific bootstrap+and CI fixes.++### Breaking changes++- **Type renames** ([#837](https://github.com/CategoricalData/hydra/issues/837)): four types whose variant names clashed with other kernel types are renamed.+  Any code, JSON, or `.hydra` text that names them must be updated.+  - `hydra.core.regex.QuantifierRange` is now `hydra.core.regex.Range`.+  - `hydra.ext.azure.dtld.SchemaPrimitive` is now `PrimitiveSchema`, and `SchemaComplex` is now `ComplexSchema`.+  - `hydra.rust.syntax.TypePath` is now `PathType`.+- **New primitive signature syntax in `.hydra`** ([#837](https://github.com/CategoricalData/hydra/issues/837)): a `primitive` definition names its parameters,+  `primitive ifElse ∀x.(p: boolean, t: lazy x, f: lazy x) : x`, instead of the old arrow chain+  (`primitive ifElse : ∀t. boolean → lazy t → lazy t → t`).+  Parameter and result descriptions move into `@param` and `@return` doc lines.+  The arrow-chain form is for `term` signatures only.+- **Raw `case` keyword is now `cases`** ([#810](https://github.com/CategoricalData/hydra/issues/810)): the textual-syntax case statement keyword matches `Term.cases`.+- **`hydra.core.json.bootstrap` is now `hydra.core.bootstrap`** ([#791](https://github.com/CategoricalData/hydra/issues/791)).+- **`and` and `or` are lazy in their second operand** ([#802](https://github.com/CategoricalData/hydra/issues/802)): both are marked lazy, mirroring `ifElse`, and the+  Java and Python hosts add thunk-accepting overloads.++### Highlights++- **The whole kernel is `.hydra`-sourced** ([#837](https://github.com/CategoricalData/hydra/issues/837), [#711](https://github.com/CategoricalData/hydra/issues/711), [#710](https://github.com/CategoricalData/hydra/issues/710), [#497](https://github.com/CategoricalData/hydra/issues/497)):+  every `hydra-kernel` module, including all `hydra.core.lib.*` primitive modules and the test modules, is sourced from+  `packages/hydra-kernel/src/main/hydra/**/*.hydra`; Phase 1 reads that text instead of the Haskell DSL.+  The Haskell DSL modules remain as a twin that must stay byte-identical (the dual-edit rule).+  `bin/verify-hydra-sources.sh` is the identity guard (it is not run by CI),+  and `heads/haskell/bin/print-hydra-sources.sh` regenerates the text from the DSL.+  A package may textually source only modules it owns.+- **Named primitive parameters** ([#837](https://github.com/CategoricalData/hydra/issues/837)): all 292 primitives print with named parameters and `@param`/`@return`+  descriptions, carried through the kernel metadata.+- **`parseModules`** ([#842](https://github.com/CategoricalData/hydra/issues/842)): `hydra.core.parse.packaging.parseModules` reads `.hydra` text into modules and is the+  supported entry point for downstream code generation from textual sources+  (see `docs/recipes/downstream-codegen.md`).+- **Kernel JSON on the classpath** ([#786](https://github.com/CategoricalData/hydra/issues/786)): the published `hydra-kernel` jar bundles the kernel's JSON modules, so+  Java downstream projects no longer need a source checkout to load the kernel.+- **Tail-call optimization on more hosts** ([#709](https://github.com/CategoricalData/hydra/issues/709)): shared `TcoLoopPlan`/`TcoStep` kernel types and a+  `lowerSelfTailRecursion` pass, consumed by the new Scala (`@tailrec`) and TypeScript lowerings.+- **Named provisions** ([#725](https://github.com/CategoricalData/hydra/issues/725)): primitives and tests carry named requirements and recommendations,+  spec prose is ported into module and primitive metadata, and the generated spec pages render comments and lifecycle.+- **Term graphs as property graphs** ([#738](https://github.com/CategoricalData/hydra/issues/738)): `hydra.pg.subtermGraph` encodes a term graph as a property graph,+  with specification pages (`docs/specification/pg/subterm-graph.md`).++### New features++- **Textual syntax sugar** ([#809](https://github.com/CategoricalData/hydra/issues/809), [#811](https://github.com/CategoricalData/hydra/issues/811)): nominal construction and elimination sugar+  (`record`/`inject`/`wrap {...}`, `project`/`unwrap [...]`), applied `case` sugar, and monadic `do` blocks+  (`do either`, `do list`, `do optional`, `do effect`).+- **Source spans** ([#815](https://github.com/CategoricalData/hydra/issues/815)): the parsers track source offsets and record term spans through the new+  `hydra.core.positions` module; spans are round-trip-exempt surface trivia.+- **Parsers and printers** ([#710](https://github.com/CategoricalData/hydra/issues/710), [#497](https://github.com/CategoricalData/hydra/issues/497)): `hydra.core.parse.core` (term, type, and type scheme parser),+  parse/print for packaging, doc-comment parsing into `EntityMetadata`, and `line:col` parse errors.+  A signature-level `lazy` keyword round-trips `Parameter.isLazy` ([#800](https://github.com/CategoricalData/hydra/issues/800)),+  and raw `cases(...)` accepts the `_` default field ([#822](https://github.com/CategoricalData/hydra/issues/822)).+- **JSON** ([#776](https://github.com/CategoricalData/hydra/issues/776), [#777](https://github.com/CategoricalData/hydra/issues/777)): `JsonWriterOptions` and `printJsonWith` for configurable JSON layout,+  and `\uXXXX` escapes with surrogate pairs in the JSON parser.+- **Error printers** ([#778](https://github.com/CategoricalData/hydra/issues/778)): real printers for inference and extraction errors replace placeholder constants.+- **Spec generator** ([#723](https://github.com/CategoricalData/hydra/issues/723)): the `hydra.RegenerateSpec` driver and `bin/regenerate-spec.sh` now exist,+  and the module-reference pages under `docs/specification/` are generated by them.+  The module reference is still partial (only the primitives and four kernel type modules are covered).+  Primitive pages show named signatures (`isAlpha(char: int32) → boolean`) with Parameters and Returns entries,+  type pages list fields and variants, and headings use local names so in-page links work.+- **Build system in Hydra** ([#788](https://github.com/CategoricalData/hydra/issues/788)): the lib-pass partition (`isLibModule`, `partitionLibModules`) moves into the+  translingual `hydra.build.modules`, consumed by the Java, Scala, and Haskell drivers.+- **Bootstrap matrix** ([#769](https://github.com/CategoricalData/hydra/issues/769)): `docs/bootstrap-matrix.md` persists the N×N cross-host generation matrix.+- **Build slot tooling** ([#730](https://github.com/CategoricalData/hydra/issues/730), [#814](https://github.com/CategoricalData/hydra/issues/814)): `with-stack-slot.sh` gains a second lane, priorities, pinning, and a memory guard,+  and scripts that run bare `stack` re-exec under it.+- **CI** ([#821](https://github.com/CategoricalData/hydra/issues/821), [#700](https://github.com/CategoricalData/hydra/issues/700)): an inference-cost guard (time and peak memory) and a dedicated haskell-tests job.++### Bug fixes++- [#799](https://github.com/CategoricalData/hydra/issues/799): shadow-renaming of variables was decoupled across three layers (`unshadowVariables`,+  `analyzeFunctionTermWithGather`, the Java coder's `dedupBindings`).+- [#803](https://github.com/CategoricalData/hydra/issues/803), [#804](https://github.com/CategoricalData/hydra/issues/804), [#805](https://github.com/CategoricalData/hydra/issues/805): printed import aliases and bare names now round-trip.+- [#798](https://github.com/CategoricalData/hydra/issues/798): a `Term.variable` encodes and decodes as `{"@var": "name"}` at any JSON position.+- [#817](https://github.com/CategoricalData/hydra/issues/817): `printFloat32`/`printFloat64` for subnormals in the Common Lisp, Emacs Lisp, and Clojure hosts.+- [#779](https://github.com/CategoricalData/hydra/issues/779): the Python coder no longer breaks on nested module names.+- [#752](https://github.com/CategoricalData/hydra/issues/752): `PropertyType.required` was hardcoded to true.+- [#751](https://github.com/CategoricalData/hydra/issues/751), [#832](https://github.com/CategoricalData/hydra/issues/832), [#838](https://github.com/CategoricalData/hydra/issues/838): the SHACL serializer emits blank nodes for anonymous shape references, RDF lists for+  `sh:in`/`sh:and`/`sh:or`/`sh:xone`, definition references under `sh:node`/`sh:not`/`sh:and`/`sh:or`/`sh:xone`,+  and qualified value shapes with their counts.+- [#754](https://github.com/CategoricalData/hydra/issues/754): IRI strings are escaped in the rdf4j serializer.+- [#748](https://github.com/CategoricalData/hydra/issues/748), [#781](https://github.com/CategoricalData/hydra/issues/781): `inferInGraphContext` routes through the discharge-and-finalize tail, and+  `inferModules` seeds its graph from both universe and target modules.+- [#764](https://github.com/CategoricalData/hydra/issues/764): `refreshModule` fails loudly on dropped bindings; binding dedup and primitive shadowing are fixed.+- [#649](https://github.com/CategoricalData/hydra/issues/649): the Python coder merges a type and a term that share a module path.+- [#780](https://github.com/CategoricalData/hydra/issues/780): generated Javadoc escapes backslashes and `*/`.+- [#782](https://github.com/CategoricalData/hydra/issues/782): simple Unicode case mapping on the Common Lisp and Emacs Lisp hosts.+- [#775](https://github.com/CategoricalData/hydra/issues/775): `mapSet` is unregistered on hosts that never implemented it.+- [#289](https://github.com/CategoricalData/hydra/issues/289), [#762](https://github.com/CategoricalData/hydra/issues/762), [#801](https://github.com/CategoricalData/hydra/issues/801): stale post-rename paths in the Go overlay imports, the TypeScript bootstrap driver,+  and the Common Lisp and Emacs Lisp test loaders.+- [#741](https://github.com/CategoricalData/hydra/issues/741), [#747](https://github.com/CategoricalData/hydra/issues/747), [#757](https://github.com/CategoricalData/hydra/issues/757), [#771](https://github.com/CategoricalData/hydra/issues/771), [#787](https://github.com/CategoricalData/hydra/issues/787), [#823](https://github.com/CategoricalData/hydra/issues/823), [#831](https://github.com/CategoricalData/hydra/issues/831): sync and cold-seed fixes+  (target assembly order, `hostOverrides` immunity, overlay hashing in the freshness gate, downstream assembly after+  overlay re-apply, the generator stamp's coder-copy component).+- [#736](https://github.com/CategoricalData/hydra/issues/736): CI pins JDK 11 for the Haskell job after `ubuntu-latest` moved to JDK 25.+- [#755](https://github.com/CategoricalData/hydra/issues/755): effects fixes (Type.effect encoder arms, Python `map_list`, Emacs Lisp loading).+- [#812](https://github.com/CategoricalData/hydra/issues/812): the Clojure/Scheme `testEnv` redirect applies to generated test trees only.+- [#768](https://github.com/CategoricalData/hydra/issues/768): the cold-seed driver step fails fast when its local fallback cannot succeed.+- [#825](https://github.com/CategoricalData/hydra/issues/825): `dist/haskell/hydra-kernel` is reseeded when stale relative to `dist/json`.+- [#839](https://github.com/CategoricalData/hydra/issues/839): the assemble freshness gate refreshes a stale input digest after a rebase instead of failing, and never rewrites a current one.+- [#826](https://github.com/CategoricalData/hydra/issues/826): Lisp coders reference nullary effect primitives by call.+- [#827](https://github.com/CategoricalData/hydra/issues/827): overlay variant-order tables are checked against `model.json`.+- [#772](https://github.com/CategoricalData/hydra/issues/772), [#756](https://github.com/CategoricalData/hydra/issues/756): several silent failures in the sync scripts and vitest/Scala drivers now fail loudly.++### Improvements++- Python DSL phantom types are threaded through combinator signatures ([#731](https://github.com/CategoricalData/hydra/issues/731), [#732](https://github.com/CategoricalData/hydra/issues/732), [#818](https://github.com/CategoricalData/hydra/issues/818)).+- Hackage and PyPI batch publish sets are derived from the package registry ([#573](https://github.com/CategoricalData/hydra/issues/573), [#577](https://github.com/CategoricalData/hydra/issues/577)).+- Pre-existing namespace leftovers from the 0.18.0 rename are cleaned up in Lisp, Scala, TypeScript, and Java bootstrap+  drivers ([#767](https://github.com/CategoricalData/hydra/issues/767), [#729](https://github.com/CategoricalData/hydra/issues/729)).+- `/bootstrap`, `/sync-default`, `/test`, and the pre-push gate default to Java and Python, with Haskell opt-in+  ([#773](https://github.com/CategoricalData/hydra/issues/773)); the bootstrap demo holds the build slot only for its own `stack` calls ([#797](https://github.com/CategoricalData/hydra/issues/797)).+- `bin/sync.sh` prints per-phase timing ([#824](https://github.com/CategoricalData/hydra/issues/824)), and the CI Haskell job is split to stay within the runner time limit.+- `with-stack-slot.sh` fails fast on low disk before a build ([#789](https://github.com/CategoricalData/hydra/issues/789)).+- `bin/verify-hydra-sources.sh --dsl` runs the dual-edit guard in reverse, regenerating from the Haskell DSL twins and+  comparing with the committed JSON ([#837](https://github.com/CategoricalData/hydra/issues/837)).+- `docs/hydra-lexicon.txt` prints primitives with named parameters, matching the generated spec pages+  ([#723](https://github.com/CategoricalData/hydra/issues/723)).++### Documentation++- `docs/specification/syntax.md` gains the module-level grammar, doc comments, import aliasing, file layout,+  `@param`/`@return`, and the named-parameter primitive signature.+- The kernel README, `docs/implementation.md`, `docs/build-system.md`, and the test and primitive recipes describe the+  `.hydra` sources and the dual-edit rule.+- The hand-written primitive spec pages use the `hydra.core.lib.*` namespace.+- Recipes and READMEs document the decoder/encoder fixpoint guard ([#760](https://github.com/CategoricalData/hydra/issues/760)), keeping derived modules out of+  re-inference ([#758](https://github.com/CategoricalData/hydra/issues/758)), the hydra-ext coder testing pattern ([#699](https://github.com/CategoricalData/hydra/issues/699)), scripts with no automated caller+  ([#714](https://github.com/CategoricalData/hydra/issues/714)), overlay-versus-prune ordering ([#645](https://github.com/CategoricalData/hydra/issues/645)), the Phase 1 memory envelope ([#592](https://github.com/CategoricalData/hydra/issues/592)),+  and the Rust coder's home in `hydra-rust` ([#382](https://github.com/CategoricalData/hydra/issues/382)).++---+ ## [0.18.0] - 2026-09-29  Module-naming systematization release: every kernel and package module moves onto a uniform@@ -48,9 +186,11 @@   JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders (extended integer widths, map-key handling), the   kernel's encode/decode generators (reversed type-parameter order on 2+-param polymorphic types), and   the Python coder (silently dropping a module's types when types and terms share a file path).-- **Self-hosted specification docs** ([#723](https://github.com/CategoricalData/hydra/issues/723)):-  the module-reference pages under `docs/specification/` are now generated directly from the kernel-  (`bin/regenerate-spec.sh`) via a new metadata-only doc coder, rather than hand-maintained.+- **Specification-docs generator, kernel side** ([#723](https://github.com/CategoricalData/hydra/issues/723)):+  a new metadata-only doc coder (`generateModuleDoc`) and `hydra.markdown` model, the translingual core+  for generating the module-reference pages under `docs/specification/`. *Erratum:* the Java driver that+  `bin/regenerate-spec.sh` invokes (`hydra.RegenerateSpec`) did not ship in 0.18.0, so the pages are still+  hand-maintained; the driver is pending under #723.  ### New features @@ -58,7 +198,7 @@   suite covering the minimal-core grammar (literals, classes, quantifiers, alternation, anchors,   grouping) across all 9 hosts. - **[#723](https://github.com/CategoricalData/hydra/issues/723)** `hydra.markdown` type module and-  `generateModuleDoc`, the metadata-only doc coder backing the self-generated spec pages.+  `generateModuleDoc`, the metadata-only doc coder intended to back self-generated spec pages. - **[#382](https://github.com/CategoricalData/hydra/issues/382)** the Rust coder is split out of   `hydra-ext` into its own first-class `hydra-rust` package. 
hydra-scala.cabal view
@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-scala-version:        0.18.0+version:        0.18.1 synopsis:       Hydra's Scala coder: emit Scala 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". Scala support for Hydra category:       Data@@ -40,7 +40,7 @@   build-depends:       base >=4.19.0 && <4.22     , containers >=0.6.7 && <0.8-    , hydra-jvm ==0.18.0-    , hydra-kernel ==0.18.0+    , hydra-jvm ==0.18.1+    , hydra-kernel ==0.18.1     , scientific >=0.3.7 && <0.4   default-language: Haskell2010
src/main/haskell/Hydra/Scala/Coder.hs view
@@ -257,8 +257,8 @@         Syntax.caseBody = body})))  -- | Encode a complex term definition with proper parameter types from the type signature-encodeComplexTermDef :: S.Set String -> t0 -> Graph.Graph -> String -> Model.Term -> Model.Type -> Either Errors.Error Syntax.Stat-encodeComplexTermDef overlaySubs cx g lname term typ =+encodeComplexTermDef :: S.Set String -> t0 -> Graph.Graph -> Model.Name -> String -> Model.Term -> Model.Type -> Either Errors.Error Syntax.Stat+encodeComplexTermDef overlaySubs cx g fname lname term typ =        let doms = extractDomains typ           paramNames = extractParams term@@ -269,6 +269,9 @@                   Lists.distinct (Lists.filter (\v -> Logic.not (Lists.member 46 (Strings.toList (Model.unName v)))) (Variables.freeVariablesInTypeOrdered typ))           tparams = Lists.map (\tv -> Utils.stparam tv) freeTypeVars           letBindings = extractLetBindings term+          tcoBody = extractBody term+          tcoAnalysisBody = extractTcoBody term+          mPlan = Analysis.lowerSelfTailRecursion fname (Lists.take paramCount paramNames) tcoAnalysisBody           gWithTypeVars =                   Graph.Graph {                     Graph.graphBoundTerms = (Graph.graphBoundTerms g),@@ -279,12 +282,13 @@                     Graph.graphPrimitives = (Graph.graphPrimitives g),                     Graph.graphSchemaTypes = (Graph.graphSchemaTypes g),                     Graph.graphTypeVariables = (Sets.union (Sets.fromList freeTypeVars) (Graph.graphTypeVariables g))}-      in (Eithers.bind (Eithers.mapList (encodeTypedParam cx gWithTypeVars) zippedParams) (\sparams -> Eithers.bind (encodeTerm overlaySubs cx gWithTypeVars (extractBody term)) (\sbody -> Eithers.bind (encodeType cx g cod) (\scod ->+          loopVarNames = Lists.map (\p -> Utils.scalaEscapeName (Names.localNameOf (Pairs.first p))) zippedParams+      in (Eithers.bind (Eithers.mapList (encodeTypedParam cx gWithTypeVars) zippedParams) (\sparams -> Eithers.bind (encodeType cx g cod) (\scod -> Optionals.match mPlan ((\overlaySubs2 -> \cx2 -> \g2 -> \gWithTypeVars2 -> \lname2 -> \tparams2 -> \sparams2 -> \scod2 -> \letBindings2 -> \freeTypeVars2 -> \tcoBody2 -> Eithers.bind (encodeTerm overlaySubs2 cx2 gWithTypeVars2 tcoBody2) (\sbody ->         let gForLets =-                Logic.ifElse (Lists.isEmpty letBindings) gWithTypeVars (Scoping.extendGraphForLet (\g2 -> \b -> Logic.ifElse (Predicates.isComplexBinding g2 b) (Just (Model.TermLiteral (Model.LiteralBoolean True))) Nothing) gWithTypeVars (Model.Let {-                  Model.letBindings = letBindings,+                Logic.ifElse (Lists.isEmpty letBindings2) gWithTypeVars2 (Scoping.extendGraphForLet (\g3 -> \b -> Logic.ifElse (Predicates.isComplexBinding g3 b) (Just (Model.TermLiteral (Model.LiteralBoolean True))) Nothing) gWithTypeVars2 (Model.Let {+                  Model.letBindings = letBindings2,                   Model.letBody = (Model.TermVariable (Model.Name "dummy"))}))-        in (Eithers.bind (Eithers.mapList (encodeLetBinding overlaySubs cx gForLets (Sets.fromList freeTypeVars)) letBindings) (\sbindings ->+        in (Eithers.bind (Eithers.mapList (encodeLetBinding overlaySubs2 cx2 gForLets (Sets.fromList freeTypeVars2)) letBindings2) (\sbindings ->           let defBody =                   Logic.ifElse (Lists.isEmpty sbindings) sbody (Syntax.DataBlock (Syntax.BlockData {                     Syntax.blockDataStats = (Lists.concat2 sbindings [@@ -292,13 +296,119 @@           in (Right (Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {             Syntax.defDefnMods = [],             Syntax.defDefnName = Syntax.NameData {-              Syntax.nameDataValue = (Syntax.PredefString lname)},-            Syntax.defDefnTparams = tparams,+              Syntax.nameDataValue = (Syntax.PredefString lname2)},+            Syntax.defDefnTparams = tparams2,             Syntax.defDefnParamss = (Lists.map (\p -> [-              p]) sparams),-            Syntax.defDefnDecltpe = (Just scod),-            Syntax.defDefnBody = defBody}))))))))))+              p]) sparams2),+            Syntax.defDefnDecltpe = (Just scod2),+            Syntax.defDefnBody = defBody})))))))) overlaySubs cx g gWithTypeVars lname tparams sparams scod letBindings freeTypeVars tcoBody) (\plan -> (\overlaySubs2 -> \cx2 -> \gWithTypeVars2 -> \lname2 -> \tparams2 -> \sparams2 -> \scod2 -> \loopVarNames2 -> \plan2 ->+        let loopName = Strings.concat2 lname2 "$loop"+            loopParams = sparams2+            initialArgs = Lists.map (\pr -> Utils.sname pr) loopVarNames2+            planBody = Coders.tcoLoopPlanBody plan2+        in (Eithers.bind (encodeTcoStep overlaySubs2 cx2 gWithTypeVars2 loopName planBody) (\loopBody ->+          let loopDefn =+                  Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {+                    Syntax.defDefnMods = [+                      Syntax.ModAnnot (Syntax.AnnotMod {+                        Syntax.annotModInit = Syntax.Init {+                          Syntax.initTpe = (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+                            Syntax.nameTypeValue = "scala.annotation.tailrec"}))),+                          Syntax.initName = (Syntax.NameValue ""),+                          Syntax.initArgss = []}})],+                    Syntax.defDefnName = Syntax.NameData {+                      Syntax.nameDataValue = (Syntax.PredefString loopName)},+                    Syntax.defDefnTparams = [],+                    Syntax.defDefnParamss = [+                      loopParams],+                    Syntax.defDefnDecltpe = (Just scod2),+                    Syntax.defDefnBody = loopBody}))+              initialCall =+                      Syntax.StatTerm (Syntax.DataApply (Syntax.ApplyData {+                        Syntax.applyDataFun = (Utils.sname loopName),+                        Syntax.applyDataArgs = initialArgs}))+              defBody =+                      Syntax.DataBlock (Syntax.BlockData {+                        Syntax.blockDataStats = [+                          loopDefn,+                          initialCall]})+          in (Right (Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {+            Syntax.defDefnMods = [],+            Syntax.defDefnName = Syntax.NameData {+              Syntax.nameDataValue = (Syntax.PredefString lname2)},+            Syntax.defDefnTparams = tparams2,+            Syntax.defDefnParamss = (Lists.map (\p -> [+              p]) sparams2),+            Syntax.defDefnDecltpe = (Just scod2),+            Syntax.defDefnBody = defBody}))))))) overlaySubs cx gWithTypeVars lname tparams sparams scod loopVarNames plan)))) +-- | Non-TCO defBody assembly for a complex term definition+encodeComplexTermDefPlainBody :: S.Set String -> t0 -> t1 -> Graph.Graph -> String -> [Syntax.ParamType] -> [Syntax.ParamData] -> Syntax.Type -> [Model.Binding] -> [Model.Name] -> Model.Term -> Either Errors.Error Syntax.Stat+encodeComplexTermDefPlainBody overlaySubs cx g gWithTypeVars lname tparams sparams scod letBindings freeTypeVars tcoBody =+    Eithers.bind (encodeTerm overlaySubs cx gWithTypeVars tcoBody) (\sbody ->+      let gForLets =+              Logic.ifElse (Lists.isEmpty letBindings) gWithTypeVars (Scoping.extendGraphForLet (\g2 -> \b -> Logic.ifElse (Predicates.isComplexBinding g2 b) (Just (Model.TermLiteral (Model.LiteralBoolean True))) Nothing) gWithTypeVars (Model.Let {+                Model.letBindings = letBindings,+                Model.letBody = (Model.TermVariable (Model.Name "dummy"))}))+      in (Eithers.bind (Eithers.mapList (encodeLetBinding overlaySubs cx gForLets (Sets.fromList freeTypeVars)) letBindings) (\sbindings ->+        let defBody =+                Logic.ifElse (Lists.isEmpty sbindings) sbody (Syntax.DataBlock (Syntax.BlockData {+                  Syntax.blockDataStats = (Lists.concat2 sbindings [+                    Syntax.StatTerm sbody])}))+        in (Right (Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {+          Syntax.defDefnMods = [],+          Syntax.defDefnName = Syntax.NameData {+            Syntax.nameDataValue = (Syntax.PredefString lname)},+          Syntax.defDefnTparams = tparams,+          Syntax.defDefnParamss = (Lists.map (\p -> [+            p]) sparams),+          Syntax.defDefnDecltpe = (Just scod),+          Syntax.defDefnBody = defBody})))))))++-- | TCO defBody assembly (@tailrec local loop) for a self-tail-recursive complex term definition+encodeComplexTermDefTcoBody :: S.Set String -> t0 -> Graph.Graph -> String -> [Syntax.ParamType] -> [Syntax.ParamData] -> Syntax.Type -> [String] -> Coders.TcoLoopPlan -> Either Errors.Error Syntax.Stat+encodeComplexTermDefTcoBody overlaySubs cx gWithTypeVars lname tparams sparams scod loopVarNames plan =++      let loopName = Strings.concat2 lname "$loop"+          loopParams = sparams+          initialArgs = Lists.map (\pr -> Utils.sname pr) loopVarNames+          planBody = Coders.tcoLoopPlanBody plan+      in (Eithers.bind (encodeTcoStep overlaySubs cx gWithTypeVars loopName planBody) (\loopBody ->+        let loopDefn =+                Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {+                  Syntax.defDefnMods = [+                    Syntax.ModAnnot (Syntax.AnnotMod {+                      Syntax.annotModInit = Syntax.Init {+                        Syntax.initTpe = (Syntax.TypeRef (Syntax.RefTypeName (Syntax.NameType {+                          Syntax.nameTypeValue = "scala.annotation.tailrec"}))),+                        Syntax.initName = (Syntax.NameValue ""),+                        Syntax.initArgss = []}})],+                  Syntax.defDefnName = Syntax.NameData {+                    Syntax.nameDataValue = (Syntax.PredefString loopName)},+                  Syntax.defDefnTparams = [],+                  Syntax.defDefnParamss = [+                    loopParams],+                  Syntax.defDefnDecltpe = (Just scod),+                  Syntax.defDefnBody = loopBody}))+            initialCall =+                    Syntax.StatTerm (Syntax.DataApply (Syntax.ApplyData {+                      Syntax.applyDataFun = (Utils.sname loopName),+                      Syntax.applyDataArgs = initialArgs}))+            defBody =+                    Syntax.DataBlock (Syntax.BlockData {+                      Syntax.blockDataStats = [+                        loopDefn,+                        initialCall]})+        in (Right (Syntax.StatDefn (Syntax.DefnDef (Syntax.DefDefn {+          Syntax.defDefnMods = [],+          Syntax.defDefnName = Syntax.NameData {+            Syntax.nameDataValue = (Syntax.PredefString lname)},+          Syntax.defDefnTparams = tparams,+          Syntax.defDefnParamss = (Lists.map (\p -> [+            p]) sparams),+          Syntax.defDefnDecltpe = (Just scod),+          Syntax.defDefnBody = defBody}))))))+ -- | Encode a Hydra function-valued term (lambda, project, cases, or unwrap) as a Scala expression encodeFunction :: S.Set String -> t0 -> Graph.Graph -> M.Map Model.Name Model.Term -> Model.Term -> Maybe Model.Term -> Either Errors.Error Syntax.Data encodeFunction overlaySubs cx g meta funTerm arg =@@ -452,6 +562,68 @@             Syntax.defDefnDecltpe = (Just scod),             Syntax.defDefnBody = defBody})))))))))) +-- | Lower a TcoStep into a Scala expression: continue -> tail call to the local loop def, return -> plain value, cases -> match, let_ -> block then recurse+encodeTcoStep :: S.Set String -> t0 -> Graph.Graph -> String -> Coders.TcoStep -> Either Errors.Error Syntax.Data+encodeTcoStep overlaySubs cx g loopName step =+    case step of+      Coders.TcoStepContinue v0 -> Eithers.bind (Eithers.mapList (\a -> encodeTerm overlaySubs cx g a) v0) (\sargs -> Right (Syntax.DataApply (Syntax.ApplyData {+        Syntax.applyDataFun = (Utils.sname loopName),+        Syntax.applyDataArgs = sargs})))+      Coders.TcoStepReturn v0 -> encodeTerm overlaySubs cx g v0+      Coders.TcoStepCases v0 ->+        let tname = Coders.tcoCaseStatementTypeName v0+            dom = Model.TypeVariable tname+            sn = Utils.nameOfType g dom+            alts = Coders.tcoCaseStatementCases v0+            dflt = Coders.tcoCaseStatementDefault v0+            scrutinee = Coders.tcoCaseStatementScrutinee v0+            isPolymorphic = Optionals.match (Resolution.resolveType g dom) False (\typ -> Resolution.fTypeIsPolymorphic typ)+            ftypes = Eithers.either (\_ -> Maps.empty) (\x_ -> x_) (Resolution.fieldTypes cx g dom)+        in (Eithers.bind (Eithers.mapList ((\ftypes2 -> \loopName2 -> \alt ->+          let altName = Coders.tcoCaseAlternativeName alt+              param = Coders.tcoCaseAlternativeParameter alt+              handler = Coders.tcoCaseAlternativeHandler alt+              payloadVar = Model.unName param+              isUnit =+                      Optionals.match (Maps.lookup altName ftypes2) False (\dom2 -> case (Strip.deannotateType dom2) of+                        Model.TypeUnit -> True+                        _ -> False)+              patArgs =+                      Logic.ifElse isUnit (Logic.ifElse isPolymorphic [+                        Syntax.PatWildcard] []) [+                        Utils.svar (Model.Name payloadVar)]+              pat =+                      Syntax.PatExtract (Syntax.ExtractPat {+                        Syntax.extractPatFun = (Utils.sname (Utils.qualifyUnionFieldName "MATCHED." sn altName)),+                        Syntax.extractPatArgs = patArgs,+                        Syntax.extractPatIsCall = (Logic.or (Logic.not isUnit) isPolymorphic)})+          in (Eithers.bind (encodeTcoStep overlaySubs cx g loopName2 handler) (\sbody -> Right (Syntax.Case {+            Syntax.casePat = pat,+            Syntax.caseCond = Nothing,+            Syntax.caseBody = sbody})))) ftypes loopName) alts) (\fieldCases -> Eithers.bind (Optionals.match dflt (Right fieldCases) (\dfltStep -> Eithers.bind (encodeTcoStep overlaySubs cx g loopName dfltStep) (\sdflt -> Right (Lists.concat2 fieldCases [+          Syntax.Case {+            Syntax.casePat = Syntax.PatWildcard,+            Syntax.caseCond = Nothing,+            Syntax.caseBody = sdflt}])))) (\scases -> Eithers.bind (encodeTerm overlaySubs cx g scrutinee) (\sscrutinee -> Right (Syntax.DataMatch (Syntax.MatchData {+          Syntax.matchDataExpr = sscrutinee,+          Syntax.matchDataCases = scases}))))))+      Coders.TcoStepLet_ v0 ->+        let tbindings = Coders.tcoLetBindings v0+            letBody = Coders.tcoLetBody v0+            coreBindings =+                    Lists.map (\tb -> Model.Binding {+                      Model.bindingName = (Coders.tcoBindingName tb),+                      Model.bindingTerm = (Coders.tcoBindingTerm tb),+                      Model.bindingTypeScheme = (Coders.tcoBindingTypeScheme tb)}) tbindings+            gLet =+                    Logic.ifElse (Lists.isEmpty coreBindings) g (Scoping.extendGraphForLet (\g2 -> \b -> Logic.ifElse (Predicates.isComplexBinding g2 b) (Just (Model.TermLiteral (Model.LiteralBoolean True))) Nothing) g (Model.Let {+                      Model.letBindings = coreBindings,+                      Model.letBody = (Model.TermVariable (Model.Name "dummy"))}))+        in (Eithers.bind (Eithers.mapList (encodeLetBinding overlaySubs cx gLet (Graph.graphTypeVariables gLet)) coreBindings) (\sbindings -> Eithers.bind (encodeTcoStep overlaySubs cx gLet loopName letBody) (\sbody -> Right (Logic.ifElse (Lists.isEmpty sbindings) sbody (Syntax.DataBlock (Syntax.BlockData {+          Syntax.blockDataStats = (Lists.concat2 sbindings [+            Syntax.StatTerm sbody])}))))))+      _ -> Left (Errors.ErrorOther (Errors.OtherError "unrecognized TcoStep variant"))+ -- | Encode a Hydra term as a Scala expression encodeTerm :: S.Set String -> t0 -> Graph.Graph -> Model.Term -> Either Errors.Error Syntax.Data encodeTerm overlaySubs cx g term0 =@@ -597,7 +769,7 @@                     _ -> False           freeTypeVarsInTyp =                   Lists.filter (\v -> Logic.not (Lists.member 46 (Strings.toList (Model.unName v)))) (Sets.toList (Variables.freeVariablesInType typ_))-      in (Logic.ifElse isFunctionType (encodeComplexTermDef overlaySubs cx g lname term typ_) (Logic.ifElse (Lists.isEmpty freeTypeVarsInTyp) (Eithers.bind (encodeType cx g typ_) (\stype -> Eithers.bind (encodeTerm overlaySubs cx g term) (\rhs -> Right (Syntax.StatDefn (Syntax.DefnVal (Syntax.ValDefn {+      in (Logic.ifElse isFunctionType (encodeComplexTermDef overlaySubs cx g name lname term typ_) (Logic.ifElse (Lists.isEmpty freeTypeVarsInTyp) (Eithers.bind (encodeType cx g typ_) (\stype -> Eithers.bind (encodeTerm overlaySubs cx g term) (\rhs -> Right (Syntax.StatDefn (Syntax.DefnVal (Syntax.ValDefn {         Syntax.valDefnMods = [           Syntax.ModLazy],         Syntax.valDefnPats = [@@ -954,6 +1126,15 @@       Model.TermTypeApplication v0 -> extractParams (Model.typeApplicationTermBody v0)       Model.TermLet v0 -> extractParams (Model.letBody v0)       _ -> []++-- | Extract the innermost non-let body from a term, for TCO analysis+extractTcoBody :: Model.Term -> Model.Term+extractTcoBody t =+    case (Strip.deannotateAndDetypeTerm t) of+      Model.TermLambda v0 -> extractTcoBody (Model.lambdaBody v0)+      Model.TermTypeLambda v0 -> extractTcoBody (Model.typeLambdaBody v0)+      Model.TermTypeApplication v0 -> extractTcoBody (Model.typeApplicationTermBody v0)+      _ -> t  -- | Convert a field type to a Scala enum case fieldToEnumCase :: t0 -> t1 -> String -> [Syntax.ParamType] -> Model.FieldType -> Either Errors.Error Syntax.Stat